@promptbook/cli 0.112.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/localChatRunner/LocalUserChatJobMetadata.ts

@@ -23,10 +23,11 @@ export function createLocalUserChatJobMetadata(options: {
     agentDirectoryName: string;
     threadId: string;
     threadCreatedAt: string;
+    jobId: string;
     queuedAt: string;
     expectedMessagesBeforeAnswer: number;
 }): LocalUserChatJobMetadata {
-    const fileName = createLocalChatMessageFileName(options.threadId, options.threadCreatedAt);
+    const fileName = createLocalChatMessageFileName(options.threadId, options.threadCreatedAt, options.jobId);
 
     return {
         version: 1,
@@ -102,15 +103,24 @@ export function withoutLocalUserChatJobMetadata(parameters: UserChatJobParameter
 /**
  * Creates the filename used by one local message-thread book.
  */
-export function createLocalChatMessageFileName(threadId: string, threadCreatedAt: string): string {
+export function createLocalChatMessageFileName(threadId: string, threadCreatedAt: string, jobId?: string): string {
     const createdOnDate = resolveLocalChatThreadCreatedOnDate(threadCreatedAt);
-    const normalizedThreadId = threadId.trim().replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+    const normalizedThreadId = threadId
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    const normalizedJobId = jobId
+        ?.trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
 
     if (normalizedThreadId.length > 0) {
-        return `${createdOnDate}-${normalizedThreadId}.book`;
+        return `${createdOnDate}-${normalizedThreadId}${normalizedJobId ? `-${normalizedJobId}` : ''}.book`;
     }
 
-    return `${createdOnDate}-${Buffer.from(threadId, 'utf8').toString('hex') || 'thread'}.book`;
+    return `${createdOnDate}-${Buffer.from(threadId, 'utf8').toString('hex') || 'thread'}${
+        normalizedJobId ? `-${normalizedJobId}` : ''
+    }.book`;
 }
 
 /**

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

@@ -13,7 +13,7 @@ import { createUserChatRunnerProgressCard } from '../userChat/createUserChatRunn
 import { updateUserChatAssistantMessage } from '../userChat/updateUserChatAssistantMessage';
 import type { UserChatJobRecord } from '../userChat/UserChatJobRecord';
 import type { UserChatJobRow } from '../userChat/UserChatJobRow';
-import { resolvePromptThreadBeforeUserMessage } from '../userChat/userChatMessageLifecycle';
+import { createUserChatRunnerThreadMessages } from '../userChat/userChatMessageLifecycle';
 import {
     createLocalUserChatJobMetadata,
     getLocalUserChatJobMetadata,
@@ -85,9 +85,11 @@ export async function processLocalUserChatJob(job: UserChatJobRecord): Promise<P
 /**
  * Processes the next local user chat job waiting for worker attention.
  */
-export async function processNextLocalUserChatJob(options: {
-    preferredJobId?: string;
-} = {}): Promise<ProcessLocalUserChatJobResult | null> {
+export async function processNextLocalUserChatJob(
+    options: {
+        preferredJobId?: string;
+    } = {},
+): Promise<ProcessLocalUserChatJobResult | null> {
     if (options.preferredJobId) {
         const claimedPreferredJob = await claimNextQueuedUserChatJob({ preferredJobId: options.preferredJobId });
         if (claimedPreferredJob) {
@@ -142,27 +144,11 @@ async function enqueueLocalUserChatJob(job: UserChatJobRecord): Promise<ProcessL
         throw new Error(`User message "${job.userMessageId}" was not found in chat "${job.chatId}".`);
     }
 
-    const previousThreadMessages = resolvePromptThreadBeforeUserMessage(chat.messages, job.userMessageId);
-    if (previousThreadMessages.some((message) => message.sender === 'AGENT' && message.isComplete === false)) {
-        return { didMutate: false, outcome: 'waiting' };
-    }
-
-    const agentInitialMessage = previousThreadMessages.length === 0
-        ? parseAgentSource(agentSourceSnapshot.agentSource).initialMessage
-        : null;
-    const initialAgentThreadMessages = agentInitialMessage
-        ? [{ sender: 'AGENT' as const, content: agentInitialMessage }]
-        : [];
-
-    const threadMessages = [
-        ...initialAgentThreadMessages,
-        ...[...previousThreadMessages, userMessage]
-            .filter((message) => message.isComplete !== false)
-            .filter((message) => message.sender === 'USER' || message.sender === 'AGENT'),
-    ].map((message) => ({
-        sender: String(message.sender),
-        content: message.content,
-    }));
+    const threadMessages = createUserChatRunnerThreadMessages({
+        messages: chat.messages,
+        userMessageId: job.userMessageId,
+        resolveInitialAgentMessage: () => parseAgentSource(agentSourceSnapshot.agentSource).initialMessage,
+    });
 
     const agentFolder = await ensureLocalAgentFolder(agentSourceSnapshot);
     const queuedAt = new Date().toISOString();
@@ -170,6 +156,7 @@ async function enqueueLocalUserChatJob(job: UserChatJobRecord): Promise<ProcessL
         agentDirectoryName: agentFolder.directoryName,
         threadId: chat.id,
         threadCreatedAt: chat.createdAt,
+        jobId: job.id,
         queuedAt,
         expectedMessagesBeforeAnswer: threadMessages.length,
     });
@@ -326,7 +313,11 @@ async function handleLocalUserChatJobProcessingError(
     const metadata = getLocalUserChatJobMetadata(job);
     const failureReason = error instanceof Error ? error.message : 'Local agent runner synchronization failed.';
 
-    if (job.status === 'QUEUED' || (job.status === 'RUNNING' && !metadata) || (metadata && isLocalUserChatJobTimedOut(metadata))) {
+    if (
+        job.status === 'QUEUED' ||
+        (job.status === 'RUNNING' && !metadata) ||
+        (metadata && isLocalUserChatJobTimedOut(metadata))
+    ) {
         await persistUserChatJobTerminalState({
             job,
             status: 'FAILED',