@promptbook/cli 0.113.0-0 → 0.113.0-10

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

@@ -0,0 +1,179 @@
+import type { Page } from 'playwright';
+import { $provideBrowserForServer } from '../tools/$provideBrowserForServer';
+import type { PagePreviewBrowserViewport } from './pagePreviewBrowserSessions';
+import {
+    attachPagePreviewBrowserSessionPage,
+    finishPagePreviewBrowserSession,
+    markPagePreviewBrowserSessionFrame,
+} from './pagePreviewBrowserSessions';
+
+/**
+ * Boundary used for MJPEG page-preview streams.
+ *
+ * @private internal constant of Agents Server page-preview streaming
+ */
+const PAGE_PREVIEW_STREAM_BOUNDARY = 'pagepreviewboundary';
+
+/**
+ * Width of the live browser preview viewport.
+ *
+ * @private internal constant of Agents Server page-preview streaming
+ */
+const PAGE_PREVIEW_VIEWPORT_WIDTH = 1280;
+
+/**
+ * Height of the live browser preview viewport.
+ *
+ * @private internal constant of Agents Server page-preview streaming
+ */
+const PAGE_PREVIEW_VIEWPORT_HEIGHT = 800;
+
+/**
+ * Milliseconds between streamed browser frames.
+ *
+ * @private internal constant of Agents Server page-preview streaming
+ */
+const PAGE_PREVIEW_FRAME_INTERVAL_MS = 350;
+
+/**
+ * JPEG quality used by the live browser preview stream.
+ *
+ * @private internal constant of Agents Server page-preview streaming
+ */
+const PAGE_PREVIEW_JPEG_QUALITY = 60;
+
+/**
+ * Navigation timeout for one page-preview browser stream.
+ *
+ * @private internal constant of Agents Server page-preview streaming
+ */
+const PAGE_PREVIEW_NAVIGATION_TIMEOUT_MS = 30_000;
+
+/**
+ * Response content type for the live page-preview stream.
+ *
+ * @private internal constant of Agents Server page-preview streaming
+ */
+export const PAGE_PREVIEW_STREAM_CONTENT_TYPE = `multipart/x-mixed-replace; boundary=${PAGE_PREVIEW_STREAM_BOUNDARY}`;
+
+/**
+ * Options used when creating one live browser preview stream.
+ *
+ * @private internal type of Agents Server page-preview streaming
+ */
+export type CreatePagePreviewBrowserStreamOptions = {
+    readonly request: Request;
+    readonly sessionId: string;
+    readonly url: string;
+};
+
+/**
+ * Creates a Playwright-backed MJPEG stream for one page-preview browser session.
+ *
+ * @param options - Stream options.
+ * @returns Readable multipart stream.
+ */
+export function createPagePreviewBrowserStream(options: CreatePagePreviewBrowserStreamOptions): ReadableStream<Uint8Array> {
+    const encoder = new TextEncoder();
+    const viewport: PagePreviewBrowserViewport = {
+        width: PAGE_PREVIEW_VIEWPORT_WIDTH,
+        height: PAGE_PREVIEW_VIEWPORT_HEIGHT,
+    };
+
+    return new ReadableStream<Uint8Array>({
+        async start(controller) {
+            let isStreamOpen = true;
+            let page: Page | null = null;
+
+            const closeStream = async (): Promise<void> => {
+                if (!isStreamOpen) {
+                    return;
+                }
+
+                isStreamOpen = false;
+                finishPagePreviewBrowserSession(options.sessionId);
+                await page?.close().catch(() => undefined);
+
+                try {
+                    controller.close();
+                } catch {
+                    // The browser may close the stream first when the modal is dismissed.
+                }
+            };
+
+            options.request.signal.addEventListener(
+                'abort',
+                () => {
+                    void closeStream();
+                },
+                { once: true },
+            );
+
+            try {
+                const browserContext = await $provideBrowserForServer({ sessionId: options.sessionId });
+                page = await browserContext.newPage();
+                attachPagePreviewBrowserSessionPage(options.sessionId, page, viewport);
+
+                await page.setViewportSize(viewport);
+                await page.goto(options.url, {
+                    waitUntil: 'domcontentloaded',
+                    timeout: PAGE_PREVIEW_NAVIGATION_TIMEOUT_MS,
+                });
+
+                while (isStreamOpen && !options.request.signal.aborted) {
+                    const buffer = await page.screenshot({
+                        type: 'jpeg',
+                        quality: PAGE_PREVIEW_JPEG_QUALITY,
+                    });
+                    const header = createPagePreviewFrameHeader(buffer.byteLength);
+
+                    controller.enqueue(encoder.encode(header));
+                    controller.enqueue(buffer);
+                    markPagePreviewBrowserSessionFrame(options.sessionId);
+                    await waitForNextPagePreviewFrame(options.request.signal);
+                }
+            } catch (error) {
+                if (!options.request.signal.aborted) {
+                    console.error('[page-preview] live browser stream failed', error);
+                    controller.error(error);
+                }
+            } finally {
+                await closeStream();
+            }
+        },
+    });
+}
+
+/**
+ * Creates one multipart frame header.
+ *
+ * @param byteLength - JPEG payload length.
+ * @returns Multipart frame header.
+ */
+function createPagePreviewFrameHeader(byteLength: number): string {
+    return `\r\n--${PAGE_PREVIEW_STREAM_BOUNDARY}\r\nContent-Type: image/jpeg\r\nContent-Length: ${byteLength}\r\n\r\n`;
+}
+
+/**
+ * Waits before sending the next stream frame, resolving early on abort.
+ *
+ * @param signal - Request abort signal.
+ */
+function waitForNextPagePreviewFrame(signal: AbortSignal): Promise<void> {
+    if (signal.aborted) {
+        return Promise.resolve();
+    }
+
+    return new Promise((resolve) => {
+        const timeout = setTimeout(resolve, PAGE_PREVIEW_FRAME_INTERVAL_MS);
+
+        signal.addEventListener(
+            'abort',
+            () => {
+                clearTimeout(timeout);
+                resolve();
+            },
+            { once: true },
+        );
+    });
+}

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

@@ -1,13 +1,30 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
-import type { AgentBasicInformation, string_book } from '../../../../src/_packages/types.index';
+import type {
+    AgentBasicInformation,
+    string_agent_permanent_id,
+    string_agent_url,
+    string_book,
+} from '../../../../src/_packages/types.index';
+import type { AgentReferenceResolver } from '../../../../src/book-2.0/agent-source/AgentReferenceResolver';
 import type { AgentCollection } from '../../../../src/collection/agent-collection/AgentCollection';
+import { DEFAULT_MAX_RECURSION } from '../../../../src/config';
+import { NotFoundError } from '../../../../src/errors/NotFoundError';
+import { ParseError } from '../../../../src/errors/ParseError';
+import { spaceTrim } from '../../../../src/utils/organization/spaceTrim';
 import { normalizeDomainForMatching } from '../../../../src/utils/validators/url/normalizeDomainForMatching';
 import type { FederatedAgentImportConfiguration } from '../constants/federatedAgentImport';
 import { createServerAgentReferenceResolver } from './agentReferenceResolver/createServerAgentReferenceResolver';
 import { loadFederatedAgentImportConfiguration } from './federatedAgentImportConfiguration';
 import { getFederatedServers } from './getFederatedServers';
 import { getWellKnownAgentUrl } from './getWellKnownAgentUrl';
-import { resolveInheritedAgentSource } from './resolveInheritedAgentSource';
+import {
+    createLocalAgentUrl,
+    normalizeLocalAgentUrlReferences,
+    normalizeLocalServerUrls,
+    resolveLocalAgentRouteReference,
+} from './localAgentRouteReferences';
+import { createMissingImportedAgentFallback } from './createMissingImportedAgentFallback';
+import { resolveInheritedAgentSource, type AgentSourceImporter } from './resolveInheritedAgentSource';
 import { createServerPublicUrl, type ServerRecord } from './serverRegistry';
 
 /**
@@ -111,11 +128,6 @@ type CustomDomainAgentRow = {
     readonly agentSource: string;
 };
 
-/**
- * Minimal agent identity row used to initialize compact-reference resolution.
- */
-type CustomDomainAgentReferenceRow = Pick<CustomDomainAgentRow, 'agentName' | 'permanentId'>;
-
 /**
  * Minimal resolved metadata needed for custom-domain matching.
  */
@@ -127,7 +139,20 @@ type ResolvedCustomDomainMetadata = Pick<AgentBasicInformation, 'links' | 'meta'
  * @param agents - Stored server-owned agents.
  * @returns Lightweight collection compatible with the resolver initialization step.
  */
-function createResolverAgentCollection(agents: ReadonlyArray<CustomDomainAgentReferenceRow>): AgentCollection {
+function createResolverAgentCollection(agents: ReadonlyArray<CustomDomainAgentRow>): AgentCollection {
+    const resolveAgent = (agentNameOrPermanentId: string): CustomDomainAgentRow => {
+        const agent = agents.find(
+            (candidate) =>
+                candidate.agentName === agentNameOrPermanentId || candidate.permanentId === agentNameOrPermanentId,
+        );
+
+        if (!agent) {
+            throw new NotFoundError(`Agent with name or id "${agentNameOrPermanentId}" not found`);
+        }
+
+        return agent;
+    };
+
     return {
         async listAgents() {
             return agents.map(
@@ -147,6 +172,13 @@ function createResolverAgentCollection(agents: ReadonlyArray<CustomDomainAgentRe
                     } satisfies AgentBasicInformation),
             );
         },
+        async getAgentPermanentId(agentNameOrPermanentId: string) {
+            const agent = resolveAgent(agentNameOrPermanentId);
+            return (agent.permanentId || agent.agentName) as string_agent_permanent_id;
+        },
+        async getAgentSource(agentNameOrPermanentId: string) {
+            return resolveAgent(agentNameOrPermanentId).agentSource as string_book;
+        },
     } as unknown as AgentCollection;
 }
 
@@ -181,6 +213,108 @@ function createCanonicalLocalAgentUrl(agent: CustomDomainAgentRow, localServerUr
     return `${localServerUrl.replace(/\/+$/g, '')}/agents/${encodeURIComponent(canonicalAgentIdentifier)}`;
 }
 
+/**
+ * Creates an Edge-safe local importer for custom-domain metadata resolution.
+ *
+ * @param options - Local collection and inheritance dependencies.
+ * @returns Local source importer for route-level agent URLs.
+ */
+function createCustomDomainLocalAgentSourceImporter(options: {
+    readonly collection: Pick<AgentCollection, 'getAgentPermanentId' | 'getAgentSource'>;
+    readonly localServerUrl: string;
+    readonly adamAgentUrl: string_agent_url;
+    readonly agentReferenceResolver: AgentReferenceResolver;
+    readonly federatedAgentImportConfiguration: FederatedAgentImportConfiguration;
+}): AgentSourceImporter {
+    const localServerUrls = normalizeLocalServerUrls([options.localServerUrl]);
+    const localAgentUrlReferences = normalizeLocalAgentUrlReferences([options.adamAgentUrl]);
+    const agentSourceImporter: AgentSourceImporter = async (agentUrl, context) => {
+        const localRouteReference = resolveLocalAgentRouteReference(agentUrl, localServerUrls, localAgentUrlReferences);
+
+        if (!localRouteReference) {
+            return null;
+        }
+
+        const nextRecursionLevel = (context.importAgentOptions.recursionLevel || 0) + 1;
+        assertCustomDomainLocalImportRecursionLevel(nextRecursionLevel, agentUrl);
+
+        let agentPermanentId: string_agent_permanent_id;
+        let unresolvedAgentSource: string_book;
+
+        try {
+            agentPermanentId = await options.collection.getAgentPermanentId(localRouteReference.agentIdentifier);
+            unresolvedAgentSource = await options.collection.getAgentSource(agentPermanentId);
+        } catch (error) {
+            if (error instanceof NotFoundError) {
+                return createMissingImportedAgentFallback(agentUrl, 1, error);
+            }
+
+            throw error;
+        }
+
+        const resolvedAgentName = readAgentSourceTitle(unresolvedAgentSource) || localRouteReference.agentIdentifier;
+        const canonicalAgentUrl = createLocalAgentUrl(localRouteReference.localServerUrl, agentPermanentId);
+
+        return resolveInheritedAgentSource(unresolvedAgentSource, {
+            adamAgentUrl: options.adamAgentUrl,
+            recursionLevel: nextRecursionLevel,
+            inheritancePath: context.importAgentOptions.inheritancePath,
+            currentAgentUrl: canonicalAgentUrl,
+            currentAgentAliases: [
+                canonicalAgentUrl,
+                createLocalAgentUrl(localRouteReference.localServerUrl, localRouteReference.agentIdentifier),
+                createLocalAgentUrl(localRouteReference.localServerUrl, resolvedAgentName),
+            ].filter((value, index, values): value is string_agent_url => values.indexOf(value) === index),
+            agentReferenceResolver: options.agentReferenceResolver,
+            federatedAgentImportConfiguration:
+                options.federatedAgentImportConfiguration || context.federatedAgentImportConfiguration,
+            agentSourceImporter,
+        });
+    };
+
+    return agentSourceImporter;
+}
+
+/**
+ * Reads the first non-empty title line from one book source.
+ *
+ * @param agentSource - Agent book source.
+ * @returns Title or `null` when the source has no title line.
+ */
+function readAgentSourceTitle(agentSource: string_book): string | null {
+    for (const line of agentSource.split(/\r?\n/)) {
+        const title = line.trim();
+
+        if (title) {
+            return title;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Throws when direct local importing would exceed the configured recursion limit.
+ *
+ * @param recursionLevel - Next recursion level.
+ * @param agentUrl - Local agent URL being imported.
+ */
+function assertCustomDomainLocalImportRecursionLevel(recursionLevel: number, agentUrl: string_agent_url): void {
+    if (recursionLevel <= DEFAULT_MAX_RECURSION) {
+        return;
+    }
+
+    throw new ParseError(
+        spaceTrim(
+            (block) => `
+                Recursion depth ${recursionLevel} exceeds maximum allowed ${DEFAULT_MAX_RECURSION} while importing local custom-domain agent:
+
+                ${block(agentUrl)}
+            `,
+        ),
+    );
+}
+
 /**
  * Parses only the resolved custom-domain metadata used by proxy routing.
  *
@@ -254,6 +388,7 @@ async function resolveCustomDomainMetadataForAgent(
         readonly adamAgentUrl: string;
         readonly agentReferenceResolver: Awaited<ReturnType<typeof createServerAgentReferenceResolver>>;
         readonly federatedAgentImportConfiguration: FederatedAgentImportConfiguration;
+        readonly agentSourceImporter: AgentSourceImporter;
     },
 ): Promise<ResolvedCustomDomainMetadata> {
     const resolvedAgentSource = await resolveInheritedAgentSource(agent.agentSource as string_book, {
@@ -261,6 +396,7 @@ async function resolveCustomDomainMetadataForAgent(
         currentAgentUrl: createCanonicalLocalAgentUrl(agent, options.localServerUrl),
         agentReferenceResolver: options.agentReferenceResolver,
         federatedAgentImportConfiguration: options.federatedAgentImportConfiguration,
+        agentSourceImporter: options.agentSourceImporter,
     });
 
     return parseResolvedCustomDomainMetadata(resolvedAgentSource);
@@ -309,7 +445,7 @@ export async function resolveCustomDomainAgent(
 
             const { data: resolverReferenceAgents, error: resolverReferenceError } = await supabase
                 .from(tableName)
-                .select('agentName, permanentId')
+                .select('agentName, permanentId, agentSource')
                 .is('deletedAt', null);
 
             if (resolverReferenceError || !Array.isArray(resolverReferenceAgents)) {
@@ -317,13 +453,21 @@ export async function resolveCustomDomainAgent(
             }
 
             const localServerUrl = createServerPublicUrl(server.domain).href;
+            const agentCollection = createResolverAgentCollection(
+                resolverReferenceAgents as Array<CustomDomainAgentRow>,
+            );
             const agentReferenceResolver = await createServerAgentReferenceResolver({
-                agentCollection: createResolverAgentCollection(
-                    resolverReferenceAgents as Array<CustomDomainAgentReferenceRow>,
-                ),
+                agentCollection,
                 localServerUrl,
                 federatedServers,
             });
+            const agentSourceImporter = createCustomDomainLocalAgentSourceImporter({
+                collection: agentCollection,
+                localServerUrl,
+                adamAgentUrl,
+                agentReferenceResolver,
+                federatedAgentImportConfiguration,
+            });
 
             let matchedAgent: CustomDomainAgentRow | undefined;
 
@@ -333,6 +477,7 @@ export async function resolveCustomDomainAgent(
                     adamAgentUrl,
                     agentReferenceResolver,
                     federatedAgentImportConfiguration,
+                    agentSourceImporter,
                 });
 
                 if (matchesResolvedCustomDomain(resolvedMetadata, candidates)) {

package/apps/agents-server/src/utils/externalChatRunner/processExternalUserChatJob.ts

@@ -7,7 +7,6 @@ import { getUserChat } from '../userChat/getUserChat';
 import { getUserChatJobById } from '../userChat/getUserChatJobById';
 import { persistUserChatJobTerminalState } from '../userChat/persistUserChatJobTerminalState';
 import { provideUserChatJobTable } from '../userChat/provideUserChatJobTable';
-import { createUserChatRunnerProgressCard } from '../userChat/createUserChatRunnerProgressCard';
 import { updateUserChatAssistantMessage } from '../userChat/updateUserChatAssistantMessage';
 import type { UserChatJobRecord } from '../userChat/UserChatJobRecord';
 import type { UserChatJobRow } from '../userChat/UserChatJobRow';
@@ -15,6 +14,7 @@ import {
     createUserChatRunnerThreadMessages,
     resolvePromptThreadBeforeUserMessage,
 } from '../userChat/userChatMessageLifecycle';
+import { runWithTaskTerminalCapture } from '../taskTerminal/runWithTaskTerminalCapture';
 import {
     EXTERNAL_USER_CHAT_JOB_ANSWER_TIMEOUT_MS,
     EXTERNAL_USER_CHAT_JOB_PROVIDER,
@@ -53,6 +53,15 @@ export type ProcessExternalUserChatJobResult = {
  * Processes one UserChatJob through the git-backed external runner contract.
  */
 export async function processExternalUserChatJob(job: UserChatJobRecord): Promise<ProcessExternalUserChatJobResult> {
+    return await runWithTaskTerminalCapture(job.id, () => processExternalUserChatJobWithinTerminalCapture(job));
+}
+
+/**
+ * Processes one external job while its console output is mirrored into the task terminal log.
+ */
+async function processExternalUserChatJobWithinTerminalCapture(
+    job: UserChatJobRecord,
+): Promise<ProcessExternalUserChatJobResult> {
     try {
         if (job.status === 'COMPLETED' || job.status === 'CANCELLED') {
             return { didMutate: false, outcome: 'ignored' };
@@ -153,7 +162,7 @@ async function enqueueExternalUserChatJob(job: UserChatJobRecord): Promise<Proce
         return { didMutate: false, outcome: 'waiting' };
     }
 
-    const threadMessages = createUserChatRunnerThreadMessages({
+    const threadMessages = await createUserChatRunnerThreadMessages({
         messages: chat.messages,
         userMessageId: job.userMessageId,
         resolveInitialAgentMessage: () => parseAgentSource(agentSourceSnapshot.agentSource).initialMessage,
@@ -189,10 +198,7 @@ async function enqueueExternalUserChatJob(job: UserChatJobRecord): Promise<Proce
             isComplete: false,
             lifecycleState: 'running',
             lifecycleError: undefined,
-            progressCard: createUserChatRunnerProgressCard({
-                runnerKind: 'external',
-                phase: 'queued_for_runner',
-            }),
+            progressCard: undefined,
         }),
     });
 

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/GetAdminChatTasksData.ts

@@ -0,0 +1,12 @@
+import type { AdminChatTaskCounters, AdminChatTaskRecord } from '../../chatTasksAdmin';
+
+/**
+ * Loaded admin chat-task data before the final response envelope is assembled.
+ *
+ * @private type of `getAdminChatTasks`
+ */
+export type GetAdminChatTasksData = {
+    items: Array<AdminChatTaskRecord>;
+    counters: AdminChatTaskCounters;
+    total: number;
+};