agenticreplay 0.1.0 → 0.1.2

package/packages/adapters/src/opencode.ts

@@ -1,257 +0,0 @@
-import { basename, join } from 'node:path';
-import { execFile as execFileCallback } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { promisify } from 'node:util';
-import type { Adapter, Launch, RecordContext } from '@agenticreplay/plugin-api';
-import { forwardBasePath } from '@agenticreplay/proxy';
-import { resolveRealBinary } from '@agenticreplay/shell-shim';
-import { detectAgent } from './detect.js';
-import { openCodeConfiguredBaseURLs, stripJsonc } from './opencode-config.js';
-import { writeOpenCodeCapturePlugin, writeOpenCodeV2CapturePlugin } from './opencode-capture.js';
-import { passKey, passThrough, proxyBase, readEnv } from './env.js';
-
-/**
- * Where OpenCode keeps the credentials `opencode auth login` writes.
- *
- * Both locations, because the data directory moved and an installation that predates the move
- * still has the old one. Finding either means the harness can authenticate on its own.
- */
-const OPENCODE_AUTH_PATHS = ['.local/share/opencode/auth.json', '.config/opencode/auth.json'];
-
-/** Whether OpenCode has credentials of its own, independent of the environment. */
-export function opencodeHasOwnAuth(env: Record<string, string | undefined> = process.env): boolean {
-  const home = env.HOME || env.USERPROFILE || homedir();
-  const paths = OPENCODE_AUTH_PATHS.map((relative) => join(home, relative));
-  if (env.XDG_DATA_HOME) paths.push(join(env.XDG_DATA_HOME, 'opencode/auth.json'));
-  if (env.XDG_CONFIG_HOME) paths.push(join(env.XDG_CONFIG_HOME, 'opencode/auth.json'));
-  return paths.some((path) => existsSync(path));
-}
-
-/**
- * OpenCode's first-party providers, and the base URL the models.dev catalog gives each.
- *
- * OpenCode resolves its API origin per model, and only the OpenAI and Anthropic origins can be
- * named with an environment variable — so a run on one of these talked straight to its provider
- * while the proxy saw nothing, and the trace came out empty while the agent answered happily.
- * The existing config overlay points these two at the proxy carrying their own destination.
- * The final-fetch plugin independently covers the full catalog, including newly added providers
- * and model-specific API origins; this table is no longer the capture allowlist.
- */
-const OPENCODE_FIRST_PARTY_BASE: Record<string, string> = {
-  opencode: 'https://opencode.ai/zen/v1',
-  'opencode-go': 'https://opencode.ai/zen/go/v1',
-};
-
-/** The environment variable the run-local overlay rides in on. */
-const CONFIG_CONTENT_VAR = 'OPENCODE_CONFIG_CONTENT';
-const execFile = promisify(execFileCallback);
-
-async function isOpenCodeV2(ctx: RecordContext): Promise<boolean> {
-  const explicit = readEnv(ctx.env, 'AGENTICREPLAY_OPENCODE_VERSION');
-  if (explicit !== undefined) return /^\s*(?:opencode\s+v?)?2(?:\.|$)/i.test(explicit);
-  await mkdir(ctx.runDir, { recursive: true });
-  const probe = await mkdtemp(join(ctx.runDir, '.opencode-version-'));
-  try {
-    const result = await execFile('opencode', ['--version'], {
-      cwd: probe,
-      env: {
-        PATH: readEnv(ctx.env, 'PATH'),
-        HOME: probe,
-        USERPROFILE: probe,
-        XDG_CONFIG_HOME: join(probe, 'config'),
-        XDG_DATA_HOME: join(probe, 'data'),
-        XDG_CACHE_HOME: join(probe, 'cache'),
-        XDG_STATE_HOME: join(probe, 'state'),
-      },
-      timeout: 5000,
-      maxBuffer: 4096,
-    });
-    return /^\s*(?:opencode\s+v?)?2(?:\.|$)/i.test(`${result.stdout}\n${result.stderr}`);
-  } catch {
-    return false;
-  } finally {
-    await rm(probe, { recursive: true, force: true });
-  }
-}
-
-function privateServerArgs(args: string[]): string[] {
-  const delimiter = args.indexOf('--');
-  const options = delimiter < 0 ? args : args.slice(0, delimiter);
-  if (options.some((arg) => /^(?:--server|--attach)(?:=|$)/.test(arg)))
-    throw new Error('OpenCode 2 capture does not support --server or --attach');
-  if (options.includes('--standalone')) return [...args];
-  const run = options.indexOf('run');
-  return run >= 0
-    ? [...args.slice(0, run + 1), '--standalone', ...args.slice(run + 1)]
-    : ['--standalone', ...args];
-}
-
-/**
- * Shells whose real binary a shim can find again, from OpenCode's own acceptable set — the
- * POSIX shells it runs commands with, minus the ones it refuses outright.
- */
-const SHIMMABLE_SHELLS = ['zsh', 'bash', 'sh', 'ksh', 'dash'] as const;
-
-/**
- * The shell OpenCode falls back to when `SHELL` is unset or one it denies, which is what a
- * recorded run should resolve through the shim so that it behaves like the unrecorded one.
- */
-function fallbackShells(): string[] {
-  return process.platform === 'darwin' ? ['zsh', 'bash', 'sh'] : ['bash', 'sh'];
-}
-
-/**
- * Route OpenCode's shell tool through the shim, by pointing `SHELL` at one.
- *
- * OpenCode resolves its shell from this variable and then execs it *by absolute path*, so the
- * PATH shim in front of `bash` and `sh` never engaged: on macOS every command ran under
- * `/bin/zsh` and the frames file stayed empty while the trace showed shell tool calls. The shim
- * named after the real shell keeps every flag OpenCode passes (`-c`, and the login wrappers)
- * byte-identical — it is argv-transparent — so the run behaves the same and the shim sees it.
- *
- * The name is resolved before the run starts, because a shim whose real binary cannot be found
- * on PATH would answer every command 127 and break the run instead of under-recording it.
- * `installShellShim` writes one shim per name in its default set; a name that is not there
- * simply never gets picked, and the end-of-run `shell.ineffective` warning is what reports the
- * layer as unused.
- */
-async function shellThroughShim(
-  env: Record<string, string | undefined>,
-  runDir: string,
-): Promise<string | undefined> {
-  if (process.platform === 'win32') return undefined;
-  const shimDir = join(runDir, 'shims');
-  const current = basename(readEnv(env, 'SHELL') ?? '').toLowerCase();
-  const candidates = SHIMMABLE_SHELLS.includes(current as (typeof SHIMMABLE_SHELLS)[number])
-    ? [current, ...fallbackShells()]
-    : fallbackShells();
-  for (const name of new Set(candidates)) {
-    if ((await resolveRealBinary(name, env['PATH'] ?? '', shimDir)) !== undefined) {
-      return join(shimDir, name);
-    }
-  }
-  return undefined;
-}
-
-/**
- * The config overlay that rewrites OpenCode's per-provider origins through the proxy.
- *
- * `provider.<id>.options.baseURL` is the one lever OpenCode honours over its catalog's origin,
- * and `OPENCODE_CONFIG_CONTENT` is the config source merged last, so the overlay decides the
- * final URL without touching the user's files. Each base URL is rewritten to
- * `<proxy>/forward/<encoded base>`: the request arrives at the proxy naming where it was headed,
- * the proxy records the exchange and forwards to that base — so an OpenAI-compatible provider
- * whose origin is neither api.openai.com nor api.anthropic.com is captured, not bypassed.
- *
- * The user's own `options.baseURL` for the same provider is carried through rather than replaced.
- * A config that could not be parsed clears the whole overlay: an unreadable intent is not a
- * licence to reroute someone's provider. An existing `OPENCODE_CONFIG_CONTENT` keeps its fields
- * and provider routing; only the run-local capture plugin is appended.
- */
-async function baseURLsThroughProxy(
-  ctx: RecordContext,
-  v2: boolean,
-): Promise<Record<string, string>> {
-  const theirs = readEnv(ctx.env, CONFIG_CONTENT_VAR);
-  if (theirs !== undefined) return withCapturePlugin(ctx, theirs, v2);
-  const scan = await openCodeConfiguredBaseURLs(ctx.env, ctx.cwd);
-  if (!scan.trusted) return {};
-  const provider: Record<string, { options: { baseURL: string } }> = {};
-  for (const [id, catalogBase] of Object.entries(OPENCODE_FIRST_PARTY_BASE)) {
-    const base = scan.overrides.get(id) ?? catalogBase;
-    provider[id] = { options: { baseURL: `${proxyBase(ctx.proxyUrl)}${forwardBasePath(base)}` } };
-  }
-  return withCapturePlugin(ctx, JSON.stringify({ provider }), v2);
-}
-
-async function withCapturePlugin(
-  ctx: RecordContext,
-  content: string,
-  v2: boolean,
-): Promise<Record<string, string>> {
-  let config: Record<string, unknown>;
-  try {
-    config = JSON.parse(stripJsonc(content));
-    if (!config || typeof config !== 'object' || Array.isArray(config))
-      throw new Error('not an object');
-    if (config.plugin !== undefined && !Array.isArray(config.plugin))
-      throw new Error('not a plugin list');
-    if (config.plugins !== undefined && !Array.isArray(config.plugins))
-      throw new Error('not a plugins list');
-  } catch {
-    // Leave invalid config for OpenCode to diagnose without discarding the user's settings.
-    return { [CONFIG_CONTENT_VAR]: content };
-  }
-  const plugin = await writeOpenCodeCapturePlugin(ctx.runDir, proxyBase(ctx.proxyUrl));
-  config.plugin = [...((config.plugin as unknown[] | undefined) ?? []), plugin];
-  if (!v2) return { [CONFIG_CONTENT_VAR]: JSON.stringify(config) };
-  if (readEnv(ctx.env, 'OPENCODE_CONFIG') !== undefined) {
-    throw new Error('OpenCode 2 capture cannot compose an existing OPENCODE_CONFIG file safely');
-  }
-  const v2Plugin = await writeOpenCodeV2CapturePlugin(ctx.runDir, proxyBase(ctx.proxyUrl));
-  // OpenCode 2 discovers plugins from a filesystem config. Keep the user's plugin order intact
-  // and point only this child process at a run-local overlay; user config remains untouched.
-  config.plugins = [...((config.plugins as unknown[] | undefined) ?? []), v2Plugin];
-  const v2Config = join(ctx.runDir, 'agenticreplay-opencode-v2-config.json');
-  await writeFile(v2Config, JSON.stringify({ plugins: config.plugins }), { mode: 0o600 });
-  return {
-    [CONFIG_CONTENT_VAR]: JSON.stringify(config),
-    OPENCODE_CONFIG: v2Config,
-  };
-}
-
-/**
- * Base URL overrides retain the existing SDK routing. The run-local plugin captures final fetches
- * to catalog APIs and ChatGPT OAuth's rewritten URL, retaining each actual destination.
- * NODE_OPTIONS/BUN_OPTIONS preloads do not run in OpenCode's compiled executable.
- */
-export const openCodeAdapter: Adapter = {
-  id: 'opencode',
-
-  async detect(_cwd: string): Promise<boolean> {
-    return detectAgent(['opencode'], ['.config/opencode', '.opencode']);
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    const v2 = await isOpenCodeV2(ctx);
-    const args = v2 ? privateServerArgs(ctx.userArgs) : [...ctx.userArgs];
-    const env: Record<string, string> = {
-      OPENAI_BASE_URL: proxyBase(ctx.proxyUrl, 'v1'),
-      // OpenCode's AI SDK appends /messages, unlike Claude Code's /v1/messages.
-      ANTHROPIC_BASE_URL: proxyBase(ctx.proxyUrl, 'v1'),
-    };
-    // Which credentials OpenCode can see is part of how it chooses a provider, so handing it a
-    // placeholder for the provider the user has *not* configured can change which model the run
-    // calls — a recorded run that answers differently from the same command uninstrumented is the
-    // worst kind of capture bug. With no credential at all there is no choice to flip, and a
-    // client that refuses to start without a key helps nobody, so placeholders stand in.
-    //
-    // Unless OpenCode has signed in on its own. `opencode auth login` writes a credential file the
-    // environment knows nothing about, and inventing both variables in front of it is the failure
-    // Claude Code showed plainly: the harness prefers the environment, authenticates with a key
-    // that is not real, and the run dies before it starts. There is no provider choice to protect
-    // there either — the credential file already made it.
-    const hasAny =
-      readEnv(ctx.env, 'OPENAI_API_KEY') !== undefined ||
-      readEnv(ctx.env, 'ANTHROPIC_API_KEY') !== undefined;
-    if (hasAny || (!v2 && opencodeHasOwnAuth(ctx.env))) {
-      passThrough(env, ctx.env, 'OPENAI_API_KEY');
-      passThrough(env, ctx.env, 'ANTHROPIC_API_KEY');
-    } else if (!v2) {
-      passKey(env, ctx.env, 'OPENAI_API_KEY');
-      passKey(env, ctx.env, 'ANTHROPIC_API_KEY');
-    }
-    Object.assign(env, await baseURLsThroughProxy(ctx, v2));
-
-    // `SHELL` overrides the user's own only to a shim standing in for a shell OpenCode would have
-    // picked anyway. With `--no-shell` there is no shim directory, OpenCode's own resolution
-    // finds nothing there and falls back exactly as it would unrecorded — so the wrong variable
-    // costs nothing, and the right one is what makes the frames file non-empty.
-    const shell = await shellThroughShim(ctx.env, ctx.runDir);
-    if (shell !== undefined) env['SHELL'] = shell;
-
-    return { command: 'opencode', args, env };
-  },
-};

package/packages/adapters/src/qwen.ts

@@ -1,113 +0,0 @@
-import type { Adapter, Launch, RecordContext } from '@agenticreplay/plugin-api';
-import { detectAgent, homeDirHas } from './detect.js';
-import { passKey, passThrough, proxyBase, readEnv } from './env.js';
-
-/** Where `qwen` writes the credentials its OAuth sign-in produces. */
-const QWEN_AUTH_PATH = '.qwen/oauth_creds.json';
-
-/** Whether Qwen Code can authenticate on its own, independent of the environment. */
-export function qwenHasOwnAuth(): boolean {
-  return homeDirHas(QWEN_AUTH_PATH);
-}
-
-/**
- * Qwen Code, which reaches four different providers and reads a separate origin for each.
- *
- * Two of the four are redirected, and the other two deliberately are not. The line is not about
- * the harness at all — it is about what agenticreplay can put on the other end.
- *
- * `OPENAI_BASE_URL` and `ANTHROPIC_BASE_URL` are moved, because the proxy can restore those
- * origins: `resolveUpstream` produces `anthropic`, `openai` and `openai-responses` keys, and the
- * dialects default to `api.anthropic.com` and `api.openai.com` when nothing is configured. A
- * redirected call reaches the provider the client was already addressing.
- *
- * `DASHSCOPE_PROXY_BASE_URL` and `GEMINI_NEXT_GEN_API_BASE_URL` are left alone, and this is the
- * uncomfortable part: they are the origins Qwen's *own* models and Gemini use, so leaving them is
- * a real gap in what a run records. Redirecting them would be worse. The proxy resolves a live
- * upstream by **wire dialect, not by provider**, and no `--upstream` form or gateway setting can
- * name either destination — so with no gateway configured (a setup the README supports outright)
- * a DashScope call arrives as `POST /v1/chat/completions`, is claimed by the openai dialect, and
- * is forwarded to `api.openai.com` carrying `Authorization: Bearer <the user's DashScope key>`.
- * A Gemini call reaches `/v1beta/models/...`, which no dialect claims, so `passthroughOrigin`
- * guesses from headers — and it recognises only Anthropic's, treating everything else as OpenAI,
- * which sends `x-goog-api-key` the same way. Its own comment says why that matters: "a wrong guess
- * does not merely fail — it hands one vendor a key issued by another."
- *
- * So these two join `WEB_SEARCH_BASE_URL` as documented gaps. That one is the web-search tool's
- * endpoint rather than a model origin — off unless `ENABLE_WEB_SEARCH` is set, keyed separately by
- * `WEB_SEARCH_API_KEY` — and pointing it at the proxy without the matching key would break a tool
- * that works today. Different reason, same conclusion: an origin agenticreplay cannot serve is one it
- * should not take away.
- *
- * To record Qwen against its own models, terminate the TLS instead of moving the origin. One host
- * is not enough, because `HostPolicy` matches a bare pattern exactly and the harness reaches a
- * whole family — read off the same bundle: `dashscope.aliyuncs.com` is only the default, with
- * `coding.dashscope.aliyuncs.com` and `coding-intl.dashscope.aliyuncs.com` for the coding plan,
- * `cn-hongkong.dashscope.aliyuncs.com`, `dashscope-intl.aliyuncs.com` and
- * `dashscope-us.aliyuncs.com` by region, and the token plan on a different domain again at
- * `token-plan.cn-beijing.maas.aliyuncs.com` / `token-plan.ap-southeast-1.maas.aliyuncs.com`. So:
- *
- *     agenticreplay record qwen --tls-intercept --tls-hosts \
- *       '+dashscope.aliyuncs.com,+*.dashscope.aliyuncs.com,+dashscope-intl.aliyuncs.com,+dashscope-us.aliyuncs.com'
- *
- * adding `+token-plan.cn-beijing.maas.aliyuncs.com` or the Singapore one if that is the plan in
- * use, and `+api-inference.modelscope.cn` for a ModelScope endpoint. The wildcard covers the
- * `*.dashscope` subdomains without reaching the console: DashScope's sign-in lives on
- * `bailian.console.aliyun.com` and `modelstudio.console.alibabacloud.com`, different domains
- * entirely, which is what makes the wildcard narrower here than one over a vendor's whole zone.
- */
-export const qwenAdapter: Adapter = {
-  id: 'qwen',
-  aliases: ['qwen-code'],
-  harnessVersions: '>=0.22.3',
-
-  async detect(_cwd: string): Promise<boolean> {
-    return detectAgent(['qwen'], ['.qwen']);
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    // Only the two origins the proxy can put a real provider behind. See the note above for why
-    // DashScope and Gemini are left pointing at their own APIs rather than at a proxy that would
-    // forward them, and their credentials, to OpenAI.
-    const env: Record<string, string> = {
-      OPENAI_BASE_URL: proxyBase(ctx.proxyUrl, 'v1'),
-      ANTHROPIC_BASE_URL: proxyBase(ctx.proxyUrl),
-    };
-
-    // The same credential rule as OpenCode, and for the same two reasons. Which keys the harness
-    // can see decides which provider it picks, so a placeholder for a provider the user never
-    // configured can change which model answers — and a recorded run that answers differently
-    // from the same command uninstrumented is the worst kind of capture bug. Separately, `qwen`
-    // signs in on its own: an OAuth run writes `~/.qwen/oauth_creds.json`, and inventing keys in
-    // front of that credential makes the harness prefer an environment key that is not real.
-    //
-    // So placeholders stand in only when there is nothing to disturb: no key in the environment
-    // and no sign-in of its own.
-    const hasAny =
-      readEnv(ctx.env, 'OPENAI_API_KEY') !== undefined ||
-      readEnv(ctx.env, 'ANTHROPIC_API_KEY') !== undefined ||
-      readEnv(ctx.env, 'ANTHROPIC_AUTH_TOKEN') !== undefined ||
-      readEnv(ctx.env, 'GEMINI_API_KEY') !== undefined ||
-      readEnv(ctx.env, 'GOOGLE_API_KEY') !== undefined ||
-      readEnv(ctx.env, 'DASHSCOPE_API_KEY') !== undefined;
-    if (hasAny || qwenHasOwnAuth()) {
-      passThrough(env, ctx.env, 'OPENAI_API_KEY');
-      passThrough(env, ctx.env, 'ANTHROPIC_API_KEY');
-      passThrough(env, ctx.env, 'ANTHROPIC_AUTH_TOKEN');
-      passThrough(env, ctx.env, 'GEMINI_API_KEY');
-      passThrough(env, ctx.env, 'GOOGLE_API_KEY');
-      passThrough(env, ctx.env, 'DASHSCOPE_API_KEY');
-    } else {
-      passKey(env, ctx.env, 'OPENAI_API_KEY');
-      passKey(env, ctx.env, 'ANTHROPIC_API_KEY');
-    }
-
-    // `OPENAI_MODEL` is passed on, never invented: Qwen Code has no default for a
-    // custom endpoint, so the model id is the operator's to supply and the adapter has no way to
-    // know which one the recording is meant to exercise.
-    passThrough(env, ctx.env, 'OPENAI_MODEL');
-    passThrough(env, ctx.env, 'QWEN_CODE_MODEL');
-
-    return { command: 'qwen', args: [...ctx.userArgs], env };
-  },
-};

package/packages/adapters/src/registry.ts

@@ -1,121 +0,0 @@
-import type { Adapter } from '@agenticreplay/plugin-api';
-import { claudeCodeAdapter } from './claude-code.js';
-import { codexAdapter } from './codex.js';
-import { cursorAdapter } from './cursor.js';
-import { hermesAdapter } from './hermes.js';
-import { kiloAdapter } from './kilo.js';
-import { mcodeAdapter } from './mcode.js';
-import { mimoAdapter } from './mimo.js';
-import { execAdapter } from './exec.js';
-import { genericOpenAiAdapter } from './generic-openai.js';
-import { gooseAdapter } from './goose.js';
-import { indexRagAdapter } from './indexrag.js';
-import { grokAdapter } from './grok.js';
-import { openClawAdapter } from './openclaw.js';
-import { nodeAdapter } from './node.js';
-import { openCodeAdapter } from './opencode.js';
-import { qwenAdapter } from './qwen.js';
-import { zcodeAdapter } from './zcode.js';
-
-export class AdapterRegistry {
-  readonly #adapters = new Map<string, Adapter>();
-  /** Alias → canonical id. Kept apart from #adapters so `ids()` stays the canonical id space. */
-  readonly #aliases = new Map<string, string>();
-
-  register(adapter: Adapter): void {
-    const existing = this.#adapters.get(adapter.id);
-    if (existing && existing !== adapter) {
-      throw new Error(
-        `adapter id '${adapter.id}' is already registered; two adapters cannot share an id — ` +
-          'rename one of them',
-      );
-    }
-    for (const alias of adapter.aliases ?? []) {
-      // An alias that shadows a real id, or one already claimed, would make `agenticreplay record <name>`
-      // silently launch a different harness than the name says. Fail at registration instead.
-      const clash = this.#adapters.get(alias) ?? this.#adapters.get(this.#aliases.get(alias) ?? '');
-      if (clash && clash !== adapter) {
-        throw new Error(
-          `adapter '${adapter.id}' claims the alias '${alias}', which already resolves to ` +
-            `'${clash.id}' — an alias cannot point at two harnesses`,
-        );
-      }
-      this.#aliases.set(alias, adapter.id);
-    }
-    this.#adapters.set(adapter.id, adapter);
-  }
-
-  get(id: string): Adapter {
-    const adapter = this.#adapters.get(id) ?? this.#adapters.get(this.#aliases.get(id) ?? '');
-    if (!adapter) {
-      throw new Error(
-        `unknown adapter '${id}'. Known adapters: ${this.names().join(', ')}. ` +
-          "If your agent is not listed, run it under 'generic-openai' and pass the command after " +
-          '--, e.g. agenticreplay record generic-openai -- my-agent --task ...',
-      );
-    }
-    return adapter;
-  }
-
-  /** Canonical ids. This is the id space a manifest is written in. */
-  ids(): string[] {
-    return [...this.#adapters.keys()];
-  }
-
-  /**
-   * Everything a user may type, canonical ids with their aliases attached.
-   *
-   * Error messages and help text use this rather than `ids()`: someone who just typed `claude`
-   * needs to see that `claude` is spelled `claude`, not be shown a list that omits it.
-   */
-  names(): string[] {
-    return this.ids().map((id) => {
-      const aliases = [...this.#aliases.entries()]
-        .filter(([, target]) => target === id)
-        .map(([alias]) => alias);
-      return aliases.length === 0 ? id : `${id} (or ${aliases.join(', ')})`;
-    });
-  }
-
-  /** First adapter that claims the workspace. A detector that throws is treated as "no". */
-  async detect(cwd: string): Promise<Adapter | undefined> {
-    for (const adapter of this.#adapters.values()) {
-      try {
-        if (await adapter.detect(cwd)) return adapter;
-      } catch {
-        continue;
-      }
-    }
-    return undefined;
-  }
-}
-
-export function defaultAdapters(): AdapterRegistry {
-  const registry = new AdapterRegistry();
-  registry.register(claudeCodeAdapter);
-  registry.register(codexAdapter);
-  registry.register(openCodeAdapter);
-  registry.register(qwenAdapter);
-  registry.register(mimoAdapter);
-  registry.register(mcodeAdapter);
-  registry.register(kiloAdapter);
-  registry.register(cursorAdapter);
-  registry.register(gooseAdapter);
-  registry.register(hermesAdapter);
-  registry.register(grokAdapter);
-  registry.register(openClawAdapter);
-  // Last of the harnesses, because detection returns the first adapter that claims the workspace
-  // and every earlier slot takes one away from an adapter that already had it. ZCode's detector
-  // reads the machine — `~/.zcode`, or `zcode` on PATH — so on a machine with two agents
-  // installed the bare `agenticreplay record` should keep answering what it answered before this adapter
-  // existed. Nothing about ZCode earns it a place ahead of them.
-  registry.register(zcodeAdapter);
-  // Before the three that decline to detect: its detector reads *this directory* rather than the
-  // machine, so it is the one adapter here that can honestly claim a workspace.
-  registry.register(indexRagAdapter);
-  registry.register(nodeAdapter);
-  registry.register(genericOpenAiAdapter);
-  // Last: it detects nothing, and it is the fallback someone reaches for by name.
-  registry.register(execAdapter);
-  return registry;
-}

package/packages/adapters/src/scaffold.ts

@@ -1,173 +0,0 @@
-import { MODEL_BASE_URL_VARS } from './contract.js';
-
-/**
- * Adapters are the growth loop: they are how AgenticReplay reaches harnesses its maintainers have
- * never run. This returns file *contents* rather than writing them — the CLI owns the filesystem,
- * and data comes back testable, so the generated code is held to the same contract as the shipped
- * adapters instead of being hoped about.
- */
-
-export interface ScaffoldFile {
-  /** Path relative to packages/adapters, where a contributor would add the file. */
-  path: string;
-  contents: string;
-}
-
-export interface ScaffoldResult {
-  files: ScaffoldFile[];
-}
-
-export interface ScaffoldOptions {
-  /** Binary that launches the harness. Defaults to the adapter id. */
-  command?: string;
-  /** Variable the harness reads for its API origin. One of MODEL_BASE_URL_VARS. */
-  baseUrlVar?: string;
-  /** Credential the harness reads. Defaults to the base-url variable's provider. */
-  apiKeyVar?: string;
-  /** Path appended to the proxy url — OpenAI SDK clients want the version segment, others do not. */
-  basePath?: string;
-}
-
-export function scaffoldAdapter(name: string, opts: ScaffoldOptions = {}): ScaffoldResult {
-  const id = toId(name);
-  if (id === '') {
-    throw new Error(
-      `adapter name '${name}' has no usable characters; ids are lowercase kebab-case, e.g. 'my-agent'`,
-    );
-  }
-  const baseUrlVar = opts.baseUrlVar ?? 'OPENAI_BASE_URL';
-  if (!(MODEL_BASE_URL_VARS as readonly string[]).includes(baseUrlVar)) {
-    throw new Error(
-      `${baseUrlVar} is not a variable the proxy speaks. Use one of ${MODEL_BASE_URL_VARS.join(', ')} — the proxy serves the Anthropic and OpenAI wire protocols, and a harness-specific variable is something you add alongside one of these, never instead of it`,
-    );
-  }
-  const provider = baseUrlVar.split('_')[0] ?? 'OPENAI';
-  const command = opts.command ?? id;
-  const apiKeyVar = opts.apiKeyVar ?? `${provider}_API_KEY`;
-  const basePath = opts.basePath ?? (provider === 'OPENAI' ? 'v1' : '');
-  const constName = exportName(id);
-
-  return {
-    files: [
-      {
-        path: `src/${id}.ts`,
-        contents: adapterSource({ id, constName, command, baseUrlVar, apiKeyVar, basePath }),
-      },
-      {
-        path: `test/${id}.test.ts`,
-        contents: testSource({ id, constName, command, baseUrlVar, apiKeyVar, basePath }),
-      },
-    ],
-  };
-}
-
-interface Names {
-  id: string;
-  constName: string;
-  command: string;
-  baseUrlVar: string;
-  apiKeyVar: string;
-  basePath: string;
-}
-
-function adapterSource(n: Names): string {
-  return `import type { Adapter, Launch, RecordContext } from '@agenticreplay/plugin-api';
-import { hasBinary } from './detect.js';
-import { passKey, proxyBase } from './env.js';
-
-/**
- * TODO: confirm that ${n.command} really reads ${n.baseUrlVar} for its API origin, then record
- * what you verified in fixtures/harness/${n.id}.json. If the harness reads some other variable,
- * this adapter captures nothing and every run still looks exactly like it worked.
- */
-export const ${n.constName}: Adapter = {
-  id: '${n.id}',
-  // harnessVersions: '>=1.0.0', // the range you actually tested against, once you have one
-
-  async detect(_cwd: string): Promise<boolean> {
-    return hasBinary('${n.command}');
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    const env: Record<string, string> = { ${n.baseUrlVar}: ${proxyCall(n.basePath)} };
-    passKey(env, ctx.env, '${n.apiKeyVar}');
-    return { command: '${n.command}', args: [...ctx.userArgs], env };
-  },
-};
-`;
-}
-
-function testSource(n: Names): string {
-  return `import type { RecordContext } from '@agenticreplay/plugin-api';
-import { describe, expect, it } from 'vitest';
-import { checkAdapterContract } from '../src/contract.js';
-import { ${n.constName} } from '../src/${n.id}.js';
-
-/**
- * Register the adapter in src/index.ts and src/registry.ts and record its wire contract in
- * fixtures/harness/${n.id}.json; test/contract.test.ts and test/harness-versions.test.ts then
- * cover it with no further opt-in. This file is for what only you can assert — the flags and
- * environment this particular harness needs.
- */
-
-function ctx(over: Partial<RecordContext> = {}): RecordContext {
-  return {
-    runId: 'run_scaffold',
-    cwd: '/work',
-    proxyUrl: 'http://127.0.0.1:51733',
-    runDir: '/work/.agenticreplay/runs/run_scaffold',
-    userArgs: [],
-    env: {},
-    ...over,
-  };
-}
-
-describe('${n.constName}', () => {
-  it('satisfies the adapter contract', async () => {
-    const result = await checkAdapterContract(${n.constName});
-    expect(result.failed).toEqual([]);
-  });
-
-  it('points ${n.command} at the recording proxy', async () => {
-    const launch = await ${n.constName}.prepare(ctx());
-    expect(launch.command).toBe('${n.command}');
-    expect(launch.env.${n.baseUrlVar}).toBe('${expectedBaseUrl(n.basePath)}');
-  });
-
-  it('passes a real key through, and substitutes a placeholder when there is none', async () => {
-    const real = await ${n.constName}.prepare(ctx({ env: { ${n.apiKeyVar}: 'sk-real' } }));
-    expect(real.env.${n.apiKeyVar}).toBe('sk-real');
-    const none = await ${n.constName}.prepare(ctx());
-    expect(none.env.${n.apiKeyVar}).toBe('agenticreplay-recorded');
-  });
-
-  it('resolves detect() rather than throwing, even for a path that does not exist', async () => {
-    await expect(${n.constName}.detect('/nope/does/not/exist')).resolves.toBe(false);
-  });
-});
-`;
-}
-
-function proxyCall(basePath: string): string {
-  return basePath === '' ? 'proxyBase(ctx.proxyUrl)' : `proxyBase(ctx.proxyUrl, '${basePath}')`;
-}
-
-function expectedBaseUrl(basePath: string): string {
-  return basePath === '' ? 'http://127.0.0.1:51733' : `http://127.0.0.1:51733/${basePath}`;
-}
-
-function toId(name: string): string {
-  return name
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-}
-
-function exportName(id: string): string {
-  const camel = id.replace(/-([a-z0-9])/g, (_, char: string) => char.toUpperCase());
-  // An identifier cannot start with a digit, and a scaffold that emits code which will not parse
-  // is worse than one that renames.
-  const safe = /^[0-9]/.test(camel) ? `agent${camel[0]?.toUpperCase()}${camel.slice(1)}` : camel;
-  return `${safe}Adapter`;
-}