mixdog 0.9.50 → 0.9.52

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -17,6 +17,7 @@ import {
     endShellJobWait,
     clearShellJobNotifyCtx,
     shellJobPublicTaskResult,
+    attachShellJobResourceLease,
 } from './shell-jobs.mjs';
 import {
     analyzeShellCommandEffects,
@@ -45,6 +46,7 @@ import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { resolveOptionalCwd } from './cwd-utils.mjs';
 import { scrubLoaderVars, scrubProviderSecrets } from '../env-scrub.mjs';
 import { resolveSessionCwd, stateFilePath, wrapPowerShellWithCwdProbe, wrapBashWithCwdProbe } from '../shell-state.mjs';
+import { resourceAdmission } from '../../../../shared/resource-admission.mjs';
 
 // Post-exec drift detection. After a foreground shell command, compare the
 // live mtime+size of files mixdog has already read this session against their
@@ -263,7 +265,11 @@ export async function executeBashTool(args, workDir, options = {}) {
         const shouldCreate = args.create === true || !userProvidedSession;
         effectiveArgs = { ...effectiveArgs, create: shouldCreate };
         try {
-            return await executeBashSessionTool('bash_session', effectiveArgs, bashWorkDir, { abortSignal: combinedPersistAbort.signal, sessionId: options?.sessionId });
+            return await executeBashSessionTool('bash_session', effectiveArgs, bashWorkDir, {
+                abortSignal: combinedPersistAbort.signal,
+                sessionId: options?.sessionId,
+                resourceAdmission: options?.resourceAdmission || resourceAdmission,
+            });
         } finally {
             combinedPersistAbort.cleanup();
         }
@@ -406,24 +412,50 @@ export async function executeBashTool(args, workDir, options = {}) {
             wrappedCommand = command;
         }
         if (runInBackground) {
-            const job = startBackgroundShellJob({
-                command: wrappedCommand,
-                timeoutMs: timeout,
-                workDir: bashWorkDir,
-                mergeStderr,
-                spawnEnv,
-                shell,
-                shellArg,
-                shellArgs,
-                shellType,
-                // Per-terminal session stamp: the dispatching terminal's
-                // claude.exe pid (server-main threads callerSession.clientHostPid).
-                clientHostPid: options?.clientHostPid,
-            });
-            if (job && job.error) return formatShellToolFailure(job.error);
-            let task;
+            let asyncAbortSignal = null;
+            try { asyncAbortSignal = (await getAbortSignalForSession(options?.sessionId)) || null; }
+            catch { asyncAbortSignal = null; }
+            const combinedAsyncAbort = _combineAbortSignals(asyncAbortSignal, options?.abortSignal || null);
+            let asyncLease = null;
+            let job;
             try {
-                task = registerBackgroundTask({
+                asyncLease = await (options?.resourceAdmission || resourceAdmission).acquire('shell', {
+                    signal: combinedAsyncAbort.signal,
+                    label: String(command).replace(/\s+/g, ' ').slice(0, 120),
+                    dependency: 'detached',
+                });
+                if (combinedAsyncAbort.signal?.aborted) {
+                    throw combinedAsyncAbort.signal.reason || new Error('shell background task cancelled before spawn');
+                }
+                job = await startBackgroundShellJob({
+                    command: wrappedCommand,
+                    timeoutMs: timeout,
+                    workDir: bashWorkDir,
+                    mergeStderr,
+                    spawnEnv,
+                    shell,
+                    shellArg,
+                    shellArgs,
+                    shellType,
+                    // Per-terminal session stamp: the dispatching terminal's
+                    // claude.exe pid (server-main threads callerSession.clientHostPid).
+                    clientHostPid: options?.clientHostPid,
+                    ...(options?.shellJobRuntime || {}),
+                });
+                if (job && job.error) {
+                    if (job.rollbackPending && attachShellJobResourceLease(job.jobId, asyncLease, { allowUnpersisted: true })) {
+                        asyncLease = null;
+                    }
+                    return formatShellToolFailure(job.error);
+                }
+                if (combinedAsyncAbort.signal?.aborted) {
+                    try { killShellJob(job.jobId); } catch {}
+                    throw combinedAsyncAbort.signal.reason || new Error('shell background task cancelled before registration');
+                }
+                if (job && !job.error && attachShellJobResourceLease(job.jobId, asyncLease)) {
+                    asyncLease = null;
+                }
+                const task = registerBackgroundTask({
                     taskId: job.jobId,
                     surface: 'shell',
                     operation: 'shell',
@@ -446,26 +478,31 @@ export async function executeBashTool(args, workDir, options = {}) {
                     resultType: 'shell_task_result',
                     cancel: () => killShellJob(job.jobId),
                 });
-            } catch (err) {
-                try { killShellJob(job.jobId); } catch { /* best effort cleanup */ }
-                return formatShellToolFailure(normalizeErrorMessage(err instanceof Error ? err.message : String(err)));
+                if (combinedAsyncAbort.signal?.aborted) {
+                    try { killShellJob(job.jobId); } catch {}
+                    cancelBackgroundTask(job.jobId, 'cancelled before background registration completed');
+                    throw combinedAsyncAbort.signal.reason || new Error('shell background task cancelled during registration');
+                }
+                // Wire a one-shot completion push so the dispatching session learns
+                // the background task finished (no polling tool is auto-driven).
+                try {
+                    watchBackgroundShellJob(job.jobId, {
+                        notifyFn: typeof options?.notifyFn === 'function' ? options.notifyFn : null,
+                        callerSessionId: options?.callerSessionId || options?.sessionId,
+                        routingSessionId: options?.routingSessionId,
+                        clientHostPid: options?.clientHostPid,
+                    });
+                } catch { /* watcher arm is best-effort; never blocks the spawn */ }
+                return _prependDestructiveWarning(command, renderBackgroundTask(task));
+            } catch (error) {
+                if (job?.jobId && !job.error) {
+                    try { killShellJob(job.jobId); } catch {}
+                }
+                return formatShellToolFailure(normalizeErrorMessage(error instanceof Error ? error.message : String(error)));
+            } finally {
+                combinedAsyncAbort.cleanup();
+                try { await asyncLease?.release(); } catch {}
             }
-            // Wire a one-shot completion push so the dispatching session learns
-            // the background task finished (no polling tool is auto-driven). The
-            // notify ctx is threaded down from the MCP dispatch frame
-            // (server-main agentContext / _dispatchByModule) the same way the
-            // agent/explore-style tools receive notifyFn/routingSessionId/clientHostPid.
-            // Missing notifyFn (e.g. a non-MCP caller) degrades to a stderr
-            // diagnostic inside watchBackgroundShellJob — never fails the spawn.
-            try {
-                watchBackgroundShellJob(job.jobId, {
-                    notifyFn: typeof options?.notifyFn === 'function' ? options.notifyFn : null,
-                    callerSessionId: options?.callerSessionId || options?.sessionId,
-                    routingSessionId: options?.routingSessionId,
-                    clientHostPid: options?.clientHostPid,
-                });
-            } catch { /* watcher arm is best-effort; never blocks the spawn */ }
-            return _prependDestructiveWarning(command, renderBackgroundTask(task));
         }
 
         let bashAbortSignal = null;

package/src/runtime/agent/orchestrator/tools/builtin/shell-job-process.mjs

@@ -10,9 +10,230 @@ export function isPidAlive(pid) {
     try {
         process.kill(pid, 0);
         return true;
-    } catch {
-        return false;
+    } catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+
+// Admission follows the owned process group on POSIX, not just the spawned
+// shell. A shell can exit after launching a descendant which remains in its
+// detached group. Windows has no process-group probe in Node; the root PID is
+// the strongest non-invasive lifecycle signal available here (tree-kill still
+// uses taskkill /T).
+export function isProcessTreeAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0) return false;
+    if (process.platform === 'win32') return isPidAlive(pid);
+    try {
+        process.kill(-pid, 0);
+        return true;
+    } catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+
+const windowsSnapshotCaches = new WeakMap();
+function windowsProcessSnapshot({ fresh = false, spawnFn = spawn } = {}) {
+    let windowsSnapshotCache = windowsSnapshotCaches.get(spawnFn);
+    if (!windowsSnapshotCache) {
+        windowsSnapshotCache = { at: 0, rows: null, inFlight: null };
+        windowsSnapshotCaches.set(spawnFn, windowsSnapshotCache);
+    }
+    const now = Date.now();
+    if (!fresh && windowsSnapshotCache.rows && now - windowsSnapshotCache.at < 750) {
+        return Promise.resolve(windowsSnapshotCache.rows);
+    }
+    if (windowsSnapshotCache.inFlight) return windowsSnapshotCache.inFlight;
+    const command = [
+        "$ErrorActionPreference='Stop'",
+        'Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,CreationDate | ForEach-Object {',
+        '  [Console]::Out.WriteLine(("{0}`t{1}`t{2}" -f $_.ProcessId,$_.ParentProcessId,$_.CreationDate))',
+        '}',
+    ].join('; ');
+    windowsSnapshotCache.inFlight = new Promise((resolve) => {
+        let child;
+        let stdout = '';
+        let settled = false;
+        let timeout = null;
+        const finish = (rows) => {
+            if (settled) return;
+            settled = true;
+            if (timeout) clearTimeout(timeout);
+            windowsSnapshotCache.inFlight = null;
+            if (rows) {
+                windowsSnapshotCache.at = Date.now();
+                windowsSnapshotCache.rows = rows;
+            }
+            resolve(rows);
+        };
+        try {
+            child = spawnFn('powershell.exe', [
+            '-NoLogo', '-NoProfile', '-NonInteractive', '-Command', command,
+            ], {
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', (chunk) => {
+                if (stdout.length <= 4 * 1024 * 1024) stdout += chunk;
+            });
+            child.once('error', () => finish(null));
+            child.once('close', (code) => {
+                if (code !== 0 || !stdout) {
+                    finish(null);
+                    return;
+                }
+                const rows = new Map();
+                for (const line of stdout.split(/\r?\n/)) {
+                    const [pidText, parentText, identity = ''] = line.split('\t');
+                    const rowPid = Number(pidText);
+                    const parentPid = Number(parentText);
+                    if (!Number.isFinite(rowPid) || rowPid <= 0 || !Number.isFinite(parentPid)) continue;
+                    rows.set(rowPid, { pid: rowPid, parentPid, identity });
+                }
+                finish(rows);
+            });
+            timeout = setTimeout(() => {
+                try { child.kill(); } catch {}
+                finish(null);
+            }, 2000);
+            if (typeof timeout.unref === 'function') timeout.unref();
+        } catch {
+            finish(null);
+        }
+    });
+    return windowsSnapshotCache.inFlight;
+}
+
+function normalizeWindowsSnapshot(snapshot) {
+    if (snapshot instanceof Map) return snapshot;
+    if (!Array.isArray(snapshot)) return null;
+    const rows = new Map();
+    for (const row of snapshot) {
+        const rowPid = Number(row?.pid);
+        const parentPid = Number(row?.parentPid);
+        if (!Number.isFinite(rowPid) || rowPid <= 0 || !Number.isFinite(parentPid)) continue;
+        rows.set(rowPid, { pid: rowPid, parentPid, identity: String(row?.identity ?? '') });
+    }
+    return rows;
+}
+
+// Invoke onQuiescent exactly once, synchronously when already quiescent or
+// after positive liveness probes stop observing the owned tree/group.
+export function trackProcessTreeQuiescence(
+    pid,
+    onQuiescent,
+    {
+        pollMs = process.platform === 'win32' ? 250 : 25,
+        probe = null,
+        platform = process.platform,
+        windowsSnapshot = windowsProcessSnapshot,
+        windowsSnapshotSpawn = spawn,
+        waitForRootExit = false,
+    } = {},
+) {
+    let settled = false;
+    let timer = null;
+    let rootExitConfirmed = !waitForRootExit;
+    const rootExitCheck = Promise.withResolvers();
+    let rootExitCheckComplete = false;
+    const ownedWindowsProcesses = new Map();
+    if (platform === 'win32') {
+        // The PID returned by spawn is durable pre-exit ownership evidence.
+        // Seed it before the first asynchronous snapshot so a child whose
+        // parent is this PID remains attributable even if the root is already
+        // absent when CIM returns.
+        ownedWindowsProcesses.set(pid, null);
+    }
+    const finish = () => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearInterval(timer);
+        try {
+            Promise.resolve(onQuiescent?.()).catch(() => {});
+        } catch { /* lifecycle cleanup must not throw */ }
+    };
+    const markRootExitChecked = () => {
+        if (!rootExitConfirmed || rootExitCheckComplete) return;
+        rootExitCheckComplete = true;
+        rootExitCheck.resolve();
+    };
+    const applyWindowsSnapshot = (snapshot) => {
+        if (settled) return;
+        const rows = normalizeWindowsSnapshot(snapshot);
+        let alive = true;
+        if (!rows) {
+            const candidates = [...ownedWindowsProcesses.keys()];
+            alive = candidates.some((candidatePid) => isPidAlive(candidatePid));
+        } else {
+            const root = rows.get(pid);
+            if (root && ownedWindowsProcesses.get(pid) == null) {
+                ownedWindowsProcesses.set(pid, root.identity);
+            }
+            let discovered = true;
+            while (discovered) {
+                discovered = false;
+                for (const row of rows.values()) {
+                    if (
+                        !ownedWindowsProcesses.has(row.pid)
+                        && ownedWindowsProcesses.has(row.parentPid)
+                    ) {
+                        ownedWindowsProcesses.set(row.pid, row.identity);
+                        discovered = true;
+                    }
+                }
+            }
+            for (const [ownedPid, identity] of ownedWindowsProcesses) {
+                const current = rows.get(ownedPid);
+                if (!current || (identity != null && current.identity !== identity)) {
+                    ownedWindowsProcesses.delete(ownedPid);
+                }
+            }
+            alive = ownedWindowsProcesses.size > 0;
+        }
+        markRootExitChecked();
+        if (rootExitConfirmed && !alive) finish();
+    };
+    const check = (fresh = false) => {
+        let alive = true;
+        try {
+            if (typeof probe === 'function') {
+                alive = probe(pid) === true;
+            } else if (platform !== 'win32') {
+                // The negative PID is the ownership boundary: never substitute
+                // a root-only probe on POSIX.
+                alive = isProcessTreeAlive(pid);
+            } else {
+                Promise.resolve(windowsSnapshot({ fresh, spawnFn: windowsSnapshotSpawn })).then(applyWindowsSnapshot, () => {});
+                return;
+            }
+        } catch {
+            return;
+        }
+        markRootExitChecked();
+        if (rootExitConfirmed && !alive) finish();
+    };
+    check();
+    if (!settled) {
+        timer = setInterval(check, Math.max(1, Number(pollMs) || 25));
+        if (typeof timer.unref === 'function') timer.unref();
     }
+    return {
+        get pending() { return !settled; },
+        afterRootExitCheck() { return rootExitCheck.promise; },
+        rootExited() {
+            if (settled || rootExitConfirmed) return false;
+            rootExitConfirmed = true;
+            check(true);
+            return true;
+        },
+        cancel() {
+            if (settled) return false;
+            settled = true;
+            if (timer) clearInterval(timer);
+            markRootExitChecked();
+            return true;
+        },
+    };
 }
 
 export function killProcessTree(pid, signal = 'SIGTERM') {