agenticreplay 0.1.0 → 0.1.2

package/packages/adapters/test/adapters.test.ts

@@ -1,666 +0,0 @@
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { delimiter, join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import type { Adapter, RecordContext } from '@agenticreplay/plugin-api';
-import {
-  AdapterRegistry,
-  claudeCodeAdapter,
-  codexAdapter,
-  selectedProvider,
-  defaultAdapters,
-  genericOpenAiAdapter,
-  hasBinary,
-  openCodeAdapter,
-} from '../src/index.js';
-
-/** A PATH with `which` on it but none of the agent binaries, so detect() is deterministic. */
-const BARE_PATH =
-  process.platform === 'win32'
-    ? join(process.env.SystemRoot ?? 'C:\\Windows', 'System32')
-    : '/usr/bin:/bin';
-
-let scratch: string;
-const saved = { ...process.env };
-
-beforeEach(() => {
-  scratch = mkdtempSync(join(tmpdir(), 'agenticreplay-adapters-'));
-});
-
-afterEach(() => {
-  // Restore in place: assigning `process.env` a fresh object detaches it from the real OS
-  // environment, and os.homedir() then reads stale values for the rest of the file.
-  for (const key of Object.keys(process.env)) if (!(key in saved)) delete process.env[key];
-  for (const [key, value] of Object.entries(saved))
-    if (value !== undefined) process.env[key] = value;
-  rmSync(scratch, { recursive: true, force: true });
-});
-
-function ctx(over: Partial<RecordContext> = {}): RecordContext {
-  return {
-    runId: 'run_abc123',
-    cwd: '/work',
-    proxyUrl: 'http://127.0.0.1:51733',
-    runDir: join(scratch, '.agenticreplay/runs/run_abc123'),
-    userArgs: [],
-    // Keep the version branch deterministic; production probes the installed binary.
-    env: { AGENTICREPLAY_OPENCODE_VERSION: '1.18.29' },
-    ...over,
-  };
-}
-
-let homeCount = 0;
-
-/** Isolate HOME (no agent config dirs) and PATH (no agent binaries). Each call gets a fresh home. */
-function isolate(homeContents: string[] = []): string {
-  const home = join(scratch, `home-${(homeCount += 1)}`);
-  mkdirSync(home, { recursive: true });
-  for (const rel of homeContents) mkdirSync(join(home, rel), { recursive: true });
-  process.env.HOME = home;
-  process.env.USERPROFILE = home;
-  process.env.PATH = BARE_PATH;
-  return home;
-}
-
-describe('OpenCode version-specific capture launch', () => {
-  const v2 = { AGENTICREPLAY_OPENCODE_VERSION: '2.0.18' };
-  it.skipIf(process.platform === 'win32')(
-    'detects the installed CLI version banner in an isolated probe',
-    async () => {
-      const bin = join(scratch, 'bin');
-      mkdirSync(bin);
-      writeFileSync(join(bin, 'opencode'), '#!/bin/sh\nprintf "opencode v2.0.18\\n"\n', {
-        mode: 0o755,
-      });
-      const launch = await openCodeAdapter.prepare(
-        ctx({ env: { PATH: `${bin}:/usr/bin:/bin`, HOME: scratch }, userArgs: ['run', 'hello'] }),
-      );
-      expect(launch.args).toEqual(['run', '--standalone', 'hello']);
-      expect(launch.env.OPENCODE_CONFIG).toContain('agenticreplay-opencode-v2-config.json');
-    },
-  );
-  it('uses a private server for run and interactive launch without changing prompt arguments', async () => {
-    const prompt = 'Explain --server and --attach options';
-    const run = await openCodeAdapter.prepare(ctx({ env: v2, userArgs: ['run', prompt] }));
-    expect(run.args).toEqual(['run', '--standalone', prompt]);
-    const interactive = await openCodeAdapter.prepare(
-      ctx({ env: v2, userArgs: ['-m', 'custom/model'] }),
-    );
-    expect(interactive.args).toEqual(['--standalone', '-m', 'custom/model']);
-  });
-  it('does not duplicate standalone or replace an explicit server', async () => {
-    const launch = await openCodeAdapter.prepare(
-      ctx({ env: v2, userArgs: ['run', '--standalone', 'hello'] }),
-    );
-    expect(launch.args).toEqual(['run', '--standalone', 'hello']);
-    await expect(
-      openCodeAdapter.prepare(
-        ctx({ env: v2, userArgs: ['run', '--server=http://localhost:1234'] }),
-      ),
-    ).rejects.toThrow('does not support');
-  });
-  it('leaves an explicit v1 config in place and rejects unsupported v2 config composition', async () => {
-    const path = join(scratch, 'selected.json');
-    writeFileSync(path, '{"model":"selected/provider"}');
-    const legacy = await openCodeAdapter.prepare(
-      ctx({
-        env: { AGENTICREPLAY_OPENCODE_VERSION: '1.18.29', OPENCODE_CONFIG: path },
-        userArgs: ['run', 'hello'],
-      }),
-    );
-    expect(legacy.args).toEqual(['run', 'hello']);
-    expect(legacy.env.OPENCODE_CONFIG).toBeUndefined();
-    expect(JSON.parse(legacy.env.OPENCODE_CONFIG_CONTENT!).plugins).toBeUndefined();
-    await expect(
-      openCodeAdapter.prepare(ctx({ env: { ...v2, OPENCODE_CONFIG: path } })),
-    ).rejects.toThrow('cannot compose');
-  });
-});
-
-describe('adapter aliases', () => {
-  /**
-   * The id is an internal handle; what a user types is the name of the binary they run. Every
-   * doc, the README headline and the demo say `agenticreplay record claude`, and that command failed with
-   * "unknown adapter 'claude'" because the adapter is registered as `claude-code`. The first
-   * command in the README is the worst possible place to make someone read an error message.
-   */
-  it('resolves an adapter by the name of the binary a user actually runs', () => {
-    const registry = defaultAdapters();
-    expect(registry.get('claude')).toBe(registry.get('claude-code'));
-  });
-
-  it('records the canonical id, so a run made via an alias replays like any other', () => {
-    // The manifest carries `adapter.id`, and replay looks the adapter back up by it. An alias that
-    // leaked into the manifest would produce a run that could be recorded but never replayed.
-    expect(defaultAdapters().get('claude').id).toBe('claude-code');
-  });
-
-  it('lists canonical ids only, so the id space stays unambiguous', () => {
-    const ids = defaultAdapters().ids();
-    expect(ids).toContain('claude-code');
-    expect(ids).not.toContain('claude');
-  });
-
-  it('names the aliases when an adapter cannot be found', () => {
-    let message = '';
-    try {
-      defaultAdapters().get('claude-cod');
-    } catch (err) {
-      message = String(err);
-    }
-    expect(message).toContain('claude-code');
-    expect(message, 'the error has to show what is typeable, not just what is canonical').toContain(
-      'claude',
-    );
-  });
-
-  it('refuses an alias that collides with another adapter id', () => {
-    const registry = new AdapterRegistry();
-    registry.register(claudeCodeAdapter);
-    expect(() =>
-      registry.register({
-        id: 'other',
-        aliases: ['claude-code'],
-        detect: async () => false,
-        prepare: async () => ({ command: 'x', args: [], env: {} }),
-      }),
-    ).toThrow(/claude-code/);
-  });
-});
-
-describe('hasBinary', () => {
-  it('finds a binary that is on PATH', async () => {
-    const bin = join(scratch, 'bin');
-    mkdirSync(bin);
-    const filename =
-      process.platform === 'win32' ? 'agenticreplay-fake-agent.cmd' : 'agenticreplay-fake-agent';
-    const contents =
-      process.platform === 'win32' ? '@echo off\r\nexit /b 0\r\n' : '#!/bin/sh\nexit 0\n';
-    writeFileSync(join(bin, filename), contents, { mode: 0o755 });
-    process.env.PATH = `${bin}${delimiter}${BARE_PATH}`;
-    expect(await hasBinary('agenticreplay-fake-agent')).toBe(true);
-  });
-
-  it('is false for a binary that is not on PATH', async () => {
-    const bin = join(scratch, 'bin');
-    mkdirSync(bin);
-    const filename =
-      process.platform === 'win32' ? 'agenticreplay-fake-agent.cmd' : 'agenticreplay-fake-agent';
-    const contents =
-      process.platform === 'win32' ? '@echo off\r\nexit /b 0\r\n' : '#!/bin/sh\nexit 0\n';
-    writeFileSync(join(bin, filename), contents, { mode: 0o755 });
-    process.env.PATH = BARE_PATH;
-    expect(await hasBinary('agenticreplay-fake-agent')).toBe(false);
-  });
-
-  it('never throws, even on a name full of shell metacharacters', async () => {
-    await expect(hasBinary('nope; rm -rf / #`whoami`')).resolves.toBe(false);
-  });
-
-  it('is false rather than throwing when PATH cannot even resolve which/where', async () => {
-    process.env.PATH = join(scratch, 'empty-dir-that-does-not-exist');
-    await expect(hasBinary('claude')).resolves.toBe(false);
-  });
-});
-
-describe('claudeCodeAdapter', () => {
-  it('is identified and declares the harness range it was tested against', () => {
-    expect(claudeCodeAdapter.id).toBe('claude-code');
-    expect(claudeCodeAdapter.harnessVersions).toBe('>=1.0.0');
-  });
-
-  it('detects a workspace by ~/.claude even when the binary is absent', async () => {
-    isolate(['.claude']);
-    expect(await claudeCodeAdapter.detect('/work')).toBe(true);
-  });
-
-  it('detects the binary on PATH even when ~/.claude is absent', async () => {
-    const home = isolate();
-    const bin = join(scratch, 'bin');
-    mkdirSync(bin);
-    const filename = process.platform === 'win32' ? 'claude.cmd' : 'claude';
-    const contents =
-      process.platform === 'win32' ? '@echo off\r\nexit /b 0\r\n' : '#!/bin/sh\nexit 0\n';
-    writeFileSync(join(bin, filename), contents, { mode: 0o755 });
-    process.env.PATH = `${bin}${delimiter}${BARE_PATH}`;
-    expect(home).toBeTruthy();
-    expect(await claudeCodeAdapter.detect('/work')).toBe(true);
-  });
-
-  it('does not detect when neither the binary nor ~/.claude is present', async () => {
-    isolate();
-    expect(await claudeCodeAdapter.detect('/work')).toBe(false);
-  });
-
-  it('follows the HOME visible in process.env, which is the one the child will get', async () => {
-    const home = isolate(['.claude']);
-    const real = process.env;
-    // A host that builds a sandboxed env object detaches process.env from the OS environment;
-    // os.homedir() then reads the stale OS value and detection disagrees with the launch.
-    process.env = { ...real, HOME: home, USERPROFILE: home, PATH: BARE_PATH };
-    try {
-      expect(await claudeCodeAdapter.detect('/work')).toBe(true);
-      process.env.HOME = join(scratch, 'nowhere');
-      process.env.USERPROFILE = process.env.HOME;
-      expect(await claudeCodeAdapter.detect('/work')).toBe(false);
-    } finally {
-      process.env = real;
-    }
-  });
-
-  it('points the agent at the proxy with no path suffix', async () => {
-    const launch = await claudeCodeAdapter.prepare(ctx());
-    expect(launch.command).toBe('claude');
-    expect(launch.env.ANTHROPIC_BASE_URL).toBe('http://127.0.0.1:51733');
-  });
-
-  it('strips a trailing slash from the proxy url', async () => {
-    const launch = await claudeCodeAdapter.prepare(ctx({ proxyUrl: 'http://127.0.0.1:51733/' }));
-    expect(launch.env.ANTHROPIC_BASE_URL).toBe('http://127.0.0.1:51733');
-  });
-
-  it('passes the user argv through', async () => {
-    const userArgs = ['-p', 'hello world'];
-    const launch = await claudeCodeAdapter.prepare(ctx({ userArgs }));
-    expect(launch.args).toEqual(['-p', 'hello world']);
-    launch.args.push('mutated');
-    expect(userArgs).toEqual(['-p', 'hello world']);
-  });
-
-  it('passes an existing API key through', async () => {
-    const launch = await claudeCodeAdapter.prepare(ctx({ env: { ANTHROPIC_API_KEY: 'sk-real' } }));
-    expect(launch.env.ANTHROPIC_API_KEY).toBe('sk-real');
-  });
-
-  // Not a placeholder, unlike every SDK-shaped adapter: a Claude Code signed in to claude.ai has
-  // no ANTHROPIC_API_KEY, and inventing one stops the launch on an interactive trust prompt and
-  // then authenticates as nobody. The absence is what lets its own credential win.
-  it('invents no key when none is set, so a subscription login still authenticates', async () => {
-    const launch = await claudeCodeAdapter.prepare(ctx());
-    expect('ANTHROPIC_API_KEY' in launch.env).toBe(false);
-  });
-
-  it('treats an empty key as unset', async () => {
-    const launch = await claudeCodeAdapter.prepare(ctx({ env: { ANTHROPIC_API_KEY: '' } }));
-    expect('ANTHROPIC_API_KEY' in launch.env).toBe(false);
-  });
-
-  it('passes ANTHROPIC_AUTH_TOKEN through only when it is set', async () => {
-    const withToken = await claudeCodeAdapter.prepare(
-      ctx({ env: { ANTHROPIC_AUTH_TOKEN: 'tok-1' } }),
-    );
-    expect(withToken.env.ANTHROPIC_AUTH_TOKEN).toBe('tok-1');
-    const without = await claudeCodeAdapter.prepare(ctx());
-    expect('ANTHROPIC_AUTH_TOKEN' in without.env).toBe(false);
-  });
-});
-
-describe('codexAdapter', () => {
-  it('is identified', () => {
-    expect(codexAdapter.id).toBe('codex');
-  });
-
-  it('points the OpenAI SDK at the proxy under /v1', async () => {
-    const launch = await codexAdapter.prepare(ctx());
-    expect(launch.command).toBe('codex');
-    expect(launch.env.OPENAI_BASE_URL).toBe('http://127.0.0.1:51733/v1');
-  });
-
-  it('does not double the slash when the proxy url already ends in one', async () => {
-    const launch = await codexAdapter.prepare(ctx({ proxyUrl: 'http://127.0.0.1:51733/' }));
-    expect(launch.env.OPENAI_BASE_URL).toBe('http://127.0.0.1:51733/v1');
-  });
-
-  // No placeholder: Codex authenticates from its own auth.json, and inventing the variable
-  // overrides that with a key that is not real.
-  it('passes OPENAI_API_KEY through, and invents none when it is unset', async () => {
-    const real = await codexAdapter.prepare(ctx({ env: { OPENAI_API_KEY: 'sk-real' } }));
-    expect(real.env.OPENAI_API_KEY).toBe('sk-real');
-    const none = await codexAdapter.prepare(ctx({ env: { CODEX_HOME: 'no-such-dir' } }));
-    expect('OPENAI_API_KEY' in none.env).toBe(false);
-  });
-
-  it('does not override the reserved built-in OpenAI provider', async () => {
-    const launch = await codexAdapter.prepare(ctx({ env: { CODEX_HOME: scratch } }));
-    expect(launch.args).toEqual(['-c', 'openai_base_url=http://127.0.0.1:51733/v1']);
-    expect(launch.env.OPENAI_BASE_URL).toBe('http://127.0.0.1:51733/v1');
-  });
-
-  it('reads the provider name out of config.toml, ignoring same-named keys in tables', () => {
-    expect(selectedProvider('model_provider = "crs"\n[model_providers.crs]\n')).toBe('crs');
-    expect(selectedProvider("model = 'x'\nmodel_provider = 'gw'\n")).toBe('gw');
-    expect(selectedProvider('[a]\nmodel_provider = "ignored"\n')).toBe('openai');
-    expect(selectedProvider('')).toBe('openai');
-  });
-
-  it('puts a custom provider override before the user argv', async () => {
-    writeFileSync(join(scratch, 'config.toml'), 'model_provider = "custom"\n');
-    const launch = await codexAdapter.prepare(
-      ctx({ env: { CODEX_HOME: scratch }, userArgs: ['exec', '--skip-git-repo-check'] }),
-    );
-    expect(launch.args).toEqual([
-      '-c',
-      'model_providers.custom.base_url=http://127.0.0.1:51733/v1',
-      'exec',
-      '--skip-git-repo-check',
-    ]);
-  });
-
-  it('detects by ~/.codex, and not at all in a bare environment', async () => {
-    isolate(['.codex']);
-    expect(await codexAdapter.detect('/work')).toBe(true);
-    isolate();
-    expect(await codexAdapter.detect('/work')).toBe(false);
-  });
-});
-
-describe('openCodeAdapter', () => {
-  it('sets both base urls because it can drive either protocol', async () => {
-    const launch = await openCodeAdapter.prepare(ctx());
-    expect(launch.command).toBe('opencode');
-    expect(launch.env.OPENAI_BASE_URL).toBe('http://127.0.0.1:51733/v1');
-    expect(launch.env.ANTHROPIC_BASE_URL).toBe('http://127.0.0.1:51733/v1');
-  });
-
-  it('passes both keys through', async () => {
-    const launch = await openCodeAdapter.prepare(
-      ctx({ env: { OPENAI_API_KEY: 'sk-o', ANTHROPIC_API_KEY: 'sk-a' } }),
-    );
-    expect(launch.env.OPENAI_API_KEY).toBe('sk-o');
-    expect(launch.env.ANTHROPIC_API_KEY).toBe('sk-a');
-  });
-
-  it('does not invent the other provider key when the user has one of them', async () => {
-    // OpenCode picks its provider per model, and which credentials it can see is part of that
-    // choice — so a fabricated second key can make a recorded run answer from a different model
-    // than the same command does without recording.
-    const openAiOnly = await openCodeAdapter.prepare(ctx({ env: { OPENAI_API_KEY: 'sk-o' } }));
-    expect(openAiOnly.env.OPENAI_API_KEY).toBe('sk-o');
-    expect('ANTHROPIC_API_KEY' in openAiOnly.env).toBe(false);
-
-    const anthropicOnly = await openCodeAdapter.prepare(
-      ctx({ env: { ANTHROPIC_API_KEY: 'sk-a' } }),
-    );
-    expect(anthropicOnly.env.ANTHROPIC_API_KEY).toBe('sk-a');
-    expect('OPENAI_API_KEY' in anthropicOnly.env).toBe(false);
-  });
-
-  it('falls back to placeholders only when the user has no credential at all', async () => {
-    // Nothing to flip here, and an SDK client that refuses to start without a key helps nobody.
-    // The branch reads the credential file `opencode auth login` writes in the real home as well
-    // as the environment, so HOME is isolated: on a machine that has signed in to OpenCode the
-    // placeholder branch is unreachable, which is not what this test is about.
-    isolate();
-    const none = await openCodeAdapter.prepare(
-      ctx({ env: { OPENCODE_VERSION: '1.18.29', AGENTICREPLAY_OPENCODE_VERSION: '1.18.29' } }),
-    );
-    expect(none.env.OPENAI_API_KEY).toBe('agenticreplay-recorded');
-    expect(none.env.ANTHROPIC_API_KEY).toBe('agenticreplay-recorded');
-  });
-
-  it('recognizes credentials in the child XDG data directory', async () => {
-    const home = isolate();
-    const data = join(home, 'xdg-data');
-    mkdirSync(join(data, 'opencode'), { recursive: true });
-    writeFileSync(join(data, 'opencode', 'auth.json'), '{"openai":{"type":"api"}}');
-    const launch = await openCodeAdapter.prepare(
-      ctx({
-        env: {
-          HOME: home,
-          XDG_DATA_HOME: data,
-          PATH: BARE_PATH,
-          OPENCODE_VERSION: '2.0.0',
-        },
-      }),
-    );
-    expect(launch.env.OPENAI_API_KEY).toBeUndefined();
-    expect(launch.env.ANTHROPIC_API_KEY).toBeUndefined();
-  });
-
-  it('does not invent provider keys for v2 without an explicit environment key', async () => {
-    const launch = await openCodeAdapter.prepare(
-      ctx({
-        env: {
-          OPENCODE_VERSION: '2.0.18',
-          AGENTICREPLAY_OPENCODE_VERSION: '2.0.18',
-          HOME: isolate(),
-          PATH: BARE_PATH,
-        },
-      }),
-    );
-    expect(launch.env.OPENAI_API_KEY).toBeUndefined();
-    expect(launch.env.ANTHROPIC_API_KEY).toBeUndefined();
-  });
-
-  it('rewrites the first-party providers through the proxy in a config overlay', async () => {
-    // OpenCode resolves its API origin per model out of its catalog, and no environment variable
-    // names those origins — so a run on `opencode-go` streamed straight to the provider while the
-    // proxy saw nothing and the trace stayed empty. The overlay points each provider at the proxy
-    // with its real base encoded into the path, which is what makes the request carry its own
-    // destination.
-    const launch = await openCodeAdapter.prepare(ctx());
-    const content = JSON.parse(launch.env.OPENCODE_CONFIG_CONTENT!);
-    expect(content.provider['opencode-go'].options.baseURL).toBe(
-      'http://127.0.0.1:51733/forward/' + encodeURIComponent('https://opencode.ai/zen/go/v1'),
-    );
-    expect(content.provider['opencode'].options.baseURL).toBe(
-      'http://127.0.0.1:51733/forward/' + encodeURIComponent('https://opencode.ai/zen/v1'),
-    );
-    // The base-url variables stay, for the providers the overlay does not name.
-    expect(launch.env.OPENAI_BASE_URL).toBe('http://127.0.0.1:51733/v1');
-  });
-
-  it('carries a user-configured base url through the redirect instead of replacing it', async () => {
-    // Someone who set `options.baseURL` for a first-party provider routed those models somewhere
-    // deliberately. The overlay merges last in OpenCode's config order, so clobbering it would
-    // send the recorded run to a host the user never named.
-    const home = isolate();
-    const configDir = join(home, '.config', 'opencode');
-    mkdirSync(configDir, { recursive: true });
-    writeFileSync(
-      join(configDir, 'opencode.jsonc'),
-      [
-        '{',
-        '  // the corporate gateway fronts the zen models too',
-        '  "provider": {',
-        '    "opencode-go": {',
-        '      "options": {',
-        '        "baseURL": "https://corpo.example/v1",',
-        '      },',
-        '    },',
-        '  },',
-        '}',
-      ].join('\n'),
-    );
-    const launch = await openCodeAdapter.prepare(ctx({ env: { HOME: home, PATH: BARE_PATH } }));
-    const content = JSON.parse(launch.env.OPENCODE_CONFIG_CONTENT!);
-    expect(content.provider['opencode-go'].options.baseURL).toBe(
-      'http://127.0.0.1:51733/forward/' + encodeURIComponent('https://corpo.example/v1'),
-    );
-    // A provider the user left alone still gets the catalog base.
-    expect(content.provider['opencode'].options.baseURL).toBe(
-      'http://127.0.0.1:51733/forward/' + encodeURIComponent('https://opencode.ai/zen/v1'),
-    );
-  });
-
-  it('skips the overlay entirely when the user config cannot be parsed', async () => {
-    // A config agenticreplay cannot read is an intent agenticreplay cannot honour. Rewriting routing on top of an
-    // unreadable config risks sending the run somewhere the user never named; capturing nothing
-    // is the recoverable failure, and the end-of-run warning says so.
-    const home = isolate();
-    const configDir = join(home, '.config', 'opencode');
-    mkdirSync(configDir, { recursive: true });
-    writeFileSync(join(configDir, 'opencode.jsonc'), '{ "provider": { "opencode-go": ');
-    const launch = await openCodeAdapter.prepare(ctx({ env: { HOME: home, PATH: BARE_PATH } }));
-    expect('OPENCODE_CONFIG_CONTENT' in launch.env).toBe(false);
-  });
-
-  it('preserves existing inline config while adding the capture plugin', async () => {
-    const theirs = '{"model":"opencode-go/glm-5.3-flash"}';
-    const launch = await openCodeAdapter.prepare(
-      ctx({ env: { OPENCODE_CONFIG_CONTENT: theirs, AGENTICREPLAY_OPENCODE_VERSION: '2.0.0' } }),
-    );
-    const content = JSON.parse(launch.env.OPENCODE_CONFIG_CONTENT!);
-    expect(content.model).toBe('opencode-go/glm-5.3-flash');
-    expect(content.provider).toBeUndefined();
-    expect(content.plugin).toHaveLength(1);
-    expect(content.plugin[0]).toMatch(/^file:.*agenticreplay-opencode-capture\.mjs$/);
-    expect(content.plugins).toHaveLength(1);
-    expect(content.plugins[0]).toMatch(/^file:.*agenticreplay-opencode-v2-capture$/);
-  });
-
-  it('points SHELL at the shim for a shell OpenCode would have picked anyway', async () => {
-    // OpenCode execs `$SHELL` by absolute path, so a PATH shim never engaged and macOS runs
-    // captured no shell frames at all. The shim must be named after the real shell — OpenCode
-    // accepts it by basename — and the real binary must be on PATH, or every command would 127.
-    if (process.platform === 'win32') return;
-    const runDir = join(scratch, 'run');
-    const launch = await openCodeAdapter.prepare(
-      ctx({
-        runDir,
-        env: { HOME: isolate(), PATH: BARE_PATH, SHELL: '/bin/zsh' },
-      }),
-    );
-    if (process.platform === 'darwin') {
-      expect(launch.env.SHELL).toBe(join(runDir, 'shims', 'zsh'));
-    } else {
-      // The shim name is whichever shell the fallback would use and PATH can resolve again.
-      expect(launch.env.SHELL).toMatch(new RegExp(`.*${join('shims', '(zsh|bash|sh)')}$`));
-    }
-  });
-
-  it('shims the shell OpenCode itself would fall back to', async () => {
-    if (process.platform === 'win32') return;
-    // `fish` is on OpenCode's deny list: unrecorded, it falls back to the platform default, and
-    // the recorded run must fall back to the shim for that same default.
-    const runDir = join(scratch, 'run');
-    const launch = await openCodeAdapter.prepare(
-      ctx({
-        runDir,
-        env: { HOME: isolate(), PATH: BARE_PATH, SHELL: '/usr/local/bin/fish' },
-      }),
-    );
-    const expected = process.platform === 'darwin' ? 'zsh' : 'bash';
-    expect(launch.env.SHELL).toBe(join(runDir, 'shims', expected));
-  });
-
-  it('detects by ~/.config/opencode, and not at all in a bare environment', async () => {
-    isolate(['.config/opencode']);
-    expect(await openCodeAdapter.detect('/work')).toBe(true);
-    isolate();
-    expect(await openCodeAdapter.detect('/work')).toBe(false);
-  });
-});
-
-describe('genericOpenAiAdapter', () => {
-  it('is never auto-selected', async () => {
-    expect(genericOpenAiAdapter.id).toBe('generic-openai');
-    expect(await genericOpenAiAdapter.detect('/work')).toBe(false);
-    expect(await genericOpenAiAdapter.detect(process.cwd())).toBe(false);
-  });
-
-  it('takes the command from the first user arg and the rest as argv', async () => {
-    const launch = await genericOpenAiAdapter.prepare(
-      ctx({ userArgs: ['my-agent', '--task', 'ship it'] }),
-    );
-    expect(launch.command).toBe('my-agent');
-    expect(launch.args).toEqual(['--task', 'ship it']);
-  });
-
-  it('sets the modern, legacy and Anthropic base urls', async () => {
-    const launch = await genericOpenAiAdapter.prepare(ctx({ userArgs: ['my-agent'] }));
-    expect(launch.env.OPENAI_BASE_URL).toBe('http://127.0.0.1:51733/v1');
-    expect(launch.env.OPENAI_API_BASE).toBe('http://127.0.0.1:51733/v1');
-    expect(launch.env.ANTHROPIC_BASE_URL).toBe('http://127.0.0.1:51733');
-  });
-
-  it('says what to do when given no command', async () => {
-    await expect(genericOpenAiAdapter.prepare(ctx({ userArgs: [] }))).rejects.toThrow(
-      /generic-openai.*--.*command/is,
-    );
-  });
-});
-
-describe('AdapterRegistry', () => {
-  it('registers every adapter by default, with the escape hatches last', () => {
-    // Order is the detection order, and `node`, `generic-openai` and `exec` all decline to detect
-    // — so they sit at the end where they cannot shadow an adapter that can recognise its own
-    // harness. `exec` is last of all: it is the one that knows the least about what it launches.
-    expect(defaultAdapters().ids()).toEqual([
-      'claude-code',
-      'codex',
-      'opencode',
-      'qwen',
-      'mimo',
-      'mcode',
-      'kilo',
-      'cursor',
-      'goose',
-      'hermes',
-      'grok',
-      'openclaw',
-      // Last of the harnesses on purpose: detection returns the first claim, so a newly added
-      // adapter goes behind the ones that already answered for these machines.
-      'zcode',
-      // The only detector here that reads the workspace rather than the machine: it asks whether
-      // *this directory* is an IndexRAG checkout, which is a fact about the run rather than about
-      // what happens to be installed.
-      'indexrag',
-      'node',
-      'generic-openai',
-      'exec',
-    ]);
-  });
-
-  it('returns a registered adapter by id', () => {
-    expect(defaultAdapters().get('codex')).toBe(codexAdapter);
-  });
-
-  it('names the known ids and the escape hatch when an id is unknown', () => {
-    let message = '';
-    try {
-      // Not a harness anyone will write an adapter for. It used to be `cursor`, which stopped
-      // being unknown the moment one was added -- and the test then passed an id that resolved,
-      // threw nothing, and asserted against an empty string.
-      defaultAdapters().get('not-an-agent');
-    } catch (err) {
-      message = (err as Error).message;
-    }
-    expect(message).toContain('not-an-agent');
-    expect(message).toContain('claude-code');
-    expect(message).toContain('generic-openai');
-  });
-
-  it('refuses to let one adapter silently shadow another', () => {
-    const registry = new AdapterRegistry();
-    registry.register(codexAdapter);
-    expect(() => registry.register({ ...codexAdapter })).toThrow(/codex/);
-  });
-
-  it('detects the first adapter that claims the workspace', async () => {
-    isolate(['.claude']);
-    const found = await defaultAdapters().detect('/work');
-    expect(found?.id).toBe('claude-code');
-  });
-
-  it('detects nothing in a bare environment', async () => {
-    isolate();
-    expect(await defaultAdapters().detect('/work')).toBeUndefined();
-  });
-
-  it('survives a third-party adapter whose detect throws', async () => {
-    isolate(['.codex']);
-    const registry = new AdapterRegistry();
-    const exploding: Adapter = {
-      id: 'exploding',
-      detect: async () => {
-        throw new Error('boom');
-      },
-      prepare: async () => ({ command: 'x', args: [], env: {} }),
-    };
-    registry.register(exploding);
-    registry.register(codexAdapter);
-    const found = await registry.detect('/work');
-    expect(found?.id).toBe('codex');
-  });
-});