@promptbook/cli 0.104.0-1 → 0.104.0-3

package/apps/agents-server/next.config.ts

@@ -2,8 +2,8 @@ import type { NextConfig } from 'next';
 import path from 'path';
 
 const nextConfig: NextConfig = {
-    output: 'standalone',
-    // <- TODO: [🐱‍🚀][🧠] How to propperly build Next.js app
+    // output: 'standalone',
+    // <- TODO: [🐱‍🚀][🧠] How to propperly build Next.js app, for both Vercel and Doceker?
 
     experimental: {
         externalDir: true,

package/apps/agents-server/package.json

@@ -1,12 +1,16 @@
 {
     "name": "promptbook-agents-server",
     "scripts": {
-        "migrate-database": "npx tsx src/database/migrate.ts",
+        "migrate-database": "npx tsx ./src/database/migrate.ts",
+        "generate-reserved-paths": "ts-node ./scripts/generate-reserved-paths/generate-reserved-paths.ts",
+        "prebuild": "npm run generate-reserved-paths",
+        "predev": "npm run generate-reserved-paths",
         "dev": "(npx kill-port 4440 || true) && next dev -p 4440",
-        "test-build": "npm run build",
+        "test": "npm run lint && npm run test-build",
+        "test-build": "(npx kill-port 4440 || true) && next build",
         "build": "(npx kill-port 4440 || true) && next build",
         "start": "next start -p 4440",
-        "lint": "next lint",
+        "lint": "next lint --max-warnings=0",
         "postinstall": "cd ../../ && npm ci"
     }
 }

package/apps/agents-server/public/swagger.json

@@ -0,0 +1,115 @@
+{
+    "openapi": "3.0.0",
+    "info": {
+        "title": "Agents Server API",
+        "version": "1.0.0",
+        "description": "API documentation for the Agents Server"
+    },
+    "servers": [
+        {
+            "url": "/",
+            "description": "Current Server"
+        }
+    ],
+    "paths": {
+        "/api/agents": {
+            "get": {
+                "summary": "List all agents",
+                "tags": ["Agents"],
+                "responses": {
+                    "200": {
+                        "description": "A list of agents",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "name": { "type": "string" },
+                                            "title": { "type": "string" },
+                                            "description": { "type": "string" }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/api/chat": {
+            "post": {
+                "summary": "Chat with an agent",
+                "tags": ["Chat"],
+                "requestBody": {
+                    "required": true,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "agentName": { "type": "string" },
+                                    "message": { "type": "string" }
+                                }
+                            }
+                        }
+                    }
+                },
+                "responses": {
+                    "200": {
+                        "description": "Chat response"
+                    }
+                }
+            }
+        },
+        "/api/agents/{agentName}": {
+            "get": {
+                "summary": "Get agent details",
+                "tags": ["Agents"],
+                "parameters": [
+                    {
+                        "name": "agentName",
+                        "in": "path",
+                        "required": true,
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "Agent details"
+                    }
+                }
+            }
+        },
+        "/api/upload": {
+            "post": {
+                "summary": "Upload a file",
+                "tags": ["Upload"],
+                "requestBody": {
+                    "content": {
+                        "multipart/form-data": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "file": {
+                                        "type": "string",
+                                        "format": "binary"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                "responses": {
+                    "200": {
+                        "description": "File uploaded"
+                    }
+                }
+            }
+        }
+    },
+    "--0": "<- TODO: !!!! Generate this file dynamically from the codebase of the Agents server app"
+}

package/apps/agents-server/scripts/generate-reserved-paths/generate-reserved-paths.ts

@@ -0,0 +1,54 @@
+import fs from 'fs';
+import path from 'path';
+import { GENERATOR_WARNING } from '../../../../src/config';
+
+const appDir = path.join(__dirname, '..', '..', 'src', 'app');
+const publicDir = path.join(__dirname, '..', '..', 'public');
+const outputFile = path.join(__dirname, '..', '..', 'src', 'generated', 'reservedPaths.ts');
+
+// Read the app directory
+const appEntries = fs.readdirSync(appDir, { withFileTypes: true });
+
+// Filter to get only directories (excluding dynamic routes like [agentName])
+const reservedPaths = appEntries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .filter((name) => !name.startsWith('[') && !name.endsWith(']'));
+
+// Read the public directory (files and folders)
+const publicEntries = fs.readdirSync(publicDir, { withFileTypes: true });
+const publicPaths = publicEntries.map((entry) => entry.name).filter((name) => !name.startsWith('.'));
+
+// Add additional paths that are not in app or public but should be reserved
+const additionalPaths = [
+    '_next', // Next.js internal paths
+    'manifest.webmanifest', // PWA manifest
+];
+
+const allReservedPaths = [...new Set([...reservedPaths, ...publicPaths, ...additionalPaths])].sort();
+
+// Generate the TypeScript file
+const content = `/**
+ * Reserved paths that should not be treated as agent names.
+ * This file is auto-generated by scripts/generate-reserved-paths.js
+ *
+ * ${GENERATOR_WARNING}
+ *
+ * @see /apps/agents-server/src/app - source directory for routes
+ * @see /apps/agents-server/public - source directory for static files
+ * @see /apps/agents-server/src/middleware.ts - where this is used
+ */
+export const RESERVED_PATHS: readonly string[] = ${JSON.stringify(allReservedPaths, null, 4)} as const;
+`;
+
+// Ensure the generated directory exists
+const generatedDir = path.dirname(outputFile);
+if (!fs.existsSync(generatedDir)) {
+    fs.mkdirSync(generatedDir, { recursive: true });
+}
+
+// Write the file
+fs.writeFileSync(outputFile, content, 'utf-8');
+
+console.log(`Generated ${outputFile} with ${allReservedPaths.length} reserved paths:`);
+console.log(allReservedPaths.join(', '));

package/apps/agents-server/scripts/generate-reserved-paths/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "commonjs",
+        "downlevelIteration": true,
+        "allowJs": true,
+        "moduleResolution": "node",
+        "forceConsistentCasingInFileNames": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "experimentalDecorators": true,
+        "noUnusedLocals": false,
+        "resolveJsonModule": true,
+        "esModuleInterop": true
+    },
+    "exclude": ["node_modules"]
+}

package/apps/agents-server/src/app/AddAgentButton.tsx

@@ -11,10 +11,10 @@ export function AddAgentButton() {
 
     const handleAddAgent = async () => {
         setIsLoading(true);
-        const agentName = await $createAgentAction();
+        const { /*agentName,*/ permanentId } = await $createAgentAction();
         // TODO: Add proper error handling and UI feedback
-        if (agentName) {
-            router.push(`/agents/${agentName}`);
+        if (permanentId) {
+            router.push(`/agents/${permanentId}`);
         } else {
             router.refresh();
             setIsLoading(false);

package/apps/agents-server/src/app/actions.ts

@@ -1,16 +1,16 @@
 'use server';
 
 import { $generateBookBoilerplate } from '@promptbook-local/core';
-import { string_agent_name } from '@promptbook-local/types';
+import { string_agent_name, string_book } from '@promptbook-local/types';
 import { revalidatePath } from 'next/cache';
-import { cookies } from 'next/headers';
+import { string_agent_permanent_id } from '../../../../src/types/typeAliases';
 import { getMetadata } from '../database/getMetadata';
 import { $provideAgentCollectionForServer } from '../tools/$provideAgentCollectionForServer';
 import { authenticateUser } from '../utils/authenticateUser';
 import { isUserAdmin } from '../utils/isUserAdmin';
 import { clearSession, setSession } from '../utils/session';
 
-export async function $createAgentAction(): Promise<string_agent_name> {
+export async function $createAgentAction(): Promise<{ agentName: string_agent_name; permanentId: string_agent_permanent_id }> {
     // TODO: [👹] Check permissions here
     if (!(await isUserAdmin())) {
         throw new Error('You are not authorized to create agents');
@@ -20,9 +20,21 @@ export async function $createAgentAction(): Promise<string_agent_name> {
     const namePool = (await getMetadata('NAME_POOL')) || 'ENGLISH';
     const agentSource = $generateBookBoilerplate({ namePool });
 
-    const { agentName } = await collection.createAgent(agentSource);
+    const { agentName, permanentId } = await collection.createAgent(agentSource);
 
-    return agentName;
+    return { agentName, permanentId };
+}
+
+export async function $createAgentFromBookAction(bookContent: string_book): Promise<{ agentName: string_agent_name; permanentId: string_agent_permanent_id }> {
+    // TODO: [👹] Check permissions here
+    if (!(await isUserAdmin())) {
+        throw new Error('You are not authorized to create agents');
+    }
+
+    const collection = await $provideAgentCollectionForServer();
+    const { agentName, permanentId } = await collection.createAgent(bookContent);
+
+    return { agentName, permanentId };
 }
 
 export async function loginAction(formData: FormData) {