@promptbook/cli 0.103.0-9 → 0.104.0-0

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

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { $getTableName } from '../../../../database/$getTableName';
+import { $provideSupabase } from '../../../../database/$provideSupabase';
+import { convertToCsv } from '../../../../utils/convertToCsv';
+import { isUserAdmin } from '../../../../utils/isUserAdmin';
+
+/**
+ * Export chat feedback as CSV.
+ *
+ * Query params:
+ * - agentName: filter by agent name (optional)
+ */
+export async function GET(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const searchParams = request.nextUrl.searchParams;
+        const agentName = searchParams.get('agentName');
+
+        const supabase = $provideSupabase();
+        const table = await $getTableName('ChatFeedback');
+
+        let query = supabase.from(table).select('*');
+
+        if (agentName) {
+            query = query.eq('agentName', agentName);
+        }
+
+        query = query.order('createdAt', { ascending: false });
+
+        const { data, error } = await query;
+
+        if (error) {
+            console.error('Export chat feedback error:', error);
+            return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+        }
+
+        const csv = convertToCsv((data || []) as Record<string, unknown>[]);
+        const filename = agentName
+            ? `chat-feedback-${agentName}-${new Date().toISOString()}.csv`
+            : `chat-feedback-${new Date().toISOString()}.csv`;
+
+        return new NextResponse(csv, {
+            headers: {
+                'Content-Type': 'text/csv',
+                'Content-Disposition': `attachment; filename="${filename}"`,
+            },
+        });
+    } catch (error) {
+        console.error('Export chat feedback error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,157 @@
+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 feedback 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, ip, textRating, userNote and expectedAnswer
+ * - 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('ChatFeedback');
+
+        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
+            // - textRating
+            // - userNote
+            // - expectedAnswer
+            const escaped = search.replace(/%/g, '\\%').replace(/_/g, '\\_');
+            query = query.or(
+                [
+                    `agentName.ilike.%${escaped}%`,
+                    `url.ilike.%${escaped}%`,
+                    `ip.ilike.%${escaped}%`,
+                    `textRating.ilike.%${escaped}%`,
+                    `userNote.ilike.%${escaped}%`,
+                    `expectedAnswer.ilike.%${escaped}%`,
+                ].join(','),
+            );
+        }
+
+        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 feedback 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 feedback error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}
+
+/**
+ * Delete chat feedback for a specific agent.
+ *
+ * Query params:
+ * - agentName: name of the agent whose feedback 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('ChatFeedback');
+
+        const { error } = await supabase
+            .from(table)
+            .delete()
+            .eq('agentName', agentName);
+
+        if (error) {
+            console.error('Clear chat feedback error:', error);
+            return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+        }
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error('Clear chat feedback error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { $getTableName } from '../../../../database/$getTableName';
+import { $provideSupabase } from '../../../../database/$provideSupabase';
+import { isUserAdmin } from '../../../../utils/isUserAdmin';
+
+/**
+ * Delete a single chat history entry by ID.
+ */
+export async function DELETE(request: NextRequest, context: { params: Promise<{ id: string }> }) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const rawId = (await context.params).id;
+    const id = Number.parseInt(rawId, 10);
+
+    if (!Number.isFinite(id) || id <= 0) {
+        return NextResponse.json({ error: 'Invalid id' }, { status: 400 });
+    }
+
+    try {
+        const supabase = $provideSupabase();
+        const table = await $getTableName('ChatHistory');
+
+        const { error } = await supabase.from(table).delete().eq('id', id);
+
+        if (error) {
+            console.error('Delete chat history row error:', error);
+            return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+        }
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error('Delete chat history row error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { $getTableName } from '../../../../database/$getTableName';
+import { $provideSupabase } from '../../../../database/$provideSupabase';
+import { convertToCsv } from '../../../../utils/convertToCsv';
+import { isUserAdmin } from '../../../../utils/isUserAdmin';
+
+/**
+ * Export chat history as CSV.
+ *
+ * Query params:
+ * - agentName: filter by agent name (optional)
+ */
+export async function GET(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const searchParams = request.nextUrl.searchParams;
+        const agentName = searchParams.get('agentName');
+
+        const supabase = $provideSupabase();
+        const table = await $getTableName('ChatHistory');
+
+        let query = supabase.from(table).select('*');
+
+        if (agentName) {
+            query = query.eq('agentName', agentName);
+        }
+
+        query = query.order('createdAt', { ascending: false });
+
+        const { data, error } = await query;
+
+        if (error) {
+            console.error('Export chat history error:', error);
+            return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+        }
+
+        const csv = convertToCsv((data || []) as Record<string, unknown>[]);
+        const filename = agentName
+            ? `chat-history-${agentName}-${new Date().toISOString()}.csv`
+            : `chat-history-${new Date().toISOString()}.csv`;
+
+        return new NextResponse(csv, {
+            headers: {
+                'Content-Type': 'text/csv',
+                'Content-Disposition': `attachment; filename="${filename}"`,
+            },
+        });
+    } catch (error) {
+        console.error('Export chat history error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

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' },
+    });
+}