mixdog 0.9.63 → 0.9.64

package/scripts/anthropic-maxtokens-test.mjs

@@ -1,119 +0,0 @@
-#!/usr/bin/env node
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { _test } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
-import { _test as _apiKeyTest } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
-
-const { resolveMaxTokens } = _test;
-const { resolveMaxTokens: resolveMaxTokensApiKey } = _apiKeyTest;
-const ENV_VAR = 'MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS';
-
-function withEnvOverride(value, fn) {
-    const had = Object.prototype.hasOwnProperty.call(process.env, ENV_VAR);
-    const prev = process.env[ENV_VAR];
-    try {
-        if (value == null) delete process.env[ENV_VAR];
-        else process.env[ENV_VAR] = value;
-        fn();
-    } finally {
-        if (had) process.env[ENV_VAR] = prev;
-        else delete process.env[ENV_VAR];
-    }
-}
-
-test('claude-sonnet-5 resolves to 65536 (catalog or fallback)', () => {
-    withEnvOverride(null, () => {
-        assert.equal(resolveMaxTokens('claude-sonnet-5'), 65536);
-    });
-});
-
-test('unknown model id falls back to a sane >=8192 value', () => {
-    withEnvOverride(null, () => {
-        const result = resolveMaxTokens('claude-totally-unknown-model-xyz');
-        assert.equal(typeof result, 'number');
-        assert.ok(Number.isFinite(result));
-        assert.ok(result >= 8192, `expected >=8192, got ${result}`);
-    });
-});
-
-test('MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS=32768 overrides the result', () => {
-    withEnvOverride('32768', () => {
-        assert.equal(resolveMaxTokens('claude-sonnet-5'), 32768);
-        assert.equal(resolveMaxTokens('claude-totally-unknown-model-xyz'), 32768);
-    });
-});
-
-test('invalid MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS=0 does not override', () => {
-    withEnvOverride(null, () => {
-        const baseline = resolveMaxTokens('claude-sonnet-5');
-        withEnvOverride('0', () => {
-            assert.equal(resolveMaxTokens('claude-sonnet-5'), baseline);
-            assert.notEqual(baseline, 0);
-        });
-    });
-});
-
-// Regression guard for the reviewer-caught masking gap: sonnet-5's baseline
-// already equals DEFAULT_SAFETY_CAP (65536), so an invalid override that
-// wrongly returns the default cap is invisible on sonnet-5. Assert on models
-// whose baseline is BELOW the cap — an invalid env value must leave them at
-// their catalog/fallback value, never jump them to 65536.
-test('invalid env values do not bypass catalog/fallback on low-cap models', () => {
-    withEnvOverride(null, () => {
-        const sonnet46 = resolveMaxTokens('claude-sonnet-4-6');
-        const unknown = resolveMaxTokens('claude-totally-unknown-model-xyz');
-        for (const bad of ['0', '-1', 'garbage', '   ']) {
-            withEnvOverride(bad, () => {
-                assert.equal(resolveMaxTokens('claude-sonnet-4-6'), sonnet46, `env=${JSON.stringify(bad)}`);
-                assert.equal(resolveMaxTokens('claude-totally-unknown-model-xyz'), unknown, `env=${JSON.stringify(bad)}`);
-            });
-        }
-    });
-});
-
-// --- API-key provider (anthropic.mjs) — shares the anthropic-max-tokens.mjs
-// helper and reads the same on-disk anthropic-oauth-models.json catalog.
-
-test('API-key provider: claude-sonnet-5 resolves to 65536 (catalog or fallback)', () => {
-    withEnvOverride(null, () => {
-        assert.equal(resolveMaxTokensApiKey('claude-sonnet-5'), 65536);
-    });
-});
-
-test('API-key provider: claude-sonnet-4-6 stays at legacy 16384 when catalog has no entry', () => {
-    withEnvOverride(null, () => {
-        const result = resolveMaxTokensApiKey('claude-sonnet-4-6');
-        assert.ok(result === 16384 || result >= 16384, `expected >=16384, got ${result}`);
-    });
-});
-
-test('API-key provider: haiku no longer starves visible output at 8192-only ceiling', () => {
-    withEnvOverride(null, () => {
-        const result = resolveMaxTokensApiKey('claude-haiku-4-5-20251001');
-        assert.ok(result >= 8192, `expected >=8192, got ${result}`);
-    });
-});
-
-test('API-key provider: unknown model id falls back to a sane >=8192 value', () => {
-    withEnvOverride(null, () => {
-        const result = resolveMaxTokensApiKey('claude-totally-unknown-model-xyz');
-        assert.equal(typeof result, 'number');
-        assert.ok(Number.isFinite(result));
-        assert.ok(result >= 8192, `expected >=8192, got ${result}`);
-    });
-});
-
-test('API-key provider: MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS=32768 overrides the result', () => {
-    withEnvOverride('32768', () => {
-        assert.equal(resolveMaxTokensApiKey('claude-sonnet-5'), 32768);
-        assert.equal(resolveMaxTokensApiKey('claude-totally-unknown-model-xyz'), 32768);
-    });
-});
-
-test('OAuth and API-key providers agree on fallback heuristic for the same model id', () => {
-    withEnvOverride(null, () => {
-        for (const id of ['claude-opus-4-8', 'claude-sonnet-4-6', 'claude-sonnet-5', 'claude-haiku-4-5-20251001', 'claude-totally-unknown-model-xyz']) {
-            assert.equal(resolveMaxTokens(id), resolveMaxTokensApiKey(id), `mismatch for ${id}`);
-        }
-    });
-});

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

@@ -1,397 +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-anthropic-race-'));
-const credentialsPath = join(root, 'anthropic-oauth-credentials.json');
-process.env.MIXDOG_DATA_DIR = root;
-process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH = credentialsPath;
-
-const credentialsModule = await import(
-    '../src/runtime/agent/orchestrator/providers/anthropic-oauth-credentials.mjs'
-);
-const { AnthropicOAuthProvider } = await import(
-    '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs'
-);
-const {
-    DEFAULT_CLI_VERSION,
-    _saveCredentialsFile,
-    loadCredentials,
-    loadCredentialsFromPath,
-    preflightAnthropicOAuthCredentials,
-    refreshOAuthCredentials,
-} = credentialsModule;
-
-after(() => {
-    delete process.env.MIXDOG_ANTHROPIC_OAUTH_REFRESH_DISABLED;
-    rmSync(root, { recursive: true, force: true });
-});
-
-function writeCredentials({ accessToken, refreshToken, expiresAt }, path = credentialsPath) {
-    _saveCredentialsFile(path, {
-        claudeAiOauth: {
-            accessToken,
-            refreshToken,
-            expiresAt,
-            scopes: ['user:inference'],
-        },
-    });
-}
-
-test('refresh uses the current CLI identity and returns a neutral sanitized 403', async () => {
-    const accessToken = 'fixture-access-must-not-leak';
-    const refreshToken = 'fixture-refresh-must-not-leak';
-    writeCredentials({
-        accessToken,
-        refreshToken,
-        expiresAt: Date.now() + 1_000,
-    });
-    const before = readFileSync(credentialsPath, 'utf8');
-    const originalFetch = globalThis.fetch;
-    let request = null;
-    globalThis.fetch = async (url, options) => {
-        request = { url, options };
-        return {
-            ok: false,
-            status: 403,
-            async text() {
-                return JSON.stringify({
-                    error: 'forbidden',
-                    accessToken,
-                    refresh_token: refreshToken,
-                    echoed: `Bearer ${accessToken}`,
-                });
-            },
-        };
-    };
-    try {
-        assert.equal(DEFAULT_CLI_VERSION, '2.1.207');
-        await assert.rejects(
-            refreshOAuthCredentials(loadCredentials()),
-            (err) => {
-                assert.match(err.message, /token refresh 403/);
-                assert.match(err.message, /claude-cli\/2\.1\.207/);
-                assert.match(err.message, /Possible causes include OAuth client compatibility/);
-                assert.match(err.message, /account or scope policy/);
-                assert.match(err.message, /proxy\/VPN\/WAF/);
-                assert.match(err.message, /regional endpoint restrictions/);
-                assert.match(err.message, /Verify the account has Claude Code access and the required scopes/);
-                assert.match(err.message, /MIXDOG_CLI_VERSION/);
-                assert.match(err.message, /retry sign-in via \/providers/);
-                assert.doesNotMatch(err.message, /rejected the OAuth client identity/);
-                assert.doesNotMatch(err.message, /fixture-access-must-not-leak/);
-                assert.doesNotMatch(err.message, /fixture-refresh-must-not-leak/);
-                return true;
-            },
-        );
-        assert.equal(
-            request.options.headers['user-agent'],
-            'claude-cli/2.1.207 (external, sdk-cli)',
-        );
-        assert.equal(request.options.redirect, 'error');
-        assert.equal(JSON.parse(request.options.body).refresh_token, refreshToken);
-        assert.equal(readFileSync(credentialsPath, 'utf8'), before);
-    } finally {
-        globalThis.fetch = originalFetch;
-    }
-});
-
-test('parallel host preflights refresh once and snapshot the leased generation', async () => {
-    writeCredentials({
-        accessToken: 'fixture-access-old',
-        refreshToken: 'fixture-refresh-old',
-        expiresAt: Date.now() + 1_000,
-    });
-    let refreshCalls = 0;
-    const refreshFn = async (current) => {
-        refreshCalls += 1;
-        await new Promise((resolve) => setTimeout(resolve, 30));
-        const raw = JSON.parse(readFileSync(current.path, 'utf8'));
-        raw.claudeAiOauth.accessToken = 'fixture-access-new';
-        raw.claudeAiOauth.refreshToken = 'fixture-refresh-new';
-        raw.claudeAiOauth.expiresAt = Date.now() + 10 * 60_000;
-        _saveCredentialsFile(current.path, raw);
-        return loadCredentials();
-    };
-
-    const snapshots = Array.from(
-        { length: 12 },
-        (_, index) => join(root, `container-${index}.json`),
-    );
-    await Promise.all(snapshots.map((snapshotPath) => (
-        preflightAnthropicOAuthCredentials({
-            minimumValidityMs: 5 * 60_000,
-            snapshotPath,
-            refreshFn,
-        })
-    )));
-
-    assert.equal(refreshCalls, 1);
-    for (const snapshotPath of snapshots) {
-        const oauth = JSON.parse(readFileSync(snapshotPath, 'utf8')).claudeAiOauth;
-        assert.equal(oauth.accessToken, 'fixture-access-new');
-        assert.equal(Object.hasOwn(oauth, 'refreshToken'), false);
-        assert.equal(Object.hasOwn(oauth, 'refresh_token'), false);
-    }
-});
-
-test('explicit credential path is pinned over a newer default candidate', async () => {
-    const explicitPath = join(root, 'explicit', 'credentials.json');
-    mkdirSync(join(root, 'explicit'), { recursive: true });
-    writeCredentials({
-        accessToken: 'fixture-default-newer',
-        refreshToken: 'fixture-default-refresh',
-        expiresAt: Date.now() + 60 * 60_000,
-    });
-    writeCredentials({
-        accessToken: 'fixture-explicit',
-        refreshToken: 'fixture-explicit-refresh',
-        expiresAt: Date.now() + 20 * 60_000,
-    }, explicitPath);
-    process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH = explicitPath;
-    const snapshotPath = join(root, 'explicit-snapshot.json');
-    try {
-        assert.equal(loadCredentials().path, explicitPath);
-        assert.equal(loadCredentials().accessToken, 'fixture-explicit');
-        await preflightAnthropicOAuthCredentials({
-            credentialsPath: explicitPath,
-            minimumValidityMs: 5 * 60_000,
-            snapshotPath,
-        });
-        const snapshot = loadCredentialsFromPath(snapshotPath);
-        assert.equal(snapshot.accessToken, 'fixture-explicit');
-        assert.equal(snapshot.refreshToken, null);
-        assert.equal(
-            loadCredentialsFromPath(credentialsPath).accessToken,
-            'fixture-default-newer',
-        );
-    } finally {
-        process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH = credentialsPath;
-    }
-});
-
-test('10 contending host processes share one token exchange lock', async () => {
-    const processCredentials = join(root, 'process-credentials.json');
-    const exchangeDir = join(root, 'exchange-owners');
-    const startPath = join(root, 'children-start');
-    const readyDir = join(root, 'children-ready');
-    const snapshotDir = join(root, 'child-snapshots');
-    mkdirSync(readyDir);
-    mkdirSync(snapshotDir);
-    mkdirSync(exchangeDir);
-    writeCredentials({
-        accessToken: 'fixture-process-old',
-        refreshToken: 'fixture-process-refresh-old',
-        expiresAt: Date.now() + 1_000,
-    }, processCredentials);
-
-    const moduleUrl = new URL(
-        '../src/runtime/agent/orchestrator/providers/anthropic-oauth-credentials.mjs',
-        import.meta.url,
-    ).href;
-    const childSource = `
-import { existsSync, writeFileSync } from 'node:fs';
-const mod = await import(${JSON.stringify(moduleUrl)});
-const stale = mod.loadCredentials();
-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', owner, { flag: 'wx' });
-  await new Promise((resolve) => setTimeout(resolve, 75));
-  return {
-    ok: true,
-    status: 200,
-    async text() {
-      return JSON.stringify({
-        access_token: 'fixture-process-new-' + owner,
-        refresh_token: 'fixture-process-refresh-new-' + owner,
-        expires_in: 600
-      });
-    }
-  };
-};
-if (process.env.CHILD_MODE === 'preflight') {
-  await mod.preflightAnthropicOAuthCredentials({
-    credentialsPath: process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH,
-    minimumValidityMs: 300000,
-    snapshotPath: process.env.SNAPSHOT_PATH
-  });
-} else {
-  await mod.refreshOAuthCredentials(stale);
-}
-`;
-
-    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,
-                    ANTHROPIC_OAUTH_CREDENTIALS_PATH: processCredentials,
-                    READY_PATH: join(readyDir, String(index)),
-                    START_PATH: startPath,
-                    EXCHANGE_DIR: exchangeDir,
-                    CHILD_MODE: index % 2 === 0 ? 'preflight' : 'refresh',
-                    SNAPSHOT_PATH: join(snapshotDir, `${index}.json`),
-                },
-                stdio: ['ignore', 'ignore', 'pipe'],
-            },
-        );
-        exits.push(new Promise((resolveExit, rejectExit) => {
-            let stderr = '';
-            child.stderr.setEncoding('utf8');
-            child.stderr.on('data', (chunk) => { stderr += chunk; });
-            child.on('error', rejectExit);
-            child.on('exit', (code) => {
-                if (code === 0) resolveExit();
-                else rejectExit(new Error(`contention child ${index} exited ${code}: ${stderr}`));
-            });
-        }));
-    }
-
-    const readyDeadline = Date.now() + 30_000;
-    while (
-        Array.from({ length: 10 }, (_, index) => existsSync(join(readyDir, String(index))))
-            .some((ready) => !ready)
-    ) {
-        if (Date.now() >= readyDeadline) throw new Error('contention children did not become ready');
-        await new Promise((resolveWait) => setTimeout(resolveWait, 20));
-    }
-    writeFileSync(startPath, 'start');
-    await Promise.all(exits);
-
-    const exchangeMarkers = readdirSync(exchangeDir)
-        .filter((name) => name.endsWith('.exchange'));
-    assert.equal(exchangeMarkers.length, 1);
-    const exchangeOwner = exchangeMarkers[0].slice(0, -'.exchange'.length);
-    assert.equal(
-        readFileSync(join(exchangeDir, exchangeMarkers[0]), 'utf8'),
-        exchangeOwner,
-    );
-    assert.equal(
-        loadCredentialsFromPath(processCredentials).accessToken,
-        `fixture-process-new-${exchangeOwner}`,
-    );
-    for (let index = 0; index < 10; index += 2) {
-        const oauth = JSON.parse(
-            readFileSync(join(snapshotDir, `${index}.json`), 'utf8'),
-        ).claudeAiOauth;
-        assert.equal(oauth.accessToken, `fixture-process-new-${exchangeOwner}`);
-        assert.equal(Object.hasOwn(oauth, 'refreshToken'), false);
-    }
-});
-
-test('host preflight fails clearly when refresh cannot satisfy the lease', async () => {
-    writeCredentials({
-        accessToken: 'fixture-access-short-old',
-        refreshToken: 'fixture-refresh-short-old',
-        expiresAt: Date.now() + 1_000,
-    });
-    const snapshotPath = join(root, 'short-lease-container.json');
-    const refreshFn = async (current) => {
-        const raw = JSON.parse(readFileSync(current.path, 'utf8'));
-        raw.claudeAiOauth.accessToken = 'fixture-access-short-new';
-        raw.claudeAiOauth.refreshToken = 'fixture-refresh-short-new';
-        raw.claudeAiOauth.expiresAt = Date.now() + 30_000;
-        _saveCredentialsFile(current.path, raw);
-        return loadCredentials();
-    };
-
-    await assert.rejects(
-        preflightAnthropicOAuthCredentials({
-            minimumValidityMs: 60_000,
-            snapshotPath,
-            refreshFn,
-        }),
-        /cannot satisfy the 60s credential lease/,
-    );
-});
-
-test('expiring, forced, and 401 containers cause zero token exchanges', async () => {
-    writeCredentials({
-        accessToken: 'fixture-access-expiring',
-        refreshToken: 'fixture-refresh-must-not-be-used',
-        expiresAt: Date.now() + 1_000,
-    });
-    process.env.MIXDOG_ANTHROPIC_OAUTH_REFRESH_DISABLED = '1';
-    let fetchCalls = 0;
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = async () => {
-        fetchCalls += 1;
-        throw new Error('refresh transport must not run');
-    };
-    try {
-        const providers = Array.from({ length: 12 }, () => {
-            const provider = Object.create(AnthropicOAuthProvider.prototype);
-            provider.credentials = loadCredentials();
-            provider.config = {};
-            return provider;
-        });
-        const results = await Promise.allSettled(
-            providers.map((provider) => provider.ensureAuth()),
-        );
-        assert.equal(fetchCalls, 0);
-        assert.ok(results.every((result) => (
-            result.status === 'rejected'
-            && /refresh is disabled.*Host credential preflight/s.test(result.reason.message)
-        )));
-        await assert.rejects(
-            refreshOAuthCredentials(loadCredentials()),
-            /host credential preflight must provide a fresh snapshot/,
-        );
-        writeCredentials({
-            accessToken: 'fixture-access-valid',
-            expiresAt: Date.now() + 10 * 60_000,
-        });
-        const forcedProvider = Object.create(AnthropicOAuthProvider.prototype);
-        forcedProvider.credentials = loadCredentials();
-        forcedProvider.config = {};
-        forcedProvider.fastModeBetaHeaderLatched = false;
-        await assert.rejects(
-            forcedProvider.ensureAuth({ forceRefresh: true, reason: 'test' }),
-            /refresh is disabled.*Host credential preflight/s,
-        );
-
-        let apiRequests = 0;
-        await assert.rejects(
-            forcedProvider.send([], 'claude-sonnet-4-5', [], {
-                _doRequestFn: async () => {
-                    apiRequests += 1;
-                    return {
-                        response: {
-                            status: 401,
-                            ok: false,
-                            headers: new Map(),
-                            async text() { return ''; },
-                        },
-                        controller: null,
-                        cancelHandler: null,
-                    };
-                },
-            }),
-            /refresh is disabled.*Host credential preflight/s,
-        );
-        assert.equal(apiRequests, 1);
-        assert.equal(fetchCalls, 0);
-    } finally {
-        globalThis.fetch = originalFetch;
-        delete process.env.MIXDOG_ANTHROPIC_OAUTH_REFRESH_DISABLED;
-    }
-});