@promptbook/cli 0.113.0-8 → 0.113.0-9

package/src/cli/cli-commands/agents-server/startAgentsServer/startUserChatJobWorkerPump.ts

@@ -0,0 +1,132 @@
+import type { WriteStream } from 'fs';
+import type { number_port } from '../../../../types/number_positive';
+import type { AgentsServerChildEnvironment } from './AgentsServerChildEnvironment';
+import type { AgentsServerLogStreams } from './AgentsServerLogStreams';
+import { logRunnerEvent } from './AgentsServerLogStreams';
+import { addUiError, type AgentsServerSupervisorState } from './AgentsServerSupervisorState';
+import { createInternalRouteErrorMessage } from './createInternalRouteErrorMessage';
+import { readInternalRouteErrorDetails } from './readInternalRouteErrorDetails';
+
+/**
+ * Local worker-pump delay while the Agents Server foreground process stays active.
+ *
+ * @private internal constant of `startAgentsServer`
+ */
+const USER_CHAT_JOB_WORKER_POLL_INTERVAL_MS = 10_000;
+
+/**
+ * Number of identical worker failures suppressed before logging a repeated summary.
+ *
+ * @private internal constant of `startAgentsServer`
+ */
+const USER_CHAT_JOB_WORKER_REPEATED_ERROR_LOG_INTERVAL = 10;
+
+/**
+ * HTTP status used by an idle internal worker tick with no job to process.
+ *
+ * @private internal constant of `startAgentsServer`
+ */
+const HTTP_NO_CONTENT_STATUS_CODE = 204;
+
+/**
+ * Starts periodic internal worker calls that queue and reconcile local message-folder jobs.
+ *
+ * @private internal utility of `startAgentsServer`
+ */
+export function startUserChatJobWorkerPump(options: {
+    readonly port: number_port;
+    readonly environment: AgentsServerChildEnvironment;
+    readonly logStreams: AgentsServerLogStreams;
+    readonly state: AgentsServerSupervisorState;
+}): () => void {
+    let isTickRunning = false;
+    const interval = setInterval(() => {
+        if (!options.state.isContinuing || isTickRunning) {
+            return;
+        }
+
+        isTickRunning = true;
+        triggerUserChatJobWorkerTick(options)
+            .then(() => {
+                clearUserChatJobWorkerError(options.state);
+            })
+            .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                reportUserChatJobWorkerError({
+                    logStream: options.logStreams.runner,
+                    message,
+                    state: options.state,
+                });
+            })
+            .finally(() => {
+                isTickRunning = false;
+            });
+    }, USER_CHAT_JOB_WORKER_POLL_INTERVAL_MS);
+
+    return () => clearInterval(interval);
+}
+
+/**
+ * Calls one internal local job worker tick over the running Next app.
+ */
+async function triggerUserChatJobWorkerTick(options: {
+    readonly port: number_port;
+    readonly environment: AgentsServerChildEnvironment;
+}): Promise<void> {
+    const response = await fetch(`http://localhost:${options.port}/api/internal/user-chat-jobs/run`, {
+        method: 'POST',
+        cache: 'no-store',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-user-chat-worker-token': options.environment.PTBK_AGENTS_SERVER_USER_CHAT_WORKER_TOKEN,
+        },
+        body: '{}',
+    });
+
+    if (!response.ok && response.status !== HTTP_NO_CONTENT_STATUS_CODE) {
+        const details = await readInternalRouteErrorDetails(response);
+        throw new Error(createInternalRouteErrorMessage('user chat worker', response, details));
+    }
+}
+
+/**
+ * Reports worker failures while suppressing identical repeated foreground noise.
+ */
+function reportUserChatJobWorkerError(options: {
+    readonly logStream: WriteStream;
+    readonly message: string;
+    readonly state: AgentsServerSupervisorState;
+}): void {
+    const previousError = options.state.lastUserChatJobWorkerError;
+
+    if (previousError?.message === options.message) {
+        const repeatCount = previousError.repeatCount + 1;
+        options.state.lastUserChatJobWorkerError = {
+            message: options.message,
+            repeatCount,
+        };
+
+        if (repeatCount % USER_CHAT_JOB_WORKER_REPEATED_ERROR_LOG_INTERVAL !== 0) {
+            return;
+        }
+
+        const repeatedMessage = `User chat worker tick is still failing after ${repeatCount} attempts: ${options.message}`;
+        logRunnerEvent(options.logStream, repeatedMessage);
+        addUiError(options.state, repeatedMessage);
+        return;
+    }
+
+    options.state.lastUserChatJobWorkerError = {
+        message: options.message,
+        repeatCount: 1,
+    };
+    logRunnerEvent(options.logStream, `User chat worker tick failed: ${options.message}`);
+    addUiError(options.state, options.message);
+}
+
+/**
+ * Resets repeated-error suppression after a successful worker tick.
+ */
+function clearUserChatJobWorkerError(state: AgentsServerSupervisorState): void {
+    state.lastUserChatJobWorkerError = undefined;
+}

package/src/cli/cli-commands/agents-server/startAgentsServer/stopChildProcess.ts

@@ -0,0 +1,14 @@
+import type { ChildProcess } from 'child_process';
+
+/**
+ * Stops only the child process spawned for the local Next server.
+ *
+ * @private internal utility of `startAgentsServer`
+ */
+export function stopChildProcess(commandProcess: ChildProcess | undefined): void {
+    if (!commandProcess || commandProcess.killed) {
+        return;
+    }
+
+    commandProcess.kill();
+}

package/src/cli/cli-commands/agents-server/startAgentsServer/waitForLocalAgentRunnerLimits.ts

@@ -0,0 +1,132 @@
+import { spaceTrim } from 'spacetrim';
+import {
+    DEFAULT_LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS,
+    DEFAULT_LOCAL_AGENT_RUNNER_MAX_PARALLEL_MESSAGES,
+} from '../../../../../apps/agents-server/src/constants/serverLimits';
+import { NotAllowed } from '../../../../errors/NotAllowed';
+import type { number_port } from '../../../../types/number_positive';
+import type { AgentsServerChildEnvironment } from './AgentsServerChildEnvironment';
+import type { AgentsServerLogStreams } from './AgentsServerLogStreams';
+import { logRunnerEvent } from './AgentsServerLogStreams';
+import type { AgentsServerSupervisorState } from './AgentsServerSupervisorState';
+import { createInternalRouteErrorMessage } from './createInternalRouteErrorMessage';
+import type { LocalAgentRunnerLimits } from './LocalAgentRunnerLimits';
+import { readInternalRouteErrorDetails } from './readInternalRouteErrorDetails';
+
+/**
+ * Delay between foreground CLI attempts to load internal Agents Server limits during startup.
+ *
+ * @private internal constant of `startAgentsServer`
+ */
+const INTERNAL_SERVER_LIMITS_RETRY_DELAY_MS = 1_000;
+
+/**
+ * Maximum time spent waiting for the internal limits route before startup fails.
+ *
+ * @private internal constant of `startAgentsServer`
+ */
+const INTERNAL_SERVER_LIMITS_STARTUP_TIMEOUT_MS = 60_000;
+
+/**
+ * Waits until the internal Next route can return current local runner limits.
+ *
+ * @private internal utility of `startAgentsServer`
+ */
+export async function waitForLocalAgentRunnerLimits(options: {
+    readonly port: number_port;
+    readonly environment: AgentsServerChildEnvironment;
+    readonly logStreams: AgentsServerLogStreams;
+    readonly state: AgentsServerSupervisorState;
+}): Promise<LocalAgentRunnerLimits> {
+    const startedAt = Date.now();
+    let lastError: unknown;
+
+    while (options.state.isContinuing && Date.now() - startedAt < INTERNAL_SERVER_LIMITS_STARTUP_TIMEOUT_MS) {
+        try {
+            const limits = await fetchLocalAgentRunnerLimits(options);
+            logRunnerEvent(
+                options.logStreams.runner,
+                `Local agent runner limits: ${limits.maxFailedAttempts} failed attempt(s), ${limits.maxParallelMessages} parallel message(s).`,
+            );
+            return limits;
+        } catch (error) {
+            lastError = error;
+            await wait(INTERNAL_SERVER_LIMITS_RETRY_DELAY_MS);
+        }
+    }
+
+    if (!options.state.isContinuing) {
+        return {
+            maxFailedAttempts: DEFAULT_LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS,
+            maxParallelMessages: DEFAULT_LOCAL_AGENT_RUNNER_MAX_PARALLEL_MESSAGES,
+        };
+    }
+
+    throw new NotAllowed(
+        spaceTrim(`
+            Failed to load local agent runner limits from the Agents Server.
+
+            ${lastError instanceof Error ? lastError.message : String(lastError)}
+        `),
+    );
+}
+
+/**
+ * Loads local runner limits through the token-protected internal Agents Server route.
+ */
+async function fetchLocalAgentRunnerLimits(options: {
+    readonly port: number_port;
+    readonly environment: AgentsServerChildEnvironment;
+}): Promise<LocalAgentRunnerLimits> {
+    const response = await fetch(`http://localhost:${options.port}/api/internal/agent-runner-limits`, {
+        method: 'GET',
+        cache: 'no-store',
+        headers: {
+            'x-user-chat-worker-token': options.environment.PTBK_AGENTS_SERVER_USER_CHAT_WORKER_TOKEN,
+        },
+    });
+
+    if (!response.ok) {
+        const details = await readInternalRouteErrorDetails(response);
+        throw new Error(createInternalRouteErrorMessage('agent runner limits', response, details));
+    }
+
+    const payload = (await response.json()) as Partial<LocalAgentRunnerLimits>;
+    return {
+        maxFailedAttempts: normalizeLocalAgentRunnerMaxFailedAttempts(payload.maxFailedAttempts),
+        maxParallelMessages: normalizeLocalAgentRunnerMaxParallelMessages(payload.maxParallelMessages),
+    };
+}
+
+/**
+ * Normalizes the local runner retry cap returned by the internal server route.
+ */
+function normalizeLocalAgentRunnerMaxFailedAttempts(rawValue: unknown): number {
+    const parsedValue = Number(rawValue);
+
+    if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
+        return DEFAULT_LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS;
+    }
+
+    return Math.floor(parsedValue);
+}
+
+/**
+ * Normalizes the local runner parallel message cap returned by the internal server route.
+ */
+function normalizeLocalAgentRunnerMaxParallelMessages(rawValue: unknown): number {
+    const parsedValue = Number(rawValue);
+
+    if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
+        return DEFAULT_LOCAL_AGENT_RUNNER_MAX_PARALLEL_MESSAGES;
+    }
+
+    return Math.floor(parsedValue);
+}
+
+/**
+ * Waits for the given delay.
+ */
+async function wait(delayMs: number): Promise<void> {
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+}