@co0ontty/wand 4.72.0 → 4.72.1

package/dist/terminal-daemon-server.d.ts

@@ -1,2 +1,14 @@
+/** Retention view of one structured run, in map insertion order (oldest first). */
+export interface StructuredRunRetentionEntry {
+    runId: string;
+    status: "running" | "exited";
+    exitedAt: number | null;
+    logChars: number;
+}
+/**
+ * Oldest-first ids of exited runs that fall outside the count, retained-log, or
+ * age budget. Running runs are never evicted: their child is still live.
+ */
+export declare function structuredRunEvictionOrder(entries: readonly StructuredRunRetentionEntry[], now?: number): string[];
 export declare function runTerminalDaemon(configPath: string): Promise<void>;
 export declare function readTerminalDaemonPid(configPath: string): number | null;

package/dist/terminal-daemon-server.js

@@ -14,6 +14,46 @@ import { PtyTerminalState } from "./pty-terminal-state.js";
 import { PtyCliExitMarker } from "./pty-shell-launch.js";
 import { appendWindow, PTY_OUTPUT_MAX_SIZE } from "./pty-text-utils.js";
 const MAX_STRUCTURED_RUNS = 256;
+/**
+ * Exited records exist so a web restart can adopt a finished turn. Each one
+ * carries a replay log capped at STRUCTURED_RUN_LOG_MAX_CHARS, so a count-only
+ * bound would still let the daemon retain 256 x 8M chars of logs; the exited
+ * set is bounded by aggregate log size as well, and old records expire.
+ */
+const MAX_EXITED_STRUCTURED_RUNS = 128;
+const EXITED_STRUCTURED_RUN_LOG_MAX_CHARS = 32 * 1024 * 1024;
+const EXITED_STRUCTURED_RUN_RETENTION_MS = 2 * 60 * 60 * 1000;
+/**
+ * Oldest-first ids of exited runs that fall outside the count, retained-log, or
+ * age budget. Running runs are never evicted: their child is still live.
+ */
+export function structuredRunEvictionOrder(entries, now = Date.now()) {
+    let total = entries.length;
+    let exitedCount = 0;
+    let exitedLogChars = 0;
+    for (const entry of entries) {
+        if (entry.status !== "exited")
+            continue;
+        exitedCount++;
+        exitedLogChars += entry.logChars;
+    }
+    const evicted = [];
+    for (const entry of entries) {
+        if (entry.status !== "exited")
+            continue;
+        const expired = entry.exitedAt !== null && now - entry.exitedAt >= EXITED_STRUCTURED_RUN_RETENTION_MS;
+        const overBudget = total > MAX_STRUCTURED_RUNS
+            || exitedCount > MAX_EXITED_STRUCTURED_RUNS
+            || exitedLogChars > EXITED_STRUCTURED_RUN_LOG_MAX_CHARS;
+        if (!expired && !overBudget)
+            continue;
+        evicted.push(entry.runId);
+        total--;
+        exitedCount--;
+        exitedLogChars -= entry.logChars;
+    }
+    return evicted;
+}
 const MAX_REQUEST_BUFFER = 4 * 1024 * 1024;
 export async function runTerminalDaemon(configPath) {
     const paths = terminalDaemonPaths(configPath);
@@ -178,16 +218,19 @@ export async function runTerminalDaemon(configPath) {
         stdoutTruncated: run.stdoutTruncated,
         stderrTruncated: run.stderrTruncated,
     });
-    /** Evict oldest exited records once the map outgrows its bound. */
+    /** Evict oldest exited records until counts, retained logs, and age are back in budget. */
     const evictStaleStructuredRuns = () => {
-        if (structuredRuns.size <= MAX_STRUCTURED_RUNS)
-            return;
+        const entries = [];
         for (const [runId, run] of structuredRuns) {
-            if (structuredRuns.size <= MAX_STRUCTURED_RUNS)
-                break;
-            if (run.status === "exited")
-                structuredRuns.delete(runId);
+            entries.push({
+                runId,
+                status: run.status,
+                exitedAt: run.exitedAt,
+                logChars: run.stdoutLog.length + run.stderrLog.length,
+            });
         }
+        for (const runId of structuredRunEvictionOrder(entries))
+            structuredRuns.delete(runId);
     };
     const structuredSpawn = (request) => {
         const existing = structuredRuns.get(request.runId);
@@ -209,6 +252,7 @@ export async function runTerminalDaemon(configPath) {
             status: "running",
             exitCode: null,
             signal: null,
+            exitedAt: null,
             stdoutSeq: 0,
             stderrSeq: 0,
             stdoutLog: "",
@@ -252,6 +296,7 @@ export async function runTerminalDaemon(configPath) {
             run.child = null;
             run.status = "exited";
             run.exitCode = code;
+            run.exitedAt = Date.now();
             run.signal = signalName === null || signalName === undefined ? null : Number(signalName) || signalNumberFromName(signalName);
             broadcast({
                 kind: "event",
@@ -261,6 +306,7 @@ export async function runTerminalDaemon(configPath) {
                 exitCode: run.exitCode ?? undefined,
                 signal: run.signal ?? undefined,
             });
+            evictStaleStructuredRuns();
         });
         return serializeStructuredRun(run);
     };

package/dist/terminal-host.d.ts

@@ -15,8 +15,6 @@ export interface TerminalProcess {
     write(data: string): void;
     resize(cols: number, rows: number): void;
     kill(signal?: string): void;
-    pause(): void;
-    resume(): void;
     onData(listener: (event: TerminalDataEvent) => void): {
         dispose(): void;
     };

package/dist/terminal-host.js

@@ -23,12 +23,6 @@ class InProcessTerminalProcess {
     kill(signal) {
         this.child.kill(signal);
     }
-    pause() {
-        this.child.pause();
-    }
-    resume() {
-        this.child.resume();
-    }
     onData(listener) {
         return this.child.onData((data) => listener({ data, seq: ++this.seq }));
     }