mixdog 0.9.63 → 0.9.64

package/scripts/usage-metrics-epoch-smoke.mjs

@@ -1,114 +0,0 @@
-#!/usr/bin/env node
-import {
-    bumpUsageMetricsEpoch,
-    bumpUsageMetricsTurnId,
-    resolveUsageMetricsEpoch,
-    usageMetricsIdempotencyKey,
-    applyAskTerminalUsageTotals,
-} from '../src/runtime/agent/orchestrator/session/manager.mjs';
-
-function assert(condition, message) {
-    if (!condition) throw new Error(message);
-}
-
-function applyDelta(sessionId, session, delta, seen) {
-    const epoch = resolveUsageMetricsEpoch(session, delta);
-    session.usageMetricsEpoch = epoch;
-    const ikey = usageMetricsIdempotencyKey(sessionId, session, delta);
-    const isReplay = seen.has(ikey);
-    seen.add(ikey);
-    if (!isReplay) {
-        session.totalInputTokens = (session.totalInputTokens || 0) + (delta.deltaInput || 0);
-    }
-    session.lastIterationIndex = delta.iterationIndex;
-    return isReplay;
-}
-
-const sessionId = 'smoke-sess';
-const session = { usageMetricsEpoch: 0, lastIterationIndex: null, totalInputTokens: 0 };
-const seen = new Set();
-
-assert(
-    applyDelta(sessionId, session, { iterationIndex: 1, deltaInput: 100 }, seen) === false,
-    'first iteration should count',
-);
-assert(session.totalInputTokens === 100, 'first iteration tokens');
-
-bumpUsageMetricsEpoch(session);
-assert(session.usageMetricsEpoch === 1, 'compact reset should bump epoch');
-
-const replay = applyDelta(sessionId, session, {
-    iterationIndex: 1,
-    usageMetricsEpoch: session.usageMetricsEpoch,
-    deltaInput: 50,
-}, seen);
-assert(replay === false, 'equal index after compact reset must not be treated as replay');
-assert(session.totalInputTokens === 150, 'post-compact iteration must add tokens');
-
-assert(
-    applyDelta(sessionId, session, {
-        iterationIndex: 1,
-        usageMetricsEpoch: 1,
-        deltaInput: 999,
-    }, seen) === true,
-    'retry of same epoch+index should replay',
-);
-assert(session.totalInputTokens === 150, 'replay must not double-count');
-
-// Semantic compact + provider send at same iteration/epoch (no_change compact path)
-const collisionSeen = new Set();
-const collisionSession = { usageMetricsEpoch: 0, lastIterationIndex: null, totalInputTokens: 0 };
-assert(
-    applyDelta(sessionId, collisionSession, {
-        iterationIndex: 1,
-        source: 'semantic_compact',
-        deltaInput: 20,
-    }, collisionSeen) === false,
-    'semantic compact usage should count',
-);
-assert(
-    applyDelta(sessionId, collisionSession, {
-        iterationIndex: 1,
-        source: 'provider_send',
-        deltaInput: 80,
-    }, collisionSeen) === false,
-    'provider send at same iteration must not replay semantic compact key',
-);
-assert(collisionSession.totalInputTokens === 100, 'semantic + provider usage both counted');
-
-// Integrated incremental + terminal: totals applied once when incremental flag set
-const integrated = { totalInputTokens: 1000, totalOutputTokens: 0, tokensCumulative: 1000 };
-integrated.totalInputTokens += 40;
-integrated.totalOutputTokens += 6;
-integrated.tokensCumulative += 46;
-applyAskTerminalUsageTotals(integrated, {
-    usage: { inputTokens: 40, outputTokens: 6 },
-    lastTurnUsage: { inputTokens: 40, outputTokens: 6 },
-}, { skipTotalsIfIncremental: true });
-assert(integrated.totalInputTokens === 1040, 'terminal must not double-count incremental turn totals');
-assert(integrated.totalOutputTokens === 6, 'terminal must not double-count output');
-assert(integrated.lastInputTokens === 40, 'terminal still updates last-turn window snapshot');
-
-// Cross-ask collision (reviewer07): ask #2 reuses iteration indices 1-2
-const crossSeen = new Set();
-const crossSession = { usageMetricsEpoch: 0, usageMetricsTurnId: 0, lastIterationIndex: null, totalInputTokens: 0 };
-bumpUsageMetricsTurnId(crossSession);
-assert(crossSession.usageMetricsTurnId === 1, 'ask #1 turn id');
-assert(applyDelta(sessionId, crossSession, { iterationIndex: 1, source: 'provider_send', deltaInput: 100 }, crossSeen) === false);
-assert(applyDelta(sessionId, crossSession, { iterationIndex: 2, source: 'provider_send', deltaInput: 200 }, crossSeen) === false);
-assert(crossSession.totalInputTokens === 300, 'ask #1 iterations counted');
-bumpUsageMetricsTurnId(crossSession);
-assert(crossSession.usageMetricsTurnId === 2, 'ask #2 turn id');
-assert(
-    applyDelta(sessionId, crossSession, { iterationIndex: 1, source: 'provider_send', deltaInput: 10 }, crossSeen) === false,
-    'ask #2 iteration 1 must not replay ask #1 key',
-);
-assert(
-    applyDelta(sessionId, crossSession, { iterationIndex: 2, source: 'provider_send', deltaInput: 20 }, crossSeen) === false,
-    'ask #2 iteration 2 must not replay ask #1 key',
-);
-assert(applyDelta(sessionId, crossSession, { iterationIndex: 3, source: 'provider_send', deltaInput: 30 }, crossSeen) === false);
-assert(crossSession.totalInputTokens === 360, 'ask #2 tokens must include iter 1-3 without undercount');
-
-process.stdout.write('usage-metrics-epoch-smoke: ok\n');
-

package/scripts/verify-release-assets-test.mjs

@@ -1,281 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash } from 'node:crypto';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-
-import {
-  GRAPH_PLATFORMS,
-  PATCH_PLATFORMS,
-  validateGraphManifest,
-  validatePatchManifest,
-  validateRuntimeManifest,
-  verifyAssetDownloads,
-  verifyReleaseAssets,
-} from './verify-release-assets.mjs';
-
-const VERSION = '1.2.3';
-const APP_VERSION = '0.9.49';
-const GRAPH_VERSION = '0.1.0';
-const bytes = Buffer.from('local release fixture');
-const sha256 = createHash('sha256').update(bytes).digest('hex');
-
-function patchFixture() {
-  return {
-    version: VERSION,
-    _comment: 'test fixture',
-    assets: Object.fromEntries(Object.entries(PATCH_PLATFORMS).map(([platform, filename]) => [
-      platform,
-      {
-        url: `https://github.com/tribgames/mixdog/releases/download/patch-v${VERSION}/${filename}`,
-        sha256,
-      },
-    ])),
-  };
-}
-
-function runtimeFixture() {
-  return {
-    release_tag: 'runtime-v1.2.3',
-    assets: Object.fromEntries(Object.keys(PATCH_PLATFORMS).map((platform) => [
-      platform,
-      { url: `https://fixtures.invalid/${platform}`, sha256, size: bytes.length },
-    ])),
-  };
-}
-
-function graphFixture() {
-  return {
-    version: GRAPH_VERSION,
-    _comment: 'test fixture',
-    assets: Object.fromEntries(Object.entries(GRAPH_PLATFORMS).map(([platform, filename]) => [
-      platform,
-      {
-        url: `https://github.com/tribgames/mixdog/releases/download/graph-v${GRAPH_VERSION}/${filename}`,
-        sha256,
-      },
-    ])),
-  };
-}
-
-test('accepts independent strict patch, runtime, app, and graph versions', () => {
-  assert.equal(validatePatchManifest(patchFixture(), `[package]\nversion = "${VERSION}"\n`).version, VERSION);
-  assert.equal(validateRuntimeManifest(runtimeFixture()).release_tag, 'runtime-v1.2.3');
-  assert.equal(validateGraphManifest(graphFixture(), { version: APP_VERSION }).version, GRAPH_VERSION);
-});
-
-test('rejects stale Cargo version, partial schema, and wrong patch tag URL', () => {
-  assert.throws(
-    () => validatePatchManifest(patchFixture(), '[package]\nversion = "1.2.2"\n'),
-    /does not match manifest version/,
-  );
-
-  const partial = patchFixture();
-  delete partial.assets['linux-arm64'];
-  assert.throws(
-    () => validatePatchManifest(partial, `[package]\nversion = "${VERSION}"\n`),
-    /keys must be exactly/,
-  );
-
-  const wrongTag = patchFixture();
-  wrongTag.assets['linux-x64'].url = wrongTag.assets['linux-x64'].url.replace('patch-v1.2.3', 'patch-v1.2.2');
-  assert.throws(
-    () => validatePatchManifest(wrongTag, `[package]\nversion = "${VERSION}"\n`),
-    /patch-v1\.2\.3/,
-  );
-
-  const extraPatch = patchFixture();
-  extraPatch.assets['freebsd-x64'] = extraPatch.assets['linux-x64'];
-  assert.throws(
-    () => validatePatchManifest(extraPatch, `[package]\nversion = "${VERSION}"\n`),
-    /keys must be exactly/,
-  );
-
-  const extraRuntime = runtimeFixture();
-  extraRuntime.assets['freebsd-x64'] = extraRuntime.assets['linux-x64'];
-  assert.throws(() => validateRuntimeManifest(extraRuntime), /keys must be exactly/);
-});
-
-test('rejects stale, noncanonical, partial, and malformed graph manifests', () => {
-  const partial = graphFixture();
-  delete partial.assets['darwin-arm64'];
-  assert.throws(() => validateGraphManifest(partial, { version: APP_VERSION }), /keys must be exactly/);
-
-  for (const replacement of [
-    'https://github.com/tribgames/mixdog/releases/download/v0.7.18/mixdog-graph-linux-x64',
-    'https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-linux-x64',
-    'https://example.com/tribgames/mixdog/releases/download/graph-v0.1.0/mixdog-graph-linux-x64',
-    'https://github.com/tribgames/mixdog/releases/download/graph-v0.1.0/mixdog-graph-wrong',
-  ]) {
-    const noncanonical = graphFixture();
-    noncanonical.assets['linux-x64'].url = replacement;
-    assert.throws(
-      () => validateGraphManifest(noncanonical, { version: APP_VERSION }),
-      /graph asset URL must be/,
-    );
-  }
-
-  const malformedDigest = graphFixture();
-  malformedDigest.assets['win32-x64'].sha256 = 'not-a-digest';
-  assert.throws(
-    () => validateGraphManifest(malformedDigest, { version: APP_VERSION }),
-    /invalid graph asset sha256/,
-  );
-
-  const malformedVersion = graphFixture();
-  malformedVersion.version = '0.1';
-  assert.throws(
-    () => validateGraphManifest(malformedVersion, { version: APP_VERSION }),
-    /not strict MAJOR\.MINOR\.PATCH/,
-  );
-});
-
-test('downloads local fixture responses, retries, and checks sha256 without network', async () => {
-  let calls = 0;
-  await verifyAssetDownloads(
-    { fixture: { url: 'https://fixtures.invalid/asset', sha256, size: bytes.length } },
-    {
-      fetchImpl: async () => {
-        calls += 1;
-        if (calls === 1) throw new Error('fixture transient failure');
-        return new Response(bytes);
-      },
-      retryDelay: async () => {},
-    },
-  );
-  assert.equal(calls, 2);
-
-  calls = 0;
-  await assert.rejects(
-    verifyAssetDownloads(
-      { fixture: { url: 'https://fixtures.invalid/asset', sha256: '0'.repeat(64) } },
-      {
-        fetchImpl: async () => {
-          calls += 1;
-          return new Response(bytes);
-        },
-        retryDelay: async () => {},
-      },
-    ),
-    /verification failed after 3 attempts: sha256 mismatch/,
-  );
-  assert.equal(calls, 3);
-});
-
-test('cancels an undeclared-size patch stream immediately at the absolute ceiling', async () => {
-  let chunksProduced = 0;
-  let cancellations = 0;
-  let aborts = 0;
-  const stream = new ReadableStream(
-    {
-      pull(controller) {
-        chunksProduced += 1;
-        controller.enqueue(Buffer.from('abc'));
-      },
-      cancel() {
-        cancellations += 1;
-      },
-    },
-    { highWaterMark: 0 },
-  );
-
-  await assert.rejects(
-    verifyAssetDownloads(
-      { fixture: { url: 'https://fixtures.invalid/asset', sha256 } },
-      {
-        attempts: 1,
-        maxAssetBytes: 5,
-        fetchImpl: async (_url, { signal }) => {
-          signal.addEventListener('abort', () => { aborts += 1; });
-          return { ok: true, status: 200, body: stream };
-        },
-      },
-    ),
-    /byte ceiling exceeded \(5 bytes\)/,
-  );
-  assert.equal(chunksProduced, 2);
-  assert.equal(cancellations, 1);
-  assert.equal(aborts, 1);
-});
-
-test('cancels immediately when a stream exceeds its declared size below the absolute ceiling', async () => {
-  let chunksProduced = 0;
-  let cancellations = 0;
-  let aborts = 0;
-  const stream = new ReadableStream(
-    {
-      pull(controller) {
-        chunksProduced += 1;
-        controller.enqueue(Buffer.from('abc'));
-      },
-      cancel() {
-        cancellations += 1;
-      },
-    },
-    { highWaterMark: 0 },
-  );
-
-  await assert.rejects(
-    verifyAssetDownloads(
-      { fixture: { url: 'https://fixtures.invalid/asset', sha256, size: 5 } },
-      {
-        attempts: 1,
-        maxAssetBytes: 10,
-        fetchImpl: async (_url, { signal }) => {
-          signal.addEventListener('abort', () => { aborts += 1; });
-          return { ok: true, status: 200, body: stream };
-        },
-      },
-    ),
-    /byte ceiling exceeded \(5 bytes\)/,
-  );
-  assert.equal(chunksProduced, 2);
-  assert.equal(cancellations, 1);
-  assert.equal(aborts, 1);
-});
-
-test('full guard reads deterministic fixtures and downloads every declared asset', async () => {
-  const dir = await mkdtemp(join(tmpdir(), 'mixdog-release-assets-'));
-  const patch = patchFixture();
-  const runtime = runtimeFixture();
-  const graph = graphFixture();
-  const expectedUrls = new Set(
-    [...Object.values(patch.assets), ...Object.values(runtime.assets), ...Object.values(graph.assets)]
-      .map(({ url }) => url),
-  );
-  const paths = {
-    patchManifestPath: join(dir, 'patch.json'),
-    cargoPath: join(dir, 'Cargo.toml'),
-    runtimeManifestPath: join(dir, 'runtime.json'),
-    graphManifestPath: join(dir, 'graph.json'),
-    packagePath: join(dir, 'package.json'),
-  };
-  await Promise.all([
-    writeFile(paths.patchManifestPath, JSON.stringify(patch)),
-    writeFile(paths.cargoPath, `[package]\nversion = "${VERSION}"\n`),
-    writeFile(paths.runtimeManifestPath, JSON.stringify(runtime)),
-    writeFile(paths.graphManifestPath, JSON.stringify(graph)),
-    writeFile(paths.packagePath, JSON.stringify({ version: APP_VERSION })),
-  ]);
-  let downloads = 0;
-  const requestedUrls = [];
-  try {
-    await verifyReleaseAssets({
-      ...paths,
-      downloadOptions: {
-        attempts: 1,
-        timeoutMs: 1000,
-        fetchImpl: async (url) => {
-          downloads += 1;
-          requestedUrls.push(url);
-          return new Response(bytes);
-        },
-      },
-    });
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-  assert.equal(downloads, 15);
-  assert.deepEqual(new Set(requestedUrls), expectedUrls);
-});

package/scripts/web-fetch-routing-test.mjs

@@ -1,158 +0,0 @@
-#!/usr/bin/env node
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import http from 'node:http';
-import {
-  isLoopbackHttpUrl,
-  preDispatchDenyForSession,
-} from '../src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs';
-import { executeTool } from '../src/runtime/agent/orchestrator/session/loop/tool-exec.mjs';
-import {
-  getInternalTools,
-  setInternalToolsProvider,
-} from '../src/runtime/agent/orchestrator/internal-tools.mjs';
-import { previewSessionTools } from '../src/runtime/agent/orchestrator/session/manager/tool-resolution.mjs';
-import { TOOL_DEFS as SEARCH_TOOL_DEFS } from '../src/runtime/search/tool-defs.mjs';
-import { dispatchSearchRuntimeTool } from '../src/session-runtime/runtime-core.mjs';
-import {
-  fetchLoopbackText,
-  fetchPublicImage,
-} from '../src/runtime/search/lib/http-fetch.mjs';
-
-test('pre-dispatch keeps hook-facing web_fetch name unchanged', () => {
-  const local = { name: 'web_fetch', arguments: { url: 'http://127.0.0.1:4321/status' } };
-  const image = { name: 'web_fetch', arguments: { url: 'https://cdn.example.com/a.png?x=1' } };
-  const document = { name: 'web_fetch', arguments: { url: 'https://example.com/docs' } };
-  assert.equal(preDispatchDenyForSession({}, local), null);
-  assert.equal(preDispatchDenyForSession({}, image), null);
-  assert.equal(preDispatchDenyForSession({}, document), null);
-  assert.equal(local.name, 'web_fetch');
-  assert.equal(image.name, 'web_fetch');
-  assert.equal(document.name, 'web_fetch');
-  assert.equal(isLoopbackHttpUrl('http://localhost:80/'), true);
-  assert.equal(isLoopbackHttpUrl('http://192.168.1.2/'), false);
-});
-
-test('hidden routed tools remain dispatchable but absent from every model schema', () => {
-  setInternalToolsProvider({
-    tools: SEARCH_TOOL_DEFS,
-    executor: async () => '',
-  });
-  const registered = getInternalTools().map((tool) => tool.name);
-  assert.equal(registered.includes('local_fetch'), true);
-  assert.equal(registered.includes('image_fetch'), true);
-  for (const spec of ['full', 'mcp', 'readonly', ['tools:mcp']]) {
-    const visible = previewSessionTools(spec, []).map((tool) => tool.name);
-    assert.equal(visible.includes('local_fetch'), false, `local_fetch leaked for ${JSON.stringify(spec)}`);
-    assert.equal(visible.includes('image_fetch'), false, `image_fetch leaked for ${JSON.stringify(spec)}`);
-    assert.equal(visible.includes('web_fetch'), true, `web_fetch missing for ${JSON.stringify(spec)}`);
-  }
-});
-
-test('hook sees public name before routed dispatch and can change routing inputs', async () => {
-  const observed = [];
-  setInternalToolsProvider({
-    tools: SEARCH_TOOL_DEFS,
-    executor: async (name, args) => {
-      observed.push({ stage: 'dispatch', name, args });
-      return { content: [{ type: 'text', text: name }] };
-    },
-  });
-  const result = await executeTool(
-    'web_fetch',
-    { url: 'https://example.com/document' },
-    process.cwd(),
-    'routing-order-test',
-    {
-      beforeToolHook: async ({ name, args }) => {
-        observed.push({ stage: 'hook', name, args });
-        return { action: 'modify', args: { url: 'http://127.0.0.1:4321/status' } };
-      },
-    },
-    { toolCallId: 'routing-order-call' },
-  );
-  assert.equal(result, 'local_fetch');
-  assert.deepEqual(observed.map(({ stage, name }) => ({ stage, name })), [
-    { stage: 'hook', name: 'web_fetch' },
-    { stage: 'dispatch', name: 'local_fetch' },
-  ]);
-});
-
-test('cancellation signal propagates across executeTool and runtime search dispatch', async () => {
-  const received = [];
-  setInternalToolsProvider({
-    tools: SEARCH_TOOL_DEFS,
-    executor: (name, args, callerCtx) => dispatchSearchRuntimeTool(name, args, callerCtx, {
-      getSearchModule: async () => ({
-        handleToolCall: async (_name, _args, options) => {
-          received.push({ name: _name, signal: options.signal });
-          await new Promise((resolve, reject) => {
-            if (options.signal.aborted) reject(options.signal.reason);
-            else options.signal.addEventListener('abort', () => reject(options.signal.reason), { once: true });
-          });
-        },
-      }),
-      getCurrentCwd: () => process.cwd(),
-      getSession: () => null,
-      notifyFnForSession: () => null,
-      runNativeWebSearch: async () => null,
-    }),
-  });
-  for (const [index, testCase] of [
-    { url: 'https://example.com/document', expectedName: 'web_fetch' },
-    { url: 'http://127.0.0.1:4321/status', expectedName: 'local_fetch' },
-  ].entries()) {
-    const controller = new AbortController();
-    const running = executeTool(
-      'web_fetch',
-      { url: testCase.url },
-      process.cwd(),
-      `cancel-test-${index}`,
-      {},
-      { toolCallId: `cancel-call-${index}`, signal: controller.signal },
-    );
-    controller.abort(new Error(`cancelled-by-test-${index}`));
-    await assert.rejects(running, new RegExp(`cancelled-by-test-${index}`));
-    assert.equal(received[index].name, testCase.expectedName);
-    assert.equal(received[index].signal, controller.signal);
-  }
-});
-
-test('local_fetch reads loopback and rejects redirect escape', async (t) => {
-  const server = http.createServer((req, res) => {
-    if (req.url === '/escape') {
-      res.writeHead(302, { location: 'http://169.254.169.254/latest/meta-data/' });
-      res.end();
-      return;
-    }
-    res.writeHead(200, { 'content-type': 'text/plain' });
-    res.end('local-ok');
-  });
-  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
-  t.after(() => server.close());
-  const { port } = server.address();
-  assert.equal(await fetchLoopbackText(`http://127.0.0.1:${port}/ok`), 'local-ok');
-  await assert.rejects(fetchLoopbackText(`http://127.0.0.1:${port}/escape`), /non-loopback/);
-  await assert.rejects(fetchLoopbackText('http://10.0.0.1/'), /non-loopback/);
-});
-
-test('public image fetch is bounded, media-shaped, and blocks private redirect targets', async () => {
-  const png = Buffer.from('89504e470d0a1a0a', 'hex');
-  const okFetch = async () => new Response(png, {
-    status: 200,
-    headers: { 'content-type': 'image/png', 'content-length': String(png.length) },
-  });
-  const image = await fetchPublicImage('https://images.example.com/a.png', { fetchImpl: okFetch });
-  assert.deepEqual(image, { mimeType: 'image/png', data: png.toString('base64'), bytes: png.length });
-
-  let calls = 0;
-  const redirectFetch = async () => {
-    calls++;
-    return new Response(null, { status: 302, headers: { location: 'http://169.254.169.254/latest/meta-data/' } });
-  };
-  await assert.rejects(
-    fetchPublicImage('https://images.example.com/a.png', { fetchImpl: redirectFetch }),
-    /private address/,
-  );
-  assert.equal(calls, 1);
-});