@promptbook/cli 0.112.0-99 → 0.113.0-0

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

@@ -0,0 +1,193 @@
+import { JSDOM } from 'jsdom';
+import { assertSafeUrl } from '../assertSafeUrl';
+
+/**
+ * URL-bearing HTML attributes that can appear in standalone chat export markup.
+ *
+ * @private internal constant of chat PDF export sanitization
+ */
+const CHAT_PDF_EXPORT_URL_ATTRIBUTE_NAMES = new Set(['href', 'poster', 'src', 'xlink:href']);
+
+/**
+ * Protocols that cannot make the PDF renderer issue server-side network requests.
+ *
+ * @private internal constant of chat PDF export sanitization
+ */
+const CHAT_PDF_EXPORT_NON_NETWORK_PROTOCOLS = new Set(['about:', 'data:']);
+
+/**
+ * Link-only protocols that are safe to keep on anchors because Playwright does not fetch them while rendering.
+ *
+ * @private internal constant of chat PDF export sanitization
+ */
+const CHAT_PDF_EXPORT_LINK_ONLY_PROTOCOLS = new Set(['mailto:', 'tel:']);
+
+/**
+ * Matches CSS `url(...)` values inside inline styles and style blocks.
+ *
+ * @private internal constant of chat PDF export sanitization
+ */
+const CHAT_PDF_EXPORT_CSS_URL_FUNCTION_REGEX = /url\(\s*(['"]?)(.*?)\1\s*\)/gi;
+
+/**
+ * Parses the generated standalone chat export HTML and removes URL attributes
+ * that would let Chromium reach private or unsupported destinations while
+ * rendering the PDF.
+ *
+ * Markdown message bodies are already sanitized by the shared `renderMarkdown`
+ * DOMPurify pipeline; this pass covers structured export URLs such as avatars,
+ * citations, attachments, and markdown image `src` attributes after HTML
+ * generation.
+ *
+ * @param html - Standalone chat export HTML generated by `buildChatHtml`.
+ * @returns HTML safe to pass into the server-side PDF renderer.
+ *
+ * @private internal utility of the Agents Server chat PDF export route
+ */
+export function sanitizeChatPdfExportHtml(html: string): string {
+    const dom = new JSDOM(html);
+    const { document } = dom.window;
+
+    for (const element of Array.from(document.querySelectorAll('*'))) {
+        sanitizeChatPdfExportElementUrlAttributes(element);
+        sanitizeChatPdfExportStyleAttribute(element);
+    }
+
+    for (const styleElement of Array.from(document.querySelectorAll('style'))) {
+        styleElement.textContent = sanitizeChatPdfExportCssUrls(styleElement.textContent || '');
+    }
+
+    return dom.serialize();
+}
+
+/**
+ * Removes unsafe URL attributes from one element.
+ *
+ * @param element - HTML element to sanitize.
+ *
+ * @private internal helper of `sanitizeChatPdfExportHtml`
+ */
+function sanitizeChatPdfExportElementUrlAttributes(element: Element): void {
+    for (const attributeName of element.getAttributeNames()) {
+        const normalizedAttributeName = attributeName.toLowerCase();
+
+        if (!CHAT_PDF_EXPORT_URL_ATTRIBUTE_NAMES.has(normalizedAttributeName)) {
+            continue;
+        }
+
+        const attributeValue = element.getAttribute(attributeName);
+
+        if (
+            attributeValue !== null &&
+            !isSafeChatPdfExportUrl(attributeValue, isChatPdfExportNetworkRequestAttribute(element, attributeName))
+        ) {
+            element.removeAttribute(attributeName);
+        }
+    }
+}
+
+/**
+ * Removes unsafe CSS `url(...)` values from one inline style attribute.
+ *
+ * @param element - HTML element whose style attribute should be sanitized.
+ *
+ * @private internal helper of `sanitizeChatPdfExportHtml`
+ */
+function sanitizeChatPdfExportStyleAttribute(element: Element): void {
+    const styleValue = element.getAttribute('style');
+
+    if (styleValue === null) {
+        return;
+    }
+
+    element.setAttribute('style', sanitizeChatPdfExportCssUrls(styleValue));
+}
+
+/**
+ * Replaces unsafe CSS `url(...)` functions with `none` so Chromium has no
+ * private/internal resource to request while keeping unrelated inline styles.
+ *
+ * @param cssValue - CSS text from a style attribute or style element.
+ * @returns CSS text without unsafe URL functions.
+ *
+ * @private internal helper of `sanitizeChatPdfExportHtml`
+ */
+function sanitizeChatPdfExportCssUrls(cssValue: string): string {
+    return cssValue.replace(CHAT_PDF_EXPORT_CSS_URL_FUNCTION_REGEX, (rawMatch: string, _quote: string, url: string) => {
+        if (isSafeChatPdfExportUrl(url, true)) {
+            return rawMatch;
+        }
+
+        return 'none';
+    });
+}
+
+/**
+ * Returns whether an attribute value can be kept in the PDF-rendered HTML.
+ *
+ * Absolute HTTP(S) URLs are checked through the Agents Server SSRF guard.
+ * Relative resource URLs are removed because server-side rendering has no
+ * trusted origin for them, while relative anchor links remain useful inside the
+ * PDF table of sources.
+ *
+ * @param rawUrl - Raw attribute or CSS URL value.
+ * @param isNetworkRequestAttribute - Whether Chromium could fetch this value during rendering.
+ * @returns Whether the URL value is safe to keep.
+ *
+ * @private internal helper of `sanitizeChatPdfExportHtml`
+ */
+function isSafeChatPdfExportUrl(rawUrl: string, isNetworkRequestAttribute: boolean): boolean {
+    const trimmedUrl = rawUrl.trim();
+
+    if (trimmedUrl === '' || trimmedUrl.startsWith('#')) {
+        return true;
+    }
+
+    const absoluteUrl = trimmedUrl.startsWith('//') ? `https:${trimmedUrl}` : trimmedUrl;
+    let parsedUrl: URL;
+    try {
+        parsedUrl = new URL(absoluteUrl);
+    } catch {
+        return !isNetworkRequestAttribute;
+    }
+
+    if (parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:') {
+        try {
+            assertSafeUrl(absoluteUrl);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    if (CHAT_PDF_EXPORT_NON_NETWORK_PROTOCOLS.has(parsedUrl.protocol)) {
+        return true;
+    }
+
+    return !isNetworkRequestAttribute && CHAT_PDF_EXPORT_LINK_ONLY_PROTOCOLS.has(parsedUrl.protocol);
+}
+
+/**
+ * Returns whether one URL attribute can trigger a network request during PDF rendering.
+ *
+ * @param element - Element that owns the attribute.
+ * @param attributeName - URL-bearing attribute name.
+ * @returns Whether Chromium may fetch the attribute while rendering.
+ *
+ * @private internal helper of `sanitizeChatPdfExportHtml`
+ */
+function isChatPdfExportNetworkRequestAttribute(element: Element, attributeName: string): boolean {
+    const normalizedAttributeName = attributeName.toLowerCase();
+
+    if (normalizedAttributeName === 'src' || normalizedAttributeName === 'poster') {
+        return true;
+    }
+
+    if (normalizedAttributeName === 'xlink:href') {
+        return true;
+    }
+
+    return normalizedAttributeName === 'href' && element.tagName.toLowerCase() !== 'a';
+}
+
+// Note: [🟢] Code for Agents Server chat PDF export sanitization should never be published into packages that could be imported into browser environment

package/apps/agents-server/src/utils/codeRunnerConfiguration.ts

@@ -37,7 +37,7 @@ export async function readConfiguredCodeRunner(): Promise<ConfiguredCodeRunner>
     >;
 
     return {
-        agent: environmentByKey.PTBK_AGENT || process.env.PTBK_AGENT || 'github-copilot',
+        agent: environmentByKey.PTBK_HARNESS || process.env.PTBK_HARNESS || process.env.PTBK_AGENT || 'github-copilot',
         model: environmentByKey.PTBK_MODEL || process.env.PTBK_MODEL || 'gpt-5.4',
         thinkingLevel: environmentByKey.PTBK_THINKING_LEVEL || process.env.PTBK_THINKING_LEVEL || 'xhigh',
     };

package/apps/agents-server/src/utils/createAdminTerminalRouteHandlers.ts

@@ -0,0 +1,264 @@
+import { NextResponse } from 'next/server';
+import { createInteractiveTerminalEventStream } from './createInteractiveTerminalEventStream';
+import { isUserGlobalAdmin } from './isUserGlobalAdmin';
+import type { InteractiveTerminalSessionSubscriber } from './interactiveTerminalSession';
+
+/**
+ * Minimal browser-safe terminal session shape handled by the shared admin API routes.
+ */
+type AdminTerminalRouteSession = {
+    /**
+     * Whether the terminal process is still active.
+     */
+    readonly isRunning: boolean;
+};
+
+/**
+ * Browser stream callbacks accepted by one admin terminal route.
+ */
+type AdminTerminalRouteSubscriber<TSession extends AdminTerminalRouteSession> = {
+    /**
+     * Called whenever the terminal backend emits output.
+     */
+    readonly onOutput: InteractiveTerminalSessionSubscriber['onOutput'];
+
+    /**
+     * Called once the terminal backend exits.
+     */
+    readonly onExit: (event: { readonly type: 'exit'; readonly snapshot: TSession }) => void;
+};
+
+/**
+ * Terminal backend operations provided by each specific admin terminal.
+ */
+type AdminTerminalRouteBackend<TSession extends AdminTerminalRouteSession> = {
+    /**
+     * Returns the latest session for the terminal purpose.
+     */
+    readonly getLatestSession: (request: Request) => Promise<TSession | null> | TSession | null;
+
+    /**
+     * Looks up one session by id.
+     */
+    readonly getSession: (sessionId: string) => Promise<TSession | null> | TSession | null;
+
+    /**
+     * Starts or reconnects to the terminal session.
+     */
+    readonly startSession: (request: Request) => Promise<TSession> | TSession;
+
+    /**
+     * Sends raw input to the terminal session.
+     */
+    readonly writeSessionInput: (sessionId: string, input: string) => Promise<TSession> | TSession;
+
+    /**
+     * Stops one terminal session.
+     */
+    readonly stopSession: (sessionId: string) => Promise<TSession> | TSession;
+
+    /**
+     * Subscribes one browser stream to live terminal events.
+     */
+    readonly subscribeToSession: (
+        sessionId: string,
+        subscriber: AdminTerminalRouteSubscriber<TSession>,
+    ) => (() => void) | null;
+};
+
+/**
+ * User-facing error messages used by the generated terminal route handlers.
+ */
+type AdminTerminalRouteMessages = {
+    /**
+     * Error used when loading the latest session fails.
+     */
+    readonly loadErrorMessage: string;
+
+    /**
+     * Error used when the stream request omits a session id.
+     */
+    readonly missingStreamSessionIdMessage: string;
+
+    /**
+     * Error used when the requested stream session does not exist.
+     */
+    readonly sessionNotFoundMessage: string;
+
+    /**
+     * Error used when starting a session fails.
+     */
+    readonly startErrorMessage: string;
+
+    /**
+     * Error used when the input request is malformed.
+     */
+    readonly missingInputMessage: string;
+
+    /**
+     * Error used when writing input fails.
+     */
+    readonly sendErrorMessage: string;
+
+    /**
+     * Error used when the stop request omits a session id.
+     */
+    readonly missingStopSessionIdMessage: string;
+
+    /**
+     * Error used when stopping a session fails.
+     */
+    readonly stopErrorMessage: string;
+};
+
+/**
+ * Generated Next.js route handlers for one admin terminal endpoint.
+ */
+type AdminTerminalRouteHandlers = {
+    /**
+     * Loads the latest terminal session or streams a specific session.
+     */
+    readonly GET: (request: Request) => Promise<Response>;
+
+    /**
+     * Starts or reconnects to the terminal session.
+     */
+    readonly POST: (request: Request) => Promise<Response>;
+
+    /**
+     * Sends raw input to a running terminal session.
+     */
+    readonly PATCH: (request: Request) => Promise<Response>;
+
+    /**
+     * Stops one terminal session.
+     */
+    readonly DELETE: (request: Request) => Promise<Response>;
+};
+
+/**
+ * Creates consistent admin terminal API handlers for GET/stream, POST, PATCH, and DELETE.
+ *
+ * @param backend - Terminal-specific backend operations.
+ * @param messages - Terminal-specific error messages.
+ * @returns Next.js route handlers ready to export from an API route.
+ */
+export function createAdminTerminalRouteHandlers<TSession extends AdminTerminalRouteSession>(
+    backend: AdminTerminalRouteBackend<TSession>,
+    messages: AdminTerminalRouteMessages,
+): AdminTerminalRouteHandlers {
+    return {
+        async GET(request: Request): Promise<Response> {
+            if (!(await isUserGlobalAdmin())) {
+                return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+            }
+
+            try {
+                const { searchParams } = new URL(request.url);
+                const sessionId = searchParams.get('sessionId')?.trim() || '';
+                const isStreamRequested = searchParams.get('stream') === '1';
+
+                if (isStreamRequested) {
+                    if (!sessionId) {
+                        return NextResponse.json({ error: messages.missingStreamSessionIdMessage }, { status: 400 });
+                    }
+
+                    const session = await backend.getSession(sessionId);
+                    if (!session) {
+                        return NextResponse.json({ error: messages.sessionNotFoundMessage }, { status: 404 });
+                    }
+
+                    return createInteractiveTerminalEventStream(
+                        request,
+                        sessionId,
+                        session,
+                        backend.subscribeToSession,
+                    );
+                }
+
+                return NextResponse.json({
+                    session: await backend.getLatestSession(request),
+                });
+            } catch (error) {
+                return createAdminTerminalErrorResponse(error, messages.loadErrorMessage);
+            }
+        },
+
+        async POST(request: Request): Promise<Response> {
+            if (!(await isUserGlobalAdmin())) {
+                return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+            }
+
+            try {
+                return NextResponse.json({
+                    session: await backend.startSession(request),
+                });
+            } catch (error) {
+                return createAdminTerminalErrorResponse(error, messages.startErrorMessage);
+            }
+        },
+
+        async PATCH(request: Request): Promise<Response> {
+            if (!(await isUserGlobalAdmin())) {
+                return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+            }
+
+            try {
+                const body = (await request.json().catch(() => null)) as
+                    | {
+                          readonly sessionId?: string;
+                          readonly input?: string;
+                      }
+                    | null;
+
+                if (!body?.sessionId || typeof body.input !== 'string') {
+                    return NextResponse.json({ error: messages.missingInputMessage }, { status: 400 });
+                }
+
+                return NextResponse.json({
+                    session: await backend.writeSessionInput(body.sessionId, body.input),
+                });
+            } catch (error) {
+                return createAdminTerminalErrorResponse(error, messages.sendErrorMessage);
+            }
+        },
+
+        async DELETE(request: Request): Promise<Response> {
+            if (!(await isUserGlobalAdmin())) {
+                return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+            }
+
+            try {
+                const body = (await request.json().catch(() => null)) as
+                    | {
+                          readonly sessionId?: string;
+                      }
+                    | null;
+
+                if (!body?.sessionId) {
+                    return NextResponse.json({ error: messages.missingStopSessionIdMessage }, { status: 400 });
+                }
+
+                return NextResponse.json({
+                    session: await backend.stopSession(body.sessionId),
+                });
+            } catch (error) {
+                return createAdminTerminalErrorResponse(error, messages.stopErrorMessage);
+            }
+        },
+    };
+}
+
+/**
+ * Converts one thrown backend failure into a consistent JSON error response.
+ *
+ * @param error - Thrown backend error.
+ * @param fallbackMessage - Message used when the thrown value is not an `Error`.
+ * @returns JSON error response.
+ */
+function createAdminTerminalErrorResponse(error: unknown, fallbackMessage: string): Response {
+    return NextResponse.json(
+        { error: error instanceof Error ? error.message : fallbackMessage },
+        { status: 500 },
+    );
+}

package/apps/agents-server/src/utils/createAgentWithDefaultVisibility.ts

@@ -1,6 +1,7 @@
 import type { AgentBasicInformation, AgentCollection, string_book } from '@promptbook-local/types';
 import type { CreateAgentInput } from '../../../../src/collection/agent-collection/CreateAgentInput';
 import { assignAgentOwner } from './agentOwnership';
+import { parseAgentSourceVisibility } from './agentVisibility';
 import { getDefaultAgentVisibility } from './getDefaultAgentVisibility';
 
 /**
@@ -27,7 +28,8 @@ export async function createAgentWithDefaultVisibility(
     options: CreateAgentWithDefaultVisibilityOptions = {},
 ): Promise<AgentBasicInformation & Required<Pick<AgentBasicInformation, 'permanentId'>>> {
     const { userId, ...createOptions } = options;
-    const visibility = options.visibility ?? (await getDefaultAgentVisibility());
+    const sourceVisibility = parseAgentSourceVisibility(agentSource, { isStrict: true });
+    const visibility = options.visibility ?? sourceVisibility ?? (await getDefaultAgentVisibility());
 
     const createdAgent = await collection.createAgent(agentSource, {
         ...createOptions,

package/apps/agents-server/src/utils/currentUserIdentity.ts

@@ -16,15 +16,20 @@ const GENERATED_USER_PASSWORD_HASH_PLACEHOLDER = 'auto-generated-user';
 const ENV_ADMIN_PASSWORD_HASH_PLACEHOLDER = 'env-admin-managed';
 
 /**
- * Database row shape for the `User` table.
+ * User row shape needed for request identity resolution.
  */
-type UserRow = AgentsServerDatabase['public']['Tables']['User']['Row'];
+type UserIdentityRow = Pick<AgentsServerDatabase['public']['Tables']['User']['Row'], 'id' | 'username' | 'isAdmin'>;
 
 /**
  * Database insert shape for the `User` table.
  */
 type UserInsert = AgentsServerDatabase['public']['Tables']['User']['Insert'];
 
+/**
+ * Supabase projection for user fields needed by request identity resolution.
+ */
+const USER_IDENTITY_SELECT_COLUMNS = 'id, username, isAdmin';
+
 /**
  * Identity resolved for the current request, including database user id.
  */
@@ -109,7 +114,11 @@ export async function ensureChatHistoryIdentity(): Promise<boolean> {
 /**
  * Attempts to find an existing user row by username and creates one when missing.
  */
-async function findOrCreateUserRow(username: string, isAdmin: boolean, passwordHash: string): Promise<UserRow> {
+async function findOrCreateUserRow(
+    username: string,
+    isAdmin: boolean,
+    passwordHash: string,
+): Promise<UserIdentityRow> {
     const existing = await findUserRowByUsername(username);
     if (existing) {
         return existing;
@@ -154,22 +163,26 @@ function isDuplicateUsernameCreateError(error: unknown): boolean {
 /**
  * Finds one user row by its username.
  */
-async function findUserRowByUsername(username: string): Promise<UserRow | null> {
+async function findUserRowByUsername(username: string): Promise<UserIdentityRow | null> {
     const supabase = $provideSupabaseForServer();
     const tableName = await $getTableName('User');
-    const { data, error } = await supabase.from(tableName).select('*').eq('username', username).maybeSingle();
+    const { data, error } = await supabase
+        .from(tableName)
+        .select(USER_IDENTITY_SELECT_COLUMNS)
+        .eq('username', username)
+        .maybeSingle();
 
     if (error) {
         throw new Error(`Failed to resolve user "${username}": ${error.message}`);
     }
 
-    return (data as UserRow | null) || null;
+    return (data as UserIdentityRow | null) || null;
 }
 
 /**
  * Inserts a new user row for the provided username.
  */
-async function insertUserRow(payload: UserInsert): Promise<UserRow> {
+async function insertUserRow(payload: UserInsert): Promise<UserIdentityRow> {
     const supabase = $provideSupabaseForServer();
     const tableName = await $getTableName('User');
     const now = new Date().toISOString();
@@ -180,7 +193,7 @@ async function insertUserRow(payload: UserInsert): Promise<UserRow> {
             createdAt: payload.createdAt ?? now,
             updatedAt: payload.updatedAt ?? now,
         })
-        .select('*')
+        .select(USER_IDENTITY_SELECT_COLUMNS)
         .maybeSingle();
 
     if (error) {
@@ -195,5 +208,5 @@ async function insertUserRow(payload: UserInsert): Promise<UserRow> {
         throw new Error(`Failed to insert user "${payload.username}".`);
     }
 
-    return data as UserRow;
+    return data as UserIdentityRow;
 }