mixdog 0.9.147 → 0.9.149

package/src/runtime/agent/orchestrator/tools/lib/shell-descendants.mjs

@@ -0,0 +1,136 @@
+'use strict';
+// Post-exit descendant observation for the shell runner.
+//
+// The question this module answers is "did the command leave anything
+// RUNNING?", and it answers it by looking at PROCESSES — never at the command
+// text. Nothing here parses, classifies or rewrites a single byte of what the
+// caller typed; the shell receives the command exactly as written and the
+// decision is taken afterwards from what the operating system reports.
+//
+// Evidence per platform, both produced by the existing spawn infrastructure:
+//   POSIX  — native/mixdog-spawn spawns every shell with `process_group(0)`,
+//            so the command owns a process group whose id is the shell pid.
+//            Once the shell has exited and been reaped, ANY remaining member
+//            of that group is a descendant it left behind, and one signal to
+//            the negative pgid reaches all of them.
+//   win32  — there is no process group to signal, but the shell's stdout and
+//            stderr pipes are INHERITED by its descendants: if they are still
+//            held when the shell process itself has exited, something of this
+//            command is alive. That observation gates a single batched
+//            process-table read (shared with mcp/child-tree.mjs) which names
+//            the survivors that are still linked to the shell pid.
+import { collectDescendantProcesses, killProcessTrees } from '../../mcp/child-tree.mjs';
+
+const isWin = process.platform === 'win32';
+
+// The spawn server waits up to 2 s for the shell's stdio pumps to drain after
+// the root process exits and then reports the exit regardless (main.rs
+// run_spawn). A close that lands at/after this threshold therefore means the
+// pipes were STILL held by another process at that deadline, not that draining
+// was slow — a normal command closes within milliseconds of its exit.
+export const STDIO_HELD_AFTER_EXIT_MS = 1_500;
+
+// Windows attaches a console host to the hidden console the shell runs in. It
+// is a real child of the shell and it lives exactly as long as console clients
+// remain, which makes it a liveness WITNESS for descendants that pid-level
+// tracking can no longer reach — but it is never a kill target: terminating it
+// leaves the actual worker running (verified) and would only destroy the
+// witness.
+const CONSOLE_HOST = /^conhost\.exe$/i;
+
+export function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM: exists but is not ours to signal. ESRCH: gone.
+    return error?.code === 'EPERM';
+  }
+}
+
+function groupAlive(pgid) {
+  if (!Number.isInteger(pgid) || pgid <= 0) return false;
+  try {
+    process.kill(-pgid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+function delay(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+
+/** Observe what the finished command left running.
+ *
+ *  Returns null when nothing is left (the normal case — the caller then
+ *  reports a plain completion), or a handle describing the survivors:
+ *    groupPid   POSIX process group that still has members
+ *    killPids   pids a cancellation can signal directly
+ *    watchPids  pids whose liveness answers "is this task still running?"
+ *    reachable  false when survivors are observable but no longer addressable
+ *               by pid (Windows re-parents nothing: a process whose parent
+ *               exited keeps a dangling parent id, so an intermediate that
+ *               already exited breaks the link). */
+export async function probeShellDescendants({ pid, stdioHeld = false } = {}) {
+  const root = Number(pid) || 0;
+  if (root <= 0) return null;
+  if (!isWin) {
+    if (!groupAlive(root)) return null;
+    return { groupPid: root, killPids: [], watchPids: [], reachable: true };
+  }
+  if (!stdioHeld) return null;
+  const found = await collectDescendantProcesses(root).catch(() => []);
+  const live = found.filter((entry) => pidAlive(entry.pid));
+  if (live.length === 0) return null;
+  const killPids = live.filter((entry) => !CONSOLE_HOST.test(entry.name)).map((entry) => entry.pid);
+  return {
+    groupPid: null,
+    killPids,
+    watchPids: live.map((entry) => entry.pid),
+    reachable: killPids.length > 0,
+  };
+}
+
+/** True while the observed survivors are still running. */
+export function descendantsAlive(handle) {
+  if (!handle) return false;
+  if (handle.groupPid) return groupAlive(handle.groupPid);
+  return handle.watchPids.some((pid) => pidAlive(pid));
+}
+
+/** Resolve once every observed survivor has exited. Poll-based on purpose:
+ *  these processes are not our children any more, so there is no exit event to
+ *  subscribe to — only their liveness can be observed. */
+export async function waitForShellDescendants(handle, { pollMs = 1_000, signal = null } = {}) {
+  while (descendantsAlive(handle)) {
+    if (signal?.aborted) return false;
+    await delay(pollMs);
+  }
+  return true;
+}
+
+/** Terminate the survivors. POSIX signals the whole process group, so the kill
+ *  is complete by construction; Windows kills every reachable tree and then
+ *  RE-OBSERVES, so the caller reports what actually died instead of what was
+ *  signalled. */
+export async function killShellDescendants(handle) {
+  if (!handle) return { terminated: true, survivors: [] };
+  if (handle.groupPid) {
+    try { process.kill(-handle.groupPid, 'SIGTERM'); } catch { /* already gone */ }
+    await delay(200);
+    if (groupAlive(handle.groupPid)) {
+      try { process.kill(-handle.groupPid, 'SIGKILL'); } catch { /* already gone */ }
+      await delay(100);
+    }
+    return { terminated: !groupAlive(handle.groupPid), survivors: [] };
+  }
+  await killProcessTrees(handle.killPids).catch(() => {});
+  const survivors = handle.watchPids.filter((pid) => pidAlive(pid));
+  return { terminated: survivors.length === 0, survivors };
+}

package/src/runtime/agent/orchestrator/tools/patch/dispatch.mjs

@@ -14,6 +14,9 @@ import {
 } from '../builtin.mjs';
 import { atomicWrite } from '../builtin/atomic-write.mjs';
 import { isSpecialFileStat } from '../builtin/device-paths.mjs';
+import { getReadSnapshot } from '../builtin/read-snapshot-runtime.mjs';
+import { snapshotCoversFullFile } from '../builtin/snapshot-helpers.mjs';
+import { hashText } from '../builtin/hash-utils.mjs';
 import { markCodeGraphDirtyPaths } from '../code-graph-state.mjs';
 import {
   classifyEntry,
@@ -37,6 +40,9 @@ import {
   findFirstFailingUnifiedHunk,
   findUnifiedHunkMatch,
   collectUnifiedNewLines,
+  collectUnifiedOpEntries,
+  terminatorsForUnifiedOps,
+  localTerminatorForWindow,
   assertSafeReplacementPlan,
   firstFailingUnifiedHunkLineDetail,
   firstMeaningfulUnifiedHunkLine,
@@ -47,6 +53,14 @@ import {
   normalizeTypographic,
   splitBufferLinesForPatch,
   splitTextLinesForPatch,
+  cloneTextLinesForPatch,
+  spliceTextLinesForPatch,
+  joinTextLinesForPatch,
+  setFinalNewlineForPatch,
+  patchTargetEncodingError,
+  detectDominantEol,
+  decodePatchTargetBuffer,
+  encodePatchTargetContent,
 } from './matcher.mjs';
 
 function formatNativeFailureContext(parsed, basePath, failedPath = '', options = {}) {
@@ -98,6 +112,50 @@ function formatNativeFailureContext(parsed, basePath, failedPath = '', options =
 // caller MUST surface throws as `Error: ...` strings.
 export async function dispatchNativePatch({ entries, basePath, nativePatchStr, fuzz, rejectPartial, dryRun, readStateScope, signal, parsed }) {
   const nativeStart = performance.now();
+  // Pre-write identity of every target. The read-snapshot recorder needs it to
+  // decide whether the session's earlier full read still described this file
+  // when the patch landed — otherwise an external change made before the patch
+  // would stay hidden behind "[file unchanged]".
+  const preMutationStats = new Map();
+  // Encoding gate, same rule as the JS writer: the native engine rewrites files
+  // as UTF-8, so a target that is not valid UTF-8 must be refused rather than
+  // silently transcoded. (UTF-16 targets are routed away before this point.)
+  for (const entry of entries || []) {
+    if (entry.kind === 'create' || entry.kind === 'delete') continue;
+    const encodingError = patchTargetEncodingError(entry.fullPath, entry.displayPath);
+    if (encodingError) return `Error: ${encodingError}`;
+  }
+  if (!dryRun) {
+    for (const entry of entries || []) {
+      try { preMutationStats.set(entry.fullPath, lstatSync(entry.fullPath)); } catch { /* absent target */ }
+    }
+  }
+  // Body-knowledge proof for the "[file unchanged]" fast path. A stat captured
+  // before the engine runs cannot vouch for the bytes it actually patched, so
+  // predict the post-apply content from bytes we verify against the session's
+  // read snapshot; after the apply, the engine's own content hash must equal
+  // that prediction. Only computed where the fast path could be inherited.
+  const bodyProofs = new Map();
+  if (!dryRun && readStateScope) {
+    for (const entry of entries || []) {
+      if (entry.kind === 'create' || entry.kind === 'delete') continue;
+      const prior = getReadSnapshot(entry.fullPath, readStateScope);
+      if (!prior?.contentHash) continue;
+      if (prior.bodyDelivered !== true && !snapshotCoversFullFile(prior)) continue;
+      try {
+        const { text } = decodePatchTargetBuffer(readFileSync(entry.fullPath), entry.displayPath);
+        if (hashText(text) !== prior.contentHash) continue; // already stale — claim nothing
+        const parsedEntry = findParsedForRow(entry, parsed, basePath);
+        if (!parsedEntry) continue;
+        const updated = applyUnifiedHunksToLines(splitTextLinesForPatch(text), parsedEntry.hunks || [], {
+          fuzz: Number.isFinite(fuzz) ? fuzz : 0,
+          displayPath: entry.displayPath,
+          eol: detectDominantEol(text),
+        });
+        bodyProofs.set(entry.fullPath, hashText(joinTextLinesForPatch(updated)));
+      } catch { /* no proof — the fast path stays off for this file */ }
+    }
+  }
   let stats;
   try {
     stats = await runServerApply(basePath, nativePatchStr, { fuzz, rejectPartial, dryRun, signal });
@@ -147,11 +205,33 @@ export async function dispatchNativePatch({ entries, basePath, nativePatchStr, f
       if (entry.kind === 'delete') {
         clearReadSnapshotForPath(entry.fullPath, readStateScope);
       } else {
+        const contentHash = stats.contentHashes?.[i] || null;
+        // Only a matching prediction proves the engine patched the bytes this
+        // session had read; otherwise the pre-mutation stat is not evidence.
+        const proof = bodyProofs.get(entry.fullPath);
+        const provenSameBytes = !!proof && !!contentHash && proof === contentHash;
+        // ONE consistent observation of the result, stat FIRST: a write that
+        // lands after the stat breaks the hash (claim dropped); one that lands
+        // after the read leaves the recorded stat older than the file, so the
+        // fast path fails closed at read time. Without that pairing an external
+        // write between the apply and this record could inherit bodyDelivered.
+        let observedStat = null;
+        let observationConsistent = false;
+        if (provenSameBytes) {
+          try {
+            observedStat = lstatSync(entry.fullPath);
+            const observed = decodePatchTargetBuffer(readFileSync(entry.fullPath), entry.displayPath);
+            observationConsistent = hashText(observed.text) === contentHash;
+          } catch {
+            observationConsistent = false;
+          }
+        }
         const snapshotMeta = {
           source: 'apply_patch_native',
           isPartialView: false,
+          preMutationStat: observationConsistent ? (preMutationStats.get(entry.fullPath) || null) : null,
         };
-        const contentHash = stats.contentHashes?.[i] || null;
+        if (observationConsistent && observedStat) snapshotMeta.st = observedStat;
         if (contentHash) snapshotMeta.contentHash = contentHash;
         recordReadSnapshotForPath(entry.fullPath, readStateScope, snapshotMeta);
       }
@@ -211,34 +291,6 @@ function entryPathKey(fullPath) {
   return process.platform === 'win32' ? String(fullPath || '').toLowerCase() : String(fullPath || '');
 }
 
-function joinTextLinesForPatch(lines) {
-  const eol = lines?.eol || '\n';
-  const body = (lines || []).join(eol);
-  return lines?.hasFinalNewline !== false ? `${body}${eol}` : body;
-}
-
-// The file's dominant line terminator. splitTextLinesForPatch() folds CRLF into
-// LF, so without this an out-of-base CRLF file would be rewritten as LF.
-function detectDominantEol(text) {
-  const body = String(text ?? '');
-  if (body.includes('\r') && !body.includes('\n')) return '\r';
-  let lf = 0;
-  let crlf = 0;
-  for (let i = 0; i < body.length; i++) {
-    if (body[i] !== '\n') continue;
-    lf++;
-    if (i > 0 && body[i - 1] === '\r') crlf++;
-  }
-  return lf > 0 && crlf * 2 >= lf ? '\r\n' : '\n';
-}
-
-function cloneTextLinesForPatch(sourceLines, eol) {
-  const lines = [...(sourceLines || [])];
-  lines.hasFinalNewline = sourceLines?.hasFinalNewline !== false;
-  lines.eol = eol || sourceLines?.eol || '\n';
-  return lines;
-}
-
 // Which side of the hunk, if any, carries an explicit
 // `` marker. Both transitions must be honoured:
 // a marker on the NEW side drops the terminator, a marker on the OLD side
@@ -300,6 +352,10 @@ function applyUnifiedHunksToLines(sourceLines, hunks, { fuzz, displayPath, eol }
       start: match.start,
       oldLen: match.end - match.start,
       newLines,
+      // Op sequence of THIS hunk: the only sound source for terminator
+      // inheritance (context keeps its own, an add takes the delete it
+      // replaces). Content alignment cannot express interior context or moves.
+      ops: collectUnifiedOpEntries(hunk),
       intent,
       atEof: match.end >= lines.length,
     });
@@ -309,12 +365,20 @@ function applyUnifiedHunksToLines(sourceLines, hunks, { fuzz, displayPath, eol }
   assertSafeReplacementPlan(replacements, `apply_patch: ${displayPath}`);
   for (let i = replacements.length - 1; i >= 0; i--) {
     const rep = replacements[i];
-    lines.splice(rep.start, rep.oldLen, ...rep.newLines);
+    const oldTerms = Array.isArray(lines.terminators)
+      ? lines.terminators.slice(rep.start, rep.start + rep.oldLen)
+      : [];
+    const newTerms = terminatorsForUnifiedOps(
+      rep.ops,
+      oldTerms,
+      localTerminatorForWindow(lines, rep.start, rep.oldLen),
+    );
+    spliceTextLinesForPatch(lines, rep.start, rep.oldLen, rep.newLines, newTerms);
     // Explicit markers win in BOTH directions; a hunk that is silent about the
     // terminator leaves the file's existing state untouched (native parity).
     if (!rep.atEof) continue;
-    if (rep.intent.newNoNewline) lines.hasFinalNewline = false;
-    else if (rep.intent.oldNoNewline) lines.hasFinalNewline = true;
+    if (rep.intent.newNoNewline) setFinalNewlineForPatch(lines, false);
+    else if (rep.intent.oldNoNewline) setFinalNewlineForPatch(lines, true);
   }
   return lines;
 }
@@ -401,21 +465,46 @@ async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateSco
     return { kind, fullPath, displayPath, added, removed };
   }
 
-  lstatRegularPatchFile(fullPath, displayPath);
-  const raw = readFileSync(fullPath);
-  const rawText = raw.toString('utf8');
+  const preMutationStat = lstatRegularPatchFile(fullPath, displayPath);
+  // Rewrite path: decode by BOM, re-encode into the same codec, and keep every
+  // untouched line's own terminator (spliceTextLinesForPatch).
+  // `toString('utf8')` here transcoded non-UTF-8 files and mangled UTF-16.
+  const { text: rawText, enc: rawEnc } = decodePatchTargetBuffer(readFileSync(fullPath), displayPath);
   const sourceLines = splitTextLinesForPatch(rawText);
   const updatedLines = applyUnifiedHunksToLines(sourceLines, entry.hunks || [], {
     fuzz: fuzzy ? 2 : 0,
     displayPath,
     eol: detectDominantEol(rawText),
   });
-  const content = joinTextLinesForPatch(updatedLines);
+  const content = encodePatchTargetContent(joinTextLinesForPatch(updatedLines), rawEnc);
   if (!dryRun) {
-    await atomicWrite(fullPath, content, { sessionId: readStateScope });
+    // The expected-target snapshot closes the read→write window: if anything
+    // rewrote this file after we read it, the write fails instead of silently
+    // clobbering it (and instead of inheriting a stale "body delivered" claim).
+    try {
+      await atomicWrite(fullPath, content, {
+        sessionId: readStateScope,
+        expectedTargetSnapshot: preMutationStat ? {
+          exists: true,
+          size: preMutationStat.size,
+          mtimeMs: preMutationStat.mtimeMs,
+          ctimeMs: preMutationStat.ctimeMs,
+          ino: preMutationStat.ino,
+        } : undefined,
+      });
+    } catch (err) {
+      if (err?.code === 'ESTALE_TARGET') {
+        throw new Error(`apply_patch: ${normalizeOutputPath(displayPath)} changed on disk during the patch; re-read it and retry`);
+      }
+      throw err;
+    }
     invalidateBuiltinResultCache([fullPath]);
     markCodeGraphDirtyPaths([fullPath]);
-    recordReadSnapshotForPath(fullPath, readStateScope, { source: 'apply_patch_js', isPartialView: false });
+    recordReadSnapshotForPath(fullPath, readStateScope, {
+      source: 'apply_patch_js',
+      isPartialView: false,
+      preMutationStat,
+    });
   }
   const { added, removed } = countHunkChanges(entry.hunks);
   return { kind, fullPath, displayPath, added, removed };