mixdog 0.9.62 → 0.9.64

package/scripts/log-writer-guard-smoke.mjs

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-/**
- * scripts/log-writer-guard-smoke.mjs — unbounded `.log` writer regression gate.
- *
- * A new `.log` file name that lands in src/ without being covered by one of the
- * bounded-writer contracts is an unbounded-growth footgun: the sibling-GC in
- * mixdog-debug.cjs only prunes names it knows (canonical set + stale-sibling
- * regexes), and the worker-boot rotation loop only rotates its explicit list.
- * Any other steady `.log` append grows without limit.
- *
- * This scans src/ for string-literal `.log` file names (the targets that feed
- * appendFile/appendFileSync/createWriteStream) and fails when a name is not:
- *   - in the canonical set (parsed live from mixdog-debug.cjs), or
- *   - in the worker-boot rotation list (parsed live from worker-bootstrap.mjs), or
- *   - matched by the dynamic / per-PID sibling patterns, or
- *   - in the explicit in-script allowlist below.
- *
- * Run:  node scripts/log-writer-guard-smoke.mjs   (or `npm run smoke:logguard`)
- * Exit: 0 = every writer covered, 1 = uncovered `.log` name(s) found.
- */
-import { readFileSync, readdirSync, statSync } from 'node:fs';
-import { dirname, join, relative } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
-const SRC = join(ROOT, 'src');
-// `dist` = built TUI bundle (generated from src/tui/*); vendor is third-party.
-const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', 'vendor']);
-const SCAN_EXT = /\.(mjs|cjs|js|jsx)$/;
-
-// `.log` file-name targets. Two shapes, both bounded to real string content:
-//   STATIC   — a quoted/backtick literal (`'boot.log'`, `"logs\\a.log"`). The
-//              `+` stem keeps us off the bare `.endsWith('.log')` guards.
-//   TEMPLATE — a `${...}` interpolation immediately followed by a static `.log`
-//              tail (`${jobId}.stdout.log`, `${root}.log`). The dynamic prefix
-//              is unverifiable, so the trailing literal (down to bare `.log`)
-//              must be covered/allowlisted or it fails.
-// Separators (`/` and `\`) are captured; basename() reduces to the file name.
-const STATIC_RE = /['"`]([\w.\-/\\]+\.log)\b/g;
-const TEMPLATE_RE = /\$\{[^}]*\}([\w.\-/\\]*\.log)\b/g;
-
-/** Last path segment, splitting on both POSIX and Windows separators. */
-function basename(p) {
-  const parts = p.split(/[\\/]/);
-  return parts[parts.length - 1];
-}
-
-/** Parse a `new Set([...])` / array of quoted `.log` names out of a source file. */
-function parseLogNames(file, anchor) {
-  let src;
-  try { src = readFileSync(file, 'utf8'); } catch { return []; }
-  const at = src.indexOf(anchor);
-  if (at === -1) return [];
-  const tail = src.slice(at, at + 2000);
-  const end = tail.indexOf(']');
-  const block = end === -1 ? tail : tail.slice(0, end);
-  return [...block.matchAll(/['"]([\w.\-]+\.log)['"]/g)].map((m) => m[1]);
-}
-
-// ── Covered names ────────────────────────────────────────────────────
-// Parsed live so a name added to either contract auto-covers here.
-const canonical = new Set(
-  parseLogNames(join(SRC, 'lib/mixdog-debug.cjs'), 'CANONICAL_PLUGIN_LOG_NAMES'),
-);
-const rotation = new Set(
-  parseLogNames(join(SRC, 'runtime/channels/lib/worker-bootstrap.mjs'), '_rotLog of ['),
-);
-
-// Explicitly bounded / non-plugin-dir writers that live outside the sibling-GC
-// contract by design (size-rotated in place, per-job spill, one-shot probes).
-const ALLOWLIST = new Set([
-  'session-start-critical.log',      // size-bounded via rotateBoundedLog()
-  'mixdog-ws-upgrade-probe.log',     // one-shot WS upgrade probe dump
-  '.stdout.log',                     // shell-jobs per-jobId spill (`${jobId}.stdout.log`)
-  '.stderr.log',                     // shell-jobs per-jobId spill (`${jobId}.stderr.log`)
-]);
-
-// Dynamic / per-PID sibling names (never literal, but keep the contract explicit).
-const DYNAMIC_RE = [
-  /^(channels|memory)-worker\.\d+\.\d+\.log$/,
-  /-worker\.\d+\.\d+\.log$/,
-  /^mcp-debug\.\d+\.\d+\.log$/,
-  /^supervisor\.\d+\.log$/,
-];
-
-function isCovered(name) {
-  return (
-    canonical.has(name) ||
-    rotation.has(name) ||
-    ALLOWLIST.has(name) ||
-    DYNAMIC_RE.some((re) => re.test(name))
-  );
-}
-
-function* walk(dir) {
-  let entries;
-  try { entries = readdirSync(dir); } catch { return; }
-  for (const name of entries) {
-    if (SKIP_DIRS.has(name)) continue;
-    const p = join(dir, name);
-    if (statSync(p).isDirectory()) yield* walk(p);
-    else if (SCAN_EXT.test(name)) yield p;
-  }
-}
-
-const offenders = [];
-let scanned = 0;
-for (const file of walk(SRC)) {
-  scanned++;
-  const lines = readFileSync(file, 'utf8').split('\n');
-  for (let i = 0; i < lines.length; i++) {
-    for (const re of [STATIC_RE, TEMPLATE_RE]) {
-      for (const m of lines[i].matchAll(re)) {
-        const name = basename(m[1]);
-        if (isCovered(name)) continue;
-        offenders.push(`${relative(ROOT, file)}:${i + 1} — uncovered \`.log\` writer target \`${name}\``);
-      }
-    }
-  }
-}
-
-if (offenders.length > 0) {
-  console.error('log-writer-guard: FAIL — uncovered unbounded `.log` writer(s):');
-  for (const line of offenders) console.error(`  ${line}`);
-  console.error(
-    `log-writer-guard: ${offenders.length} offender(s). Add the name to CANONICAL_PLUGIN_LOG_NAMES ` +
-    '(mixdog-debug.cjs), the worker-boot rotation list, or the ALLOWLIST in this script.',
-  );
-  process.exit(1);
-}
-console.log(`log-writer-guard: ok — ${scanned} files scanned, every \`.log\` writer covered`);

package/scripts/maintenance-default-routes-test.mjs

@@ -1,164 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { DEFAULT_MAINTENANCE } from '../src/runtime/agent/orchestrator/config.mjs';
-import { resolveMaintenanceRoute } from '../src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs';
-import { resolveAgentSpawnPreset } from '../src/standalone/agent-tool.mjs';
-import { exploreResultCacheKey, resolveExploreRoute } from '../src/standalone/explore-tool.mjs';
-
-const main = { id: 'main', name: 'MAIN', type: 'agent', provider: 'main-provider', model: 'main-model', tools: 'full' };
-const configWithMain = (overrides = {}) => ({
-  default: 'main',
-  presets: [main],
-  maintenance: { ...DEFAULT_MAINTENANCE },
-  ...overrides,
-});
-const normalizedRoute = (route, provider = route.provider || 'anthropic-oauth') => ({
-  provider,
-  model: route.model,
-  effort: undefined,
-  fast: false,
-});
-
-test('empty Explore and Maintainer routes inherit Main in hidden and public dispatch', () => {
-  assert.equal(DEFAULT_MAINTENANCE.explore, undefined);
-  assert.equal(DEFAULT_MAINTENANCE.memory, undefined);
-  assert.deepEqual(DEFAULT_MAINTENANCE.scheduler, DEFAULT_MAINTENANCE.webhook);
-  assert.equal(DEFAULT_MAINTENANCE.scheduler.provider, 'anthropic-oauth');
-  assert.match(DEFAULT_MAINTENANCE.scheduler.model, /haiku/i);
-
-  const config = configWithMain();
-  assert.equal(resolveMaintenanceRoute({ agent: 'explorer', config }), 'main');
-  assert.equal(resolveMaintenanceRoute({ agent: 'cycle1-agent', config }), 'main');
-  assert.equal(resolveMaintenanceRoute({ agent: 'scheduler-task', config }), DEFAULT_MAINTENANCE.scheduler);
-  assert.equal(resolveAgentSpawnPreset(config, { agent: 'explore' }).preset, main);
-  assert.equal(resolveAgentSpawnPreset(config, { agent: 'maintainer' }).preset, main);
-});
-
-test('public agent, workflow, and maintenance routes override Main inheritance', () => {
-  const exploreAgent = { provider: 'agent-provider', model: 'agent-model' };
-  const maintainerWorkflow = { provider: 'workflow-provider', model: 'workflow-model' };
-  const exploreMaintenance = { provider: 'maintenance-provider', model: 'maintenance-model' };
-  assert.deepEqual(
-    resolveAgentSpawnPreset(configWithMain({ agents: { explore: exploreAgent } }), { agent: 'explore' }).preset,
-    { id: 'agent-explore', name: 'AGENT EXPLORE', type: 'agent', ...exploreAgent, effort: undefined, fast: false, tools: 'full' },
-  );
-  assert.deepEqual(
-    resolveAgentSpawnPreset(configWithMain({
-      workflowRoutes: { memory: maintainerWorkflow },
-      maintenance: { ...DEFAULT_MAINTENANCE, memory: { provider: 'ignored-provider', model: 'ignored-model' } },
-    }), { agent: 'maintainer' }).preset,
-    { id: 'agent-maintainer', name: 'AGENT MAINTAINER', type: 'agent', ...maintainerWorkflow, effort: undefined, fast: false, tools: 'full' },
-  );
-  const config = configWithMain({
-    maintenance: {
-      ...DEFAULT_MAINTENANCE,
-      explore: exploreMaintenance,
-    },
-  });
-  assert.deepEqual(resolveMaintenanceRoute({ agent: 'explorer', config }), normalizedRoute(exploreMaintenance));
-  assert.deepEqual(
-    resolveAgentSpawnPreset(config, { agent: 'explore' }).preset,
-    { id: 'agent-explore', name: 'AGENT EXPLORE', type: 'agent', ...exploreMaintenance, effort: undefined, fast: false, tools: 'full' },
-  );
-});
-
-test('hidden Explore and Maintainer routes use public precedence, including the legacy maintainer alias', () => {
-  const agentRoute = { provider: 'agent-provider', model: 'agent-model' };
-  const workflowRoute = { provider: 'workflow-provider', model: 'workflow-model' };
-  const maintenanceRoute = { provider: 'maintenance-provider', model: 'maintenance-model' };
-  assert.deepEqual(resolveMaintenanceRoute({
-    agent: 'explorer',
-    config: configWithMain({
-      agents: { explore: agentRoute },
-      workflowRoutes: { explorer: workflowRoute },
-      maintenance: { ...DEFAULT_MAINTENANCE, explore: maintenanceRoute },
-    }),
-  }), normalizedRoute(agentRoute));
-  assert.deepEqual(resolveMaintenanceRoute({
-    agent: 'cycle1-agent',
-    config: configWithMain({
-      workflowRoutes: { memory: workflowRoute },
-      maintenance: { ...DEFAULT_MAINTENANCE, memory: maintenanceRoute },
-    }),
-  }), normalizedRoute(workflowRoute));
-  assert.deepEqual(resolveMaintenanceRoute({
-    agent: 'cycle2-agent',
-    config: configWithMain({
-      maintenance: { ...DEFAULT_MAINTENANCE, memory: maintenanceRoute },
-    }),
-  }), normalizedRoute(maintenanceRoute));
-  assert.deepEqual(resolveMaintenanceRoute({
-    agent: 'cycle3-agent',
-    config: configWithMain({ agents: { maintenance: agentRoute } }),
-  }), normalizedRoute(agentRoute));
-});
-
-test('Explore cache identity follows the effective route when Main changes', () => {
-  const first = configWithMain();
-  const secondMain = { ...main, model: 'replacement-main-model' };
-  const second = configWithMain({ presets: [secondMain] });
-  const query = 'locate the route';
-  const cwd = '/tmp/project';
-  assert.deepEqual(resolveExploreRoute(first), main);
-  assert.deepEqual(resolveExploreRoute(second), secondMain);
-  assert.notEqual(
-    exploreResultCacheKey({ cwd, route: resolveExploreRoute(first), query }),
-    exploreResultCacheKey({ cwd, route: resolveExploreRoute(second), query }),
-  );
-});
-
-test('hidden precedence normalizes model-only routes with the public provider fallback', () => {
-  const modelOnly = { model: 'model-only' };
-  assert.deepEqual(
-    resolveMaintenanceRoute({ agent: 'explorer', config: configWithMain({ defaultProvider: 'openai', agents: { explore: modelOnly } }) }),
-    normalizedRoute(modelOnly, 'openai'),
-  );
-  assert.deepEqual(
-    resolveMaintenanceRoute({ agent: 'cycle1-agent', config: configWithMain({ defaultProvider: 'gemini', agents: { maintenance: modelOnly } }) }),
-    normalizedRoute(modelOnly, 'gemini'),
-  );
-  assert.deepEqual(
-    resolveMaintenanceRoute({ agent: 'explorer', config: configWithMain({ defaultProvider: 'xai', workflowRoutes: { explorer: modelOnly } }) }),
-    normalizedRoute(modelOnly, 'xai'),
-  );
-  assert.deepEqual(
-    resolveMaintenanceRoute({ agent: 'cycle2-agent', config: configWithMain({ maintenance: { ...DEFAULT_MAINTENANCE, memory: modelOnly } }) }),
-    normalizedRoute(modelOnly),
-  );
-});
-
-test('loadConfig preserves persisted model-only Explore and Maintainer routes with the configured provider', () => {
-  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-maintenance-config-'));
-  writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({
-    agent: {
-      defaultProvider: 'openai',
-      maintenance: {
-        explore: { model: 'gpt-test' },
-        memory: { model: 'gpt-maintainer-test' },
-      },
-    },
-  }));
-  const runner = [
-    "import { loadConfig } from './src/runtime/agent/orchestrator/config.mjs';",
-    "console.log(JSON.stringify(loadConfig({ secrets: false }).maintenance));",
-  ].join(' ');
-  const result = spawnSync(process.execPath, ['--input-type=module', '--eval', runner], {
-    cwd: process.cwd(),
-    env: { ...process.env, MIXDOG_DATA_DIR: dataDir },
-    encoding: 'utf8',
-  });
-  assert.equal(result.status, 0, result.stderr);
-  const maintenance = JSON.parse(result.stdout);
-  assert.deepEqual(maintenance.explore, { provider: 'openai', model: 'gpt-test' });
-  assert.deepEqual(maintenance.memory, { provider: 'openai', model: 'gpt-maintainer-test' });
-});
-
-test('config maintenance migration has no standalone provider runtime dependency', () => {
-  const source = readFileSync(new URL('../src/runtime/agent/orchestrator/config.mjs', import.meta.url), 'utf8');
-  assert.doesNotMatch(source, /standalone\/provider-admin/);
-  assert.match(source, /CONFIG_PROVIDER_IDS/);
-});

package/scripts/max-output-recovery-persist-test.mjs

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
-process.env.MIXDOG_DATA_DIR = mkdtempSync(join(tmpdir(), 'mixdog-max-output-persist-'));
-
-test('askSession persists recovery history without duplicating the returned aggregate', async () => {
-    const { initProviders, getProvider } = await import('../src/runtime/agent/orchestrator/providers/registry.mjs');
-    await initProviders({ gemini: { enabled: true, apiKey: 'test-only' } });
-    const provider = getProvider('gemini');
-    const responses = [
-        {
-            content: 'persisted partial ',
-            stopReason: 'MAX_TOKENS',
-            truncated: true,
-            usage: { inputTokens: 4, outputTokens: 3, cachedTokens: 1, promptTokens: 4 },
-        },
-        {
-            content: 'terminal segment',
-            stopReason: 'end_turn',
-            usage: { inputTokens: 2, outputTokens: 2, cachedTokens: 0, promptTokens: 2 },
-        },
-    ];
-    let sendIndex = 0;
-    const streamed = [];
-    provider.send = async (_messages, _model, _tools, opts = {}) => {
-        const response = responses[sendIndex++];
-        assert.ok(response, `unexpected provider send ${sendIndex}`);
-        opts.onTextDelta?.(response.content);
-        streamed.push(response.content);
-        return response;
-    };
-
-    const { createSession, askSession, getSession } = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
-    const session = createSession({
-        provider: 'gemini',
-        model: 'gemini-test',
-        tools: [],
-        cwd: process.cwd(),
-        skipAgentRules: true,
-        skipSkills: true,
-        compaction: { auto: false },
-    });
-
-    const result = await askSession(
-        session.id,
-        'produce a long answer',
-        null,
-        null,
-        process.cwd(),
-        null,
-        { onTextDelta: () => {} },
-    );
-    const persisted = getSession(session.id);
-    const partialRows = persisted.messages.filter((message) => message.role === 'assistant' && message.content === 'persisted partial ');
-    const terminalRows = persisted.messages.filter((message) => message.role === 'assistant' && message.content === 'terminal segment');
-    const aggregateRows = persisted.messages.filter((message) => message.role === 'assistant' && message.content === result.content);
-
-    assert.equal(result.content, 'persisted partial terminal segment');
-    assert.equal(streamed.join(''), result.content, 'streamed TUI text matches the aggregate without duplication');
-    assert.equal(partialRows.length, 1);
-    assert.equal(terminalRows.length, 1);
-    assert.equal(aggregateRows.length, 0, 'aggregate is returned but is not persisted over the recovery chain');
-    assert.equal(
-        persisted.messages.filter((message) => message?.meta?.source === 'max-output-recovery').length,
-        1,
-    );
-    assert.deepEqual(
-        {
-            inputTokens: result.usage.inputTokens,
-            outputTokens: result.usage.outputTokens,
-            cachedTokens: result.usage.cachedTokens,
-            promptTokens: result.usage.promptTokens,
-        },
-        { inputTokens: 6, outputTokens: 5, cachedTokens: 1, promptTokens: 6 },
-    );
-});