push

src/controllers/agentController.ts

@@ -1,6 +1,7 @@
 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);
@@ -119,6 +120,23 @@ export class AgentController {
   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,

src/controllers/walletController.ts

@@ -61,6 +61,14 @@ export class WalletController {
 
       const paymentReference = `wallet_${userId}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 
+      // Paystack callback should point to backend endpoint, which then redirects to frontend
+      // For Hugging Face Spaces: https://nexusbert-zurri.hf.space/api/wallet/callback
+      // For local: http://localhost:7860/api/wallet/callback
+      const backendUrl = process.env.PAYSTACK_CALLBACK_URL 
+        || (process.env.HF_SPACE_ID || process.env.SPACE_ID 
+          ? `https://nexusbert-zurri.hf.space/api/wallet/callback`
+          : `${process.env.API_BASE_URL || process.env.BACKEND_URL || 'http://localhost:7860'}/api/wallet/callback`);
+
       const paymentData = await getPaystackService().initializeTransaction({
         email: user.email,
         amount: Math.round(amount * 100),
@@ -71,7 +79,7 @@ export class WalletController {
           amountInNaira: amount,
           amountInDollars: amountInDollars,
         },
-        callback_url: process.env.PAYSTACK_CALLBACK_URL || `${process.env.FRONTEND_URL || 'http://localhost:3000'}/payment/callback`,
+        callback_url: backendUrl,
       });
 
       // Return payment info for frontend

src/docs/swagger.ts

@@ -198,6 +198,51 @@ export const swaggerSpec = swaggerJSDoc({
             },
           },
         },
+        User: {
+          type: 'object',
+          properties: {
+            id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'User ID',
+            },
+            email: {
+              type: 'string',
+              format: 'email',
+              description: 'User email address',
+            },
+            name: {
+              type: 'string',
+              nullable: true,
+              description: 'User display name',
+            },
+            isAdmin: {
+              type: 'boolean',
+              default: false,
+              description: 'Whether user has admin privileges',
+            },
+            isCreator: {
+              type: 'boolean',
+              default: false,
+              description: 'Whether user can create and manage agents',
+            },
+            isActive: {
+              type: 'boolean',
+              default: true,
+              description: 'Whether user account is active',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'date-time',
+              description: 'Account creation timestamp',
+            },
+            updatedAt: {
+              type: 'string',
+              format: 'date-time',
+              description: 'Last update timestamp',
+            },
+          },
+        },
       },
     },
     security: [{ bearerAuth: [] }],

src/routes/agentRoutes.ts

@@ -107,6 +107,28 @@ router.get('/', optionalAuth, agentController.listAgents.bind(agentController));
 // Specific routes must come BEFORE /:id to avoid route conflicts
 // These routes are matched first to prevent conflicts with /:id
 
+/**
+ * @swagger
+ * /agents/new:
+ *   get:
+ *     summary: Get agent creation form info (frontend route)
+ *     tags: [Agents]
+ *     description: This endpoint exists to prevent /new from being caught by /:id route
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: Agent creation info
+ */
+router.get('/new', authenticate, (req, res) => {
+  res.json({ 
+    message: 'Use POST /api/agents to create an agent',
+    requiresCreator: true,
+    endpoint: '/api/agents',
+    method: 'POST',
+  });
+});
+
 /**
  * @swagger
  * /agents/my/list:

src/routes/authRoutes.ts

@@ -134,15 +134,16 @@ router.post('/register', authLimiter, async (req: Request, res: Response) => {
       { expiresIn: '7d' }
     );
 
-    res.status(201).json({
-      token,
-      user: {
-        id: savedUser.id,
-        email: savedUser.email,
-        name: savedUser.name,
-        isAdmin: savedUser.isAdmin,
-      },
-    });
+      res.status(201).json({
+        token,
+        user: {
+          id: savedUser.id,
+          email: savedUser.email,
+          name: savedUser.name,
+          isAdmin: savedUser.isAdmin,
+          isCreator: savedUser.isCreator,
+        },
+      });
   } catch (error) {
     console.error('Register error:', error);
     res.status(500).json({ error: 'Failed to register user' });
@@ -186,17 +187,7 @@ router.post('/register', authLimiter, async (req: Request, res: Response) => {
  *                   type: string
  *                   description: JWT authentication token
  *                 user:
- *                   type: object
- *                   properties:
- *                     id:
- *                       type: string
- *                       format: uuid
- *                     email:
- *                       type: string
- *                     name:
- *                       type: string
- *                     isAdmin:
- *                       type: boolean
+ *                   $ref: '#/components/schemas/User'
  *       401:
  *         description: Invalid credentials
  *       403:
@@ -272,6 +263,7 @@ router.post('/login', authLimiter, async (req: Request, res: Response) => {
         email: user.email,
         name: user.name,
         isAdmin: user.isAdmin,
+        isCreator: user.isCreator,
       },
     });
   } catch (error) {
@@ -336,7 +328,7 @@ router.get('/me', authenticate, async (req: Request, res: Response) => {
     const userId = (req as any).user.id;
     const user = await userRepository.findOne({
       where: { id: userId },
-      select: ['id', 'email', 'name', 'isAdmin', 'createdAt'],
+      select: ['id', 'email', 'name', 'isAdmin', 'isCreator', 'createdAt'],
     });
 
     if (!user) {
@@ -355,6 +347,7 @@ router.get('/me', authenticate, async (req: Request, res: Response) => {
       email: user.email,
       name: user.name,
       isAdmin: user.isAdmin,
+      isCreator: user.isCreator,
       createdAt: user.createdAt,
       wallet: {
         balance: Number(wallet.balance),

src/routes/userRoutes.ts

@@ -1,10 +1,101 @@
-import { Router } from 'express';
+import { Router, Request, Response } from 'express';
 import { authenticate } from '../middlewares/auth';
 import { UserController } from '../controllers/userController';
+import { AppDataSource } from '../config/database';
+import { User } from '../entities/User';
 
 const router = Router();
 const userController = new UserController();
+const userRepository = AppDataSource.getRepository(User);
 
+/**
+ * @swagger
+ * /users/me/history:
+ *   get:
+ *     summary: Get user's chat history across all agents
+ *     tags: [Users]
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: Chat history
+ */
 router.get('/me/history', authenticate, userController.getMyHistory.bind(userController));
 
+/**
+ * @swagger
+ * /users/become-creator:
+ *   post:
+ *     summary: Become a creator (enable agent creation)
+ *     tags: [Users]
+ *     description: |
+ *       Allows a regular user to become a creator and start creating agents.
+ *       This sets the `isCreator` field to `true` in the database, enabling the user to:
+ *       - Create new agent listings
+ *       - Manage their own agents (edit, delete, delist, relist)
+ *       - View creator dashboard and earnings
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: Successfully became a creator
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 message:
+ *                   type: string
+ *                   example: "You are now a creator! You can create and manage agents."
+ *                 user:
+ *                   $ref: '#/components/schemas/User'
+ *       400:
+ *         description: User is already a creator
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 error:
+ *                   type: string
+ *                   example: "You are already a creator"
+ *       401:
+ *         description: Unauthorized - authentication required
+ *       404:
+ *         description: User not found
+ *       500:
+ *         description: Server error
+ */
+router.post('/become-creator', authenticate, async (req: Request, res: Response) => {
+  try {
+    const userId = (req as any).user.id;
+    const user = await userRepository.findOne({ where: { id: userId } });
+
+    if (!user) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+
+    if (user.isCreator) {
+      return res.status(400).json({ error: 'You are already a creator' });
+    }
+
+    user.isCreator = true;
+    await userRepository.save(user);
+
+    res.json({
+      message: 'You are now a creator! You can create and manage agents.',
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        isCreator: user.isCreator,
+        isAdmin: user.isAdmin,
+      },
+    });
+  } catch (error) {
+    console.error('Become creator error:', error);
+    res.status(500).json({ error: 'Failed to become creator' });
+  }
+});
+
 export default router;