nexus-agentd 0.3.1 → 0.4.0

package/dist/artifact-store.js

@@ -35,6 +35,7 @@ export class ArtifactStore {
     pending = new Map();
     inFlight = new Map();
     pendingDeletes = new Set();
+    pendingManifests = new Set();
     queuedBytes = 0;
     totalBytes = 0;
     activeDrain;
@@ -261,11 +262,49 @@ export class ArtifactStore {
             this.entries.set(entryKey(runId, normalized.id), entry);
             byId.set(normalized.id, next);
         }
-        const views = Array.from(byId.values()).slice(0, this.maxArtifactsPerRun);
+        this.trimRunEntries(runId);
+        const views = this.viewsForRun(runId);
         this.emit(runId, views);
         this.scheduleDrain();
         return structuredClone(views);
     }
+    /**
+     * Caps how many artifacts a single run retains. `recordArtifacts` is
+     * incremental, so a protocol stream that reports a fresh id per event
+     * (screenshots, timestamped logs) would otherwise grow `entries` without
+     * bound and make every emit clone the whole run.
+     */
+    trimRunEntries(runId) {
+        const entries = Array.from(this.entries.values())
+            .filter((entry) => entry.runId === runId)
+            .sort((left, right) => left.view.createdAt - right.view.createdAt);
+        let excess = entries.length - this.maxArtifactsPerRun;
+        if (excess <= 0)
+            return;
+        for (const entry of entries) {
+            if (excess <= 0)
+                break;
+            // An in-flight payload cannot be unlinked while it is being
+            // written; it is the newest entry in practice, so a later call
+            // trims it instead.
+            if (this.inFlight.has(entryKey(runId, entry.id)))
+                continue;
+            this.dropEntry(entry);
+            excess -= 1;
+        }
+    }
+    dropEntry(entry) {
+        this.entries.delete(entryKey(entry.runId, entry.id));
+        this.removePending(entry.runId, entry.id);
+        this.totalBytes -= entry.bytes || 0;
+        if (entry.filePath) {
+            const filePath = entry.filePath;
+            void this.safeUnlink(filePath).catch(() => undefined);
+        }
+        // The manifest still lists the dropped entry; rewrite it on the next
+        // drain so a restart cannot resurrect an artifact with no payload.
+        this.pendingManifests.add(entry.runId);
+    }
     /** Merge display metadata from a RunStore update without dropping storage state. */
     mergeViews(runId, views, notify = true) {
         this.assertInitialized();
@@ -356,6 +395,7 @@ export class ArtifactStore {
                 this.queuedBytes -= item.bytes.length;
             this.pending.delete(runId);
         }
+        this.pendingManifests.delete(runId);
         this.pendingDeletes.add(runId);
         this.scheduleDrain();
     }
@@ -393,7 +433,7 @@ export class ArtifactStore {
         this.assertInitialized();
         if (this.activeDrain)
             await this.activeDrain;
-        if (this.pending.size || this.pendingDeletes.size) {
+        if (this.pending.size || this.pendingDeletes.size || this.pendingManifests.size) {
             // A previous background attempt may have failed. Keep the
             // snapshot dirty and let an explicit flush retry it.
             this.lastError = undefined;
@@ -454,11 +494,28 @@ export class ArtifactStore {
     }
     async drainLoop() {
         this.lastError = undefined;
-        while (this.pending.size || this.pendingDeletes.size) {
+        while (this.pending.size || this.pendingDeletes.size || this.pendingManifests.size) {
             const runId = this.pendingDeletes.values().next().value;
             if (runId) {
                 this.pendingDeletes.delete(runId);
-                await this.deleteRunDirectory(runId);
+                try {
+                    await this.deleteRunDirectory(runId);
+                }
+                catch (error) {
+                    // Keep the delete queued: dropping it would leave the
+                    // directory on disk with no record left to remove it.
+                    this.pendingDeletes.add(runId);
+                    throw error;
+                }
+                continue;
+            }
+            const manifestRunId = this.pendingManifests.values().next().value;
+            if (manifestRunId) {
+                this.pendingManifests.delete(manifestRunId);
+                // removeRun drops the whole directory; rewriting a manifest
+                // afterwards would recreate it.
+                if (this.runIds.has(manifestRunId))
+                    await this.writeManifest(manifestRunId);
                 continue;
             }
             const batchEntry = this.pending.entries().next().value;
@@ -498,8 +555,13 @@ export class ArtifactStore {
         const startedAt = performance.now();
         const key = entryKey(item.runId, item.id);
         let entry = this.entries.get(key);
-        if (!entry)
+        if (!entry) {
+            // The entry was dropped after this batch left `pending`, so
+            // removeRun and dropEntry could no longer see it there. Releasing
+            // the budget here is the only remaining place that can.
+            this.queuedBytes -= item.bytes.length;
             return;
+        }
         const runDir = this.runDirectory(item.runId);
         await this.io.mkdir(runDir, { recursive: true, mode: 0o700 });
         await this.ensureDirectory(runDir, false);

package/dist/process-tree.js

@@ -1,23 +1,45 @@
 import { spawn } from 'node:child_process';
 const DEFAULT_GRACE_MS = 2_000;
 const FORCE_KILL_WAIT_MS = 1_000;
+// Enumerating costs about a second on an idle machine and considerably more
+// when the gateway is busy. The sweep runs on every teardown — including a
+// failed ACP startup, which callers bound at five seconds — so it is capped
+// short: an incomplete sweep beats a teardown that never returns.
+const PROCESS_TABLE_TIMEOUT_MS = 1_200;
+const PROCESS_TABLE_TTL_MS = 1_000;
+// Windows reports a killed process as gone from `tasklist` slightly before the
+// kernel closes the handles it held, so callers that delete the workspace or
+// temp directory right after a teardown can still see EBUSY.
+const PROCESS_EXIT_SETTLE_MS = 150;
+let processTableCache;
 export async function terminateProcessTree(child, options = {}) {
     const pid = child.pid;
     if (!pid)
         return;
     const graceMs = Math.max(0, options.graceMs ?? DEFAULT_GRACE_MS);
     if (process.platform === 'win32') {
-        // Once a Windows process has exited taskkill can no longer address its
-        // descendants by the parent's PID. Callers should tear down before
-        // exit when they need Windows tree semantics.
-        if (hasExited(child))
-            return;
-        await taskkill(pid, false);
-        if (await waitForExit(child, graceMs))
-            return;
-        await taskkill(pid, true);
-        if (await waitForExit(child, FORCE_KILL_WAIT_MS))
+        // `taskkill` without /F only posts WM_CLOSE, which console processes
+        // never handle: the graceful pass always fails and burns the whole
+        // grace period before the forced retry. Force the tree kill directly.
+        if (!hasExited(child)) {
+            await taskkill(pid, true);
+            if (!(await waitForExit(child, Math.max(graceMs, FORCE_KILL_WAIT_MS)))) {
+                // A forced kill can still lose the race on a loaded machine,
+                // where the process takes longer than the wait to disappear.
+                await taskkill(pid, true);
+                await waitForExit(child, FORCE_KILL_WAIT_MS);
+            }
+        }
+        // A forced `taskkill /T` walks the tree as it exists at that instant,
+        // so a child spawned moments before the leader died survives as an
+        // orphan holding ports, file locks and inherited pipes — and a leader
+        // that exited before we got here cannot be addressed by taskkill at
+        // all. Sweep by parent id in both cases.
+        await terminateOrphanedDescendants(pid);
+        if (hasExited(child)) {
+            await delay(PROCESS_EXIT_SETTLE_MS);
             return;
+        }
         throw new Error(`Failed to terminate process ${pid}`);
     }
     if (options.ownsProcessGroup === true) {
@@ -106,6 +128,111 @@ function taskkill(pid, force) {
         killer.once('exit', finish);
     });
 }
+/**
+ * Kills every process that still records `pid` as an ancestor.
+ *
+ * `taskkill /T` walks the live process tree, so it cannot reach children once
+ * their parent has exited. Windows keeps the original parent id on the child
+ * after that, which is enough to find the survivors. Best-effort by design: an
+ * unreadable process table just leaves the sweep incomplete.
+ */
+async function terminateOrphanedDescendants(pid) {
+    const doomed = collectDescendants(await windowsProcessTable(), pid);
+    if (!doomed.length)
+        return;
+    for (const target of doomed)
+        await taskkill(target, true);
+    // Killing a parent can strand its own children, so rescan for what is left.
+    const remaining = collectDescendants(await windowsProcessTable(true), pid);
+    for (const survivor of remaining)
+        await taskkill(survivor, true);
+}
+function collectDescendants(table, root) {
+    if (!table)
+        return [];
+    const found = [];
+    const pending = [...(table.get(root) || [])];
+    while (pending.length) {
+        const next = pending.shift();
+        if (found.includes(next))
+            continue;
+        found.push(next);
+        pending.push(...(table.get(next) || []));
+    }
+    return found;
+}
+/**
+ * Snapshots the Windows process table as parent id -> child ids. Enumerating
+ * costs about a second, and a teardown that arrives alongside others (probing
+ * every driver at startup, shutting a session down) asks the same question, so
+ * concurrent callers share one snapshot. `refresh` bypasses it when the answer
+ * has to describe the state after a kill.
+ */
+function windowsProcessTable(refresh = false) {
+    const now = Date.now();
+    if (!refresh && processTableCache && now - processTableCache.at < PROCESS_TABLE_TTL_MS) {
+        return processTableCache.promise;
+    }
+    const promise = snapshotProcessTable();
+    processTableCache = { at: now, promise };
+    return promise;
+}
+function snapshotProcessTable() {
+    return new Promise((resolve) => {
+        let lister;
+        try {
+            lister = spawn('powershell.exe', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId)" }'
+            ], { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        }
+        catch {
+            resolve(undefined);
+            return;
+        }
+        let output = '';
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => {
+            try {
+                lister.kill();
+            }
+            catch { }
+            finish(undefined);
+        }, PROCESS_TABLE_TIMEOUT_MS);
+        lister.stdout?.on('data', (chunk) => {
+            output = `${output}${String(chunk)}`.slice(-4_000_000);
+        });
+        lister.once('error', () => finish(undefined));
+        lister.once('exit', (code) => {
+            finish(code === 0 ? parseProcessTable(output) : undefined);
+        });
+    });
+}
+function parseProcessTable(output) {
+    const table = new Map();
+    for (const line of output.split(/\r?\n/)) {
+        const match = /^(\d+)\s+(\d+)$/.exec(line.trim());
+        if (!match)
+            continue;
+        const child = Number(match[1]);
+        const parent = Number(match[2]);
+        const siblings = table.get(parent);
+        if (siblings)
+            siblings.push(child);
+        else
+            table.set(parent, [child]);
+    }
+    return table;
+}
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/run-store.js

@@ -442,16 +442,31 @@ export class RunStore {
         const run = this.runs.get(runId);
         if (!run)
             return;
-        run.artifacts = structuredClone(views);
-        run.artifactCount = run.artifacts.length;
-        run.updatedAt = this.now();
         if (!this.initialized) {
+            // The artifact store prunes during its own init and emits as it
+            // goes, but at that point it only knows about manifest-backed
+            // entries — the rest of runs.json has not been restored yet.
+            // Replacing wholesale would drop metadata-only artifacts for good,
+            // while skipping the update would lose the storage status the
+            // prune just decided (expired/evicted), which restoreRun then
+            // misreads as metadata_only. Merge both sides instead.
+            run.artifacts = mergeArtifactViews(run.artifacts, views);
+            run.artifactCount = run.artifacts.length;
             this.dirty = true;
             return;
         }
+        run.artifacts = structuredClone(views);
+        run.artifactCount = run.artifacts.length;
+        run.updatedAt = this.now();
         this.changed();
     }
 }
+function mergeArtifactViews(existing, incoming) {
+    const merged = new Map(existing.map((view) => [view.id, view]));
+    for (const view of incoming)
+        merged.set(view.id, view);
+    return Array.from(merged.values());
+}
 export function runStorePathForConfig(configPath) {
     const absolute = path.resolve(configPath);
     const extension = path.extname(absolute);

package/dist/session.js

@@ -936,9 +936,46 @@ function mediaTypeForPath(path) {
         case '.txt':
         case '.log':
         case '.md':
+        case '.markdown':
+        case '.conf':
+        case '.ini':
+        case '.toml':
+        case '.env':
             return 'text/plain';
         case '.json':
             return 'application/json';
+        case '.html':
+        case '.htm':
+            return 'text/html';
+        case '.css':
+            return 'text/css';
+        case '.js':
+        case '.mjs':
+        case '.cjs':
+            return 'text/javascript';
+        case '.ts':
+        case '.tsx':
+        case '.jsx':
+        case '.py':
+        case '.rb':
+        case '.go':
+        case '.rs':
+        case '.java':
+        case '.c':
+        case '.h':
+        case '.cpp':
+        case '.sh':
+        case '.bash':
+        case '.ps1':
+        case '.sql':
+            return 'text/plain';
+        case '.yaml':
+        case '.yml':
+            return 'text/yaml';
+        case '.xml':
+            return 'application/xml';
+        case '.csv':
+            return 'text/csv';
         case '.pdf':
             return 'application/pdf';
         case '.png':
@@ -952,10 +989,41 @@ function mediaTypeForPath(path) {
             return 'image/webp';
         case '.svg':
             return 'image/svg+xml';
-        case '.csv':
-            return 'text/csv';
+        case '.bmp':
+            return 'image/bmp';
+        case '.ico':
+            return 'image/x-icon';
+        case '.wav':
+            return 'audio/wav';
+        case '.mp3':
+            return 'audio/mpeg';
+        case '.ogg':
+        case '.oga':
+            return 'audio/ogg';
+        case '.m4a':
+            return 'audio/mp4';
+        case '.aac':
+            return 'audio/aac';
+        case '.flac':
+            return 'audio/flac';
+        case '.mp4':
+            return 'video/mp4';
+        case '.webm':
+            return 'video/webm';
+        case '.mov':
+            return 'video/quicktime';
+        case '.mkv':
+            return 'video/x-matroska';
         case '.zip':
             return 'application/zip';
+        case '.doc':
+            return 'application/msword';
+        case '.docx':
+            return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+        case '.xlsx':
+            return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+        case '.pptx':
+            return 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
         default:
             return 'application/octet-stream';
     }