mixdog 0.9.63 → 0.9.64

package/scripts/native-edit-wire-test.mjs

@@ -1,152 +0,0 @@
-#!/usr/bin/env node
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { once } from 'node:events';
-import {
-  existsSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-import {
-  closeNativePatchServerForTests,
-  runServerEdit,
-} from '../src/runtime/agent/orchestrator/tools/patch.mjs';
-
-const binary = process.env.MIXDOG_EDIT_NATIVE_BIN;
-assert.ok(binary, 'MIXDOG_EDIT_NATIVE_BIN must point to the release mixdog-patch binary');
-assert.ok(existsSync(binary), `native EDIT test binary does not exist: ${binary}`);
-
-const responseFields = [
-  'replacements',
-  'readMs',
-  'applyMs',
-  'writeMs',
-  'totalMs',
-  'tier',
-  'contentHash',
-  'roundtripMs',
-];
-
-function digest(content) {
-  return createHash('sha256').update(content).digest('hex');
-}
-
-function assertCompleteResponse(response, { replacements, tier, content }) {
-  assert.deepEqual(Object.keys(response), responseFields, 'EDIT response must expose all eight decoded fields');
-  assert.equal(response.replacements, replacements);
-  assert.equal(response.tier, tier);
-  assert.match(response.contentHash, /^[a-f0-9]{64}$/);
-  assert.equal(response.contentHash, digest(content), 'EDIT response hash must describe the resulting bytes');
-  for (const field of ['readMs', 'applyMs', 'writeMs', 'totalMs', 'roundtripMs']) {
-    assert.ok(Number.isFinite(response[field]) && response[field] >= 0, `${field} must be a non-negative number`);
-  }
-}
-
-function edit(fullPath, oldString, newString, options = {}) {
-  return runServerEdit({
-    fullPath,
-    oldBuf: Buffer.from(oldString, 'utf8'),
-    newBuf: Buffer.from(newString, 'utf8'),
-    ...options,
-  });
-}
-
-async function rawEdit(fullPath, oldString, newString, { replaceAll = false, dryRun = false } = {}) {
-  const pathBuf = Buffer.from(fullPath, 'utf8');
-  const oldBuf = Buffer.from(oldString, 'utf8');
-  const newBuf = Buffer.from(newString, 'utf8');
-  const child = spawn(binary, ['--server'], { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
-  const stdout = [];
-  const stderr = [];
-  child.stdout.on('data', (chunk) => stdout.push(chunk));
-  child.stderr.on('data', (chunk) => stderr.push(chunk));
-  child.stdin.end(Buffer.concat([
-    Buffer.from(`EDIT ${pathBuf.length} ${oldBuf.length} ${newBuf.length} ${replaceAll ? 1 : 0} ${dryRun ? 1 : 0}\n`),
-    pathBuf,
-    oldBuf,
-    newBuf,
-    Buffer.from('QUIT\n'),
-  ]));
-  const [code] = await once(child, 'exit');
-  assert.equal(code, 0, `raw native EDIT server failed: ${Buffer.concat(stderr).toString('utf8')}`);
-  return Buffer.concat(stdout).toString('utf8').trimEnd();
-}
-
-function assertRawResponse(line) {
-  const fields = line.split('\t');
-  assert.equal(fields.length, 8, 'raw EDIT response must contain exactly eight tab-delimited fields');
-  assert.equal(fields[0], 'OK');
-  for (const index of [2, 3, 4, 5]) {
-    assert.notEqual(fields[index], '', `raw EDIT timing field ${index} must be present`);
-    assert.match(fields[index], /^\d+(?:\.\d+)?$/, `raw EDIT timing field ${index} must be numeric`);
-  }
-}
-
-test('native EDIT production wire path preserves matching and response invariants', async (t) => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-native-edit-wire-'));
-  try {
-    await t.test('rejects ambiguity, then reports the replace-all repeat count and full response', async () => {
-      const path = join(root, 'repeats.txt');
-      writeFileSync(path, 'token token token\n', 'utf8');
-
-      await assert.rejects(
-        edit(path, 'token', 'value'),
-        (error) => {
-          assert.equal(error.message, 'old_string found 3 times');
-          return true;
-        },
-      );
-      assert.equal(readFileSync(path, 'utf8'), 'token token token\n');
-
-      const expected = 'value value value\n';
-      assertRawResponse(await rawEdit(path, 'token', 'value', { replaceAll: true, dryRun: true }));
-      const response = await edit(path, 'token', 'value', { replaceAll: true });
-      assert.equal(readFileSync(path, 'utf8'), expected);
-      assertCompleteResponse(response, { replacements: 3, tier: 'exact', content: expected });
-    });
-
-    await t.test('rejects a 30-line folded match without writing', async () => {
-      const path = join(root, 'folded-30.txt');
-      const source = Array.from({ length: 30 }, (_, i) => `line ${i + 1} “value”`).join('\n');
-      const foldedNeedle = Array.from({ length: 30 }, (_, i) => `line ${i + 1} "value"`).join('\n');
-      writeFileSync(path, source, 'utf8');
-
-      await assert.rejects(
-        edit(path, foldedNeedle, 'unsafe replacement'),
-        /old_string is 30 lines \(>= 30\)\./,
-      );
-      assert.equal(readFileSync(path, 'utf8'), source);
-    });
-
-    await t.test('absorbs the deleted line newline', async () => {
-      const path = join(root, 'delete-crlf.txt');
-      const source = 'keep\r\ndelete me\r\nafter\r\n';
-      const expected = 'keep\r\nafter\r\n';
-      writeFileSync(path, source, 'utf8');
-
-      const response = await edit(path, 'delete me', '');
-      assert.equal(readFileSync(path, 'utf8'), expected);
-      assertCompleteResponse(response, { replacements: 1, tier: 'exact', content: expected });
-    });
-
-    await t.test('preserves CRLF while lowering an LF-authored replacement', async () => {
-      const path = join(root, 'preserve-crlf.txt');
-      const source = 'head\r\nold a\r\nold b\r\ntail\r\n';
-      const expected = 'head\r\nnew a\r\nnew b\r\ntail\r\n';
-      writeFileSync(path, source, 'utf8');
-
-      const response = await edit(path, 'old a\nold b', 'new a\nnew b');
-      assert.equal(readFileSync(path, 'utf8'), expected);
-      assertCompleteResponse(response, { replacements: 1, tier: 'crlf', content: expected });
-    });
-  } finally {
-    await closeNativePatchServerForTests();
-    rmSync(root, { recursive: true, force: true });
-  }
-});

package/scripts/notify-completion-mirror-test.mjs

@@ -1,73 +0,0 @@
-// notifyFnForSession must not double-inject a background-task completion. The
-// mirror skip is gated on an EXPLICIT model-visible-delivery ack
-// (modelVisibleDelivered), set ONLY by the TUI execution-ui path that injects
-// the completion body into the active loop — never on a generic truthy
-// onNotification return. So: delivered ack → mirror suppressed; headless /
-// display-only / API listener (no ack) → mirror kept as the sole delivery.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { shouldMirrorCompletionToPendingQueue } from '../src/session-runtime/runtime-core.mjs';
-
-// A terminal agent completion with a Result body — accepted by
-// shouldPersistModelVisibleToolCompletion.
-const completionText = 'Async agent task task_1 completed finished.\n\nResult:\n> ok';
-const completionMeta = { type: 'agent_task_result', execution_id: 'task_1', status: 'completed' };
-
-test('delivered-live completion: no pending mirror (explicit model-visible ack)', () => {
-  const mirror = shouldMirrorCompletionToPendingQueue({
-    callerSessionId: 'sess_live',
-    modelVisibleDelivered: true,
-    hasEnqueue: true,
-    text: completionText,
-    meta: completionMeta,
-  });
-  assert.equal(mirror, false, 'live twin already injected → mirror suppressed');
-});
-
-test('headless completion: pending mirror kept (no ack)', () => {
-  const mirror = shouldMirrorCompletionToPendingQueue({
-    callerSessionId: 'sess_headless',
-    modelVisibleDelivered: false,
-    hasEnqueue: true,
-    text: completionText,
-    meta: completionMeta,
-  });
-  assert.equal(mirror, true, 'no listener delivered → queue copy is the sole delivery');
-});
-
-test('display-only listener returning true (no ack): pending mirror kept', () => {
-  // A generic display/API listener consumes the event (would return true) but
-  // never injects the model-visible body, so it sets NO modelVisibleDelivered
-  // ack. The mirror must stay, or the model never sees the completion body.
-  const mirror = shouldMirrorCompletionToPendingQueue({
-    callerSessionId: 'sess_display_only',
-    modelVisibleDelivered: false,
-    hasEnqueue: true,
-    text: completionText,
-    meta: completionMeta,
-  });
-  assert.equal(mirror, true, 'generic handled===true is NOT an ack → mirror kept');
-});
-
-test('unhandled but non-terminal notification is never mirrored', () => {
-  const mirror = shouldMirrorCompletionToPendingQueue({
-    callerSessionId: 'sess_headless',
-    modelVisibleDelivered: false,
-    hasEnqueue: true,
-    text: 'still running...',
-    meta: { status: 'running' },
-  });
-  assert.equal(mirror, false, 'only persistable terminal completions mirror');
-});
-
-test('missing session id or enqueue capability never mirrors', () => {
-  assert.equal(shouldMirrorCompletionToPendingQueue({
-    callerSessionId: '', modelVisibleDelivered: false, hasEnqueue: true,
-    text: completionText, meta: completionMeta,
-  }), false, 'no caller session → nothing to mirror into');
-  assert.equal(shouldMirrorCompletionToPendingQueue({
-    callerSessionId: 'sess_headless', modelVisibleDelivered: false, hasEnqueue: false,
-    text: completionText, meta: completionMeta,
-  }), false, 'no enqueue capability → cannot mirror');
-});

package/scripts/openai-oauth-refresh-race-test.mjs

@@ -1,120 +0,0 @@
-import test, { after } from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { spawn } from 'node:child_process';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-const root = mkdtempSync(join(tmpdir(), 'mixdog-openai-race-'));
-const tokenPath = join(root, 'openai-oauth.json');
-const readyDir = join(root, 'ready');
-const exchangeDir = join(root, 'exchanges');
-const resultDir = join(root, 'results');
-const startPath = join(root, 'start');
-const moduleUrl = new URL(
-  '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs',
-  import.meta.url,
-).href;
-
-after(() => rmSync(root, { recursive: true, force: true }));
-
-function waitForExit(child) {
-  return new Promise((resolve, reject) => {
-    let stderr = '';
-    child.stderr.setEncoding('utf8');
-    child.stderr.on('data', (chunk) => { stderr += chunk; });
-    child.on('error', reject);
-    child.on('exit', (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`OpenAI contention child exited ${code}: ${stderr}`));
-    });
-  });
-}
-
-test('contending OpenAI OAuth processes share one reread/exchange/write lock', async () => {
-  mkdirSync(readyDir);
-  mkdirSync(exchangeDir);
-  mkdirSync(resultDir);
-  writeFileSync(tokenPath, JSON.stringify({
-    access_token: 'fixture-old-access',
-    refresh_token: 'fixture-old-refresh',
-    expires_at: Date.now() + 1_000,
-  }));
-
-  const childSource = `
-import { existsSync, writeFileSync } from 'node:fs';
-const { OpenAIOAuthProvider } = await import(${JSON.stringify(moduleUrl)});
-const provider = Object.create(OpenAIOAuthProvider.prototype);
-provider.config = {};
-provider.tokens = {
-  ...JSON.parse(await (await import('node:fs/promises')).readFile(process.env.TOKEN_PATH, 'utf8')),
-  _mtimeMs: (await (await import('node:fs/promises')).stat(process.env.TOKEN_PATH)).mtimeMs
-};
-provider._lastDiskScan = provider.tokens._mtimeMs;
-provider._refreshFallbackUntil = 0;
-writeFileSync(process.env.READY_PATH, 'ready');
-while (!existsSync(process.env.START_PATH)) await new Promise((resolve) => setTimeout(resolve, 10));
-globalThis.fetch = async () => {
-  const owner = String(process.pid);
-  writeFileSync(process.env.EXCHANGE_DIR + '/' + owner, 'exchange', { flag: 'wx' });
-  await new Promise((resolve) => setTimeout(resolve, 75));
-  return {
-    ok: true,
-    status: 200,
-    async json() {
-      return {
-        access_token: 'fixture-new-access-' + owner,
-        refresh_token: 'fixture-new-refresh-' + owner,
-        expires_in: 600
-      };
-    }
-  };
-};
-const tokens = await provider.ensureAuth();
-writeFileSync(process.env.RESULT_PATH, tokens.access_token);
-`;
-
-  const exits = [];
-  for (let index = 0; index < 10; index += 1) {
-    const child = spawn(process.execPath, ['--input-type=module', '--eval', childSource], {
-      env: {
-        ...process.env,
-        MIXDOG_DATA_DIR: root,
-        OPENAI_OAUTH_CREDENTIALS_PATH: tokenPath,
-        TOKEN_PATH: tokenPath,
-        READY_PATH: join(readyDir, String(index)),
-        START_PATH: startPath,
-        EXCHANGE_DIR: exchangeDir,
-        RESULT_PATH: join(resultDir, String(index)),
-      },
-      stdio: ['ignore', 'ignore', 'pipe'],
-    });
-    exits.push(waitForExit(child));
-  }
-
-  const deadline = Date.now() + 30_000;
-  while (readdirSync(readyDir).length < 10) {
-    if (Date.now() >= deadline) throw new Error('OpenAI contention children did not become ready');
-    await new Promise((resolve) => setTimeout(resolve, 20));
-  }
-  writeFileSync(startPath, 'start');
-  await Promise.all(exits);
-
-  const exchanges = readdirSync(exchangeDir);
-  assert.equal(exchanges.length, 1);
-  const winner = exchanges[0];
-  const expected = `fixture-new-access-${winner}`;
-  assert.equal(JSON.parse(readFileSync(tokenPath, 'utf8')).access_token, expected);
-  for (const result of readdirSync(resultDir)) {
-    assert.equal(readFileSync(join(resultDir, result), 'utf8'), expected);
-  }
-  assert.equal(existsSync(`${tokenPath}.refresh.lock`), false);
-});