mixdog 1.2.5 → 1.3.0

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

@@ -23,6 +23,7 @@ const POWERSHELL_RESERVED_HEADS = new Set([
   'dir',
   'echo',
   'erase',
+  'fc',
   'foreach',
   'help',
   'history',
@@ -110,12 +111,19 @@ function _disabledByEnv(env) {
 
 // Quote-aware argv split for native CreateProcess. Unlike shellTokenize this
 // keeps Windows backslashes literal so `C:\foo\bar.exe` is one path token.
-export function tokenizeDirectArgv(command) {
+// `strict` is for callers that must reproduce PowerShell's own parse (the
+// direct spawn): a form where PowerShell and this splitter could disagree —
+// a `\"` that PowerShell does not treat as an escape, or text glued to the
+// closing quote of a string that opened its argument (PowerShell starts a new
+// argument there) — returns null so the command runs through the shell
+// unchanged.
+export function tokenizeDirectArgv(command, { strict = false } = {}) {
   const text = String(command || '');
   const tokens = [];
   let current = '';
   let quote = null;
   let started = false;
+  let leading = false;
   const push = () => {
     if (started) tokens.push(current);
     current = '';
@@ -125,12 +133,20 @@ export function tokenizeDirectArgv(command) {
     const ch = text[i];
     if (quote === '"') {
       if (ch === '\\' && text[i + 1] === '"') {
+        if (strict) return null;
         current += '"';
         i += 1;
         continue;
       }
       if (ch === '"') {
+        // PowerShell: a doubled quote inside a double-quoted string is a literal quote.
+        if (text[i + 1] === '"') {
+          current += '"';
+          i += 1;
+          continue;
+        }
         quote = null;
+        if (strict && leading && i + 1 < text.length && !/\s/.test(text[i + 1])) return null;
         continue;
       }
       current += ch;
@@ -138,13 +154,24 @@ export function tokenizeDirectArgv(command) {
     }
     if (quote === "'") {
       if (ch === "'") {
+        // PowerShell: a doubled quote inside a single-quoted string is a literal quote.
+        if (text[i + 1] === "'") {
+          current += "'";
+          i += 1;
+          continue;
+        }
         quote = null;
+        if (strict && leading && i + 1 < text.length && !/\s/.test(text[i + 1])) return null;
         continue;
       }
       current += ch;
       continue;
     }
     if (ch === "'" || ch === '"') {
+      // A string that opens an argument ends it: PowerShell starts a NEW
+      // argument at whatever is glued behind the closing quote. A string
+      // opened mid-argument (`a"b c"d`) joins its neighbours.
+      leading = !started;
       quote = ch;
       started = true;
       continue;
@@ -185,6 +212,9 @@ export function commandNeedsShell(command) {
       continue;
     }
     if ('|&;<>()\n\r{}'.includes(ch) || ch === '`') return true;
+    // A bare `~` expands to the home directory and `@name` splats, both before
+    // the native program sees the argument.
+    if ((ch === '~' || ch === '@') && (i === 0 || /\s/.test(text[i - 1]))) return true;
     if ('*?[]'.includes(ch)) return true;
     if (ch === '$') return true;
     if (ch === '#' && (i === 0 || /\s/.test(text[i - 1]))) return true;
@@ -192,6 +222,14 @@ export function commandNeedsShell(command) {
   return quote != null;
 }
 
+function _isFile(file) {
+  try {
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
 function _isUsableExe(file) {
   try {
     if (!/\.exe$/i.test(file)) return false;
@@ -215,17 +253,29 @@ export function resolveDirectExe(
     const resolved = isAbsolute(name) || /^[A-Za-z]:[\\/]/.test(name) ? name : pathResolve(baseCwd, name);
     return _isUsableExe(resolved) ? resolved : null;
   }
-  const fileName = /\.exe$/i.test(name) ? name : `${name}.exe`;
+  const explicitExe = /\.exe$/i.test(name);
   const seen = new Set();
-  const dirs = [baseCwd, ...String(pathValue || '').split(pathDelimiter)];
-  for (const dir of dirs) {
+  // PowerShell never looks in the current directory for a bare command name,
+  // so neither may this resolver: a project-local `tool.exe` is not `tool`.
+  for (const dir of String(pathValue || '').split(pathDelimiter)) {
     if (!dir) continue;
     const key = dir.toLowerCase();
     if (seen.has(key)) continue;
     seen.add(key);
-    if (seen.size > maxDirectories + 1) break;
-    const candidate = pathJoin(dir, fileName);
+    if (seen.size > maxDirectories) break;
+    if (explicitExe) {
+      const candidate = pathJoin(dir, name);
+      if (_isUsableExe(candidate)) return candidate;
+      continue;
+    }
+    // PowerShell takes the first directory holding ANY runnable form of the
+    // name, and a `.com`/`.ps1` there outranks the `.exe` while a `.cmd`/`.bat`
+    // shim in an earlier directory shadows a later `.exe`: all stay with the shell.
+    const has = (ext) => _isFile(pathJoin(dir, `${name}${ext}`));
+    if (has('.com') || has('.ps1')) return null;
+    const candidate = pathJoin(dir, `${name}.exe`);
     if (_isUsableExe(candidate)) return candidate;
+    if (has('.bat') || has('.cmd')) return null;
   }
   return null;
 }
@@ -244,7 +294,7 @@ export function planDirectExeSpawn(
   if (_disabledByEnv(env)) return null;
   const text = String(command || '').trim();
   if (!text || commandNeedsShell(text) || hasPowerShellOnlySyntax(text)) return null;
-  const tokens = tokenizeDirectArgv(text);
+  const tokens = tokenizeDirectArgv(text, { strict: true });
   if (!tokens || tokens.length === 0) return null;
   if (tokens.includes('--%')) return null;
   const head = tokens[0];

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

@@ -8,7 +8,7 @@ import {
 // eval), so the static cycle through session/manager.mjs is safe — same
 // pattern as loop/tool-exec.mjs.
 import { enqueuePendingMessage, markCompletionEntry } from '../../session/manager.mjs';
-import { completeBackgroundTask } from '../../../../shared/background-tasks.mjs';
+import { completeBackgroundTask, getBackgroundTask } from '../../../../shared/background-tasks.mjs';
 import {
   cancelNativeTask,
   getNativeTask,
@@ -28,36 +28,54 @@ import {
   adoptShellWorkspaceAdmission,
   clearTerminationHold,
   completeShellJobRecord,
+  isShellOwnerSessionClosed,
   listShellJobRecords,
   markShellJobTerminationUnconfirmed,
+  noteShellJobSurvivors,
   publishShellJobRecord,
   registerTerminationHold,
   retireShellJobRecord,
   takeReleaseRequest,
 } from './lib/shell-job-records.mjs';
-import { createProcessTreeTracker, killAfterSnapshot, watchTermination } from '../lib/shell-descendants.mjs';
+import {
+  createProcessTreeTracker,
+  killAfterSnapshot,
+  PROCESS_TABLE_READ_BOUND_MS,
+  watchTermination,
+  withinBound,
+} from '../lib/shell-descendants.mjs';
 import {
   flushPendingOwnerCancels,
+  prepareOwnedShellTreeKills,
   registerOwnedShellTree,
   unregisterOwnedShellTree,
 } from '../lib/owned-shell-trees.mjs';
 
-// Pre-kill snapshot of a tracked background job: the promotion baseline, or a
-// fresh read when that did not complete. Marks the job killed, so its settle
-// relies on this snapshot instead of an after-exit observation.
+// Bound on how long a runtime/session shutdown waits for the sweep of what a
+// cancelled job started outside its process group.
+const SHUTDOWN_TREE_CONFIRM_MS = 3_000;
+// Lead of the pre-deadline snapshot over a native timeout kill: one table
+// read's bound plus margin.
+const PRE_DEADLINE_CAPTURE_MS = PROCESS_TABLE_READ_BOUND_MS + 1_000;
+
+// Pre-kill snapshot of a tracked background job: always a fresh read, since
+// the promotion baseline predates whatever the job started since (a server,
+// an npm child); the baseline still stands when the fresh read fails. Marks
+// the job killed, so its settle relies on this snapshot instead of an
+// after-exit observation.
 function prepareTrackedKill(entry) {
   entry.killed = true;
-  if (entry.tracker.complete) return true;
-  return (entry.baseline || Promise.resolve(false)).then(
-    (complete) => complete || entry.tracker.capture().catch(() => false)
+  return (entry.baseline || Promise.resolve(false)).then(() =>
+    entry.tracker.capture().catch(() => entry.tracker.complete)
   );
 }
 import { isPidAlive } from '../../../../shared/pid-liveness.mjs';
 import {
   renderShellCompletionEnvelope,
-  renderShellCompletionNotice,
   shellCompletionInstruction,
 } from '../../../../shared/task-notification-envelope.mjs';
+import { formatDuration } from '../../../../shared/shell-output-summary.mjs';
+import { readShellTaskOutput } from './lib/shell-task-output.mjs';
 
 export { shellJobPublicTaskResult } from './lib/shell-job-insights.mjs';
 
@@ -105,7 +123,17 @@ function trackShellJobRecord(task, options) {
     adoptShellWorkspaceAdmission(jobId, hold);
   }
   const tracker = task?.cwd ? createProcessTreeTracker({ pid: task.pid }) : null;
-  const entry = { tracker, killed: false, baseline: null };
+  let resolveTerminated = null;
+  const entry = {
+    tracker,
+    killed: false,
+    baseline: null,
+    // Settles once every process of the job is confirmed gone (or the user
+    // force-released it): what `task cancel` waits on before it reports.
+    terminated: new Promise((resolve) => {
+      resolveTerminated = resolve;
+    }),
+  };
   if (tracker) {
     backgroundTrackers.set(jobId, entry);
     // Baseline identities while the promoted root is known to run, so a later
@@ -117,9 +145,24 @@ function trackShellJobRecord(task, options) {
   }
   let unsubscribe = null;
   let settled = false;
+  // The native runner enforces the job's deadline itself, with no snapshot
+  // from here: one is taken shortly before it, so the timeout kill has the
+  // identities of what the job started since its promotion.
+  const deadlineMs = Math.floor(Number(options?.timeoutMs) || 0);
+  const deadlineCapture =
+    tracker && deadlineMs > 0
+      ? setTimeout(
+          () => {
+            if (!settled) void tracker.capture().catch(() => false);
+          },
+          Math.max(0, deadlineMs - PRE_DEADLINE_CAPTURE_MS)
+        )
+      : null;
+  deadlineCapture?.unref?.();
   const settle = (detail) => {
     if (settled || !detail || detail.status === 'running') return;
     settled = true;
+    clearTimeout(deadlineCapture);
     try {
       unsubscribe?.();
     } catch {}
@@ -144,12 +187,17 @@ function trackShellJobRecord(task, options) {
       stop();
       clearTerminationHold(jobId);
       if (backgroundTrackers.get(jobId) === entry) backgroundTrackers.delete(jobId);
+      resolveTerminated(true);
       return completeShellJobRecord(jobId, normalized);
     };
     const stop = watchTermination({
       tracker,
+      // A killed job is not over while processes it started still run.
+      sweep: killed,
       onTerminated: finish,
       releaseRequested: () => takeReleaseRequest(jobId),
+      ownerClosed: () => isShellOwnerSessionClosed(options?.ownerSessionId),
+      onSurvivors: (pids) => void noteShellJobSurvivors(jobId, pids),
       onUnconfirmed: () => {
         void markShellJobTerminationUnconfirmed(jobId);
         registerTerminationHold(jobId, {
@@ -226,7 +274,18 @@ function shellJobFailureCause(detail) {
   return `exited with code ${exitCode}`;
 }
 
-export function buildShellCompletion(jobId, detail) {
+function completionStreams(detail) {
+  return {
+    stdout_path: detail?.stdoutPath || null,
+    stderr_path: detail?.mergeStderr === true ? null : detail?.stderrPath || null,
+    stdout_preview: detail?.stdoutPreview || '',
+    stderr_preview: detail?.mergeStderr === true ? '' : detail?.stderrPreview || '',
+  };
+}
+
+/** `output`: the unseen output to deliver (the task cursor's remainder). By
+ *  default the whole capture is read with a fresh cursor, consuming nothing. */
+export function buildShellCompletion(jobId, detail, { output } = {}) {
   const exitCode = typeof detail?.exitCode === 'number' ? detail.exitCode : null;
   const status = detail?.status || 'unknown';
   const taskStatus = shellJobTaskStatus(detail);
@@ -234,29 +293,36 @@ export function buildShellCompletion(jobId, detail) {
   // native task has no `error` of its own.
   const failureCause = taskStatus === 'failed' ? shellJobFailureCause(detail) : null;
   const reported = failureCause && !detail?.error ? { ...detail, error: failureCause } : detail;
+  const startedMs = Date.parse(detail?.startedAt || '');
+  const finishedMs = Date.parse(detail?.finishedAt || '');
+  // The completion carries the result itself — exit code, duration and the
+  // output (whole when short, else a summary with the log path) — so the
+  // agent never needs a follow-up read for it.
   const body = renderShellCompletionEnvelope({
     jobId,
     status: taskStatus,
     exitCode,
     command: detail?.command,
-    summary: detail?.summary || failureCause || null,
-    stdoutPreview: detail?.stdoutPreview,
-    stderrPreview: detail?.stderrPreview,
-    mergeStderr: detail?.mergeStderr,
     outputFile: detail?.stdoutPath,
     error: failureCause,
+    result: [
+      [
+        exitCode !== null ? `exit code: ${exitCode}` : null,
+        Number.isFinite(startedMs) && Number.isFinite(finishedMs)
+          ? `duration: ${formatDuration(finishedMs - startedMs)}`
+          : null,
+      ]
+        .filter(Boolean)
+        .join(', ') || null,
+      output ?? readShellTaskOutput({ status: 'completed' }, completionStreams(detail), { terminal: true }),
+    ]
+      .filter(Boolean)
+      .join('\n'),
   });
   return {
     taskStatus,
     body,
-    notification: renderShellCompletionNotice({
-      jobId,
-      status: taskStatus,
-      exitCode,
-      command: detail?.command,
-      outputFile: detail?.stdoutPath,
-      error: failureCause,
-    }),
+    notification: body,
     instruction: shellCompletionInstruction({ jobId, status, exitCode }),
     result: shellJobPublicTaskResult(reported),
     error: failureCause,
@@ -343,6 +409,15 @@ export function killShellJob(jobId) {
   return { ...attachJobInsights(normalizeShellJobDetail(detail)), killed: wasRunning };
 }
 
+/** True once every process of a tracked background job is confirmed gone,
+ *  false while any is still alive when `timeoutMs` passes. A job without a
+ *  process tracker (or one already finished) has nothing left to confirm. */
+export async function waitShellJobTerminated(jobId, timeoutMs) {
+  const entry = backgroundTrackers.get(String(jobId || ''));
+  if (!entry) return true;
+  return withinBound(entry.terminated, timeoutMs, false);
+}
+
 export function clearShellJobNotifyCtx(jobId) {
   jobNotifyCtxByJobId.delete(jobId);
 }
@@ -383,7 +458,14 @@ export function watchBackgroundShellJob(jobId, notifyCtx) {
     backgroundShellJobWatchers.delete(jobId);
     jobNotifyCtxByJobId.delete(jobId);
     const enriched = attachJobInsights(normalizeShellJobDetail(detail));
-    const completion = buildShellCompletion(jobId, enriched);
+    // The notice carries only what the agent has not seen yet: the task's
+    // cursor remainder. Kept on the task so a wait/read that reaches the
+    // finished task first returns that same remainder (and suppresses the
+    // notice) instead of an empty read.
+    const task = getBackgroundTask(jobId);
+    const output = task ? readShellTaskOutput(task, completionStreams(enriched), { terminal: true }) : undefined;
+    if (task) task.completionOutput = output;
+    const completion = buildShellCompletion(jobId, enriched, { output });
     const completedTask = completeBackgroundTask(jobId, {
       status: completion.taskStatus,
       result: completion.result,
@@ -471,7 +553,7 @@ export async function promoteForegroundShellJob({
   }
   // Added before tracking: the record's settlement removes it again.
   promotedJobIds.add(native.jobId);
-  trackShellJobRecord(native, { ownerSessionId, clientHostPid, startedAtMs: started });
+  trackShellJobRecord(native, { ownerSessionId, clientHostPid, startedAtMs: started, timeoutMs });
   return native;
 }
 
@@ -593,18 +675,26 @@ export async function shutdownShellJobs(_reason = 'runtime-close', { scope = nul
     (task) => task.status === 'running' && (!scoped || String(task.ownerSessionId || '') === ownerSessionId)
   );
   let cancelledWatchers = 0;
-  for (const task of jobs) {
-    if (cancelBackgroundShellJobWatch(task.jobId)) cancelledWatchers += 1;
-    try {
-      cancelNativeTask(task.jobId);
-    } catch {}
-    jobNotifyCtxByJobId.delete(task.jobId);
-  }
+  // Identities first, as every other kill does: once a root dies, what it
+  // started outside its process group is reparented and can no longer be
+  // found. The cancel is sent at the snapshot bound regardless.
+  await killAfterSnapshot(Promise.all(prepareOwnedShellTreeKills(scoped ? ownerSessionId : null)), () => {
+    for (const task of jobs) {
+      if (cancelBackgroundShellJobWatch(task.jobId)) cancelledWatchers += 1;
+      try {
+        cancelNativeTask(task.jobId);
+      } catch {}
+      jobNotifyCtxByJobId.delete(task.jobId);
+    }
+  });
   const settled = await Promise.all(jobs.map((task) => waitNativeTask(task.jobId, 1_200).catch(() => null)));
   // A process still running after the wait is not forgotten: it keeps being
   // stopped until its exit is confirmed.
   const unconfirmed = jobs.filter((_, index) => settled[index]?.status === 'running').map((task) => task.jobId);
   for (const jobId of unconfirmed) retryShutdownSurvivor(jobId, 1);
+  // The roots are gone; what they started outside their group is swept by
+  // each job's termination watch. Shutdown waits for that, bounded.
+  const treesGone = await Promise.all(jobs.map((task) => waitShellJobTerminated(task.jobId, SHUTDOWN_TREE_CONFIRM_MS)));
   if (scoped) {
     // The owning session is gone: nothing can query its tasks again, so
     // drop ALL of its retained state — not only the ones that happened to
@@ -624,6 +714,7 @@ export async function shutdownShellJobs(_reason = 'runtime-close', { scope = nul
     cancelledJobs: jobs.length,
     confirmedJobs: settled.filter((task) => task && task.status !== 'running').length,
     unconfirmedJobs: unconfirmed,
+    treeUnconfirmedJobs: jobs.filter((_, index) => !treesGone[index]).map((task) => task.jobId),
     cancelledWatchers,
   };
 }

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

@@ -213,6 +213,11 @@ function buildSuccessSummary(command, stdout) {
   return null;
 }
 
+// A line redrawn with `\r` shows only its last non-empty frame.
+function lastVisibleFrame(frames) {
+  return [...frames].reverse().find((frame) => frame !== '') ?? '';
+}
+
 export function foldCarriageReturnFrames(value) {
   const text = String(value ?? '');
   if (!/\r(?!\n)/.test(text)) return null;
@@ -223,12 +228,32 @@ export function foldCarriageReturnFrames(value) {
     const frames = line.split('\r');
     if (frames.length === 1) return line;
     omitted += frames.length - 1;
-    return [...frames].reverse().find((frame) => frame !== '') ?? '';
+    return lastVisibleFrame(frames);
   });
   if (!omitted) return null;
   return `${out.join('\n')}\n... [${omitted} overwritten progress frames omitted]`;
 }
 
+/** The same `\r` folding for output that arrives in chunks: the line still
+ *  open at a chunk's end keeps its state, so a progress bar redrawn across
+ *  deliveries shows its latest frame once, while plain continuation text of
+ *  that line is passed through as is. */
+export function createCarriageReturnFolder() {
+  let open = '';
+  return function fold(chunk) {
+    const lines = String(chunk ?? '')
+      .replace(/\r\n/g, '\n')
+      .split('\n');
+    const out = lines.map((line, index) => {
+      const redraw = line.includes('\r');
+      const visible = redraw ? lastVisibleFrame((index === 0 ? open + line : line).split('\r')) : line;
+      if (index === lines.length - 1) open = index === 0 && !redraw ? open + line : visible;
+      return visible;
+    });
+    return out.join('\n');
+  };
+}
+
 function hasDiagnosticHazard(value) {
   return /\b(?:errors?|warnings?|failed|failure|panic|fatal|xpass|xfailed|cancelled|todo|skipped)\b/i.test(
     String(value ?? '')

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

@@ -1,5 +1,6 @@
 import { countSplitLines } from './path-utils.mjs';
 import { TOOL_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
+import { DELIVERY_FULL_CHARS, fitPieces, shellTextPiece } from './lib/shell-delivery.mjs';
 
 const SHELL_OUTPUT_MAX_BYTES = TOOL_OUTPUT_MAX_BYTES;
 
@@ -7,11 +8,6 @@ export const SMART_BASH_MAX_LINES = 400;
 export const SMART_BASH_MAX_BYTES = TOOL_OUTPUT_MAX_BYTES;
 export const SMART_BASH_HEAD_LINES = 80;
 export const SMART_BASH_TAIL_LINES = 80;
-export const BACKGROUND_PARTIAL_OUTPUT_MAX_BYTES = 10 * 1024;
-const BACKGROUND_PARTIAL_OUTPUT_HEAD_BYTES = 2 * 1024;
-
-const BACKGROUND_PARTIAL_TRUNCATION_MARKER = '\n\n... [partial output truncated; head and tail shown] ...\n\n';
-
 function utf8Prefix(value, maxBytes) {
   const buffer = Buffer.from(String(value ?? ''), 'utf8');
   if (buffer.length <= maxBytes) return buffer.toString('utf8');
@@ -20,31 +16,20 @@ function utf8Prefix(value, maxBytes) {
   return buffer.subarray(0, end).toString('utf8');
 }
 
-function utf8Suffix(value, maxBytes) {
-  const buffer = Buffer.from(String(value ?? ''), 'utf8');
-  if (buffer.length <= maxBytes) return buffer.toString('utf8');
-  let start = buffer.length - maxBytes;
-  while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) start += 1;
-  return buffer.subarray(start).toString('utf8');
-}
-
+// Partial output of a promoted command that has no task record, in the shared
+// delivery shape (lib/shell-delivery.mjs).
 export function renderBackgroundPartialOutput(stdout, stderr) {
-  const sections = [];
-  const out = String(stdout ?? '');
-  const err = String(stderr ?? '');
-  if (out) sections.push(`[partial stdout]\n${out}`);
-  if (err) sections.push(`[partial stderr]\n${err}`);
-  const merged = sections.join('\n\n');
-  if (!merged) return '';
-  if (Buffer.byteLength(merged, 'utf8') <= BACKGROUND_PARTIAL_OUTPUT_MAX_BYTES) return merged;
-
-  const markerBytes = Buffer.byteLength(BACKGROUND_PARTIAL_TRUNCATION_MARKER, 'utf8');
-  const tailBytes = BACKGROUND_PARTIAL_OUTPUT_MAX_BYTES - BACKGROUND_PARTIAL_OUTPUT_HEAD_BYTES - markerBytes;
-  return (
-    utf8Prefix(merged, BACKGROUND_PARTIAL_OUTPUT_HEAD_BYTES) +
-    BACKGROUND_PARTIAL_TRUNCATION_MARKER +
-    utf8Suffix(merged, tailBytes)
+  const streams = [
+    ['stdout', String(stdout ?? '')],
+    ['stderr', String(stderr ?? '')],
+  ].filter(([, text]) => text);
+  const headings = streams.map(([label]) => `[partial ${label}]\n`);
+  const fixed = headings.reduce((sum, heading) => sum + heading.length, 2 * Math.max(0, streams.length - 1));
+  const bodies = fitPieces(
+    streams.map(([label, text]) => shellTextPiece(text, { label })),
+    DELIVERY_FULL_CHARS - fixed
   );
+  return streams.map((_, index) => `${headings[index]}${bodies[index]}`).join('\n\n');
 }
 
 export function smartMiddleTruncate(content) {