mixdog 1.2.2 → 1.2.4

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

@@ -12,24 +12,67 @@
  * The owner marker disappears when the job settles and a `.done` marker keeps
  * the terminal JSON out of live counters. Terminal metadata remains available
  * for a bounded manual-recovery window.
+ *
+ * Ordering: a promoted job keeps its foreground id, so the foreground marker's
+ * retire and the promoted job's publish address the same files. Every publish,
+ * complete and retire for one jobId therefore runs on a per-job chain, strictly
+ * in call order and never overlapping. A record is written atomically (temp
+ * file + rename) and always before its owner marker, so a reader never sees a
+ * partial `.json`, and a marker never exists without its `.json`.
  */
 import { access, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { writeJsonAtomicAsync } from '../../../../../shared/atomic-file.mjs';
 import { isPidAlive } from '../../../../../shared/pid-liveness.mjs';
 import { displayShellCommand } from '../../../../../shared/shell-display.mjs';
+import { tryAdmitWorkspaceActivity } from '../../../../../shared/worktrees/activity-gate.mjs';
+import { worktreeError } from '../../../../../shared/worktrees/contract.mjs';
+import { workspaceSees } from '../../../../../shared/worktrees/workspace-visibility.mjs';
+
+const workspaceLeases = new Map();
+
+/** Transfer a foreground reader to a surviving-descendant task without a lease gap. */
+export function adoptShellWorkspaceAdmission(jobId, leave) {
+  const prior = workspaceLeases.get(jobId);
+  workspaceLeases.set(
+    jobId,
+    prior
+      ? () => {
+          prior();
+          leave();
+        }
+      : leave
+  );
+}
 
 // A record whose owner process is gone is garbage. Age alone never deletes a
 // live owner's job, so an unlimited long-running shell keeps its record.
 const ORPHAN_GRACE_MS = 60 * 60 * 1000;
 const COMPLETED_SHELL_JOB_TTL_MS = 30 * 60 * 1000;
 
-const publishing = new Map();
+const chains = new Map();
 const paths = new Map();
 const records = new Map();
-const retired = new Set();
+// jobId -> token of the live terminal record. Every publish/retire clears it and
+// every completion replaces it, so a TTL timer armed for an older incarnation
+// can tell its files are no longer the ones it was armed for.
+const incarnations = new Map();
+let incarnationSeq = 0;
 let sweepStarted = false;
 
+/** Run `operation` after every earlier operation for `jobId` has finished. */
+function enqueue(jobId, operation) {
+  const run = (chains.get(jobId) || Promise.resolve()).then(operation);
+  const tail = run.catch(() => {});
+  chains.set(jobId, tail);
+  void tail.then(() => {
+    if (chains.get(jobId) === tail) chains.delete(jobId);
+  });
+  return run;
+}
+
 function dataDir() {
   return process.env.MIXDOG_DATA_DIR || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data');
 }
@@ -132,17 +175,32 @@ async function sweepOrphanRecords(dir) {
 /** Publish the record for a job that has just started or been promoted. */
 export function publishShellJobRecord(
   task,
-  { ownerSessionId = null, clientHostPid = null, startedAtMs = 0, foreground = false } = {}
+  {
+    ownerSessionId = null,
+    clientHostPid = null,
+    startedAtMs = 0,
+    foreground = false,
+    terminationUnconfirmed = false,
+  } = {}
 ) {
   const jobId = String(task?.jobId || '').trim();
   if (!jobId) return;
+  if (task?.cwd) {
+    const leave = tryAdmitWorkspaceActivity(ownerSessionId || jobId, task.cwd, {
+      pid: Number(task.pid) || process.pid,
+      kind: 'command',
+    });
+    if (!leave) throw worktreeError('WORKTREE_BUSY_JOBS', 'The command folder is being managed.');
+    // A descendant handoff can reuse the job id with a different live pid.
+    // Acquire its reader before releasing any predecessor's admission.
+    adoptShellWorkspaceAdmission(jobId, leave);
+  }
   const ownerPid = Number(clientHostPid ?? task?.clientHostPid) || process.pid;
   const dir = jobsDir();
   const jsonPath = join(dir, `${jobId}.json`);
   const ownerPath = join(dir, `${jobId}.owner-${ownerPid}`);
-  retired.delete(jobId);
   paths.set(jobId, [jsonPath, ownerPath]);
-  const work = (async () => {
+  void enqueue(jobId, async () => {
     try {
       await mkdir(dir, { recursive: true });
       if (!sweepStarted) {
@@ -170,88 +228,230 @@ export function publishShellJobRecord(
         // removed on settle. Restart recovery skips them: there is no
         // task id to report and no waiter to notify.
         ...(foreground ? { foreground: true } : {}),
+        // A killed command whose processes are not confirmed gone: its
+        // result is reported, but the readouts keep listing it.
+        ...(terminationUnconfirmed ? { terminationUnconfirmed: true } : {}),
+        // Its owner session closed: any session that sees the folder lists
+        // (and may release) it.
+        ...(closedOwnerSessions.has(String(ownerSessionId || '')) ? { ownerSessionClosed: true } : {}),
       };
       records.set(jobId, record);
-      await writeFile(jsonPath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+      incarnations.delete(jobId);
+      // The record lands whole before the marker that advertises it.
+      await writeJsonAtomicAsync(jsonPath, record, { fsync: false });
       await writeFile(ownerPath, '', 'utf8');
     } catch {
       /* the record is presentation only; never fail a job for it */
     }
-    // A job that settled while the write was in flight must not leave a
-    // record behind.
-    if (retired.has(jobId)) await removePaths([jsonPath, ownerPath]);
-  })();
-  publishing.set(jobId, work);
-  void work.finally(() => {
-    if (publishing.get(jobId) === work) publishing.delete(jobId);
   });
 }
 
 /** Preserve a bounded terminal snapshot for manual recovery after restart. */
+// jobId -> { ownerSessionId, release } for every job whose result is reported
+// but whose processes are not confirmed gone. The hold is dropped by the
+// termination watch on confirmation, or by an explicit user force-release —
+// never by a timer.
+const terminationHolds = new Map();
+// Owner sessions that closed in this runtime: their holds have no owner left
+// to release them, so any session that sees the workspace may.
+const closedOwnerSessions = new Set();
+
+export function registerTerminationHold(jobId, { ownerSessionId = null, cwd = null, release }) {
+  const key = String(jobId || '').trim();
+  if (key && typeof release === 'function') terminationHolds.set(key, { ownerSessionId, cwd, release });
+}
+
+export function clearTerminationHold(jobId) {
+  terminationHolds.delete(String(jobId || '').trim());
+}
+
+/** The owner session closed: its live records are flagged so every surface
+ *  can list them for the sessions that see their folder. */
+export function noteShellOwnerSessionClosed(sessionId) {
+  const id = String(sessionId || '').trim();
+  if (!id) return;
+  closedOwnerSessions.add(id);
+  for (const [jobId, record] of records) {
+    if (record?.ownerSessionId === id) void patchRunningShellJobRecord(jobId, { ownerSessionClosed: true });
+  }
+}
+
+const releaseRequestPath = (key) => join(jobsDir(), `${key}.release-requested`);
+
+async function requestRemoteRelease(key, caller) {
+  const id = validJobId(key);
+  const record = id ? JSON.parse(await readFile(join(jobsDir(), `${id}.json`), 'utf8')) : null;
+  if (record?.status !== 'running' || record.terminationUnconfirmed !== true) throw new Error('not held');
+  const hold = { ownerSessionId: record.ownerSessionId || null, cwd: record.cwd };
+  if (!mayRelease(hold, { ...caller, ownerClosed: record.ownerSessionClosed === true })) {
+    throw new Error('not permitted');
+  }
+  await writeFile(releaseRequestPath(id), '', 'utf8');
+  return { released: true, deferred: true };
+}
+
+/** Consume a cross-process release request for `jobId`; true when one existed. */
+export function takeReleaseRequest(jobId) {
+  const key = validJobId(jobId);
+  if (!key) return false;
+  try {
+    unlinkSync(releaseRequestPath(key));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function mayRelease(hold, { callerSessionId, callerCwd, ownerClosed = closedOwnerSessions.has(hold.ownerSessionId) }) {
+  if (!hold.ownerSessionId || hold.ownerSessionId === callerSessionId) return true;
+  return ownerClosed && workspaceSees(hold.cwd, callerCwd);
+}
+
+/** Explicit user action ("Release anyway"): drop the workspace hold of a job
+ *  whose termination is unconfirmed. The surface asks for confirmation first.
+ *  The owning session may release it; once that session has closed, any
+ *  session whose workspace (`callerCwd`) sees the hold's folder may. */
+export async function forceReleaseTerminationHold(jobId, { callerSessionId = null, callerCwd = null } = {}) {
+  const key = String(jobId || '').trim();
+  const refused = { released: false, error: `no unconfirmed termination hold: ${key}` };
+  const hold = terminationHolds.get(key);
+  // The hold lives in another runtime process (a desktop pane's session shard):
+  // its own observation loop honours the request at its next pass.
+  if (!hold) return requestRemoteRelease(key, { callerSessionId, callerCwd }).catch(() => refused);
+  if (!mayRelease(hold, { callerSessionId, callerCwd })) return refused;
+  try {
+    await hold.release();
+  } catch (error) {
+    return { released: false, error: error instanceof Error ? error.message : String(error) };
+  }
+  if (terminationHolds.get(key) === hold) terminationHolds.delete(key);
+  return { released: true };
+}
+
+/** Release the workspace admission adopted under `jobId` without a record of
+ *  its own (survivors a finished foreground command left behind), once they
+ *  are confirmed gone. */
+export function releaseShellJobWorkspace(jobId) {
+  const key = String(jobId || '').trim();
+  const leave = workspaceLeases.get(key);
+  if (!leave) return;
+  leave();
+  if (workspaceLeases.get(key) === leave) workspaceLeases.delete(key);
+}
+
+/** Flag a still-open job record as "termination unconfirmed" for the readouts. */
+export function markShellJobTerminationUnconfirmed(jobId) {
+  return patchRunningShellJobRecord(jobId, { terminationUnconfirmed: true });
+}
+
+function patchRunningShellJobRecord(jobId, patch) {
+  const key = validJobId(jobId);
+  if (!key) return Promise.resolve(false);
+  const jsonPath = join(jobsDir(), `${key}.json`);
+  return enqueue(key, async () => {
+    const record = records.get(key);
+    if (record?.status !== 'running') return false;
+    const next = { ...record, ...patch };
+    records.set(key, next);
+    await writeJsonAtomicAsync(jsonPath, next, { fsync: false });
+    return true;
+  }).catch(() => false);
+}
+
 export function completeShellJobRecord(jobId, detail) {
   const key = validJobId(jobId);
   if (!key) return Promise.resolve(false);
+  const leaveWorkspace = workspaceLeases.get(key);
   const dir = jobsDir();
   const jsonPath = join(dir, `${key}.json`);
   const donePath = join(dir, `${key}.done`);
   const list = paths.get(key) || [jsonPath];
   const ownerPaths = list.filter((path) => path.includes('.owner-'));
-  const pending = publishing.get(key);
-  const work = (async () => {
+  return enqueue(key, async () => {
     try {
-      await pending;
-    } catch {}
-    await mkdir(dir, { recursive: true });
-    let base = records.get(key) || null;
-    if (!base) {
-      try {
-        base = JSON.parse(await readFile(jsonPath, 'utf8'));
-      } catch {}
+      await mkdir(dir, { recursive: true });
+      let base = records.get(key) || null;
+      if (!base) {
+        try {
+          base = JSON.parse(await readFile(jsonPath, 'utf8'));
+        } catch {}
+      }
+      const record = terminalRecord(base, { ...detail, jobId: key });
+      records.set(key, record);
+      await writeJsonAtomicAsync(jsonPath, record, { fsync: false });
+      await writeFile(donePath, '', 'utf8');
+    } finally {
+      // Callers complete a record only once its processes are confirmed gone
+      // (or explicitly released): the workspace admission follows that, not
+      // the record write, so a failed write cannot strand it with no handle.
+      leaveWorkspace?.();
+      if (workspaceLeases.get(key) === leaveWorkspace) workspaceLeases.delete(key);
     }
-    const record = terminalRecord(base, { ...detail, jobId: key });
-    records.set(key, record);
-    await writeFile(jsonPath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
-    await writeFile(donePath, '', 'utf8');
     await removePaths(ownerPaths);
     paths.set(key, [jsonPath, donePath]);
+    const incarnation = ++incarnationSeq;
+    incarnations.set(key, incarnation);
     const timer = setTimeout(() => {
-      records.delete(key);
-      paths.delete(key);
-      void removePaths([jsonPath, donePath]);
+      // Expire through the job's queue and only if no publish, retire or newer
+      // completion has replaced the files this timer was armed for.
+      void enqueue(key, async () => {
+        if (incarnations.get(key) !== incarnation) return;
+        incarnations.delete(key);
+        records.delete(key);
+        paths.delete(key);
+        await removePaths([jsonPath, donePath]);
+      });
     }, COMPLETED_SHELL_JOB_TTL_MS);
     timer.unref?.();
     return true;
-  })().catch(() => false);
-  return work;
+  }).catch(() => false);
+}
+
+/** Test support: settles once every record write queued so far for `jobId`
+ *  has finished, so a test waits on the write itself, not on elapsed turns. */
+export function _shellJobRecordWritesSettledForTest(jobId) {
+  return chains.get(String(jobId || '').trim()) || Promise.resolve();
 }
 
-export async function readShellJobRecord(jobId) {
+export async function readShellJobRecord(jobId, { strict = false } = {}) {
   const key = validJobId(jobId);
   if (!key) return null;
   const dir = jobsDir();
   const jsonPath = join(dir, `${key}.json`);
   try {
     const record = JSON.parse(await readFile(jsonPath, 'utf8'));
+    if (
+      strict &&
+      (!record ||
+        !['running', 'completed', 'failed', 'cancelled'].includes(record.status) ||
+        (record.status === 'running' && !record.cwd))
+    )
+      throw new Error(`Cannot inspect shell job ${key}.`);
     const done = await access(join(dir, `${key}.done`)).then(
       () => true,
-      () => false
+      (error) => {
+        if (strict && error?.code !== 'ENOENT') throw error;
+        return false;
+      }
     );
     return { ...record, recovered: true, terminal: done || record?.status !== 'running' };
-  } catch {
+  } catch (error) {
+    if (strict && error?.code !== 'ENOENT') throw error;
     return null;
   }
 }
 
-export async function listShellJobRecords() {
+export async function listShellJobRecords({ strict = false } = {}) {
   const dir = jobsDir();
   let names;
   try {
     names = await readdir(dir);
-  } catch {
+  } catch (error) {
+    if (strict && error?.code !== 'ENOENT') throw error;
     return [];
   }
   const rows = await Promise.all(
-    names.filter((name) => name.endsWith('.json')).map((name) => readShellJobRecord(name.slice(0, -5)))
+    names.filter((name) => name.endsWith('.json')).map((name) => readShellJobRecord(name.slice(0, -5), { strict }))
   );
   const cutoff = Date.now() - COMPLETED_SHELL_JOB_TTL_MS;
   return rows.filter((record) => {
@@ -266,18 +466,16 @@ export async function listShellJobRecords() {
 export function retireShellJobRecord(jobId) {
   const key = String(jobId || '').trim();
   if (!key) return;
-  retired.add(key);
-  records.delete(key);
+  const leaveWorkspace = workspaceLeases.get(key);
+  workspaceLeases.delete(key);
   const list = paths.get(key);
   paths.delete(key);
-  const pending = publishing.get(key);
-  void (async () => {
-    try {
-      await pending;
-    } catch {
-      /* the publish path owns its failure */
-    }
+  // Queued behind every earlier publish and ahead of any later one: a promoted
+  // job publishing after this call is written only once this removal is done.
+  void enqueue(key, async () => {
+    records.delete(key);
+    incarnations.delete(key);
     await removePaths(list);
-    retired.delete(key);
-  })();
+    leaveWorkspace?.();
+  });
 }

package/src/runtime/agent/orchestrator/tools/builtin/lib/shell-task-output.mjs

@@ -2,9 +2,10 @@ import { closeSync, fstatSync, openSync, readSync } from 'node:fs';
 import { stripAnsi } from '../../shell-exec-output.mjs';
 import { FileEncodingSniffer, ShellStreamDecoder, alignedOffset, oemTextEncoding } from '../../shell-codepage.mjs';
 
-const PAGE_BYTES = 8 * 1024;
-const COMPLETION_BYTES = 12 * 1024;
+import { TOOL_OUTPUT_PAGE_BYTES, TOOL_OUTPUT_TAIL_BYTES } from '../../../../../shared/tool-output-budget.mjs';
 const cursors = new WeakMap();
+const ESC = '\x1b';
+const PENDING_ANSI_INTRODUCER = new RegExp(`${ESC}(?:\\[[0-?]*[ -/]*|\\](?:(?!${ESC}\\\\)[^\x07\x9c])*)?$`);
 
 function newCursor() {
   return {
@@ -36,7 +37,7 @@ function visibleText(cursor, text) {
   const value = cursor.ansi + text;
   // Retain only the introducer of an unfinished CSI/OSC, not its potentially
   // unbounded payload. It will be stripped with the following chunk.
-  const pending = /\x1b(?:\[[0-?]*[ -/]*|\](?:(?!\x1b\\)[^\x07\x9c])*)?$/.exec(value);
+  const pending = PENDING_ANSI_INTRODUCER.exec(value);
   cursor.ansi = '';
   if (!pending) return stripAnsi(value);
   const sequence = pending[0];
@@ -53,7 +54,7 @@ function visibleText(cursor, text) {
 export function readShellTaskOutput(task, result = {}, { output = 'new' } = {}) {
   const replay = output === 'tail';
   const terminal = task.status !== 'running';
-  const limit = terminal || replay ? COMPLETION_BYTES : PAGE_BYTES;
+  const limit = terminal || replay ? TOOL_OUTPUT_TAIL_BYTES : TOOL_OUTPUT_PAGE_BYTES;
   let streams = replay ? new Map() : cursors.get(task);
   if (!streams) {
     streams = new Map();

package/src/runtime/agent/orchestrator/tools/builtin/read-formatting.mjs

@@ -79,10 +79,15 @@ export function parseLineLimitArg(value, defaultValue) {
   return Math.max(1, Math.trunc(n));
 }
 
+/** Whether the read display clips this source line. */
+export function isReadLineClipped(line, { truncateLongLine = true } = {}) {
+  return truncateLongLine && String(line ?? '').length > READ_MAX_RENDERED_LINE_CHARS;
+}
+
 export function truncateReadLineText(line, { truncateLongLine = true } = {}) {
   let text = String(line ?? '');
   const originalLength = text.length;
-  if (truncateLongLine && text.length > READ_MAX_RENDERED_LINE_CHARS) {
+  if (isReadLineClipped(text, { truncateLongLine })) {
     const cps = [...text];
     const head = cps.slice(0, 1_500).join('');
     const tail = cps.slice(-300).join('');

package/src/runtime/agent/orchestrator/tools/builtin/runtime-capabilities.mjs

@@ -41,7 +41,29 @@ function _posixStartupShell(candidates = ['/bin/bash', '/usr/bin/bash', '/bin/sh
   return null;
 }
 
-export function describeShellToolsStartupState({
+// Every session composes this line. Probing it means up to names×PATHEXT×PATH
+// stats on Windows (~40ms) or a login-shell spawn on POSIX, both on the event
+// loop, so one answer per PATH/shell is reused for a short window — the same
+// rule as gitExecutablePresent: a session opened after an install still picks
+// the tool up once the window passes.
+const SHELL_TOOLS_STARTUP_TTL_MS = 30_000;
+let _shellToolsStartup = null;
+
+export function describeShellToolsStartupState(options = {}) {
+  if (options._spawnSync) return _probeShellToolsStartupState(options);
+  const { platform = process.platform, names = SHELL_TOOL_STARTUP_NAMES, shellPath = null } = options;
+  const pathValue = options.pathValue ?? (process.env.PATH || '');
+  const key = JSON.stringify([platform, names, shellPath, pathValue]);
+  const now = Date.now();
+  if (_shellToolsStartup?.key === key && now - _shellToolsStartup.at < SHELL_TOOLS_STARTUP_TTL_MS) {
+    return _shellToolsStartup.value;
+  }
+  const value = _probeShellToolsStartupState(options);
+  _shellToolsStartup = { key, at: now, value };
+  return value;
+}
+
+function _probeShellToolsStartupState({
   platform = process.platform,
   names = SHELL_TOOL_STARTUP_NAMES,
   shellPath = null,

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

@@ -3,6 +3,7 @@ import { assertPathReachable, assertPathsReachable } from './fs-reachability.mjs
 import { isAbsolute, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
+import { isBuiltin } from 'node:module';
 import { cwdRelativePath, normalizeInputPath, normalizeOutputPath, resolveAgainstCwd } from './path-utils.mjs';
 
 // Hard-block patterns live exclusively in ../shell-policy.mjs (BLOCKED_PATTERNS /
@@ -661,6 +662,24 @@ const LONG_INLINE_SCRIPT_RE =
   /\b(node(?:\.exe)?|python3?|py)((?:\s+--?[\w-]+(?:=[^\s"']+)?)*)\s+(-e|--eval|-c)\s+(?:"((?:[^"\\]|\\.)*)"|'((?:[^']|'')*)')/i;
 const POWERSHELL_FILE_SEMANTIC_RE = /\$(?:PSScriptRoot|PSCommandPath|MyInvocation)\b|^\s*(?:param\s*\(|#requires\b)/im;
 
+// `node -e` resolves a package name from the working directory; a hoisted file
+// resolves it from the temp directory it lives in, where no node_modules is.
+// Any package specifier (not a Node builtin), require.resolve, or a specifier
+// that is not a string literal therefore keeps the -e form.
+const NODE_SPECIFIER_RE = /(?:\brequire\s*\(\s*|\bimport\s*\(\s*|\bfrom\s+|\bimport\s+)['"]([^'"]+)['"]/g;
+const NODE_LOADER_CALL_RE = /\b(?:require|import)\s*\(/g;
+const NODE_LITERAL_LOADER_CALL_RE = /\b(?:require|import)\s*\(\s*['"][^'"]+['"]/g;
+function importsPackage(body) {
+  if (/\brequire\s*\.\s*resolve\b/.test(body)) return true;
+  if ((body.match(NODE_LOADER_CALL_RE) || []).length !== (body.match(NODE_LITERAL_LOADER_CALL_RE) || []).length) {
+    return true;
+  }
+  for (const [, specifier] of body.matchAll(NODE_SPECIFIER_RE)) {
+    if (!isBuiltin(specifier)) return true;
+  }
+  return false;
+}
+
 /** File extension a hoisted inline script gets: Python, or the Node module kind the flags declare. */
 function inlineScriptExtension(isNode, esm) {
   if (!isNode) return '.py';
@@ -684,6 +703,7 @@ export function planInlineScriptHoist(command) {
   const [whole, exe, rawFlags, , body] = match;
   if (INLINE_UNSAFE_BODY.test(body)) return null;
   if (INLINE_FILE_RELATIVE.test(body)) return null;
+  if (/^node/i.test(exe) && importsPackage(body)) return null;
   const { extension, keptFlags } = inlineScriptFileShape(exe, rawFlags);
   return {
     exe,