mixdog 0.9.63 → 0.9.64

package/scripts/apply-patch-edit-smoke.mjs

@@ -1,71 +0,0 @@
-#!/usr/bin/env node
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-function assertOk(label, result) {
-  const text = String(result || '');
-  if (!text || /^Error[\s:]/.test(text)) {
-    throw new Error(`${label} failed:\n${text}`);
-  }
-  return text;
-}
-
-const tmp = mkdtempSync(join(tmpdir(), 'mixdog-apply-patch-smoke-'));
-
-try {
-  writeFileSync(join(tmp, 'target.txt'), 'alpha\nbeta\ngamma\n', 'utf8');
-
-  const editResult = await executePatchTool('apply_patch', {
-    base_path: tmp,
-    patch: `*** Begin Patch
-*** Update File: target.txt
-@@
- alpha
--beta
-+bravo
- gamma
-*** Add File: created.txt
-+created by apply_patch smoke
-+second line
-*** End Patch
-`,
-  }, tmp, {});
-  assertOk('apply_patch edit', editResult);
-
-  assert(
-    readFileSync(join(tmp, 'target.txt'), 'utf8') === 'alpha\nbravo\ngamma\n',
-    'apply_patch update did not write the expected target.txt contents',
-  );
-  assert(
-    readFileSync(join(tmp, 'created.txt'), 'utf8') === 'created by apply_patch smoke\nsecond line\n',
-    'apply_patch add did not write the expected created.txt contents',
-  );
-
-  const deleteResult = await executePatchTool('apply_patch', {
-    base_path: tmp,
-    patch: `*** Begin Patch
-*** Delete File: created.txt
-*** End Patch
-`,
-  }, tmp, {});
-  assertOk('apply_patch delete', deleteResult);
-
-  let deleteMissing = false;
-  try {
-    readFileSync(join(tmp, 'created.txt'), 'utf8');
-  } catch (err) {
-    if (err?.code === 'ENOENT') deleteMissing = true;
-    else throw err;
-  }
-  assert(deleteMissing, 'apply_patch delete left created.txt on disk');
-
-  process.stdout.write('apply_patch edit smoke passed\n');
-} finally {
-  rmSync(tmp, { recursive: true, force: true });
-}

package/scripts/arg-guard-test.mjs

@@ -1,93 +0,0 @@
-// Regression tests for validateBuiltinArgs numeric coercion + over-max clamp:
-// - integer-shaped strings ("5") coerce to numbers instead of erroring
-// - over-max integers clamp to the cap instead of erroring
-// - truly non-numeric / below-min input keeps the existing error
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { validateBuiltinArgs } from '../src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs';
-
-test('read offset/limit as numeric strings coerce to numbers', () => {
-    const a = { path: 'x.mjs', offset: '5', limit: '40' };
-    assert.equal(validateBuiltinArgs('read', a), null);
-    assert.equal(a.offset, 5);
-    assert.equal(a.limit, 40);
-});
-
-test('read line/context as numeric strings coerce and window', () => {
-    const a = { path: 'x.mjs', line: '100', context: '5' };
-    assert.equal(validateBuiltinArgs('read', a), null);
-    assert.equal(a.offset, 94);
-    assert.equal(a.limit, 11);
-});
-
-test('grep head_limit/offset/-C as numeric strings coerce', () => {
-    const a = { pattern: 'x', head_limit: '3', offset: '10', '-C': '2' };
-    assert.equal(validateBuiltinArgs('grep', a), null);
-    assert.equal(a.head_limit, 3);
-    assert.equal(a.offset, 10);
-    assert.equal(a['-C'], 2);
-});
-
-test('grep empty context strings are treated as omitted', () => {
-    const a = { pattern: 'x', output_mode: 'content_with_context', '-A': '', '-B': '', '-C': '', context: '' };
-    assert.equal(validateBuiltinArgs('grep', a), null);
-    assert.equal(Object.prototype.hasOwnProperty.call(a, '-A'), false);
-    assert.equal(Object.prototype.hasOwnProperty.call(a, '-B'), false);
-    assert.equal(Object.prototype.hasOwnProperty.call(a, '-C'), false);
-    assert.equal(Object.prototype.hasOwnProperty.call(a, 'context'), false);
-});
-
-test('list/find/glob head_limit as numeric string coerces', () => {
-    const l = { path: '.', head_limit: '5' };
-    assert.equal(validateBuiltinArgs('list', l), null);
-    assert.equal(l.head_limit, 5);
-    const f = { query: 'x', head_limit: '5' };
-    assert.equal(validateBuiltinArgs('find', f), null);
-    assert.equal(f.head_limit, 5);
-    const g = { pattern: '*.mjs', head_limit: '5' };
-    assert.equal(validateBuiltinArgs('glob', g), null);
-    assert.equal(g.head_limit, 5);
-});
-
-test('over-max integer clamps to the cap instead of erroring', () => {
-    // read n cap is 0..10000; a huge value clamps down instead of erroring.
-    const a = { path: 'x.mjs', n: 999999999 };
-    assert.equal(validateBuiltinArgs('read', a), null);
-    assert.equal(a.n, 10000);
-});
-
-test('over-max numeric-string clamps too', () => {
-    const a = { path: 'x.mjs', n: '999999999' };
-    assert.equal(validateBuiltinArgs('read', a), null);
-    assert.equal(a.n, 10000);
-});
-
-test('non-numeric string still errors', () => {
-    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', limit: 'soon' }), /must be an integer/);
-    assert.match(validateBuiltinArgs('list', { path: '.', head_limit: 'soon' }), /finite integer/);
-});
-
-test('below-min (negative) still errors', () => {
-    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', offset: -1 }), /must be >= 0/);
-    assert.match(validateBuiltinArgs('list', { path: '.', head_limit: '-2' }), /must be >= 0/);
-});
-
-test('fractional numeric string is not coerced (still errors)', () => {
-    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', limit: '3.5' }), /must be an integer/);
-});
-
-test('grep pattern and glob-filter numeric values coerce to strings', () => {
-    const pattern = { pattern: 123 };
-    assert.equal(validateBuiltinArgs('grep', pattern), null);
-    assert.equal(pattern.pattern, '123');
-
-    const patternArray = { pattern: [123, 'a'] };
-    assert.equal(validateBuiltinArgs('grep', patternArray), null);
-    assert.deepEqual(patternArray.pattern, ['123', 'a']);
-
-    const glob = { pattern: 'x', glob: 123 };
-    assert.equal(validateBuiltinArgs('grep', glob), null);
-    assert.equal(glob.glob, '123');
-
-    assert.match(validateBuiltinArgs('grep', { pattern: {} }), /must be string or string\[\]/);
-});

package/scripts/async-notify-settlement-test.mjs

@@ -1,99 +0,0 @@
-// A Promise-returning notifyFn must only *mark* a background-task completion
-// delivered after the promise settles. When it rejects/declines AND the
-// enqueueFallback rescue also fails, the task must be left UN-marked so a later
-// reconcile can retry — never silently marked delivered before settlement.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import {
-  registerBackgroundTask,
-  completeBackgroundTask,
-  getBackgroundTask,
-  setBackgroundTaskEnqueueFallback,
-  reconcileBackgroundTask,
-} from '../src/runtime/shared/background-tasks.mjs';
-
-const tick = () => new Promise((r) => setImmediate(r));
-
-test('async notifyFn rejection with no rescue does not mark delivered', async () => {
-  setBackgroundTaskEnqueueFallback(null); // no fallback channel → nothing lands
-  const task = registerBackgroundTask({
-    surface: 'tool',
-    operation: 'run',
-    resultType: 'tool_task_result',
-    context: { notifyFn: () => Promise.reject(new Error('boom')) },
-  });
-  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
-
-  // Optimistic marks were applied synchronously; settlement must clear them.
-  await tick();
-  await tick();
-  const t = getBackgroundTask(task.taskId);
-  assert.equal(t.notifiedWithBody, false, 'body delivery un-marked after async failure');
-  assert.equal(t.notified, false, 'notified un-marked after async failure');
-});
-
-test('async notifyFn success keeps the completion marked delivered', async () => {
-  setBackgroundTaskEnqueueFallback(null);
-  const task = registerBackgroundTask({
-    surface: 'tool',
-    operation: 'run',
-    resultType: 'tool_task_result',
-    context: { notifyFn: () => Promise.resolve(true) },
-  });
-  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
-
-  await tick();
-  await tick();
-  const t = getBackgroundTask(task.taskId);
-  assert.equal(t.notifiedWithBody, true, 'successful async delivery stays marked');
-  assert.equal(t.notified, true, 'successful async delivery stays notified');
-});
-
-test('async notifyFn rejection is rescued by fallback and stays marked', async () => {
-  const enqueued = [];
-  setBackgroundTaskEnqueueFallback((sessionId, text) => { enqueued.push({ sessionId, text }); return 1; });
-  const task = registerBackgroundTask({
-    surface: 'tool',
-    operation: 'run',
-    resultType: 'tool_task_result',
-    context: { notifyFn: () => Promise.reject(new Error('boom')), callerSessionId: 'sess_rescue' },
-  });
-  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
-
-  await tick();
-  await tick();
-  const t = getBackgroundTask(task.taskId);
-  assert.equal(enqueued.length, 1, 'fallback rescued the completion once');
-  assert.equal(t.notifiedWithBody, true, 'rescued delivery stays marked exactly once');
-});
-
-test('reconcile retries an un-marked completion on an already-terminal task', async () => {
-  // First completion: async notifyFn rejects and there is NO fallback, so the
-  // task is driven terminal but the body notification un-marks itself.
-  setBackgroundTaskEnqueueFallback(null);
-  const task = registerBackgroundTask({
-    surface: 'tool',
-    operation: 'run',
-    resultType: 'tool_task_result',
-    context: { notifyFn: () => Promise.reject(new Error('boom')), callerSessionId: 'sess_reconcile' },
-  });
-  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
-  await tick();
-  await tick();
-  const before = getBackgroundTask(task.taskId);
-  assert.equal(before.notifiedWithBody, false, 'body un-marked after the failed async notify');
-
-  // A later reconcile on the (already-terminal) task must retry the delivery
-  // rather than returning early. With a working fallback now in place it lands.
-  const enqueued = [];
-  setBackgroundTaskEnqueueFallback((sessionId, text) => { enqueued.push({ sessionId, text }); return 1; });
-  reconcileBackgroundTask(task.taskId, { status: 'completed', terminalReason: 'reconciled' });
-  await tick();
-  await tick();
-  const after = getBackgroundTask(task.taskId);
-  assert.equal(enqueued.length, 1, 'reconcile re-fired the completion once on the terminal task');
-  assert.equal(after.notifiedWithBody, true, 'reconcile retry marks the body delivered');
-});
-
-test.after(() => { setBackgroundTaskEnqueueFallback(null); });

package/scripts/atomic-lock-tryonce-test.mjs

@@ -1,125 +0,0 @@
-// Proves try-once (timeoutMs:0) lock behavior: when the lock is already held,
-// withFileLockSync/withFileLock return IMMEDIATELY with ELOCKCONTENDED and
-// never sleep (no Atomics.wait / setTimeout backoff). Also asserts sync+async
-// lock interop: neither can enter the critical section while the other holds.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  existsSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  utimesSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-  withFileLockSync,
-  withFileLock,
-} from '../src/runtime/shared/atomic-file.mjs';
-
-function tmpLock() {
-  const dir = mkdtempSync(join(tmpdir(), 'mixlock-'));
-  return { dir, lockPath: join(dir, 't.lock') };
-}
-
-test('try-once sync throws ELOCKCONTENDED without sleeping when held', () => {
-  const { dir, lockPath } = tmpLock();
-  try {
-    withFileLockSync(lockPath, () => {
-      const started = Date.now();
-      assert.throws(
-        () => withFileLockSync(lockPath, () => 'unreachable', { timeoutMs: 0 }),
-        (e) => e?.code === 'ELOCKCONTENDED',
-      );
-      assert.ok(Date.now() - started < 20, `try-once slept ${Date.now() - started}ms`);
-    });
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('try-once async rejects ELOCKCONTENDED without sleeping when held', async () => {
-  const { dir, lockPath } = tmpLock();
-  try {
-    await withFileLockSync(lockPath, async () => {
-      const started = Date.now();
-      await assert.rejects(
-        withFileLock(lockPath, () => 'unreachable', { timeoutMs: 0 }),
-        (e) => e?.code === 'ELOCKCONTENDED',
-      );
-      assert.ok(Date.now() - started < 20, `try-once slept ${Date.now() - started}ms`);
-    });
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('async holder blocks sync try-once, then sync acquires after release', async () => {
-  const { dir, lockPath } = tmpLock();
-  try {
-    await withFileLock(lockPath, () => {
-      assert.throws(
-        () => withFileLockSync(lockPath, () => 'unreachable', { timeoutMs: 0 }),
-        (e) => e?.code === 'ELOCKCONTENDED',
-      );
-    });
-    const val = withFileLockSync(lockPath, () => 7, { timeoutMs: 0 });
-    assert.equal(val, 7);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('published reclaim guards are non-revocable regardless of owner, contents, or age', () => {
-  for (const [name, content, aged] of [
-    ['live', `${process.pid + 1} 1 live\n`, false],
-    ['same-pid', `${process.pid} 1 sibling\n`, false],
-    ['empty', '', false],
-    ['malformed', 'not-a-guard', false],
-    ['aged-dead', '2147483647 1 corpse\n', true],
-  ]) {
-    const { dir, lockPath } = tmpLock();
-    try {
-      const guardPath = `${lockPath}.reclaim`;
-      writeFileSync(lockPath, '2147483647 1 dead-lock\n');
-      writeFileSync(guardPath, content);
-      if (aged) {
-        const old = new Date(Date.now() - 60000);
-        utimesSync(guardPath, old, old);
-      }
-      assert.throws(
-        () => withFileLockSync(lockPath, () => 'unreachable', { timeoutMs: 5, staleMs: 1 }),
-        (error) => error?.code === 'ELOCKTIMEOUT',
-        name,
-      );
-      assert.equal(readFileSync(guardPath, 'utf8'), content, name);
-      assert.equal(existsSync(lockPath), true, name);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  }
-});
-
-test('overlapping dead-guard contenders neither delete nor replace the guard', async () => {
-  const { dir, lockPath } = tmpLock();
-  try {
-    const guardPath = `${lockPath}.reclaim`;
-    const guard = '2147483647 1 dead-guard\n';
-    writeFileSync(lockPath, '2147483647 1 dead-lock\n');
-    writeFileSync(guardPath, guard);
-    const attempts = await Promise.allSettled([
-      withFileLock(lockPath, () => 'unreachable', { timeoutMs: 10, staleMs: 1 }),
-      withFileLock(lockPath, () => 'unreachable', { timeoutMs: 10, staleMs: 1 }),
-    ]);
-    assert.deepEqual(attempts.map(({ status, reason }) => [status, reason?.code]), [
-      ['rejected', 'ELOCKTIMEOUT'],
-      ['rejected', 'ELOCKTIMEOUT'],
-    ]);
-    assert.equal(readFileSync(guardPath, 'utf8'), guard);
-    assert.equal(existsSync(lockPath), true);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});

package/scripts/background-task-meta-smoke.mjs

@@ -1,38 +0,0 @@
-import assert from 'node:assert/strict';
-import {
-  registerBackgroundTask,
-  renderBackgroundTask,
-  taskSummary,
-} from '../src/runtime/shared/background-tasks.mjs';
-
-const task = registerBackgroundTask({
-  surface: 'agent',
-  operation: 'spawn',
-  label: 'smoke',
-  meta: {
-    tag: 'w1',
-    agent: 'worker',
-    firstResponseTimeoutMs: 30_000,
-    idleTimeoutMs: 120_000,
-    spawnPrepTimeoutMs: 90_000,
-    watchdogPolicy: { firstResponseMs: 30_000 },
-  },
-});
-
-const rendered = renderBackgroundTask(task, { includeResult: false });
-for (const forbidden of [
-  'firstResponseTimeoutMs',
-  'idleTimeoutMs',
-  'spawnPrepTimeoutMs',
-  'watchdogPolicy',
-]) {
-  assert.equal(rendered.includes(forbidden), false, `render leaked ${forbidden}`);
-}
-
-const summary = taskSummary(task);
-assert.equal(summary.firstResponseTimeoutMs, undefined);
-assert.equal(summary.idleTimeoutMs, undefined);
-assert.equal(summary.spawnPrepTimeoutMs, undefined);
-assert.equal(summary.tag, 'w1');
-
-console.log('background-task-meta-smoke: ok');