@akira-tl/forgerelay 0.4.6 → 0.5.0

package/dist/process-sessions.js

@@ -6,21 +6,33 @@ const DEFAULT_POLL_YIELD_MS = 5_000;
 const MAX_START_YIELD_MS = 300_000;
 const MAX_COMMAND_YIELD_MS = 300_000;
 const MAX_POLL_YIELD_MS = 300_000;
+const MAX_EXECUTION_TIMEOUT_MS = 24 * 60 * 60 * 1_000;
 const DEFAULT_MAX_OUTPUT_TOKENS = 10_000;
 const DEFAULT_BUFFER_CHARACTERS = 256_000;
 const DEFAULT_MAX_ACTIVE_PROCESSES = 64;
 const DEFAULT_MAX_COMPLETED_PROCESSES = 128;
 const COMPLETED_PROCESS_TTL_MS = 5 * 60 * 1_000;
+const COMPACT_COMPLETION_TTL_MS = 24 * 60 * 60 * 1_000;
+const COMPACT_COMPLETION_CHARACTERS = 16 * 1024;
+const COMPACT_COMPLETION_OUTPUT_TOKENS = COMPACT_COMPLETION_CHARACTERS / 4;
 const DEFAULT_COLUMNS = 80;
 const DEFAULT_ROWS = 24;
 function boundedInteger(value, fallback, maximum) {
     if (value === undefined)
-        return fallback;
+        return Math.min(fallback, maximum);
     if (!Number.isFinite(value) || value < 0) {
         throw new Error("Duration and output limits must be non-negative.");
     }
     return Math.min(Math.floor(value), maximum);
 }
+function optionalExecutionTimeout(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isInteger(value) || value < 1 || value > MAX_EXECUTION_TIMEOUT_MS) {
+        throw new Error(`Execution timeout must be an integer between 1 and ${MAX_EXECUTION_TIMEOUT_MS}ms.`);
+    }
+    return value;
+}
 function terminalSize(value, fallback) {
     if (value === undefined)
         return fallback;
@@ -215,9 +227,11 @@ export class ProcessManager {
         this.monotonicNow = options.monotonicNow ?? (() => performance.now());
     }
     async start(input) {
+        input.signal?.throwIfAborted();
         if (this.stats().running >= this.maxActiveProcesses) {
             throw new Error(`Active process limit reached (${this.maxActiveProcesses}). Poll, interrupt, or wait for an existing process before starting another.`);
         }
+        const executionTimeoutMs = optionalExecutionTimeout(input.timeoutMs);
         const processEntry = this.createProcess(input);
         this.processes.set(processEntry.id, processEntry);
         try {
@@ -230,8 +244,19 @@ export class ProcessManager {
             this.processes.delete(processEntry.id);
             throw error;
         }
+        this.armExecutionTimeout(processEntry, executionTimeoutMs);
         const yieldTimeMs = boundedInteger(input.yieldTimeMs, DEFAULT_EXEC_YIELD_MS, this.maxStartYieldMs);
-        await this.waitForExit(processEntry, yieldTimeMs);
+        try {
+            await this.waitForExit(processEntry, yieldTimeMs, input.signal);
+            input.signal?.throwIfAborted();
+        }
+        catch (error) {
+            if (input.signal?.aborted) {
+                processEntry.discardOnFinish = true;
+                this.stopProcess(processEntry, "SIGTERM");
+            }
+            throw error;
+        }
         if (processEntry.running)
             processEntry.background = true;
         const snapshot = this.consume(processEntry, input.maxOutputTokens);
@@ -263,7 +288,7 @@ export class ProcessManager {
             const fallback = interactionRequested ? DEFAULT_INTERACTIVE_YIELD_MS : DEFAULT_POLL_YIELD_MS;
             const maximum = interactionRequested ? MAX_COMMAND_YIELD_MS : MAX_POLL_YIELD_MS;
             const yieldTimeMs = boundedInteger(input.yieldTimeMs, fallback, maximum);
-            await this.waitForExit(processEntry, yieldTimeMs);
+            await this.waitForExit(processEntry, yieldTimeMs, input.signal);
         }
         const snapshot = this.consume(processEntry, input.maxOutputTokens);
         if (!processEntry.running)
@@ -271,7 +296,9 @@ export class ProcessManager {
         return snapshot;
     }
     activeWorkspaceIds() {
-        return new Set([...this.processes.values()].map((processEntry) => processEntry.workspaceId));
+        return new Set([...this.processes.values()]
+            .filter((processEntry) => processEntry.running)
+            .map((processEntry) => processEntry.workspaceId));
     }
     stats() {
         let running = 0;
@@ -311,10 +338,17 @@ export class ProcessManager {
         if (processEntry.running)
             processEntry.process?.kill("SIGTERM");
     }
+    discardUndelivered(workspaceId, processId) {
+        const processEntry = this.getOwnedProcess(workspaceId, processId);
+        processEntry.discardOnFinish = true;
+        if (processEntry.running)
+            this.stopProcess(processEntry, "SIGTERM");
+        else
+            this.removeProcess(processEntry.id);
+    }
     shutdown() {
         for (const processEntry of this.processes.values()) {
-            if (processEntry.cleanupTimer)
-                clearTimeout(processEntry.cleanupTimer);
+            this.clearProcessTimers(processEntry);
             if (processEntry.running)
                 processEntry.process?.kill("SIGTERM");
         }
@@ -322,19 +356,32 @@ export class ProcessManager {
         this.completedByWorkspace.clear();
         this.completedProcessIds.length = 0;
     }
-    async waitForExit(processEntry, yieldTimeMs) {
+    async waitForExit(processEntry, yieldTimeMs, signal) {
+        signal?.throwIfAborted();
         let timer;
+        let abortListener;
         try {
-            await Promise.race([
+            const waits = [
                 processEntry.exitPromise,
                 new Promise((resolve) => {
                     timer = setTimeout(resolve, yieldTimeMs);
                 }),
-            ]);
+            ];
+            if (signal) {
+                waits.push(new Promise((_resolve, reject) => {
+                    abortListener = () => reject(signal.reason instanceof Error
+                        ? signal.reason
+                        : Object.assign(new Error("Process wait cancelled by Host."), { name: "AbortError" }));
+                    signal.addEventListener("abort", abortListener, { once: true });
+                }));
+            }
+            await Promise.race(waits);
         }
         finally {
             if (timer)
                 clearTimeout(timer);
+            if (signal && abortListener)
+                signal.removeEventListener("abort", abortListener);
         }
     }
     createProcess(input) {
@@ -351,7 +398,10 @@ export class ProcessManager {
             rows: terminalSize(input.rows, DEFAULT_ROWS),
             buffer: new HeadTailBuffer(this.maxBufferCharacters),
             running: true,
+            timedOut: false,
+            outputWasTruncated: false,
             background: false,
+            discardOnFinish: false,
             exitPromise,
             resolveExit,
         };
@@ -423,9 +473,18 @@ export class ProcessManager {
         processEntry.running = false;
         processEntry.exitCode = exitCode;
         processEntry.signal = signal;
+        processEntry.finishedAtMonotonic = this.monotonicNow();
         processEntry.process = undefined;
+        if (processEntry.executionTimeoutTimer)
+            clearTimeout(processEntry.executionTimeoutTimer);
+        if (processEntry.forceKillTimer)
+            clearTimeout(processEntry.forceKillTimer);
         processEntry.resolveExit();
-        processEntry.cleanupTimer = setTimeout(() => this.removeProcess(processEntry.id), this.completedProcessTtlMs);
+        if (processEntry.discardOnFinish) {
+            this.removeProcess(processEntry.id);
+            return;
+        }
+        processEntry.cleanupTimer = setTimeout(() => this.compactCompletedProcess(processEntry), this.completedProcessTtlMs);
         processEntry.cleanupTimer.unref();
         if (processEntry.background) {
             const completed = this.completedByWorkspace.get(processEntry.workspaceId) ?? [];
@@ -442,6 +501,17 @@ export class ProcessManager {
             }
         }
     }
+    compactCompletedProcess(processEntry) {
+        if (processEntry.running || !this.processes.has(processEntry.id))
+            return;
+        const compacted = this.consume(processEntry, COMPACT_COMPLETION_OUTPUT_TOKENS);
+        processEntry.buffer = new HeadTailBuffer(COMPACT_COMPLETION_CHARACTERS);
+        processEntry.buffer.append(compacted.output);
+        processEntry.outputWasTruncated = compacted.outputTruncated;
+        const remainingMs = Math.max(1, COMPACT_COMPLETION_TTL_MS - this.completedProcessTtlMs);
+        processEntry.cleanupTimer = setTimeout(() => this.removeProcess(processEntry.id), remainingMs);
+        processEntry.cleanupTimer.unref();
+    }
     append(processEntry, output) {
         processEntry.buffer.append(output);
     }
@@ -449,18 +519,53 @@ export class ProcessManager {
         const limit = boundedInteger(maxOutputTokens, DEFAULT_MAX_OUTPUT_TOKENS, 100_000);
         const maxCharacters = Math.max(256, limit * 4);
         const buffered = processEntry.buffer.drain(maxCharacters);
+        if (buffered.truncated)
+            processEntry.outputWasTruncated = true;
         const processId = processEntry.running ? processEntry.id : undefined;
+        const endedAt = processEntry.finishedAtMonotonic ?? this.monotonicNow();
         return {
             processId,
             sessionId: processId,
             output: buffered.output,
-            outputTruncated: buffered.truncated,
+            outputTruncated: processEntry.outputWasTruncated,
             running: processEntry.running,
             exitCode: processEntry.exitCode,
             signal: processEntry.signal,
-            wallTimeMs: Math.max(0, Math.round(this.monotonicNow() - processEntry.startedAtMonotonic)),
+            timedOut: processEntry.timedOut,
+            wallTimeMs: Math.max(0, Math.round(endedAt - processEntry.startedAtMonotonic)),
         };
     }
+    armExecutionTimeout(processEntry, timeoutMs) {
+        if (timeoutMs === undefined)
+            return;
+        processEntry.executionTimeoutTimer = setTimeout(() => {
+            if (!processEntry.running)
+                return;
+            processEntry.timedOut = true;
+            this.stopProcess(processEntry, "SIGTERM");
+        }, timeoutMs);
+        processEntry.executionTimeoutTimer.unref();
+    }
+    stopProcess(processEntry, signal) {
+        if (!processEntry.running)
+            return;
+        processEntry.process?.kill(signal);
+        if (processEntry.forceKillTimer)
+            clearTimeout(processEntry.forceKillTimer);
+        processEntry.forceKillTimer = setTimeout(() => {
+            if (processEntry.running)
+                processEntry.process?.kill("SIGKILL");
+        }, 500);
+        processEntry.forceKillTimer.unref();
+    }
+    clearProcessTimers(processEntry) {
+        if (processEntry.cleanupTimer)
+            clearTimeout(processEntry.cleanupTimer);
+        if (processEntry.executionTimeoutTimer)
+            clearTimeout(processEntry.executionTimeoutTimer);
+        if (processEntry.forceKillTimer)
+            clearTimeout(processEntry.forceKillTimer);
+    }
     getOwnedProcess(workspaceId, processId) {
         const processEntry = this.processes.get(processId);
         if (!processEntry)
@@ -472,8 +577,8 @@ export class ProcessManager {
     }
     removeProcess(processId) {
         const processEntry = this.processes.get(processId);
-        if (processEntry?.cleanupTimer)
-            clearTimeout(processEntry.cleanupTimer);
+        if (processEntry)
+            this.clearProcessTimers(processEntry);
         this.processes.delete(processId);
         const completedIndex = this.completedProcessIds.indexOf(processId);
         if (completedIndex >= 0)