@promptbook/cli 0.103.0-10 → 0.103.0-100

package/apps/agents-server/src/app/api/chat-history/route.ts

@@ -0,0 +1,147 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { $getTableName } from '../../../database/$getTableName';
+import { $provideSupabase } from '../../../database/$provideSupabase';
+import { isUserAdmin } from '../../../utils/isUserAdmin';
+
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
+
+type SortField = 'createdAt' | 'agentName' | 'id';
+type SortOrder = 'asc' | 'desc';
+
+function parsePositiveInt(value: string | null, fallback: number): number {
+    if (!value) return fallback;
+    const parsed = parseInt(value, 10);
+    if (Number.isNaN(parsed) || parsed <= 0) return fallback;
+    return parsed;
+}
+
+function parseSortField(value: string | null): SortField {
+    if (value === 'agentName' || value === 'id') return value;
+    return 'createdAt';
+}
+
+function parseSortOrder(value: string | null): SortOrder {
+    return value === 'asc' ? 'asc' : 'desc';
+}
+
+/**
+ * List chat history with filters, search and pagination.
+ *
+ * Query params:
+ * - page: number (1-based)
+ * - pageSize: number (items per page)
+ * - agentName: filter by agent name
+ * - search: free-text search across agentName, url and ip
+ * - sortBy: createdAt | agentName | id (default: createdAt)
+ * - sortOrder: asc | desc (default: desc)
+ */
+export async function GET(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const searchParams = request.nextUrl.searchParams;
+
+        const page = parsePositiveInt(searchParams.get('page'), 1);
+        const pageSize = Math.min(
+            MAX_PAGE_SIZE,
+            parsePositiveInt(searchParams.get('pageSize'), DEFAULT_PAGE_SIZE),
+        );
+        const agentName = searchParams.get('agentName');
+        const search = searchParams.get('search')?.trim() || '';
+        const sortBy = parseSortField(searchParams.get('sortBy'));
+        const sortOrder = parseSortOrder(searchParams.get('sortOrder'));
+
+        const supabase = $provideSupabase();
+        const table = await $getTableName('ChatHistory');
+
+        let query = supabase
+            .from(table)
+            .select('*', { count: 'exact' });
+
+        if (agentName) {
+            query = query.eq('agentName', agentName);
+        }
+
+        if (search) {
+            // Note: We intentionally limit search to simple text columns
+            // to keep the query portable and efficient.
+            //
+            // This searches across:
+            // - agentName
+            // - url
+            // - ip
+            const escaped = search.replace(/%/g, '\\%').replace(/_/g, '\\_');
+            query = query.or(
+                `agentName.ilike.%${escaped}%,url.ilike.%${escaped}%,ip.ilike.%${escaped}%`,
+            );
+        }
+
+        query = query.order(sortBy, { ascending: sortOrder === 'asc' });
+
+        const from = (page - 1) * pageSize;
+        const to = from + pageSize - 1;
+
+        query = query.range(from, to);
+
+        const { data, error, count } = await query;
+
+        if (error) {
+            console.error('List chat history error:', error);
+            return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+        }
+
+        return NextResponse.json({
+            items: data ?? [],
+            total: count ?? 0,
+            page,
+            pageSize,
+            sortBy,
+            sortOrder,
+        });
+    } catch (error) {
+        console.error('List chat history error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}
+
+/**
+ * Delete chat history for a specific agent.
+ *
+ * Query params:
+ * - agentName: name of the agent whose history should be removed
+ */
+export async function DELETE(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const searchParams = request.nextUrl.searchParams;
+    const agentName = searchParams.get('agentName');
+
+    if (!agentName) {
+        return NextResponse.json({ error: 'agentName is required' }, { status: 400 });
+    }
+
+    try {
+        const supabase = $provideSupabase();
+        const table = await $getTableName('ChatHistory');
+
+        const { error } = await supabase
+            .from(table)
+            .delete()
+            .eq('agentName', agentName);
+
+        if (error) {
+            console.error('Clear chat history error:', error);
+            return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+        }
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error('Clear chat history error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/api/chat-streaming/route.ts

@@ -0,0 +1,48 @@
+import { OpenAI } from 'openai';
+import { forTime } from 'waitasecond';
+
+export async function GET(request: Request) {
+    const { searchParams } = new URL(request.url);
+    const message = searchParams.get('message') || 'Hello, who are you?';
+
+    const openaiClient = new OpenAI({
+        apiKey: process.env.OPENAI_API_KEY,
+    });
+
+    // Enable streaming from OpenAI
+    const stream = await openaiClient.chat.completions.create({
+        model: 'gpt-3.5-turbo',
+        messages: [
+            { role: 'system', content: 'You are a helpful assistant.' },
+            { role: 'user', content: message },
+        ],
+        stream: true,
+    });
+
+    // Create a ReadableStream to send chunks to the client as they arrive
+    const readableStream = new ReadableStream({
+        async start(controller) {
+            for await (const chunk of stream) {
+                // Each chunk contains a delta message
+                const content = chunk.choices[0]?.delta?.content;
+                if (content) {
+                    controller.enqueue(new TextEncoder().encode(content));
+                }
+            }
+
+            await forTime(100);
+            controller.enqueue(new TextEncoder().encode('\n\n[DONE]'));
+
+            controller.close();
+        },
+    });
+
+    return new Response(readableStream, {
+        status: 200,
+        headers: { 'Content-Type': 'text/markdown' },
+    });
+}
+
+/**
+ * Note: [🐚] This is how streaming is implemented correctly
+ */

package/apps/agents-server/src/app/api/embed.js/route.ts

@@ -0,0 +1,93 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(request: NextRequest) {
+    const protocol = request.nextUrl.protocol;
+    const host = request.nextUrl.host;
+    const baseUrl = `${protocol}//${host}`;
+
+    const script = `
+(function() {
+    if (customElements.get('promptbook-agent')) {
+        return;
+    }
+
+    class PromptbookAgentElement extends HTMLElement {
+        constructor() {
+            super();
+            this.iframe = null;
+        }
+
+        static get observedAttributes() {
+            return ['agent-url'];
+        }
+
+        connectedCallback() {
+            this.render();
+            window.addEventListener('message', this.handleMessage.bind(this));
+        }
+
+        disconnectedCallback() {
+            window.removeEventListener('message', this.handleMessage.bind(this));
+        }
+
+        attributeChangedCallback(name, oldValue, newValue) {
+            if (name === 'agent-url' && oldValue !== newValue) {
+                this.render();
+            }
+        }
+
+        handleMessage(event) {
+            if (event.data && event.data.type === 'PROMPTBOOK_AGENT_RESIZE') {
+                if (event.data.isOpen) {
+                    this.iframe.style.width = '450px';
+                    this.iframe.style.height = '650px';
+                    this.iframe.style.maxHeight = '90vh';
+                    this.iframe.style.maxWidth = '90vw';
+                    this.iframe.style.boxShadow = '0 4px 12px rgba(0,0,0,0.15)';
+                    this.iframe.style.borderRadius = '12px';
+                } else {
+                    this.iframe.style.width = '60px';
+                    this.iframe.style.height = '60px';
+                    this.iframe.style.boxShadow = 'none';
+                    this.iframe.style.borderRadius = '0';
+                }
+            }
+        }
+
+        render() {
+            const agentUrl = this.getAttribute('agent-url');
+            if (!agentUrl) return;
+
+            if (!this.iframe) {
+                this.attachShadow({ mode: 'open' });
+                this.iframe = document.createElement('iframe');
+                this.iframe.style.border = 'none';
+                this.iframe.style.position = 'fixed';
+                this.iframe.style.bottom = '20px';
+                this.iframe.style.right = '20px';
+                this.iframe.style.width = '60px';
+                this.iframe.style.height = '60px';
+                this.iframe.style.zIndex = '2147483647'; // Max z-index
+                this.iframe.style.transition = 'width 0.3s ease, height 0.3s ease';
+                this.iframe.style.backgroundColor = 'transparent';
+                this.iframe.setAttribute('allow', 'microphone'); // Allow microphone if needed for voice
+                this.shadowRoot.appendChild(this.iframe);
+            }
+
+            // Construct embed URL pointing to the Next.js page we created
+            const embedUrl = '${baseUrl}/embed?agentUrl=' + encodeURIComponent(agentUrl);
+            this.iframe.src = embedUrl;
+        }
+    }
+
+    customElements.define('promptbook-agent', PromptbookAgentElement);
+})();
+    `;
+
+    return new NextResponse(script, {
+        headers: {
+            'Content-Type': 'application/javascript',
+            'Access-Control-Allow-Origin': '*',
+        },
+    });
+}

package/apps/agents-server/src/app/api/federated-agents/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server';
+import { getFederatedServersFromMetadata } from '../../../utils/getFederatedServersFromMetadata';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+    try {
+        const federatedServers = await getFederatedServersFromMetadata();
+
+        return NextResponse.json({
+            federatedServers,
+        });
+    } catch (error) {
+        console.error('Error fetching federated servers:', error);
+        return NextResponse.json({ error: 'Failed to fetch federated servers' }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/api/long-running-task/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from 'next/server';
+import { getLongRunningTask } from '../../../deamons/longRunningTask';
+
+export function GET() {
+    const task = getLongRunningTask();
+    return NextResponse.json(task);
+}

package/apps/agents-server/src/app/api/long-streaming/route.ts

@@ -0,0 +1,20 @@
+import { forTime } from 'waitasecond';
+import { just } from '../../../../../../src/utils/organization/just';
+
+export async function GET() {
+    const readableStream = new ReadableStream({
+        async start(controller) {
+            while (just(true)) {
+                await forTime(100);
+                controller.enqueue(new TextEncoder().encode('x'));
+            }
+
+            controller.close();
+        },
+    });
+
+    return new Response(readableStream, {
+        status: 200,
+        headers: { 'Content-Type': 'text/plain' },
+    });
+}

package/apps/agents-server/src/app/api/metadata/route.ts

@@ -0,0 +1,116 @@
+import { $getTableName } from '../../../database/$getTableName';
+import { $provideSupabase } from '../../../database/$provideSupabase';
+import { isUserAdmin } from '../../../utils/isUserAdmin';
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const supabase = $provideSupabase();
+    const table = await $getTableName('Metadata');
+
+    const { data, error } = await supabase.from(table).select('*').order('key');
+
+    if (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+
+    return NextResponse.json(data);
+}
+
+export async function POST(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const body = await request.json();
+        const { key, value, note } = body;
+
+        if (!key || !value) {
+            return NextResponse.json({ error: 'Key and value are required' }, { status: 400 });
+        }
+
+        const supabase = $provideSupabase();
+        const table = await $getTableName('Metadata');
+
+        const { data, error } = await supabase
+            .from(table)
+            .insert({ key, value, note })
+            .select()
+            .single();
+
+        if (error) {
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+
+        return NextResponse.json(data);
+    } catch (e) {
+        return NextResponse.json({ error: 'Invalid request body' }, { status: 400 });
+    }
+}
+
+export async function PUT(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const body = await request.json();
+        const { key, value, note } = body;
+
+        if (!key || !value) {
+            return NextResponse.json({ error: 'Key and value are required' }, { status: 400 });
+        }
+
+        const supabase = $provideSupabase();
+        const table = await $getTableName('Metadata');
+
+        // Using upsert if it exists or update if strict
+        // Since key is unique, upsert works well, but usually PUT implies update.
+        // Let's use update to be safe and explicit about editing existing.
+        // Actually, for editing, we identify by ID or Key.
+        // Let's use Key as identifier since it is unique.
+
+        const { data, error } = await supabase
+            .from(table)
+            .update({ value, note, updatedAt: new Date().toISOString() })
+            .eq('key', key)
+            .select()
+            .single();
+
+        if (error) {
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+
+        return NextResponse.json(data);
+    } catch (e) {
+        return NextResponse.json({ error: 'Invalid request body' }, { status: 400 });
+    }
+}
+
+export async function DELETE(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const searchParams = request.nextUrl.searchParams;
+    const key = searchParams.get('key');
+
+    if (!key) {
+        return NextResponse.json({ error: 'Key is required' }, { status: 400 });
+    }
+
+    const supabase = $provideSupabase();
+    const table = await $getTableName('Metadata');
+
+    const { error } = await supabase.from(table).delete().eq('key', key);
+
+    if (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+
+    return NextResponse.json({ success: true });
+}

package/apps/agents-server/src/app/api/openai/v1/chat/completions/route.ts

@@ -0,0 +1,6 @@
+import { handleChatCompletion } from '@/src/utils/handleChatCompletion';
+import { NextRequest } from 'next/server';
+
+export async function POST(request: NextRequest) {
+    return handleChatCompletion(request, {}, 'OpenAI API Chat Completion (Global)');
+}

package/apps/agents-server/src/app/api/openai/v1/models/route.ts

@@ -0,0 +1,65 @@
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { validateApiKey } from '@/src/utils/validateApiKey';
+import { NextRequest, NextResponse } from 'next/server';
+
+/**
+ * GET /api/openai/v1/models
+ *
+ * Lists all available agents as models for the OpenAI-compatible API.
+ */
+export async function GET(request: NextRequest) {
+    // Validate API key explicitly (in addition to middleware)
+    const apiKeyValidation = await validateApiKey(request);
+    if (!apiKeyValidation.isValid) {
+        return NextResponse.json(
+            {
+                error: {
+                    message: apiKeyValidation.error || 'Invalid API key',
+                    type: 'authentication_error',
+                },
+            },
+            { status: 401 },
+        );
+    }
+
+    try {
+        const collection = await $provideAgentCollectionForServer();
+        const agentNames = await collection.listAgents();
+
+        const models = agentNames.map((agentName) => ({
+            id: agentName,
+            object: 'model',
+            created: Math.floor(Date.now() / 1000), // We don't have creation date readily available in listAgents
+            owned_by: 'promptbook',
+            permission: [
+                {
+                    id: `modelperm-${agentName}`,
+                    object: 'model_permission',
+                    created: Math.floor(Date.now() / 1000),
+                    allow_create_engine: false,
+                    allow_sampling: true,
+                    allow_logprobs: false,
+                    allow_search_indices: false,
+                    allow_view: true,
+                    allow_fine_tuning: false,
+                    organization: '*',
+                    group: null,
+                    is_blocking: false,
+                },
+            ],
+            root: agentName,
+            parent: null,
+        }));
+
+        return NextResponse.json({
+            object: 'list',
+            data: models,
+        });
+    } catch (error) {
+        console.error('Error in models listing handler:', error);
+        return NextResponse.json(
+            { error: { message: (error as Error).message || 'Internal Server Error', type: 'server_error' } },
+            { status: 500 },
+        );
+    }
+}

package/apps/agents-server/src/app/api/upload/route.ts

@@ -0,0 +1,83 @@
+import { nextRequestToNodeRequest } from '@/src/utils/cdn/utils/nextRequestToNodeRequest';
+import { TODO_any } from '@promptbook-local/types';
+import { serializeError } from '@promptbook-local/utils';
+import formidable from 'formidable';
+import { readFile } from 'fs/promises';
+import { NextRequest, NextResponse } from 'next/server';
+import { forTime } from 'waitasecond';
+import { assertsError } from '../../../../../../src/errors/assertsError';
+import { string_url } from '../../../../../../src/types/typeAliases';
+import { keepUnused } from '../../../../../../src/utils/organization/keepUnused';
+import { $provideCdnForServer } from '../../../../src/tools/$provideCdnForServer';
+import { getUserFileCdnKey } from '../../../../src/utils/cdn/utils/getUserFileCdnKey';
+import { validateMimeType } from '../../../../src/utils/validators/validateMimeType';
+import { getMetadata } from '../../../database/getMetadata';
+
+export async function POST(request: NextRequest) {
+    try {
+        await forTime(1);
+        // await forTime(5000);
+
+        const nodeRequest = await nextRequestToNodeRequest(request);
+        let maxFileSizeMb = Number((await getMetadata('MAX_FILE_UPLOAD_SIZE_MB')) || '50'); // <- TODO: [🌲] To /config.ts
+
+        if (Number.isNaN(maxFileSizeMb)) {
+            maxFileSizeMb = 50; // <- TODO: [🌲] To /config.ts
+        }
+
+        const maxFileSize = maxFileSizeMb * 1024 * 1024;
+
+        const files = await new Promise<formidable.Files>((resolve, reject) => {
+            const form = formidable({ maxFileSize });
+            form.parse(nodeRequest as TODO_any, (error, fields, files) => {
+                keepUnused(fields);
+
+                if (error) {
+                    return reject(error);
+                }
+                resolve(files);
+            });
+        });
+
+        const uploadedFiles = files.file;
+
+        if (!uploadedFiles || uploadedFiles.length !== 1) {
+            return NextResponse.json(
+                { message: 'In form data there is not EXACTLY one "file" field' },
+                { status: 400 },
+            );
+        }
+
+        const uploadedFile = uploadedFiles[0]!;
+        const fileBuffer = await readFile(uploadedFile.filepath);
+        const cdn = $provideCdnForServer();
+        const key = getUserFileCdnKey(fileBuffer, uploadedFile.originalFilename || uploadedFile.newFilename);
+
+        await cdn.setItem(key, {
+            type: validateMimeType(uploadedFile.mimetype),
+            data: fileBuffer,
+        });
+
+        const fileUrl = cdn.getItemUrl(key);
+
+        return NextResponse.json({ fileUrl: fileUrl.href as string_url }, { status: 201 });
+    } catch (error) {
+        assertsError(error);
+
+        console.error(error);
+
+        return new Response(
+            JSON.stringify(
+                serializeError(error),
+                // <- TODO: [🐱‍🚀] Rename `serializeError` to `errorToJson`
+                null,
+                4,
+                // <- TODO: [🐱‍🚀] Allow to configure pretty print for agent server
+            ),
+            {
+                status: 400, // <- TODO: [🐱‍🚀] Make `errorToHttpStatusCode`
+                headers: { 'Content-Type': 'application/json' },
+            },
+        );
+    }
+}

package/apps/agents-server/src/app/api/users/[username]/route.ts

@@ -0,0 +1,75 @@
+import { $getTableName } from '@/src/database/$getTableName';
+import { NextResponse } from 'next/server';
+import { $provideSupabaseForServer } from '../../../../database/$provideSupabaseForServer';
+import { hashPassword } from '../../../../utils/auth';
+import { isUserAdmin } from '../../../../utils/isUserAdmin';
+
+export async function PATCH(request: Request, { params }: { params: Promise<{ username: string }> }) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const { username: usernameParam } = await params;
+        const body = await request.json();
+        const { password, isAdmin } = body;
+
+        const updates: { updatedAt: string; passwordHash?: string; isAdmin?: boolean } = {
+            updatedAt: new Date().toISOString(),
+        };
+
+        if (password) {
+            updates.passwordHash = await hashPassword(password);
+        }
+
+        if (typeof isAdmin === 'boolean') {
+            updates.isAdmin = isAdmin;
+        }
+
+        const supabase = $provideSupabaseForServer();
+        const { data: updatedUser, error } = await supabase
+            .from(await $getTableName('User'))
+            .update(updates)
+            .eq('username', usernameParam)
+            .select('id, username, createdAt, updatedAt, isAdmin')
+            .single();
+
+        if (error) {
+            throw error;
+        }
+
+        if (!updatedUser) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        return NextResponse.json(updatedUser);
+    } catch (error) {
+        console.error('Update user error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}
+
+export async function DELETE(request: Request, { params }: { params: Promise<{ username: string }> }) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const { username: usernameParam } = await params;
+        const supabase = $provideSupabaseForServer();
+
+        const { error } = await supabase
+            .from(await $getTableName('User'))
+            .delete()
+            .eq('username', usernameParam);
+
+        if (error) {
+            throw error;
+        }
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error('Delete user error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}