@promptbook/cli 0.112.0-97 → 0.112.0-99

package/apps/agents-server/src/components/AdminTerminal/useAdminTerminalSession.ts

@@ -0,0 +1,336 @@
+'use client';
+
+import { useCallback, useEffect, useState } from 'react';
+
+/**
+ * Minimal terminal-session shape used by the shared admin terminal hook.
+ */
+export type AdminTerminalSession = {
+    /**
+     * Session identifier.
+     */
+    readonly id: string;
+
+    /**
+     * Whether the terminal process is still running.
+     */
+    readonly isRunning: boolean;
+
+    /**
+     * Buffered terminal output.
+     */
+    readonly output: string;
+
+    /**
+     * ISO timestamp when the session started.
+     */
+    readonly startedAt: string;
+
+    /**
+     * ISO timestamp when the session finished.
+     */
+    readonly finishedAt: string | null;
+
+    /**
+     * Exit code when available.
+     */
+    readonly exitCode: number | null;
+
+    /**
+     * Exit signal when available.
+     */
+    readonly signal: string | null;
+};
+
+/**
+ * Shared API response shape used by the admin terminal routes.
+ */
+type AdminTerminalSessionResponse<TSession extends AdminTerminalSession> = {
+    /**
+     * Loaded or updated session snapshot.
+     */
+    readonly session: TSession | null;
+
+    /**
+     * API error, when the request failed.
+     */
+    readonly error?: string;
+};
+
+/**
+ * Options accepted by the shared admin terminal hook.
+ */
+type UseAdminTerminalSessionOptions = {
+    /**
+     * Base API route used for GET/POST/PATCH/DELETE requests.
+     */
+    readonly basePath: string;
+
+    /**
+     * Fallback error message used when loading the latest session fails.
+     */
+    readonly loadErrorMessage: string;
+
+    /**
+     * Fallback error message used when starting a new session fails.
+     */
+    readonly startErrorMessage: string;
+
+    /**
+     * Fallback error message used when sending input fails.
+     */
+    readonly sendErrorMessage: string;
+
+    /**
+     * Fallback error message used when stopping a session fails.
+     */
+    readonly stopErrorMessage: string;
+
+    /**
+     * Success message shown after starting a new session.
+     */
+    readonly startSuccessMessage: string;
+
+    /**
+     * Success message shown when the process exits with code `0`.
+     */
+    readonly finishSuccessMessage: string;
+
+    /**
+     * Error message shown when the process exits with a non-zero code.
+     */
+    readonly finishErrorMessage: string;
+};
+
+/**
+ * Shared browser hook for admin pages that start, stream, write to, and stop one terminal session.
+ *
+ * @param options - API endpoints and user-facing messages for the terminal.
+ * @returns Session state, status messages, and imperative helpers.
+ */
+export function useAdminTerminalSession<TSession extends AdminTerminalSession>(
+    options: UseAdminTerminalSessionOptions,
+) {
+    const [session, setSession] = useState<TSession | null>(null);
+    const [input, setInput] = useState('');
+    const [isLoadingSession, setIsLoadingSession] = useState(true);
+    const [isStarting, setIsStarting] = useState(false);
+    const [isSending, setIsSending] = useState(false);
+    const [isStopping, setIsStopping] = useState(false);
+    const [errorMessage, setErrorMessage] = useState<string | null>(null);
+    const [successMessage, setSuccessMessage] = useState<string | null>(null);
+
+    /**
+     * Loads the latest session snapshot for the current terminal.
+     */
+    const loadSession = useCallback(async (): Promise<void> => {
+        try {
+            setIsLoadingSession(true);
+            setErrorMessage(null);
+
+            const response = await fetch(options.basePath, { cache: 'no-store' });
+            const payload = (await response.json()) as AdminTerminalSessionResponse<TSession>;
+
+            if (!response.ok) {
+                throw new Error(payload.error || options.loadErrorMessage);
+            }
+
+            setSession(payload.session);
+        } catch (error) {
+            setErrorMessage(error instanceof Error ? error.message : options.loadErrorMessage);
+        } finally {
+            setIsLoadingSession(false);
+        }
+    }, [options.basePath, options.loadErrorMessage]);
+
+    useEffect(() => {
+        void loadSession();
+    }, [loadSession]);
+
+    useEffect(() => {
+        const sessionId = session?.id;
+        if (!sessionId) {
+            return;
+        }
+
+        const eventSource = new EventSource(`${options.basePath}?sessionId=${encodeURIComponent(sessionId)}&stream=1`);
+
+        const handleSnapshot = (event: MessageEvent<string>) => {
+            const payload = JSON.parse(event.data) as TSession;
+            setSession(payload);
+        };
+        const handleOutput = (event: MessageEvent<string>) => {
+            const payload = JSON.parse(event.data) as { readonly chunk: string };
+            setSession((currentSession) => {
+                if (!currentSession || currentSession.id !== sessionId) {
+                    return currentSession;
+                }
+
+                return {
+                    ...currentSession,
+                    output: currentSession.output + payload.chunk,
+                };
+            });
+        };
+        const handleExit = (event: MessageEvent<string>) => {
+            const payload = JSON.parse(event.data) as TSession;
+            setSession(payload);
+            setIsStarting(false);
+            setIsSending(false);
+            setIsStopping(false);
+
+            if (payload.exitCode === 0) {
+                setSuccessMessage(options.finishSuccessMessage);
+                setErrorMessage(null);
+            } else {
+                setSuccessMessage(null);
+                setErrorMessage(options.finishErrorMessage);
+            }
+
+            eventSource.close();
+        };
+
+        eventSource.addEventListener('snapshot', handleSnapshot as EventListener);
+        eventSource.addEventListener('output', handleOutput as EventListener);
+        eventSource.addEventListener('exit', handleExit as EventListener);
+        eventSource.onerror = () => {
+            eventSource.close();
+        };
+
+        return () => {
+            eventSource.close();
+        };
+    }, [options.basePath, options.finishErrorMessage, options.finishSuccessMessage, session?.id]);
+
+    /**
+     * Starts or reconnects to the managed terminal session.
+     */
+    const startSession = useCallback(async (): Promise<void> => {
+        try {
+            setIsStarting(true);
+            setErrorMessage(null);
+            setSuccessMessage(null);
+
+            const response = await fetch(options.basePath, { method: 'POST' });
+            const payload = (await response.json()) as AdminTerminalSessionResponse<TSession>;
+
+            if (!response.ok || !payload.session) {
+                throw new Error(payload.error || options.startErrorMessage);
+            }
+
+            setSession(payload.session);
+            setSuccessMessage(options.startSuccessMessage);
+        } catch (error) {
+            setErrorMessage(error instanceof Error ? error.message : options.startErrorMessage);
+        } finally {
+            setIsStarting(false);
+        }
+    }, [options.basePath, options.startErrorMessage, options.startSuccessMessage]);
+
+    /**
+     * Sends one raw input chunk to the running terminal session.
+     *
+     * @param nextInput - Raw text or control characters to write.
+     */
+    const sendInput = useCallback(
+        async (nextInput: string): Promise<void> => {
+            if (!session) {
+                return;
+            }
+
+            try {
+                setIsSending(true);
+                setErrorMessage(null);
+
+                const response = await fetch(options.basePath, {
+                    method: 'PATCH',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        sessionId: session.id,
+                        input: nextInput,
+                    }),
+                });
+                const payload = (await response.json()) as AdminTerminalSessionResponse<TSession>;
+
+                if (!response.ok) {
+                    throw new Error(payload.error || options.sendErrorMessage);
+                }
+
+                if (payload.session) {
+                    setSession(payload.session);
+                }
+            } catch (error) {
+                setErrorMessage(error instanceof Error ? error.message : options.sendErrorMessage);
+            } finally {
+                setIsSending(false);
+            }
+        },
+        [options.basePath, options.sendErrorMessage, session],
+    );
+
+    /**
+     * Stops the active terminal session.
+     */
+    const stopSession = useCallback(async (): Promise<void> => {
+        if (!session) {
+            return;
+        }
+
+        try {
+            setIsStopping(true);
+            setErrorMessage(null);
+
+            const response = await fetch(options.basePath, {
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    sessionId: session.id,
+                }),
+            });
+            const payload = (await response.json()) as AdminTerminalSessionResponse<TSession>;
+
+            if (!response.ok) {
+                throw new Error(payload.error || options.stopErrorMessage);
+            }
+
+            if (payload.session) {
+                setSession(payload.session);
+            }
+        } catch (error) {
+            setErrorMessage(error instanceof Error ? error.message : options.stopErrorMessage);
+        } finally {
+            setIsStopping(false);
+        }
+    }, [options.basePath, options.stopErrorMessage, session]);
+
+    /**
+     * Clears any terminal status messages shown above the panel.
+     */
+    const clearMessages = useCallback((): void => {
+        setErrorMessage(null);
+        setSuccessMessage(null);
+    }, []);
+
+    return {
+        session,
+        input,
+        setInput,
+        isLoadingSession,
+        isStarting,
+        isSending,
+        isStopping,
+        errorMessage,
+        successMessage,
+        setErrorMessage,
+        setSuccessMessage,
+        clearMessages,
+        loadSession,
+        startSession,
+        sendInput,
+        stopSession,
+    };
+}

package/apps/agents-server/src/components/Header/buildHeaderSystemMenuItems.ts

@@ -220,6 +220,10 @@ export function buildHeaderSystemMenuItems({
                       label: translate('header.codeRunners'),
                       href: '/admin/code-runners',
                   } as SubMenuItem,
+                  {
+                      label: translate('header.cliAccess'),
+                      href: '/admin/cli-access',
+                  } as SubMenuItem,
               ]
             : []),
     ];

package/apps/agents-server/src/database/$provideClientSql.ts

@@ -1,5 +1,6 @@
 import { $isRunningInNode } from '@promptbook-local/utils';
-import { $providePostgresPool } from './$providePostgresPool';
+import { Pool } from 'pg';
+import { resolvePostgresConnectionString } from './resolvePostgresConnectionString';
 
 /**
  * SQL tagged-template executor used by server routes and utilities.
@@ -30,6 +31,13 @@ export type ClientSqlExecutor = ClientSql & {
     readonly raw: ClientSqlRaw;
 };
 
+/**
+ * Shared PostgreSQL pool reused across all requests in the server process.
+ *
+ * @private internal singleton of Agents Server database layer
+ */
+let clientPool: Pool | undefined;
+
 /**
  * Provides SQL tagged-template client for server-side PostgreSQL access.
  *
@@ -40,7 +48,12 @@ export async function $provideClientSql(): Promise<ClientSqlExecutor> {
         throw new Error('Function `$provideClientSql` can only be used in Node.js runtime.');
     }
 
-    const clientPool = $providePostgresPool();
+    if (!clientPool) {
+        clientPool = new Pool({
+            connectionString: resolvePostgresConnectionString(),
+            ssl: { rejectUnauthorized: false },
+        });
+    }
 
     const executeTemplate = async <TRow = Array<Record<string, unknown>>>(
         templateStrings: TemplateStringsArray,
@@ -55,7 +68,7 @@ export async function $provideClientSql(): Promise<ClientSqlExecutor> {
         }
 
         const text = textChunks.join('');
-        const result = await clientPool.query(text, [...templateValues]);
+        const result = await clientPool!.query(text, [...templateValues]);
         return result.rows as TRow;
     };
 
@@ -63,7 +76,7 @@ export async function $provideClientSql(): Promise<ClientSqlExecutor> {
         text: string,
         values: ReadonlyArray<unknown> = [],
     ): Promise<TRow> => {
-        const result = await clientPool.query(text, [...values]);
+        const result = await clientPool!.query(text, [...values]);
         return result.rows as TRow;
     };
 

package/apps/agents-server/src/database/$provideDatabaseAdminExecutor.ts

@@ -1,7 +1,7 @@
 import type { StudioBFFSqlLintDetails, StudioBFFSqlLintResult } from '@prisma/studio-core/data/bff';
-import type { Pool, PoolClient } from 'pg';
-import { $providePostgresPool } from './$providePostgresPool';
+import { Pool, type PoolClient } from 'pg';
 import { isAgentsServerSqliteMode } from './agentsServerDatabaseMode';
+import { resolvePostgresConnectionString } from './resolvePostgresConnectionString';
 import {
     $provideAgentsServerSqliteDatabase,
     type AgentsServerSqliteDatabase,
@@ -31,6 +31,11 @@ export type DatabaseAdminExecutor = {
     readonly lintSql: (details: StudioBFFSqlLintDetails) => Promise<StudioBFFSqlLintResult>;
 };
 
+/**
+ * Shared PostgreSQL pool for Embedded Prisma Studio requests.
+ */
+let databaseAdminPostgresPool: Pool | null = null;
+
 /**
  * Provides a raw SQL executor for the configured Agents Server database backend.
  *
@@ -48,7 +53,7 @@ export function $provideDatabaseAdminExecutor(): DatabaseAdminExecutor {
  * @returns PostgreSQL-backed database admin executor.
  */
 function $providePostgresDatabaseAdminExecutor(): DatabaseAdminExecutor {
-    const pool = $providePostgresPool();
+    const pool = $provideDatabaseAdminPostgresPool();
 
     return {
         execute: (query) => executePostgresDatabaseAdminQuery(pool, query),
@@ -77,6 +82,22 @@ function $provideSqliteDatabaseAdminExecutor(): DatabaseAdminExecutor {
     };
 }
 
+/**
+ * Provides the shared PostgreSQL connection pool for raw database admin access.
+ *
+ * @returns Shared PostgreSQL pool.
+ */
+function $provideDatabaseAdminPostgresPool(): Pool {
+    if (!databaseAdminPostgresPool) {
+        databaseAdminPostgresPool = new Pool({
+            connectionString: resolvePostgresConnectionString(),
+            ssl: { rejectUnauthorized: false },
+        });
+    }
+
+    return databaseAdminPostgresPool;
+}
+
 /**
  * Executes one PostgreSQL query for Embedded Prisma Studio.
  *

package/apps/agents-server/src/database/$provideSupabaseForServer.ts

@@ -1,12 +1,9 @@
-import { createRequire } from 'module';
 import { $isRunningInNode } from '@promptbook-local/utils';
 import { createClient, SupabaseClient } from '@supabase/supabase-js';
-import { isAgentsServerPostgresMode, isAgentsServerSqliteMode } from './agentsServerDatabaseMode';
+import { isAgentsServerSqliteMode } from './agentsServerDatabaseMode';
 import { $provideLocalSqliteSupabase } from './sqlite/$provideLocalSqliteSupabase';
 import { AgentsServerDatabase } from './schema';
 
-const requirePostgresSupabase = createRequire(__filename);
-
 /**
  * Internal cache for `$provideSupabaseForServer`
  *
@@ -35,13 +32,6 @@ export function $provideSupabaseForServer(): SupabaseClient<AgentsServerDatabase
         return $provideLocalSqliteSupabase() as SupabaseClient<AgentsServerDatabase>;
     }
 
-    if (isAgentsServerPostgresMode()) {
-        const { $provideLocalPostgresSupabase } = requirePostgresSupabase(
-            './postgres/$provideLocalPostgresSupabase',
-        ) as typeof import('./postgres/$provideLocalPostgresSupabase');
-        return $provideLocalPostgresSupabase() as SupabaseClient<AgentsServerDatabase>;
-    }
-
     if (!supabase) {
         // Create a single supabase client for interacting with your database
         supabase = createClient<AgentsServerDatabase>(

package/apps/agents-server/src/database/agentsServerDatabaseMode.ts

@@ -11,7 +11,7 @@ export const AGENTS_SERVER_SQLITE_PATH_ENV_NAME = 'PTBK_AGENTS_SERVER_SQLITE_PAT
 /**
  * Supported Agents Server database backends.
  */
-export type AgentsServerDatabaseMode = 'supabase' | 'sqlite' | 'postgres';
+export type AgentsServerDatabaseMode = 'supabase' | 'sqlite';
 
 /**
  * Resolves the configured Agents Server database backend.
@@ -23,10 +23,6 @@ export function resolveAgentsServerDatabaseMode(): AgentsServerDatabaseMode {
         return 'sqlite';
     }
 
-    if (rawMode === 'postgres' || rawMode === 'postgresql') {
-        return 'postgres';
-    }
-
     return 'supabase';
 }
 
@@ -36,18 +32,3 @@ export function resolveAgentsServerDatabaseMode(): AgentsServerDatabaseMode {
 export function isAgentsServerSqliteMode(): boolean {
     return resolveAgentsServerDatabaseMode() === 'sqlite';
 }
-
-/**
- * Returns whether the Agents Server is using the standalone PostgreSQL backend.
- */
-export function isAgentsServerPostgresMode(): boolean {
-    return resolveAgentsServerDatabaseMode() === 'postgres';
-}
-
-/**
- * Returns whether the Agents Server is using a standalone local database backend.
- */
-export function isAgentsServerStandaloneMode(): boolean {
-    const databaseMode = resolveAgentsServerDatabaseMode();
-    return databaseMode === 'sqlite' || databaseMode === 'postgres';
-}

package/apps/agents-server/src/languages/ServerTranslationKeys.ts

@@ -146,6 +146,7 @@ export const SERVER_TRANSLATION_KEYS = [
     'header.database',
     'header.logs',
     'header.codeRunners',
+    'header.cliAccess',
     'header.models',
     'header.openApiDocumentation',
     'header.apiTokens',

package/apps/agents-server/src/languages/translations/czech.yaml

@@ -140,6 +140,7 @@ header.update: Aktualizace
 header.database: Databáze
 header.logs: Logy
 header.codeRunners: Code runnery
+header.cliAccess: CLI přístup
 header.models: Modely
 header.openApiDocumentation: Dokumentace OpenAPI
 header.apiTokens: API tokeny

package/apps/agents-server/src/languages/translations/english.yaml

@@ -142,6 +142,7 @@ header.update: Update
 header.database: Database
 header.logs: Logs
 header.codeRunners: Code runners
+header.cliAccess: CLI Access
 header.models: Models
 header.openApiDocumentation: OpenAPI Documentation
 header.apiTokens: API Tokens

package/apps/agents-server/src/tools/$provideServer.ts

@@ -1,7 +1,7 @@
 import { NEXT_PUBLIC_SITE_URL, SUPABASE_TABLE_PREFIX } from '@/config';
 import { headers } from 'next/headers';
 import { cache } from 'react';
-import { isAgentsServerStandaloneMode } from '../database/agentsServerDatabaseMode';
+import { isAgentsServerSqliteMode } from '../database/agentsServerDatabaseMode';
 import { resolveInternalServerOrigin } from '../utils/resolveInternalServerOrigin';
 import { createServerPublicUrl, listRegisteredServersUsingServiceRole } from '../utils/serverRegistry';
 import { resolveServerSelection } from '../utils/serverSelection';
@@ -37,7 +37,7 @@ const getCachedProvidedServer = cache(async (): Promise<ProvidedServer> => {
     const requestHost = headersList.get('host');
     const xPromptbookServer = headersList.get('x-promptbook-server');
 
-    if (isAgentsServerStandaloneMode()) {
+    if (isAgentsServerSqliteMode()) {
         if (isLocalDevelopmentHost(requestHost)) {
             return {
                 id: null,

package/apps/agents-server/src/tools/BrowserConnectionProvider.ts

@@ -410,7 +410,7 @@ export class BrowserConnectionProvider {
         await mkdir(userDataDir, { recursive: true });
 
         const launchOptions: NonNullable<Parameters<typeof chromium.launchPersistentContext>[1]> = {
-            headless: false,
+            headless: true,
             args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
         };
 

package/apps/agents-server/src/utils/chatExport/downloadChatPdfFromServer.ts

@@ -0,0 +1,59 @@
+import type { ChatMessage } from '../../../../../src/book-components/Chat/types/ChatMessage';
+import type { ChatParticipant } from '../../../../../src/book-components/Chat/types/ChatParticipant';
+import { downloadBlob, parseFilenameFromContentDisposition } from '../download/browserFileDownload';
+
+/**
+ * Payload sent to the Agents Server PDF export endpoint.
+ *
+ * @private internal type for `downloadChatPdfFromServer`
+ */
+type DownloadChatPdfFromServerOptions = {
+    readonly title: string;
+    readonly messages: ReadonlyArray<ChatMessage>;
+    readonly participants: ReadonlyArray<ChatParticipant>;
+};
+
+/**
+ * Requests a server-rendered chat PDF and triggers the browser download.
+ *
+ * @param options - Chat export payload.
+ */
+export async function downloadChatPdfFromServer(options: DownloadChatPdfFromServerOptions): Promise<void> {
+    const response = await fetch('/api/chat/export/pdf', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            title: options.title,
+            messages: options.messages,
+            participants: options.participants.map(serializeChatParticipantForExport),
+        }),
+    });
+
+    if (!response.ok) {
+        const payload = (await response.json().catch(() => null)) as { error?: string } | null;
+        throw new Error(payload?.error || 'Failed to export chat as PDF.');
+    }
+
+    const pdfBlob = await response.blob();
+    const filename =
+        parseFilenameFromContentDisposition(response.headers.get('Content-Disposition')) || 'chat-export.pdf';
+
+    downloadBlob(pdfBlob, filename);
+}
+
+/**
+ * Normalizes participant data so the payload stays JSON-safe when custom color helpers are used.
+ *
+ * @param participant - One chat participant.
+ * @returns Serializable participant payload.
+ *
+ * @private helper for `downloadChatPdfFromServer`
+ */
+function serializeChatParticipantForExport(participant: ChatParticipant): ChatParticipant {
+    return {
+        ...participant,
+        color: participant.color ? String(participant.color) : undefined,
+    };
+}

package/apps/agents-server/src/utils/chatExport/renderHtmlToPdfOnServer.ts

@@ -0,0 +1,37 @@
+import { $provideBrowserForServer } from '@/src/tools/$provideBrowserForServer';
+
+/**
+ * Browser viewport used while rendering standalone HTML exports to PDF.
+ */
+const CHAT_EXPORT_PDF_VIEWPORT = {
+    width: 1280,
+    height: 1600,
+} as const;
+
+/**
+ * Prints standalone HTML into a PDF using the shared server-side Chromium instance.
+ *
+ * @param html - Fully rendered standalone HTML document.
+ * @returns PDF bytes ready for an HTTP response.
+ */
+export async function renderHtmlToPdfOnServer(html: string): Promise<Buffer> {
+    const browserContext = await $provideBrowserForServer();
+    const page = await browserContext.newPage();
+
+    try {
+        await page.setViewportSize(CHAT_EXPORT_PDF_VIEWPORT);
+        await page.emulateMedia({ media: 'print' });
+        await page.setContent(html, { waitUntil: 'load' });
+        await page.evaluate(async () => {
+            await document.fonts?.ready;
+        });
+
+        return await page.pdf({
+            format: 'Letter',
+            printBackground: true,
+            preferCSSPageSize: true,
+        });
+    } finally {
+        await page.close();
+    }
+}