mixdog 0.9.46 → 0.9.49

package/scripts/shell-failure-diagnostics-test.mjs

@@ -0,0 +1,211 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { classifyToolFailure } from '../src/runtime/agent/orchestrator/agent-trace-format.mjs';
+import { ExecResult, execShellCommand } from '../src/runtime/agent/orchestrator/tools/shell-command.mjs';
+import { _composeShellFailure, _shellFailureStatus } from '../src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs';
+
+test('shell trace classification uses only the leading status marker', () => {
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [exit code: 1]\n\ncommand timed out while parsing an aborted field',
+    'shell',
+  ), 'command-exit');
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [signal: SIGKILL]\n\n(no output)',
+    'shell',
+  ), 'process/signal');
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [timeout: 500ms signal: SIGTERM cause: timeout]',
+    'shell',
+  ), 'timeout/abort');
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [signal: SIGTERM cause: cancellation]',
+    'shell',
+  ), 'timeout/abort');
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [signal: SIGKILL cause: output-limit]',
+    'shell',
+  ), 'runtime/failure');
+  assert.equal(classifyToolFailure(
+    '⚠️ destructive command warning\nError: [shell-run-failed] [signal: SIGKILL]',
+    'shell',
+  ), 'process/signal');
+});
+
+test('shell failure rendering preserves actual signals and runtime kill causes', () => {
+  const status = (opts) => _shellFailureStatus(new ExecResult({
+    stdout: '', stderr: '', exitCode: null, taskId: 'test', ...opts,
+  }), 500).statusDetail;
+  assert.match(status({ signal: 'SIGKILL' }), /^\[signal: SIGKILL\]$/);
+  assert.match(status({ signal: 'SIGTERM', killed: true, killCause: 'cancellation' }),
+    /^\[signal: SIGTERM cause: cancellation\]$/);
+  assert.match(status({ signal: 'SIGTERM', killed: true, timedOut: true, killCause: 'timeout' }),
+    /^\[timeout: 500ms signal: SIGTERM cause: timeout\]/);
+  assert.match(status({
+    killed: true,
+    killCause: 'output-capture-error',
+    outputCaptureError: new Error('disk full'),
+  }), /^\[output capture failed cause: output-capture-error signal: SIGKILL\]$/);
+  assert.match(status({ signal: 'SIGKILL', killed: true, killCause: 'output-limit' }),
+    /^\[signal: SIGKILL cause: output-limit\]$/);
+});
+
+test('WMIC rewrite note follows the leading shell failure marker', () => {
+  const rendered = _composeShellFailure(
+    '[shell-run-failed] [exit code: 1]',
+    'Error: ',
+    '[auto-rewrite: deprecated wmic process query -> PowerShell; timeout capped at 30000ms]',
+    '(no output)',
+  );
+  assert.match(rendered, /^Error: \[shell-run-failed\] \[exit code: 1\]\n\[auto-rewrite:/);
+  assert.equal(classifyToolFailure(rendered, 'shell'), 'command-exit');
+});
+
+async function withoutUnhandledProcessFailure(run) {
+  const uncaught = [];
+  const rejected = [];
+  const onUncaught = (err) => uncaught.push(err);
+  const onRejected = (err) => rejected.push(err);
+  process.on('uncaughtException', onUncaught);
+  process.on('unhandledRejection', onRejected);
+  try {
+    const result = await run();
+    await new Promise((resolveTurn) => setImmediate(resolveTurn));
+    assert.deepEqual(uncaught, [], `unexpected uncaught error: ${uncaught[0]?.stack || uncaught[0]}`);
+    assert.deepEqual(rejected, [], `unexpected unhandled rejection: ${rejected[0]?.stack || rejected[0]}`);
+    return result;
+  } finally {
+    process.removeListener('uncaughtException', onUncaught);
+    process.removeListener('unhandledRejection', onRejected);
+  }
+}
+
+function assertSpawnToolFailure(result) {
+  assert.equal(result.failurePhase, 'tool');
+  assert.equal(result.failureReason, 'spawn failed');
+  const status = _shellFailureStatus(result, 1000);
+  assert.equal(status.shellToolFailed, true);
+  const rendered = _composeShellFailure(
+    `[shell-tool-failed] ${status.statusDetail}`,
+    'Error: ',
+    '',
+    result.stderr,
+  );
+  assert.match(rendered, /^Error: \[shell-tool-failed\] \[spawn failed\]/);
+  assert.equal(classifyToolFailure(rendered, 'shell'), 'tool-call/failure');
+}
+
+test('asynchronous ENOENT spawn errors remain shell tool failures', async () => {
+  const missing = await withoutUnhandledProcessFailure(() => execShellCommand({
+    shell: join(tmpdir(), `mixdog-missing-shell-${process.pid}`),
+    shellArg: '-c',
+    command: 'echo unreachable',
+    env: process.env,
+    cwd: process.cwd(),
+    timeoutMs: 1000,
+  }));
+  assertSpawnToolFailure(missing);
+  assert.match(missing.stderr, /ENOENT|not found/i);
+});
+
+test('asynchronous EACCES spawn errors remain shell tool failures', async (t) => {
+  if (process.platform === 'win32') return t.skip('executable-bit case is POSIX-only');
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-eacces-shell-'));
+  try {
+    const denied = join(dir, 'denied.sh');
+    writeFileSync(denied, '#!/bin/sh\necho unreachable\n');
+    chmodSync(denied, 0o600);
+    const result = await withoutUnhandledProcessFailure(() => execShellCommand({
+      shell: denied,
+      shellArg: '-c',
+      command: 'echo unreachable',
+      env: process.env,
+      cwd: process.cwd(),
+      timeoutMs: 1000,
+    }));
+    assertSpawnToolFailure(result);
+    assert.match(result.stderr, /EACCES|permission denied/i);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('execShellCommand carries cancellation cause alongside process signal', async () => {
+  const controller = new AbortController();
+  const isWindows = process.platform === 'win32';
+  const promise = execShellCommand({
+    shell: isWindows ? (process.env.ComSpec || 'cmd.exe') : '/bin/sh',
+    shellArg: isWindows ? '/c' : '-c',
+    command: isWindows ? 'ping 127.0.0.1 -n 20 > nul' : 'sleep 10',
+    env: process.env,
+    cwd: process.cwd(),
+    timeoutMs: 5000,
+    abortSignal: controller.signal,
+    backgroundOnTimeout: false,
+  });
+  setTimeout(() => controller.abort(), 100);
+  const result = await promise;
+  assert.equal(result.killed, true);
+  assert.equal(result.killCause, 'cancellation');
+  assert.ok(result.signal || process.platform === 'win32');
+});
+
+test('cancellation racing with auto-background adoption is returned as cancelled', async () => {
+  let abortReads = 0;
+  const racingSignal = {
+    get aborted() { abortReads += 1; return abortReads >= 2; },
+    addEventListener() {},
+    removeEventListener() {},
+  };
+  const isWindows = process.platform === 'win32';
+  const result = await execShellCommand({
+    shell: isWindows ? (process.env.ComSpec || 'cmd.exe') : '/bin/sh',
+    shellArg: isWindows ? '/c' : '-c',
+    command: isWindows ? 'ping 127.0.0.1 -n 20 > nul' : 'sleep 10',
+    env: process.env,
+    cwd: process.cwd(),
+    timeoutMs: 5000,
+    abortSignal: racingSignal,
+    autoBackgroundMs: 25,
+    backgroundOnTimeout: false,
+  });
+  assert.equal(result.backgrounded, false);
+  assert.equal(result.killed, true);
+  assert.equal(result.killCause, 'cancellation');
+});
+
+test('tool-failures separates actionable totals while retaining command-exit rows', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-tool-failures-test-'));
+  try {
+    const history = join(dir, 'history');
+    mkdirSync(history);
+    const rows = [
+      { ts: 1, tool_name: 'shell', category: 'process/signal', error_first_line: 'SIGKILL' },
+      { ts: 2, tool_name: 'shell', category: 'runtime/failure', error_first_line: 'capture guard' },
+      ...Array.from({ length: 45 }, (_, index) => ({
+        ts: index + 3,
+        tool_name: 'shell',
+        category: 'command-exit',
+        error_first_line: `exit ${index}`,
+      })),
+    ];
+    writeFileSync(join(history, 'tool-failures.jsonl'), `${rows.map(JSON.stringify).join('\n')}\n`);
+    const script = resolve('scripts/tool-failures.mjs');
+    const text = spawnSync(process.execPath, [script, '--data-dir', dir, '--limit', '2'], { encoding: 'utf8' });
+    assert.equal(text.status, 0, text.stderr);
+    assert.match(text.stdout, /actionable failures: 2\/2 shown/);
+    assert.match(text.stdout, /command exits: 2\/45 shown \(retained\)/);
+    assert.equal((text.stdout.match(/^- /gm) || []).length, 4);
+    const json = spawnSync(process.execPath, [script, '--data-dir', dir, '--limit', '2', '--json'], { encoding: 'utf8' });
+    assert.equal(json.status, 0, json.stderr);
+    const report = JSON.parse(json.stdout);
+    assert.deepEqual(report.actionable_failures, { shown: 2, matched: 2 });
+    assert.deepEqual(report.command_exits, { shown: 2, matched: 45 });
+    assert.equal(report.rows.length, 4);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/statusline-quota-hysteresis-test.mjs

@@ -1,6 +1,10 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { acceptQuotaSnapshot } from '../src/ui/statusline.mjs';
+import {
+  acceptQuotaSnapshot,
+  fallbackStatusline,
+  resolveContextUsedPct,
+} from '../src/ui/statusline.mjs';
 
 // Monotonic hysteresis for the 5H/7D usage segment: once a value has rendered,
 // an OLDER shared-cache snapshot (written by another mixdog instance) must not
@@ -35,3 +39,24 @@ test('own-instance live data always wins; empty timestamps preserve prior behavi
   // Shared→shared same asOf → accept (idempotent refresh).
   assert.equal(acceptQuotaSnapshot({ asOf: 2000, owned: false }, { asOf: 2000, owned: false }), true);
 });
+
+test('context percentage uses compaction pressure over trigger and ignores gateway boundary percent', () => {
+  const args = {
+    stats: {
+      currentEstimatedContextTokens: 75_000,
+      currentContextSource: 'estimated',
+    },
+    contextWindow: 100_000,
+    compactBoundaryTokens: 100_000,
+    autoCompactTokenLimit: 75_000,
+  };
+  assert.equal(resolveContextUsedPct({
+    ...args,
+    gatewayStatus: { contextUsedPct: 75 },
+  }), 100);
+  assert.match(
+    fallbackStatusline({ provider: 'openai', model: 'test', ...args })
+      .replace(/\x1b\[[0-9;]*m/g, ''),
+    /\b100%/,
+  );
+});

package/scripts/streaming-tail-window-test.mjs

@@ -0,0 +1,29 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  windowPlainStreamingText,
+} from '../src/tui/markdown/streaming-markdown.mjs';
+import {
+  measureStreamingMarkdownRenderedRows,
+} from '../src/tui/markdown/measure-rendered-rows.mjs';
+
+test('bottom-pinned plain streaming text keeps only the visible suffix', () => {
+  const lines = Array.from({ length: 100 }, (_, index) => `plain line ${index}`);
+  const full = lines.join('\n');
+  const windowed = windowPlainStreamingText(full, 80, 12);
+
+  assert.equal(windowed, lines.slice(-12).join('\n'));
+  assert.ok(measureStreamingMarkdownRenderedRows(full, 83, 'plain-window-full') > 12);
+});
+
+test('markdown streaming text is never internally windowed', () => {
+  const markdown = `${'plain history\n'.repeat(100)}**live markdown**`;
+  assert.equal(windowPlainStreamingText(markdown, 80, 12), markdown.trim());
+});
+
+test('wrapped plain lines consume the streaming row budget', () => {
+  const lines = ['old', 'x'.repeat(160), 'new'];
+  assert.equal(windowPlainStreamingText(lines.join('\n'), 80, 2), lines.slice(-1).join('\n'));
+  assert.equal(windowPlainStreamingText(lines.join('\n'), 80, 3), lines.slice(-2).join('\n'));
+});

package/scripts/tool-failures.mjs

@@ -94,20 +94,33 @@ const rows = files.flatMap(readRows)
   .filter((row) => !agentFilter || String(row.agent || '-') === agentFilter)
   .filter((row) => !categoryFilter || rowCategory(row) === categoryFilter)
   .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
-const recent = rows.slice(-limit);
+const isCommandExit = (row) => rowCategory(row) === 'command-exit';
+const actionableRows = rows.filter((row) => !isCommandExit(row));
+const commandExitRows = rows.filter(isCommandExit);
+// Limit each partition independently so a burst of ordinary command exits
+// cannot crowd runtime/actionable failures out of the displayed report.
+const actionableRecent = actionableRows.slice(-limit);
+const commandExitRecent = commandExitRows.slice(-limit);
+const recent = [...actionableRecent, ...commandExitRecent]
+  .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
 const byTool = new Map();
 const byCategory = new Map();
+const actionableByTool = new Map();
+const commandExitByTool = new Map();
 for (const row of recent) {
   const tool = rowTool(row);
   const category = rowCategory(row);
   inc(byTool, tool);
   inc(byCategory, `${tool} / ${category}`);
+  inc(isCommandExit(row) ? commandExitByTool : actionableByTool, tool);
 }
 
 if (jsonMode) {
   console.log(JSON.stringify({
     shown: recent.length,
     matched: rows.length,
+    actionable_failures: { shown: actionableRecent.length, matched: actionableRows.length },
+    command_exits: { shown: commandExitRecent.length, matched: commandExitRows.length },
     since: sinceTs ? new Date(sinceTs).toISOString() : null,
     filters: {
       tool: toolFilter,
@@ -116,13 +129,17 @@ if (jsonMode) {
     },
     sources: files.filter(existsSync),
     tools: Object.fromEntries([...byTool.entries()].sort((a, b) => b[1] - a[1])),
+    actionable_tools: Object.fromEntries([...actionableByTool.entries()].sort((a, b) => b[1] - a[1])),
+    command_exit_tools: Object.fromEntries([...commandExitByTool.entries()].sort((a, b) => b[1] - a[1])),
     categories: Object.fromEntries([...byCategory.entries()].sort((a, b) => b[1] - a[1])),
     rows: recent,
   }, null, 2));
   process.exit(0);
 }
 
-console.log(`tool failures: ${recent.length}/${rows.length} shown`);
+console.log(`actionable failures: ${actionableRecent.length}/${actionableRows.length} shown`);
+console.log(`command exits: ${commandExitRecent.length}/${commandExitRows.length} shown (retained)`);
+console.log(`rows: ${recent.length}/${rows.length} shown`);
 if (sinceTs) console.log(`since: ${new Date(sinceTs).toISOString()}`);
 const filterParts = [
   toolFilter ? `tool=${toolFilter}` : '',
@@ -131,7 +148,8 @@ const filterParts = [
 ].filter(Boolean);
 if (filterParts.length) console.log(`filters: ${filterParts.join(', ')}`);
 if (files.length > 0) console.log(`sources: ${files.filter(existsSync).join(', ') || '(none)'}`);
-console.log(`tools: ${[...byTool.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
+console.log(`actionable tools: ${[...actionableByTool.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
+console.log(`command-exit tools: ${[...commandExitByTool.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
 console.log(`categories: ${[...byCategory.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
 for (const row of recent) {
   const tool = rowTool(row);