@promptbook/cli 0.113.0-0 → 0.113.0-1

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

@@ -1,8 +1,17 @@
 import { ensureUserChatTimeoutWorkerBootstrapped } from '@/src/utils/userChatTimeout/ensureUserChatTimeoutWorkerBootstrapped';
-import type { AdminChatTaskListResponse } from './chatTasksAdmin';
+import type { AdminChatTaskCounters, AdminChatTaskListResponse, AdminChatTaskRecord } from './chatTasksAdmin';
 import { getAdminChatTasks } from './getAdminChatTasksResponse/getAdminChatTasks';
-import { parseAdminChatTaskQuery } from './getAdminChatTasksResponse/parseAdminChatTaskQuery';
+import { mapVpsSelfUpdateJobToAdminChatTask } from './getAdminChatTasksResponse/mapVpsSelfUpdateJobToAdminChatTask';
+import { parseAdminChatTaskQuery, type ParsedAdminChatTaskQuery } from './getAdminChatTasksResponse/parseAdminChatTaskQuery';
 import { throttledAdminRecovery } from './getAdminChatTasksResponse/throttledAdminRecovery';
+import { readVpsSelfUpdateJobSnapshot } from './vpsSelfUpdate';
+
+/**
+ * Milliseconds in one hour.
+ *
+ * @private internal constant of `getAdminChatTasksResponse`
+ */
+const HOUR_IN_MILLISECONDS = 60 * 60 * 1000;
 
 /**
  * Successful task-manager response envelope.
@@ -53,13 +62,23 @@ export async function getAdminChatTasksResponse(
     await throttledAdminRecovery();
 
     const adminChatTasks = await getAdminChatTasks(parsedQuery);
+    const vpsSelfUpdateTask = await loadVpsSelfUpdateAdminChatTask();
+    const injectedTasks = collectAdminChatTasksToInject(vpsSelfUpdateTask, parsedQuery);
+    const { items, total } = mergeInjectedAdminChatTasks({
+        databaseItems: adminChatTasks.items,
+        databaseTotal: adminChatTasks.total,
+        injectedTasks,
+        page: parsedQuery.page,
+        pageSize: parsedQuery.pageSize,
+    });
+    const counters = mergeInjectedAdminChatTaskCounters(adminChatTasks.counters, vpsSelfUpdateTask);
 
     return {
         status: 200,
         response: {
-            items: adminChatTasks.items,
-            counters: adminChatTasks.counters,
-            total: adminChatTasks.total,
+            items,
+            counters,
+            total,
             page: parsedQuery.page,
             pageSize: parsedQuery.pageSize,
             view: parsedQuery.view,
@@ -69,3 +88,174 @@ export async function getAdminChatTasksResponse(
         },
     };
 }
+
+/**
+ * Loads the currently persisted standalone VPS self-update task, if any.
+ *
+ * The read is defensive so a corrupt status file cannot block the admin task manager from rendering.
+ *
+ * @returns Injectable task record or `null` when no self-update has ever been triggered on this server.
+ */
+async function loadVpsSelfUpdateAdminChatTask(): Promise<AdminChatTaskRecord | null> {
+    try {
+        const jobSnapshot = await readVpsSelfUpdateJobSnapshot();
+        return mapVpsSelfUpdateJobToAdminChatTask(jobSnapshot);
+    } catch (error) {
+        console.error('[admin-chat-task] failed to load VPS self-update task snapshot', error);
+        return null;
+    }
+}
+
+/**
+ * Filters out injected tasks that do not belong to the requested admin task-manager view or search.
+ *
+ * @param vpsSelfUpdateTask - Currently persisted self-update task or `null`.
+ * @param query - Parsed admin task-manager query.
+ * @returns Tasks to inject on top of the database-backed items.
+ */
+function collectAdminChatTasksToInject(
+    vpsSelfUpdateTask: AdminChatTaskRecord | null,
+    query: ParsedAdminChatTaskQuery,
+): ReadonlyArray<AdminChatTaskRecord> {
+    if (!vpsSelfUpdateTask) {
+        return [];
+    }
+
+    if (!matchesAdminChatTaskView(vpsSelfUpdateTask, query, Date.now())) {
+        return [];
+    }
+
+    if (!matchesAdminChatTaskSearch(vpsSelfUpdateTask, query.search)) {
+        return [];
+    }
+
+    return [vpsSelfUpdateTask];
+}
+
+/**
+ * Prepends the injected task rows to the paginated database items so the self-update stays visible on page 1.
+ *
+ * @param options - Merge inputs.
+ * @returns Merged items for the current page and the updated total row count.
+ */
+function mergeInjectedAdminChatTasks(options: {
+    readonly databaseItems: ReadonlyArray<AdminChatTaskRecord>;
+    readonly databaseTotal: number;
+    readonly injectedTasks: ReadonlyArray<AdminChatTaskRecord>;
+    readonly page: number;
+    readonly pageSize: number;
+}): { items: Array<AdminChatTaskRecord>; total: number } {
+    const total = options.databaseTotal + options.injectedTasks.length;
+
+    if (options.injectedTasks.length === 0) {
+        return { items: [...options.databaseItems], total };
+    }
+
+    if (options.page !== 1) {
+        return { items: [...options.databaseItems], total };
+    }
+
+    const items = [...options.injectedTasks, ...options.databaseItems].slice(0, options.pageSize);
+    return { items, total };
+}
+
+/**
+ * Adds the injected self-update task to the summary counters so the header metrics stay accurate.
+ *
+ * @param databaseCounters - Counters computed from durable database rows.
+ * @param vpsSelfUpdateTask - Currently persisted self-update task or `null`.
+ * @returns Merged counters including the injected task.
+ */
+function mergeInjectedAdminChatTaskCounters(
+    databaseCounters: AdminChatTaskCounters,
+    vpsSelfUpdateTask: AdminChatTaskRecord | null,
+): AdminChatTaskCounters {
+    if (!vpsSelfUpdateTask) {
+        return databaseCounters;
+    }
+
+    const nowTimestamp = Date.now();
+    const isRunning = vpsSelfUpdateTask.status === 'RUNNING';
+    const isFailedInWindow =
+        vpsSelfUpdateTask.status === 'FAILED' &&
+        isIsoTimestampAtOrAfter(vpsSelfUpdateTask.finishedAt, nowTimestamp - 24 * HOUR_IN_MILLISECONDS);
+
+    return {
+        runningCount: databaseCounters.runningCount + (isRunning ? 1 : 0),
+        queuedCount: databaseCounters.queuedCount,
+        failedLast24hCount: databaseCounters.failedLast24hCount + (isFailedInWindow ? 1 : 0),
+        oldestQueuedAgeMs: databaseCounters.oldestQueuedAgeMs,
+    };
+}
+
+/**
+ * Returns whether the injected task belongs in the requested admin task-manager view.
+ *
+ * @param task - Injected task.
+ * @param query - Parsed admin task-manager query.
+ * @param nowTimestamp - Current epoch used for time-window filtering.
+ * @returns `true` when the task should be included.
+ */
+function matchesAdminChatTaskView(
+    task: AdminChatTaskRecord,
+    query: ParsedAdminChatTaskQuery,
+    nowTimestamp: number,
+): boolean {
+    switch (query.view) {
+        case 'running':
+            return task.status === 'RUNNING';
+        case 'queued':
+            return task.status === 'QUEUED';
+        case 'failed':
+            return (
+                task.status === 'FAILED' &&
+                isIsoTimestampAtOrAfter(task.finishedAt, nowTimestamp - 24 * HOUR_IN_MILLISECONDS)
+            );
+        case 'all':
+            return isIsoTimestampAtOrAfter(task.updatedAt, nowTimestamp - query.timeWindowHours * HOUR_IN_MILLISECONDS);
+        case 'active':
+        default:
+            return task.status === 'QUEUED' || task.status === 'RUNNING';
+    }
+}
+
+/**
+ * Returns whether the injected task matches the free-text admin search input.
+ *
+ * @param task - Injected task.
+ * @param search - Trimmed search text from the parsed query.
+ * @returns `true` when the task should be included.
+ */
+function matchesAdminChatTaskSearch(task: AdminChatTaskRecord, search: string): boolean {
+    if (!search) {
+        return true;
+    }
+
+    const normalizedSearch = search.toLowerCase();
+    if (task.id.toLowerCase().includes(normalizedSearch)) {
+        return true;
+    }
+    if (task.agentPermanentId.toLowerCase().includes(normalizedSearch)) {
+        return true;
+    }
+    if ((task.agentName || '').toLowerCase().includes(normalizedSearch)) {
+        return true;
+    }
+    return task.chatId.toLowerCase().includes(normalizedSearch);
+}
+
+/**
+ * Returns whether one ISO timestamp is at or after the given cutoff.
+ *
+ * @param timestampIso - Optional ISO timestamp.
+ * @param cutoffTimestamp - Epoch cutoff in milliseconds.
+ * @returns `true` when the timestamp is at or after the cutoff.
+ */
+function isIsoTimestampAtOrAfter(timestampIso: string | null, cutoffTimestamp: number): boolean {
+    if (!timestampIso) {
+        return false;
+    }
+
+    const timestamp = Date.parse(timestampIso);
+    return Number.isFinite(timestamp) && timestamp >= cutoffTimestamp;
+}

package/apps/agents-server/src/utils/pagePreview/livePagePreviewSessions.ts

@@ -0,0 +1,365 @@
+import type { Page } from 'playwright';
+import { spaceTrim } from 'spacetrim';
+import {
+    LIVE_PAGE_PREVIEW_VIEWPORT_HEIGHT,
+    LIVE_PAGE_PREVIEW_VIEWPORT_WIDTH,
+} from '../../../../../src/book-components/Chat/utils/livePagePreviewConstants';
+import { KnowledgeScrapeError } from '../../../../../src/errors/KnowledgeScrapeError';
+import { $provideBrowserForServer } from '../../tools/$provideBrowserForServer';
+
+/**
+ * Pattern for live-preview session identifiers created by the browser client.
+ */
+const LIVE_PAGE_PREVIEW_SESSION_ID_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;
+
+/**
+ * Navigation timeout for opening a live knowledge preview page.
+ */
+const LIVE_PAGE_PREVIEW_NAVIGATION_TIMEOUT_MS = 30_000;
+
+/**
+ * Playwright action timeout for live-preview interactions.
+ */
+const LIVE_PAGE_PREVIEW_ACTION_TIMEOUT_MS = 5_000;
+
+/**
+ * Idle session lifetime before a stale live-preview page is closed.
+ */
+const LIVE_PAGE_PREVIEW_SESSION_IDLE_TIMEOUT_MS = 60_000;
+
+/**
+ * Multipart response boundary used by the live-preview image stream.
+ */
+const LIVE_PAGE_PREVIEW_STREAM_BOUNDARY = 'page-preview-frame';
+
+/**
+ * Delay between live-preview browser frames.
+ */
+const LIVE_PAGE_PREVIEW_FRAME_INTERVAL_MS = 500;
+
+/**
+ * JPEG quality for live-preview browser frames.
+ */
+const LIVE_PAGE_PREVIEW_JPEG_QUALITY = 65;
+
+/**
+ * Browser page stored for a live knowledge preview session.
+ */
+type LivePagePreviewSession = {
+    readonly page: Page;
+    readonly url: string;
+    lastAccessedAt: number;
+};
+
+/**
+ * Pointer interaction sent from the live preview image to the browser page.
+ */
+type LivePagePreviewClickInteraction = {
+    readonly type: 'click';
+    readonly x: number;
+    readonly y: number;
+};
+
+/**
+ * Wheel interaction sent from the live preview image to the browser page.
+ */
+type LivePagePreviewWheelInteraction = {
+    readonly type: 'wheel';
+    readonly deltaX: number;
+    readonly deltaY: number;
+};
+
+/**
+ * Keyboard interaction sent from the live preview image to the browser page.
+ */
+type LivePagePreviewKeyDownInteraction = {
+    readonly type: 'keyDown';
+    readonly key: string;
+};
+
+/**
+ * Supported interaction payload for a live knowledge preview session.
+ */
+export type LivePagePreviewInteraction =
+    | LivePagePreviewClickInteraction
+    | LivePagePreviewWheelInteraction
+    | LivePagePreviewKeyDownInteraction;
+
+/**
+ * Active browser pages for live knowledge previews.
+ */
+const LIVE_PAGE_PREVIEW_SESSIONS = new Map<string, LivePagePreviewSession>();
+
+/**
+ * Content type for the live-preview multipart image stream.
+ */
+export const LIVE_PAGE_PREVIEW_STREAM_CONTENT_TYPE = `multipart/x-mixed-replace; boundary=${LIVE_PAGE_PREVIEW_STREAM_BOUNDARY}`;
+
+/**
+ * Checks whether a live-preview session identifier is safe to use as a map key.
+ *
+ * @param sessionId - Candidate session identifier.
+ * @returns True when the value is a valid live-preview session id.
+ */
+export function isLivePagePreviewSessionId(sessionId: string): boolean {
+    return LIVE_PAGE_PREVIEW_SESSION_ID_PATTERN.test(sessionId);
+}
+
+/**
+ * Opens or reuses the browser page for one live knowledge preview.
+ *
+ * @param options - Session, target URL, and request cancellation signal.
+ * @returns Playwright page backing the live preview.
+ */
+export async function getOrCreateLivePagePreviewSession(options: {
+    readonly sessionId: string;
+    readonly url: string;
+    readonly signal: AbortSignal;
+}): Promise<Page> {
+    pruneExpiredLivePagePreviewSessions();
+
+    const existingSession = LIVE_PAGE_PREVIEW_SESSIONS.get(options.sessionId);
+    if (existingSession && existingSession.url === options.url && !existingSession.page.isClosed()) {
+        existingSession.lastAccessedAt = Date.now();
+        return existingSession.page;
+    }
+
+    if (existingSession) {
+        await closeLivePagePreviewSession(options.sessionId);
+    }
+
+    const browserContext = await $provideBrowserForServer({
+        signal: options.signal,
+        sessionId: options.sessionId,
+    });
+    const page = await browserContext.newPage();
+
+    try {
+        page.setDefaultNavigationTimeout(LIVE_PAGE_PREVIEW_NAVIGATION_TIMEOUT_MS);
+        page.setDefaultTimeout(LIVE_PAGE_PREVIEW_ACTION_TIMEOUT_MS);
+        await page.setViewportSize({
+            width: LIVE_PAGE_PREVIEW_VIEWPORT_WIDTH,
+            height: LIVE_PAGE_PREVIEW_VIEWPORT_HEIGHT,
+        });
+        await page.goto(options.url, {
+            waitUntil: 'domcontentloaded',
+            timeout: LIVE_PAGE_PREVIEW_NAVIGATION_TIMEOUT_MS,
+        });
+    } catch {
+        await closeLivePagePreviewPage(page);
+        throw new KnowledgeScrapeError(
+            spaceTrim(`
+                Failed to open live knowledge preview for \`${options.url}\`.
+
+                The browser session could not navigate to the requested source.
+            `),
+        );
+    }
+
+    LIVE_PAGE_PREVIEW_SESSIONS.set(options.sessionId, {
+        page,
+        url: options.url,
+        lastAccessedAt: Date.now(),
+    });
+
+    return page;
+}
+
+/**
+ * Closes one live knowledge preview session if it exists.
+ *
+ * @param sessionId - Live-preview session identifier.
+ */
+export async function closeLivePagePreviewSession(sessionId: string): Promise<void> {
+    const existingSession = LIVE_PAGE_PREVIEW_SESSIONS.get(sessionId);
+    if (!existingSession) {
+        return;
+    }
+
+    LIVE_PAGE_PREVIEW_SESSIONS.delete(sessionId);
+    await closeLivePagePreviewPage(existingSession.page);
+}
+
+/**
+ * Creates an MJPEG stream from an active live-preview browser page.
+ *
+ * @param options - Session identifier, browser page, and request cancellation signal.
+ * @returns Readable stream that emits JPEG browser frames until the client disconnects.
+ */
+export function createLivePagePreviewStream(options: {
+    readonly sessionId: string;
+    readonly page: Page;
+    readonly signal: AbortSignal;
+}): ReadableStream<Uint8Array> {
+    const encoder = new TextEncoder();
+    let isStreamClosed = false;
+    let isSessionClosed = false;
+
+    const closeSessionOnce = async (): Promise<void> => {
+        if (isSessionClosed) {
+            return;
+        }
+
+        isSessionClosed = true;
+        await closeLivePagePreviewSession(options.sessionId);
+    };
+
+    return new ReadableStream<Uint8Array>({
+        async start(controller) {
+            const handleAbort = (): void => {
+                isStreamClosed = true;
+                void closeSessionOnce();
+            };
+
+            options.signal.addEventListener('abort', handleAbort, { once: true });
+
+            try {
+                while (!isStreamClosed && !options.signal.aborted && !options.page.isClosed()) {
+                    const buffer = await options.page.screenshot({
+                        type: 'jpeg',
+                        quality: LIVE_PAGE_PREVIEW_JPEG_QUALITY,
+                    });
+
+                    if (isStreamClosed || options.signal.aborted || options.page.isClosed()) {
+                        break;
+                    }
+
+                    const header = [
+                        '',
+                        `--${LIVE_PAGE_PREVIEW_STREAM_BOUNDARY}`,
+                        'Content-Type: image/jpeg',
+                        `Content-Length: ${buffer.length}`,
+                        '',
+                        '',
+                    ].join('\r\n');
+
+                    controller.enqueue(encoder.encode(header));
+                    controller.enqueue(buffer);
+
+                    await waitForLivePagePreviewFrame(options.signal);
+                }
+            } catch (error) {
+                if (!isStreamClosed && !options.signal.aborted) {
+                    console.error('Error streaming live page preview:', error);
+                }
+            } finally {
+                isStreamClosed = true;
+                options.signal.removeEventListener('abort', handleAbort);
+                await closeSessionOnce();
+
+                try {
+                    controller.close();
+                } catch {
+                    // The client can disconnect before the server closes the stream.
+                }
+            }
+        },
+        async cancel() {
+            isStreamClosed = true;
+            await closeSessionOnce();
+        },
+    });
+}
+
+/**
+ * Applies one browser interaction to an active live preview session.
+ *
+ * @param options - Session identifier and normalized interaction.
+ * @returns True when the interaction was applied to an active session.
+ */
+export async function applyLivePagePreviewInteraction(options: {
+    readonly sessionId: string;
+    readonly interaction: LivePagePreviewInteraction;
+}): Promise<boolean> {
+    const session = LIVE_PAGE_PREVIEW_SESSIONS.get(options.sessionId);
+    if (!session || session.page.isClosed()) {
+        LIVE_PAGE_PREVIEW_SESSIONS.delete(options.sessionId);
+        return false;
+    }
+
+    session.lastAccessedAt = Date.now();
+
+    switch (options.interaction.type) {
+        case 'click':
+            await session.page.mouse.click(
+                clampLivePagePreviewCoordinate(options.interaction.x, LIVE_PAGE_PREVIEW_VIEWPORT_WIDTH),
+                clampLivePagePreviewCoordinate(options.interaction.y, LIVE_PAGE_PREVIEW_VIEWPORT_HEIGHT),
+            );
+            return true;
+
+        case 'wheel':
+            await session.page.mouse.wheel(options.interaction.deltaX, options.interaction.deltaY);
+            return true;
+
+        case 'keyDown':
+            await session.page.keyboard.press(options.interaction.key);
+            return true;
+    }
+}
+
+/**
+ * Removes stale live-preview sessions left behind by disconnected clients.
+ */
+function pruneExpiredLivePagePreviewSessions(): void {
+    const now = Date.now();
+    for (const [sessionId, session] of LIVE_PAGE_PREVIEW_SESSIONS) {
+        const isExpired = now - session.lastAccessedAt > LIVE_PAGE_PREVIEW_SESSION_IDLE_TIMEOUT_MS;
+        if (isExpired || session.page.isClosed()) {
+            LIVE_PAGE_PREVIEW_SESSIONS.delete(sessionId);
+            void closeLivePagePreviewPage(session.page);
+        }
+    }
+}
+
+/**
+ * Waits between streamed browser frames, resolving early when the request is aborted.
+ *
+ * @param signal - Request cancellation signal.
+ */
+async function waitForLivePagePreviewFrame(signal: AbortSignal): Promise<void> {
+    if (signal.aborted) {
+        return;
+    }
+
+    await new Promise<void>((resolve) => {
+        const timeout = setTimeout(() => {
+            signal.removeEventListener('abort', handleAbort);
+            resolve();
+        }, LIVE_PAGE_PREVIEW_FRAME_INTERVAL_MS);
+
+        function handleAbort(): void {
+            clearTimeout(timeout);
+            resolve();
+        }
+
+        signal.addEventListener('abort', handleAbort, { once: true });
+    });
+}
+
+/**
+ * Closes a Playwright page while ignoring cleanup errors.
+ *
+ * @param page - Browser page to close.
+ */
+async function closeLivePagePreviewPage(page: Page): Promise<void> {
+    if (page.isClosed()) {
+        return;
+    }
+
+    await page.close().catch(() => undefined);
+}
+
+/**
+ * Clamps a pointer coordinate to the configured live-preview viewport.
+ *
+ * @param value - Raw coordinate from the web UI.
+ * @param maximum - Maximum coordinate value for one axis.
+ * @returns Coordinate safe to pass into Playwright.
+ */
+function clampLivePagePreviewCoordinate(value: number, maximum: number): number {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+
+    return Math.min(Math.max(value, 0), maximum);
+}

package/apps/agents-server/src/utils/pagePreview/resolvePagePreviewRequestUrl.ts

@@ -0,0 +1,74 @@
+import type { NextRequest } from 'next/server';
+import { NextResponse } from 'next/server';
+import { assertsError } from '../../../../../src/errors/assertsError';
+import { assertSafeUrl } from '../assertSafeUrl';
+import { getCurrentUser } from '../getCurrentUser';
+
+/**
+ * Query parameter used by page-preview API endpoints.
+ */
+const PAGE_PREVIEW_URL_QUERY_PARAMETER = 'url';
+
+/**
+ * Successful page-preview request URL resolution.
+ */
+type PagePreviewRequestUrlSuccess = {
+    readonly url: string;
+    readonly errorResponse: null;
+};
+
+/**
+ * Failed page-preview request URL resolution.
+ */
+type PagePreviewRequestUrlFailure = {
+    readonly url: null;
+    readonly errorResponse: NextResponse;
+};
+
+/**
+ * Result of authenticating and validating a page-preview request URL.
+ */
+export type PagePreviewRequestUrlResolution = PagePreviewRequestUrlSuccess | PagePreviewRequestUrlFailure;
+
+/**
+ * Authenticates a page-preview request and validates its target URL against SSRF-sensitive destinations.
+ *
+ * @param request - Incoming Next.js request.
+ * @returns Valid target URL or a ready-made error response.
+ */
+export async function resolvePagePreviewRequestUrl(request: NextRequest): Promise<PagePreviewRequestUrlResolution> {
+    const currentUser = await getCurrentUser();
+    if (!currentUser) {
+        return {
+            url: null,
+            errorResponse: NextResponse.json({ error: 'Unauthorized' }, { status: 401 }),
+        };
+    }
+
+    const url = request.nextUrl.searchParams.get(PAGE_PREVIEW_URL_QUERY_PARAMETER);
+
+    if (!url) {
+        return {
+            url: null,
+            errorResponse: NextResponse.json(
+                { error: `Missing required query parameter: ${PAGE_PREVIEW_URL_QUERY_PARAMETER}` },
+                { status: 400 },
+            ),
+        };
+    }
+
+    try {
+        assertSafeUrl(url);
+    } catch (error) {
+        assertsError(error);
+        return {
+            url: null,
+            errorResponse: NextResponse.json({ error: error.message }, { status: 400 }),
+        };
+    }
+
+    return {
+        url,
+        errorResponse: null,
+    };
+}

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

@@ -1042,6 +1042,18 @@ function resolveVpsSelfUpdateStateDirectory(): string {
     return resolve(dirname(resolveVpsEnvironmentFilePath()), '.promptbook', 'self-update');
 }
 
+/**
+ * Reads a lightweight snapshot of the currently persisted standalone VPS self-update job.
+ *
+ * Reads only the persisted status file and its log tail — no git access, no remote fetching —
+ * so it is safe to call from frequent polling loops such as the admin task manager.
+ *
+ * @returns Parsed job snapshot (status `idle` when no job has ever been persisted).
+ */
+export async function readVpsSelfUpdateJobSnapshot(): Promise<VpsSelfUpdateJobSnapshot> {
+    return readPersistedVpsSelfUpdateJob();
+}
+
 /**
  * Reads one persisted update-job snapshot from disk.
  *

package/esm/index.es.js

@@ -59,7 +59,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.113.0-0';
+const PROMPTBOOK_ENGINE_VERSION = '0.113.0-1';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name

package/esm/src/book-components/Chat/Chat/CitationIframePreview.d.ts

@@ -9,8 +9,8 @@ export type CitationIframePreviewProps = {
 };
 /**
  * Renders a citation URL preview as an iframe when the target page allows embedding,
- * or falls back to a server-side screenshot with an "Open in new tab" link when it
- * does not (e.g. X-Frame-Options: DENY / SAMEORIGIN).
+ * or falls back to a live server-side browser preview with an "Open in new tab" link
+ * when it does not (e.g. X-Frame-Options: DENY / SAMEORIGIN).
  *
  * Embedding capability is determined by `GET /api/page-preview/check?url=<url>`.
  * If that endpoint is unavailable the component falls back to the iframe directly.