Spaces:

nexusbert
/

zurri

Runtime error

zurri / src /controllers /agentController.ts

push

f5035b9 12 months ago

13.2 kB

import { Request, Response } from 'express';
import { AppDataSource } from '../config/database';
import { Agent, AgentStatus } from '../entities/Agent';
import { User } from '../entities/User';
import { IpfsService } from '../services/ipfsService';

const agentRepository = AppDataSource.getRepository(Agent);
const ipfsService = new IpfsService();

interface MulterFile {
  fieldname: string;
  originalname: string;
  encoding: string;
  mimetype: string;
  size: number;
  buffer: Buffer;
}

export class AgentController {
  /**
   * List all approved agents (marketplace)
   */
  async listAgents(req: Request, res: Response) {
    try {
      const { page = 1, limit = 20, search, sortBy = 'createdAt' } = req.query;

      const query = agentRepository
        .createQueryBuilder('agent')
        .where('agent.status = :status', { status: AgentStatus.APPROVED });

      if (search) {
        query.andWhere(
          '(agent.name ILIKE :search OR agent.description ILIKE :search OR agent.category ILIKE :search)',
          { search: `%${search}%` }
        );
      }

      // Filter by category if provided
      if (req.query.category) {
        query.andWhere('agent.category = :category', { category: req.query.category });
      }

      const sortOrder = req.query.sortOrder === 'asc' ? 'ASC' : 'DESC';
      query.orderBy(`agent.${sortBy}`, sortOrder);

      const skip = (Number(page) - 1) * Number(limit);
      query.skip(skip).take(Number(limit));

      const [agents, total] = await query.getManyAndCount();

      // Format agents to match expected structure
      const formattedAgents = agents.map(agent => ({
        ...agent,
        avatar: agent.avatar,
        reputation: agent.reputation || 0,
        capabilities: agent.capabilities || [],
        // Hide endpoint from public listings
        endpoint: undefined,
      }));

      res.json({
        agents: formattedAgents,
        pagination: {
          page: Number(page),
          limit: Number(limit),
          total,
          totalPages: Math.ceil(total / Number(limit)),
        },
      });
    } catch (error) {
      console.error('List agents error:', error);
      res.status(500).json({ error: 'Failed to list agents' });
    }
  }

  /**
   * Get single agent by ID
   */
  async getAgent(req: Request, res: Response) {
    try {
      const { id } = req.params;
      const agent = await agentRepository.findOne({
        where: { id },
      });

      if (!agent) {
        return res.status(404).json({ error: 'Agent not found' });
      }

      // Only show endpoint to agent creator or admins
      const userId = (req as any).user?.id;
      if (agent.creatorId !== userId && !(req as any).user?.isAdmin) {
        // Create a copy without the endpoint for security
        const { endpoint, ...agentWithoutEndpoint } = agent;
        res.json({
          ...agentWithoutEndpoint,
          // Format response to match expected structure
          avatar: agentWithoutEndpoint.avatar,
          reputation: agent.reputation || 0,
          capabilities: agent.capabilities || [],
        });
        return;
      }

      // Format response to match expected structure
      res.json({
        ...agent,
        reputation: agent.reputation || 0,
        capabilities: agent.capabilities || [],
      });
    } catch (error) {
      console.error('Get agent error:', error);
      res.status(500).json({ error: 'Failed to get agent' });
    }
  }

  /**
   * Create new agent listing (creator)
   */
  async createAgent(req: Request, res: Response) {
    try {
      const userId = (req as any).user.id;
      const isAdmin = (req as any).user.isAdmin;
      
      // Check if user is a creator or admin
      const userRepository = AppDataSource.getRepository(User);
      const user = await userRepository.findOne({ where: { id: userId } });
      
      if (!user) {
        return res.status(404).json({ error: 'User not found' });
      }
      
      if (!user.isCreator && !isAdmin) {
        return res.status(403).json({ 
          error: 'You must be a creator to create agents',
          message: 'Please become a creator first by calling POST /api/users/become-creator',
          becomeCreatorEndpoint: '/api/users/become-creator',
        });
      }
      const avatarFile = (req as any).file as MulterFile | undefined;
      const {
        name,
        description,
        endpoint,
        category,
        capabilities,
        price,
        pointsPerTask, // Required: Points charged per task (1 point = $0.05)
        isSubscription = false, // Default to pay-per-task
        subscriptionDuration,
        promptTemplate,
        metadata,
      } = req.body;

      // Parse capabilities if it's a string
      let parsedCapabilities: string[] = [];
      if (capabilities) {
        if (typeof capabilities === 'string') {
          try {
            parsedCapabilities = JSON.parse(capabilities);
          } catch {
            parsedCapabilities = [capabilities];
          }
        } else if (Array.isArray(capabilities)) {
          parsedCapabilities = capabilities;
        }
      }

      // Validate required fields
      if (!name || !description || !endpoint || pointsPerTask === undefined) {
        return res.status(400).json({ 
          error: 'Missing required fields. Name, description, endpoint, and pointsPerTask are required.',
          note: 'pointsPerTask is the number of points charged per task (1 point = $0.05)'
        });
      }

      // Validate pointsPerTask
      if (pointsPerTask < 0) {
        return res.status(400).json({ error: 'pointsPerTask must be 0 or greater (0 = free agent)' });
      }

      // Validate capabilities is an array
      if (!Array.isArray(parsedCapabilities)) {
        return res.status(400).json({ error: 'Capabilities must be an array' });
      }

      // Upload avatar to IPFS if provided
      let avatarUrl: string | undefined;
      if (avatarFile) {
        try {
          const fileObj = new File(
            [avatarFile.buffer],
            avatarFile.originalname || `avatar-${Date.now()}.${avatarFile.mimetype.split('/')[1]}`,
            { type: avatarFile.mimetype }
          );

          const upload = await ipfsService.uploadFile(fileObj);
          avatarUrl = ipfsService.getGatewayUrl(upload.cid);
        } catch (error) {
          console.error('Avatar upload error:', error);
          return res.status(500).json({ error: 'Failed to upload avatar image' });
        }
      }

      // Upload metadata to IPFS
      let ipfsHash: string | undefined;
      try {
        ipfsHash = await ipfsService.uploadMetadata({
          name,
          description,
          endpoint,
          price,
          creatorId: userId,
          category,
          capabilities: parsedCapabilities,
          metadata,
        });
      } catch (error) {
        console.warn('IPFS upload failed, continuing without IPFS hash');
      }

      // Use price as fallback for pointsPerTask if not provided (backward compatibility)
      const finalPointsPerTask = pointsPerTask !== undefined ? pointsPerTask : (price ? price * 20 : 0); // 1 dollar = 20 points

      const agent = agentRepository.create({
        name,
        avatar: avatarUrl,
        description,
        endpoint,
        category,
        capabilities: parsedCapabilities,
        price: price || pointsPerTask * 0.05, // Convert points to dollars for legacy field
        pointsPerTask: finalPointsPerTask,
        isSubscription: false, // All agents now use pay-per-task model
        subscriptionDuration: undefined, // Not used in pay-per-task model
        promptTemplate,
        metadata: metadata ? (typeof metadata === 'string' ? JSON.parse(metadata) : metadata) : undefined,
        creatorId: userId,
        ipfsHash,
        status: AgentStatus.PENDING,
        reputation: 0, // Start at 0, will be updated based on ratings
        ratingCount: 0,
      });

      const savedAgent = await agentRepository.save(agent);

      res.status(201).json(savedAgent);
    } catch (error: any) {
      console.error('Create agent error:', error);
      res.status(500).json({ error: error.message || 'Failed to create agent' });
    }
  }

  /**
   * Update agent (creator only)
   */
  async updateAgent(req: Request, res: Response) {
    try {
      const { id } = req.params;
      const userId = (req as any).user.id;
      const isAdmin = (req as any).user.isAdmin;

      const agent = await agentRepository.findOne({
        where: { id },
      });

      if (!agent) {
        return res.status(404).json({ error: 'Agent not found' });
      }

      // Only creator or admin can update
      if (agent.creatorId !== userId && !isAdmin) {
        return res.status(403).json({ error: 'Unauthorized' });
      }

      // Can't update if approved (requires re-submission)
      if (agent.status === AgentStatus.APPROVED && agent.creatorId !== userId) {
        return res.status(400).json({
          error: 'Approved agents cannot be updated. Create a new listing.',
        });
      }

      const avatarFile = (req as any).file as MulterFile | undefined;
      const updateData = req.body;
      delete updateData.status; // Don't allow status updates via this endpoint
      delete updateData.creatorId; // Don't allow creator change
      delete updateData.reputation; // Reputation is calculated from ratings
      delete updateData.ratingCount; // Rating count is managed by system
      delete updateData.avatar; // Avatar comes from file upload, not body

      // Parse capabilities if it's a string
      if (updateData.capabilities) {
        if (typeof updateData.capabilities === 'string') {
          try {
            updateData.capabilities = JSON.parse(updateData.capabilities);
          } catch {
            updateData.capabilities = [updateData.capabilities];
          }
        }
      }

      // Validate capabilities if provided
      if (updateData.capabilities && !Array.isArray(updateData.capabilities)) {
        return res.status(400).json({ error: 'Capabilities must be an array' });
      }

      // Upload new avatar if provided
      if (avatarFile) {
        try {
          const fileObj = new File(
            [avatarFile.buffer],
            avatarFile.originalname || `avatar-${Date.now()}.${avatarFile.mimetype.split('/')[1]}`,
            { type: avatarFile.mimetype }
          );

          const upload = await ipfsService.uploadFile(fileObj);
          updateData.avatar = ipfsService.getGatewayUrl(upload.cid);
        } catch (error) {
          console.error('Avatar upload error:', error);
          return res.status(500).json({ error: 'Failed to upload avatar image' });
        }
      }

      Object.assign(agent, updateData);

      // Parse metadata if it's a string
      if (updateData.metadata && typeof updateData.metadata === 'string') {
        try {
          updateData.metadata = JSON.parse(updateData.metadata);
        } catch {
          // Keep as string if not valid JSON
        }
      }

      // Update IPFS if metadata changed
      if (updateData.name || updateData.description || updateData.price || updateData.category || updateData.capabilities) {
        try {
          agent.ipfsHash = await ipfsService.uploadMetadata({
            name: agent.name,
            description: agent.description,
            endpoint: agent.endpoint,
            price: agent.price,
            creatorId: agent.creatorId,
            category: agent.category,
            capabilities: agent.capabilities,
            metadata: agent.metadata,
          });
        } catch (error) {
          console.warn('IPFS update failed');
        }
      }

      const updatedAgent = await agentRepository.save(agent);

      res.json(updatedAgent);
    } catch (error) {
      console.error('Update agent error:', error);
      res.status(500).json({ error: 'Failed to update agent' });
    }
  }

  /**
   * Delete agent (creator only)
   */
  async deleteAgent(req: Request, res: Response) {
    try {
      const { id } = req.params;
      const userId = (req as any).user.id;
      const isAdmin = (req as any).user.isAdmin;

      const agent = await agentRepository.findOne({
        where: { id },
      });

      if (!agent) {
        return res.status(404).json({ error: 'Agent not found' });
      }

      if (agent.creatorId !== userId && !isAdmin) {
        return res.status(403).json({ error: 'Unauthorized' });
      }

      await agentRepository.remove(agent);

      res.json({ message: 'Agent deleted' });
    } catch (error) {
      console.error('Delete agent error:', error);
      res.status(500).json({ error: 'Failed to delete agent' });
    }
  }

  /**
   * Get user's agents (creator)
   */
  async getMyAgents(req: Request, res: Response) {
    try {
      const userId = (req as any).user.id;
      const agents = await agentRepository.find({
        where: { creatorId: userId },
        order: { createdAt: 'DESC' },
      });

      res.json(agents);
    } catch (error) {
      console.error('Get my agents error:', error);
      res.status(500).json({ error: 'Failed to get your agents' });
    }
  }
}

	import { Request, Response } from 'express';
	import { AppDataSource } from '../config/database';
	import { Agent, AgentStatus } from '../entities/Agent';
	import { User } from '../entities/User';
	import { IpfsService } from '../services/ipfsService';

	const agentRepository = AppDataSource.getRepository(Agent);
	const ipfsService = new IpfsService();

	interface MulterFile {
	fieldname: string;
	originalname: string;
	encoding: string;
	mimetype: string;
	size: number;
	buffer: Buffer;
	}

	export class AgentController {
	/**
	* List all approved agents (marketplace)
	*/
	async listAgents(req: Request, res: Response) {
	try {
	const { page = 1, limit = 20, search, sortBy = 'createdAt' } = req.query;

	const query = agentRepository
	.createQueryBuilder('agent')
	.where('agent.status = :status', { status: AgentStatus.APPROVED });

	if (search) {
	query.andWhere(
	'(agent.name ILIKE :search OR agent.description ILIKE :search OR agent.category ILIKE :search)',
	{ search: `%${search}%` }
	);
	}

	// Filter by category if provided
	if (req.query.category) {
	query.andWhere('agent.category = :category', { category: req.query.category });
	}

	const sortOrder = req.query.sortOrder === 'asc' ? 'ASC' : 'DESC';
	query.orderBy(`agent.${sortBy}`, sortOrder);

	const skip = (Number(page) - 1) * Number(limit);
	query.skip(skip).take(Number(limit));

	const [agents, total] = await query.getManyAndCount();

	// Format agents to match expected structure
	const formattedAgents = agents.map(agent => ({
	...agent,
	avatar: agent.avatar,
	reputation: agent.reputation \|\| 0,
	capabilities: agent.capabilities \|\| [],
	// Hide endpoint from public listings
	endpoint: undefined,
	}));

	res.json({
	agents: formattedAgents,
	pagination: {
	page: Number(page),
	limit: Number(limit),
	total,
	totalPages: Math.ceil(total / Number(limit)),
	},
	});
	} catch (error) {
	console.error('List agents error:', error);
	res.status(500).json({ error: 'Failed to list agents' });
	}
	}

	/**
	* Get single agent by ID
	*/
	async getAgent(req: Request, res: Response) {
	try {
	const { id } = req.params;
	const agent = await agentRepository.findOne({
	where: { id },
	});

	if (!agent) {
	return res.status(404).json({ error: 'Agent not found' });
	}

	// Only show endpoint to agent creator or admins
	const userId = (req as any).user?.id;
	if (agent.creatorId !== userId && !(req as any).user?.isAdmin) {
	// Create a copy without the endpoint for security
	const { endpoint, ...agentWithoutEndpoint } = agent;
	res.json({
	...agentWithoutEndpoint,
	// Format response to match expected structure
	avatar: agentWithoutEndpoint.avatar,
	reputation: agent.reputation \|\| 0,
	capabilities: agent.capabilities \|\| [],
	});
	return;
	}

	// Format response to match expected structure
	res.json({
	...agent,
	reputation: agent.reputation \|\| 0,
	capabilities: agent.capabilities \|\| [],
	});
	} catch (error) {
	console.error('Get agent error:', error);
	res.status(500).json({ error: 'Failed to get agent' });
	}
	}

	/**
	* Create new agent listing (creator)
	*/
	async createAgent(req: Request, res: Response) {
	try {
	const userId = (req as any).user.id;
	const isAdmin = (req as any).user.isAdmin;

	// Check if user is a creator or admin
	const userRepository = AppDataSource.getRepository(User);
	const user = await userRepository.findOne({ where: { id: userId } });

	if (!user) {
	return res.status(404).json({ error: 'User not found' });
	}

	if (!user.isCreator && !isAdmin) {
	return res.status(403).json({
	error: 'You must be a creator to create agents',
	message: 'Please become a creator first by calling POST /api/users/become-creator',
	becomeCreatorEndpoint: '/api/users/become-creator',
	});
	}
	const avatarFile = (req as any).file as MulterFile \| undefined;
	const {
	name,
	description,
	endpoint,
	category,
	capabilities,
	price,
	pointsPerTask, // Required: Points charged per task (1 point = $0.05)
	isSubscription = false, // Default to pay-per-task
	subscriptionDuration,
	promptTemplate,
	metadata,
	} = req.body;

	// Parse capabilities if it's a string
	let parsedCapabilities: string[] = [];
	if (capabilities) {
	if (typeof capabilities === 'string') {
	try {
	parsedCapabilities = JSON.parse(capabilities);
	} catch {
	parsedCapabilities = [capabilities];
	}
	} else if (Array.isArray(capabilities)) {
	parsedCapabilities = capabilities;
	}
	}

	// Validate required fields
	if (!name \|\| !description \|\| !endpoint \|\| pointsPerTask === undefined) {
	return res.status(400).json({
	error: 'Missing required fields. Name, description, endpoint, and pointsPerTask are required.',
	note: 'pointsPerTask is the number of points charged per task (1 point = $0.05)'
	});
	}

	// Validate pointsPerTask
	if (pointsPerTask < 0) {
	return res.status(400).json({ error: 'pointsPerTask must be 0 or greater (0 = free agent)' });
	}

	// Validate capabilities is an array
	if (!Array.isArray(parsedCapabilities)) {
	return res.status(400).json({ error: 'Capabilities must be an array' });
	}

	// Upload avatar to IPFS if provided
	let avatarUrl: string \| undefined;
	if (avatarFile) {
	try {
	const fileObj = new File(
	[avatarFile.buffer],
	avatarFile.originalname \|\| `avatar-${Date.now()}.${avatarFile.mimetype.split('/')[1]}`,
	{ type: avatarFile.mimetype }
	);

	const upload = await ipfsService.uploadFile(fileObj);
	avatarUrl = ipfsService.getGatewayUrl(upload.cid);
	} catch (error) {
	console.error('Avatar upload error:', error);
	return res.status(500).json({ error: 'Failed to upload avatar image' });
	}
	}

	// Upload metadata to IPFS
	let ipfsHash: string \| undefined;
	try {
	ipfsHash = await ipfsService.uploadMetadata({
	name,
	description,
	endpoint,
	price,
	creatorId: userId,
	category,
	capabilities: parsedCapabilities,
	metadata,
	});
	} catch (error) {
	console.warn('IPFS upload failed, continuing without IPFS hash');
	}

	// Use price as fallback for pointsPerTask if not provided (backward compatibility)
	const finalPointsPerTask = pointsPerTask !== undefined ? pointsPerTask : (price ? price * 20 : 0); // 1 dollar = 20 points

	const agent = agentRepository.create({
	name,
	avatar: avatarUrl,
	description,
	endpoint,
	category,
	capabilities: parsedCapabilities,
	price: price \|\| pointsPerTask * 0.05, // Convert points to dollars for legacy field
	pointsPerTask: finalPointsPerTask,
	isSubscription: false, // All agents now use pay-per-task model
	subscriptionDuration: undefined, // Not used in pay-per-task model
	promptTemplate,
	metadata: metadata ? (typeof metadata === 'string' ? JSON.parse(metadata) : metadata) : undefined,
	creatorId: userId,
	ipfsHash,
	status: AgentStatus.PENDING,
	reputation: 0, // Start at 0, will be updated based on ratings
	ratingCount: 0,
	});

	const savedAgent = await agentRepository.save(agent);

	res.status(201).json(savedAgent);
	} catch (error: any) {
	console.error('Create agent error:', error);
	res.status(500).json({ error: error.message \|\| 'Failed to create agent' });
	}
	}

	/**
	* Update agent (creator only)
	*/
	async updateAgent(req: Request, res: Response) {
	try {
	const { id } = req.params;
	const userId = (req as any).user.id;
	const isAdmin = (req as any).user.isAdmin;

	const agent = await agentRepository.findOne({
	where: { id },
	});

	if (!agent) {
	return res.status(404).json({ error: 'Agent not found' });
	}

	// Only creator or admin can update
	if (agent.creatorId !== userId && !isAdmin) {
	return res.status(403).json({ error: 'Unauthorized' });
	}

	// Can't update if approved (requires re-submission)
	if (agent.status === AgentStatus.APPROVED && agent.creatorId !== userId) {
	return res.status(400).json({
	error: 'Approved agents cannot be updated. Create a new listing.',
	});
	}

	const avatarFile = (req as any).file as MulterFile \| undefined;
	const updateData = req.body;
	delete updateData.status; // Don't allow status updates via this endpoint
	delete updateData.creatorId; // Don't allow creator change
	delete updateData.reputation; // Reputation is calculated from ratings
	delete updateData.ratingCount; // Rating count is managed by system
	delete updateData.avatar; // Avatar comes from file upload, not body

	// Parse capabilities if it's a string
	if (updateData.capabilities) {
	if (typeof updateData.capabilities === 'string') {
	try {
	updateData.capabilities = JSON.parse(updateData.capabilities);
	} catch {
	updateData.capabilities = [updateData.capabilities];
	}
	}
	}

	// Validate capabilities if provided
	if (updateData.capabilities && !Array.isArray(updateData.capabilities)) {
	return res.status(400).json({ error: 'Capabilities must be an array' });
	}

	// Upload new avatar if provided
	if (avatarFile) {
	try {
	const fileObj = new File(
	[avatarFile.buffer],
	avatarFile.originalname \|\| `avatar-${Date.now()}.${avatarFile.mimetype.split('/')[1]}`,
	{ type: avatarFile.mimetype }
	);

	const upload = await ipfsService.uploadFile(fileObj);
	updateData.avatar = ipfsService.getGatewayUrl(upload.cid);
	} catch (error) {
	console.error('Avatar upload error:', error);
	return res.status(500).json({ error: 'Failed to upload avatar image' });
	}
	}

	Object.assign(agent, updateData);

	// Parse metadata if it's a string
	if (updateData.metadata && typeof updateData.metadata === 'string') {
	try {
	updateData.metadata = JSON.parse(updateData.metadata);
	} catch {
	// Keep as string if not valid JSON
	}
	}

	// Update IPFS if metadata changed
	if (updateData.name \|\| updateData.description \|\| updateData.price \|\| updateData.category \|\| updateData.capabilities) {
	try {
	agent.ipfsHash = await ipfsService.uploadMetadata({
	name: agent.name,
	description: agent.description,
	endpoint: agent.endpoint,
	price: agent.price,
	creatorId: agent.creatorId,
	category: agent.category,
	capabilities: agent.capabilities,
	metadata: agent.metadata,
	});
	} catch (error) {
	console.warn('IPFS update failed');
	}
	}

	const updatedAgent = await agentRepository.save(agent);

	res.json(updatedAgent);
	} catch (error) {
	console.error('Update agent error:', error);
	res.status(500).json({ error: 'Failed to update agent' });
	}
	}

	/**
	* Delete agent (creator only)
	*/
	async deleteAgent(req: Request, res: Response) {
	try {
	const { id } = req.params;
	const userId = (req as any).user.id;
	const isAdmin = (req as any).user.isAdmin;

	const agent = await agentRepository.findOne({
	where: { id },
	});

	if (!agent) {
	return res.status(404).json({ error: 'Agent not found' });
	}

	if (agent.creatorId !== userId && !isAdmin) {
	return res.status(403).json({ error: 'Unauthorized' });
	}

	await agentRepository.remove(agent);

	res.json({ message: 'Agent deleted' });
	} catch (error) {
	console.error('Delete agent error:', error);
	res.status(500).json({ error: 'Failed to delete agent' });
	}
	}

	/**
	* Get user's agents (creator)
	*/
	async getMyAgents(req: Request, res: Response) {
	try {
	const userId = (req as any).user.id;
	const agents = await agentRepository.find({
	where: { creatorId: userId },
	order: { createdAt: 'DESC' },
	});

	res.json(agents);
	} catch (error) {
	console.error('Get my agents error:', error);
	res.status(500).json({ error: 'Failed to get your agents' });
	}
	}
	}