@promptbook/cli 0.113.0-8 → 0.113.0-9

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

@@ -1,9 +1,10 @@
 import type { AdminChatTaskRecord } from '../chatTasksAdmin';
 import type { UserChatJobStatus } from '../userChat/UserChatJobRecord';
 import type { VpsSelfUpdateJobSnapshot } from '../vpsSelfUpdate';
+import { resolveVpsSelfUpdateJobIdentity } from '../vpsSelfUpdate/vpsSelfUpdateJobIdentity';
 
 /**
- * Stable synthetic task id used for the singleton standalone VPS self-update task row.
+ * Stable synthetic task id prefix used for standalone VPS self-update task rows.
  *
  * @private internal admin utility of Agents Server
  */
@@ -34,9 +35,11 @@ export function mapVpsSelfUpdateJobToAdminChatTask(job: VpsSelfUpdateJobSnapshot
     const updatedAt = finishedAt || startedAt || new Date().toISOString();
     const errorSummary = job.errorMessage || null;
     const currentStepDetails = job.currentStep || null;
+    const triggerLabel = formatVpsSelfUpdateTrigger(job.trigger);
+    const taskId = `${VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID}:${resolveVpsSelfUpdateJobIdentity(job)}`;
 
     return {
-        id: VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID,
+        id: taskId,
         kind: 'VPS_SELF_UPDATE',
         status,
         createdAt: startedAt || updatedAt,
@@ -56,14 +59,24 @@ export function mapVpsSelfUpdateJobToAdminChatTask(job: VpsSelfUpdateJobSnapshot
         lastErrorDetails: currentStepDetails,
         userId: 0,
         username: null,
-        agentPermanentId: VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID,
-        agentName: job.targetEnvironment.label,
+        agentPermanentId: taskId,
+        agentName: `${triggerLabel} self-update: ${job.targetEnvironment.label}`,
         chatId: job.targetBranch || job.targetEnvironment.branch || VPS_SELF_UPDATE_ADMIN_CHAT_TASK_ID,
         workerId: job.pid !== null ? String(job.pid) : null,
-        queueName: VPS_SELF_UPDATE_ADMIN_CHAT_TASK_QUEUE_NAME,
+        queueName: `${VPS_SELF_UPDATE_ADMIN_CHAT_TASK_QUEUE_NAME}:${job.trigger}`,
     };
 }
 
+/**
+ * Formats one self-update trigger for task-manager display.
+ *
+ * @param trigger - Persisted self-update trigger.
+ * @returns Capitalized trigger label.
+ */
+function formatVpsSelfUpdateTrigger(trigger: VpsSelfUpdateJobSnapshot['trigger']): string {
+    return trigger === 'automatic' ? 'Automatic' : 'Manual';
+}
+
 /**
  * Maps the shell-owned self-update status to the durable chat-task status enum used by the admin task manager.
  *

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

@@ -1,11 +1,12 @@
 import { ensureUserChatTimeoutWorkerBootstrapped } from '@/src/utils/userChatTimeout/ensureUserChatTimeoutWorkerBootstrapped';
 import type { AdminChatTaskCounters, AdminChatTaskListResponse, AdminChatTaskRecord } from './chatTasksAdmin';
 import { getAdminChatTasks } from './getAdminChatTasksResponse/getAdminChatTasks';
+import { compareAdminChatTasks } from './getAdminChatTasksResponse/getAdminChatTasks/compareAdminChatTasks';
 import { mapVpsSelfUpdateJobToAdminChatTask } from './getAdminChatTasksResponse/mapVpsSelfUpdateJobToAdminChatTask';
 import { parseAdminChatTaskQuery, type ParsedAdminChatTaskQuery } from './getAdminChatTasksResponse/parseAdminChatTaskQuery';
 import { throttledAdminRecovery } from './getAdminChatTasksResponse/throttledAdminRecovery';
 import { listPagePreviewBrowserAdminTasks } from './pagePreviewBrowserSessions';
-import { readVpsSelfUpdateJobSnapshot } from './vpsSelfUpdate';
+import { readVpsSelfUpdateJobTaskSnapshots } from './vpsSelfUpdate';
 
 /**
  * Milliseconds in one hour.
@@ -62,13 +63,12 @@ export async function getAdminChatTasksResponse(
     // [🧠] Recovery operations are throttled to avoid hammering the DB on every admin poll
     await throttledAdminRecovery();
 
-    const adminChatTasks = await getAdminChatTasks(parsedQuery);
-    const vpsSelfUpdateTask = await loadVpsSelfUpdateAdminChatTask();
+    const vpsSelfUpdateTasks = await loadVpsSelfUpdateAdminChatTasks();
     const pagePreviewBrowserTasks = listPagePreviewBrowserAdminTasks();
-    const injectableTasks = [vpsSelfUpdateTask, ...pagePreviewBrowserTasks].filter(
-        (task): task is AdminChatTaskRecord => task !== null,
-    );
+    const injectableTasks = [...vpsSelfUpdateTasks, ...pagePreviewBrowserTasks];
     const injectedTasks = collectAdminChatTasksToInject(injectableTasks, parsedQuery);
+    const databaseQuery = createInjectedAwareAdminChatTaskQuery(parsedQuery, injectedTasks.length);
+    const adminChatTasks = await getAdminChatTasks(databaseQuery);
     const { items, total } = mergeInjectedAdminChatTasks({
         databaseItems: adminChatTasks.items,
         databaseTotal: adminChatTasks.total,
@@ -95,19 +95,21 @@ export async function getAdminChatTasksResponse(
 }
 
 /**
- * Loads the currently persisted standalone VPS self-update task, if any.
+ * Loads persisted standalone VPS self-update tasks, 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.
+ * @returns Injectable task records.
  */
-async function loadVpsSelfUpdateAdminChatTask(): Promise<AdminChatTaskRecord | null> {
+async function loadVpsSelfUpdateAdminChatTasks(): Promise<Array<AdminChatTaskRecord>> {
     try {
-        const jobSnapshot = await readVpsSelfUpdateJobSnapshot();
-        return mapVpsSelfUpdateJobToAdminChatTask(jobSnapshot);
+        const jobSnapshots = await readVpsSelfUpdateJobTaskSnapshots();
+        return jobSnapshots
+            .map(mapVpsSelfUpdateJobToAdminChatTask)
+            .filter((task): task is AdminChatTaskRecord => task !== null);
     } catch (error) {
-        console.error('[admin-chat-task] failed to load VPS self-update task snapshot', error);
-        return null;
+        console.error('[admin-chat-task] failed to load VPS self-update task snapshots', error);
+        return [];
     }
 }
 
@@ -123,13 +125,42 @@ function collectAdminChatTasksToInject(
     query: ParsedAdminChatTaskQuery,
 ): ReadonlyArray<AdminChatTaskRecord> {
     const nowTimestamp = Date.now();
-    return injectableTasks.filter(
-        (task) => matchesAdminChatTaskView(task, query, nowTimestamp) && matchesAdminChatTaskSearch(task, query.search),
-    );
+    return injectableTasks
+        .filter(
+            (task) =>
+                matchesAdminChatTaskView(task, query, nowTimestamp) &&
+                matchesAdminChatTaskSearch(task, query.search),
+        )
+        .sort((leftTask, rightTask) => compareAdminChatTasks(leftTask, rightTask, query.view));
 }
 
 /**
- * Prepends the injected task rows to the paginated database items so the self-update stays visible on page 1.
+ * Builds the database query needed to merge injected task rows into the requested page.
+ *
+ * @param query - Parsed admin task-manager query.
+ * @param injectedTaskCount - Number of injected rows that appear before database-backed rows.
+ * @returns Query used for loading enough database-backed rows to fill the final page.
+ */
+function createInjectedAwareAdminChatTaskQuery(
+    query: ParsedAdminChatTaskQuery,
+    injectedTaskCount: number,
+): ParsedAdminChatTaskQuery {
+    if (injectedTaskCount === 0) {
+        return query;
+    }
+
+    const pageOffset = (query.page - 1) * query.pageSize;
+    const databaseEndOffset = Math.max(0, pageOffset + query.pageSize - injectedTaskCount);
+
+    return {
+        ...query,
+        page: 1,
+        pageSize: Math.max(1, databaseEndOffset),
+    };
+}
+
+/**
+ * Prepends injected task rows to the database-backed items and returns the requested combined page.
  *
  * @param options - Merge inputs.
  * @returns Merged items for the current page and the updated total row count.
@@ -142,16 +173,21 @@ function mergeInjectedAdminChatTasks(options: {
     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 pageOffset = (options.page - 1) * options.pageSize;
+    const injectedItems = options.injectedTasks.slice(pageOffset, pageOffset + options.pageSize);
+    const remainingPageSize = options.pageSize - injectedItems.length;
+
+    if (remainingPageSize <= 0) {
+        return { items: [...injectedItems], total };
     }
 
-    const items = [...options.injectedTasks, ...options.databaseItems].slice(0, options.pageSize);
+    const databaseOffset = Math.max(0, pageOffset - options.injectedTasks.length);
+    const databaseItems = options.databaseItems.slice(databaseOffset, databaseOffset + remainingPageSize);
+    const items = [...injectedItems, ...databaseItems];
     return { items, total };
 }
 

package/apps/agents-server/src/utils/localChatRunner/processLocalUserChatJob.ts

@@ -9,11 +9,11 @@ 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';
 import { createUserChatRunnerThreadMessages } from '../userChat/userChatMessageLifecycle';
+import { runWithTaskTerminalCapture } from '../taskTerminal/runWithTaskTerminalCapture';
 import {
     createLocalUserChatJobMetadata,
     getLocalUserChatJobMetadata,
@@ -45,6 +45,15 @@ export type ProcessLocalUserChatJobResult = {
  * Processes one UserChatJob through the local message-folder runner contract.
  */
 export async function processLocalUserChatJob(job: UserChatJobRecord): Promise<ProcessLocalUserChatJobResult> {
+    return await runWithTaskTerminalCapture(job.id, () => processLocalUserChatJobWithinTerminalCapture(job));
+}
+
+/**
+ * Processes one local job while its console output is mirrored into the task terminal log.
+ */
+async function processLocalUserChatJobWithinTerminalCapture(
+    job: UserChatJobRecord,
+): Promise<ProcessLocalUserChatJobResult> {
     try {
         if (job.status === 'COMPLETED' || job.status === 'CANCELLED') {
             return { didMutate: false, outcome: 'ignored' };
@@ -120,6 +129,15 @@ export async function processNextLocalUserChatJob(
  * Enqueues one local queued job into the current agent folder.
  */
 async function enqueueLocalUserChatJob(job: UserChatJobRecord): Promise<ProcessLocalUserChatJobResult> {
+    return await runWithTaskTerminalCapture(job.id, () => enqueueLocalUserChatJobWithinTerminalCapture(job));
+}
+
+/**
+ * Enqueues one local job while its console output is mirrored into the task terminal log.
+ */
+async function enqueueLocalUserChatJobWithinTerminalCapture(
+    job: UserChatJobRecord,
+): Promise<ProcessLocalUserChatJobResult> {
     const [chat, agentSourceSnapshot] = await Promise.all([
         getUserChat({
             userId: job.userId,
@@ -176,10 +194,7 @@ async function enqueueLocalUserChatJob(job: UserChatJobRecord): Promise<ProcessL
             isComplete: false,
             lifecycleState: 'running',
             lifecycleError: undefined,
-            progressCard: createUserChatRunnerProgressCard({
-                runnerKind: 'local',
-                phase: 'queued_for_runner',
-            }),
+            progressCard: undefined,
         }),
     });
 

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

@@ -1,6 +1,7 @@
 import type { Page } from 'playwright';
 import type { AdminChatTaskRecord } from './chatTasksAdmin';
 import type { UserInfo } from './getCurrentUser';
+import { appendTaskTerminalLogLine, markTaskTerminalLogFinished } from './taskTerminal/taskTerminalLog';
 
 /**
  * Prefix for browser-preview session identifiers created by the citation preview UI.
@@ -125,6 +126,10 @@ export function registerPagePreviewBrowserSession(
     };
 
     pagePreviewBrowserSessions.set(options.sessionId, session);
+    appendTaskTerminalLogLine(
+        options.sessionId,
+        `Started live browser preview of ${options.url} for user #${session.userId} (${session.username || 'unknown'}).`,
+    );
     return session;
 }
 
@@ -148,6 +153,10 @@ export function attachPagePreviewBrowserSessionPage(
     session.page = page;
     session.viewport = viewport;
     session.updatedAt = new Date().toISOString();
+    appendTaskTerminalLogLine(
+        sessionId,
+        `Browser page attached with a ${viewport.width}x${viewport.height} viewport, streaming frames.`,
+    );
 }
 
 /**
@@ -172,7 +181,10 @@ export function markPagePreviewBrowserSessionFrame(sessionId: string): void {
  * @param sessionId - Active session id.
  */
 export function finishPagePreviewBrowserSession(sessionId: string): void {
-    pagePreviewBrowserSessions.delete(sessionId);
+    if (pagePreviewBrowserSessions.delete(sessionId)) {
+        appendTaskTerminalLogLine(sessionId, 'Browser preview session finished.');
+        markTaskTerminalLogFinished(sessionId, { isSuccessful: true });
+    }
 }
 
 /**

package/apps/agents-server/src/utils/resourceMonitor/formatResourceMonitorValue.ts

@@ -0,0 +1,50 @@
+/**
+ * Byte units used for compact resource values.
+ */
+const BYTE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'] as const;
+
+/**
+ * Converts a nullable byte count into a compact display value.
+ *
+ * @param bytes - Byte count.
+ * @returns Human-readable byte value.
+ */
+export function formatResourceBytes(bytes: number | null | undefined): string {
+    if (bytes === null || bytes === undefined || !Number.isFinite(bytes) || bytes <= 0) {
+        return '0 B';
+    }
+
+    const exponent = Math.min(BYTE_UNITS.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
+    const value = bytes / Math.pow(1024, exponent);
+    const precision = value >= 10 || exponent === 0 ? 0 : 1;
+
+    return `${value.toFixed(precision)} ${BYTE_UNITS[exponent]}`;
+}
+
+/**
+ * Converts a nullable ratio into a display percentage.
+ *
+ * @param ratio - Ratio from `0` to `1`.
+ * @returns Human-readable percentage or fallback.
+ */
+export function formatResourcePercentage(ratio: number | null | undefined): string {
+    if (ratio === null || ratio === undefined || !Number.isFinite(ratio)) {
+        return 'Not available';
+    }
+
+    return `${(ratio * 100).toFixed(0)}%`;
+}
+
+/**
+ * Converts a nullable byte-per-second count into a compact display value.
+ *
+ * @param bytesPerSecond - Byte count per second.
+ * @returns Human-readable rate or fallback.
+ */
+export function formatResourceRate(bytesPerSecond: number | null | undefined): string {
+    if (bytesPerSecond === null || bytesPerSecond === undefined || !Number.isFinite(bytesPerSecond)) {
+        return 'Not available';
+    }
+
+    return `${formatResourceBytes(bytesPerSecond)}/s`;
+}

package/apps/agents-server/src/utils/resourceMonitor/readCpuResourceUsage.ts

@@ -0,0 +1,75 @@
+import os from 'node:os';
+
+import { DEFAULT_PROCESS_CPU_SAMPLE_DURATION_MS } from './resourceMonitorConstants';
+import { waitForResourceMonitorSample } from './waitForResourceMonitorSample';
+import type { CpuResourceUsage } from './resourceMonitorTypes';
+
+/**
+ * Options for reading CPU usage.
+ */
+type ReadCpuResourceUsageOptions = {
+    /**
+     * Whether the current Node.js process CPU usage should be sampled.
+     */
+    readonly isProcessUsageSampled: boolean;
+
+    /**
+     * Optional process CPU sampling duration.
+     */
+    readonly sampleDurationMs?: number;
+};
+
+/**
+ * Reads platform load average and optionally samples current process CPU usage.
+ *
+ * @param options - CPU reader options.
+ * @returns CPU usage snapshot.
+ */
+export async function readCpuResourceUsage({
+    isProcessUsageSampled,
+    sampleDurationMs = DEFAULT_PROCESS_CPU_SAMPLE_DURATION_MS,
+}: ReadCpuResourceUsageOptions): Promise<CpuResourceUsage> {
+    const coreCount = Math.max(os.cpus().length, 1);
+    const isLoadAverageAvailable = process.platform !== 'win32';
+    const [averageLoadOneMinute, averageLoadFiveMinutes, averageLoadFifteenMinutes] = isLoadAverageAvailable
+        ? os.loadavg()
+        : [null, null, null];
+    const loadRatio = averageLoadOneMinute === null ? null : averageLoadOneMinute / coreCount;
+    const processUsageRatio = isProcessUsageSampled
+        ? await sampleProcessCpuUsageRatio(coreCount, sampleDurationMs)
+        : null;
+
+    return {
+        coreCount,
+        averageLoadOneMinute,
+        averageLoadFiveMinutes,
+        averageLoadFifteenMinutes,
+        loadRatio,
+        processUsageRatio,
+    };
+}
+
+/**
+ * Samples current Node.js process CPU usage over a short interval.
+ *
+ * @param coreCount - Logical CPU core count.
+ * @param sampleDurationMs - Sampling duration in milliseconds.
+ * @returns Process CPU ratio across all logical cores.
+ */
+async function sampleProcessCpuUsageRatio(coreCount: number, sampleDurationMs: number): Promise<number | null> {
+    const startedUsage = process.cpuUsage();
+    const startedAtNanoseconds = process.hrtime.bigint();
+
+    await waitForResourceMonitorSample(sampleDurationMs);
+
+    const elapsedMicroseconds = Number(process.hrtime.bigint() - startedAtNanoseconds) / 1000;
+    if (!Number.isFinite(elapsedMicroseconds) || elapsedMicroseconds <= 0) {
+        return null;
+    }
+
+    const usage = process.cpuUsage(startedUsage);
+    const usedMicroseconds = usage.user + usage.system;
+    const processUsageRatio = usedMicroseconds / elapsedMicroseconds / Math.max(coreCount, 1);
+
+    return Number.isFinite(processUsageRatio) ? Math.max(processUsageRatio, 0) : null;
+}

package/apps/agents-server/src/utils/resourceMonitor/readDiskResourceUsage.ts

@@ -0,0 +1,42 @@
+import { statfs } from 'node:fs/promises';
+
+import type { DiskResourceUsage } from './resourceMonitorTypes';
+
+/**
+ * Reads disk usage for the filesystem that hosts the server process.
+ *
+ * @param inspectedPath - Filesystem path to inspect.
+ * @returns Disk usage snapshot.
+ */
+export async function readDiskResourceUsage(inspectedPath: string = process.cwd()): Promise<DiskResourceUsage> {
+    try {
+        const fileSystemStats = await statfs(inspectedPath);
+        const blockSize = fileSystemStats.bsize;
+        const totalBytes = fileSystemStats.blocks * blockSize;
+        const freeBytes = fileSystemStats.bfree * blockSize;
+        const availableBytes = fileSystemStats.bavail * blockSize;
+        const usedBytes = Math.max(totalBytes - freeBytes, 0);
+
+        return {
+            inspectedPath,
+            totalBytes,
+            freeBytes,
+            availableBytes,
+            usedBytes,
+            usedRatio: totalBytes > 0 ? usedBytes / totalBytes : null,
+            availableRatio: totalBytes > 0 ? availableBytes / totalBytes : null,
+            errorMessage: null,
+        };
+    } catch (error) {
+        return {
+            inspectedPath,
+            totalBytes: null,
+            freeBytes: null,
+            availableBytes: null,
+            usedBytes: null,
+            usedRatio: null,
+            availableRatio: null,
+            errorMessage: error instanceof Error ? error.message : 'Disk usage is not available.',
+        };
+    }
+}

package/apps/agents-server/src/utils/resourceMonitor/readMemoryResourceUsage.ts

@@ -0,0 +1,28 @@
+import os from 'node:os';
+
+import type { MemoryResourceUsage } from './resourceMonitorTypes';
+
+/**
+ * Reads current host and process memory usage.
+ *
+ * @returns Memory usage snapshot.
+ */
+export function readMemoryResourceUsage(): MemoryResourceUsage {
+    const totalBytes = os.totalmem();
+    const freeBytes = os.freemem();
+    const usedBytes = Math.max(totalBytes - freeBytes, 0);
+    const memoryUsage = process.memoryUsage();
+
+    return {
+        totalBytes,
+        freeBytes,
+        usedBytes,
+        usedRatio: totalBytes > 0 ? usedBytes / totalBytes : 0,
+        availableRatio: totalBytes > 0 ? freeBytes / totalBytes : 0,
+        processRssBytes: memoryUsage.rss,
+        processHeapUsedBytes: memoryUsage.heapUsed,
+        processHeapTotalBytes: memoryUsage.heapTotal,
+        processExternalBytes: memoryUsage.external,
+        processArrayBuffersBytes: memoryUsage.arrayBuffers ?? 0,
+    };
+}