agenticreplay 0.1.0 → 0.1.2

package/packages/adapters/src/claude-code.ts

@@ -1,109 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import type { Adapter, Launch, RecordContext, SessionSupport } from '@agenticreplay/plugin-api';
-import { detectAgent, homeDir } from './detect.js';
-import { passThrough, proxyBase, readEnv } from './env.js';
-import { contentText, parseJsonl } from './session.js';
-
-/**
- * Claude Code names a project directory after the working directory, with every character that is
- * not a letter, a digit or a hyphen replaced by one.
- *
- * Checked against a real install rather than inferred: a directory called `slug_test.dir v2`
- * becomes `slug-test-dir-v2`, so underscores, dots and spaces all fold the same way the path
- * separators do. An earlier version replaced only `\`, `/` and `:`, which was right for every
- * path it happened to be tested against and wrong for the first one with an underscore in it —
- * the computed name missed the real directory by one character, and the session capture then
- * found nothing and said nothing. Hence {@link claudeSession}'s fallback: a guess about someone
- * else's naming should not be the only thing holding the capture up.
- */
-export function claudeProjectSlug(cwd: string): string {
-  return cwd.replace(/[^A-Za-z0-9-]/g, '-');
-}
-
-/**
- * Claude Code's transcript.
- *
- * `user` entries carry what the person typed, which is the half of a run agenticreplay cannot see from the
- * wire. Entries the harness generates for itself — tool results, the attachments it splices in —
- * arrive with the same `user` role, so they are filtered out: a replay driven by a tool result
- * would ask the model something the recording never asked.
- */
-export const claudeSession: SessionSupport = {
-  dir(cwd, env) {
-    const home = readEnv(env, 'CLAUDE_CONFIG_DIR') ?? join(homeDir(), '.claude');
-    const projects = join(home, 'projects');
-    const named = join(projects, claudeProjectSlug(cwd));
-    // The slug is a guess about someone else's naming, and a wrong guess loses the capture in
-    // silence. When the directory it names is not there, watch the whole projects tree instead:
-    // the file that changed during this run is still this run's, whatever it ended up called.
-    return existsSync(named) ? named : projects;
-  },
-
-  parse(bytes) {
-    const prompts: string[] = [];
-    let id: string | undefined;
-    for (const entry of parseJsonl(bytes)) {
-      if (typeof entry['sessionId'] === 'string') id ??= entry['sessionId'];
-      if (entry['type'] !== 'user') continue;
-      const message = entry['message'];
-      if (message === null || typeof message !== 'object') continue;
-      const text = contentText((message as { content?: unknown }).content).trim();
-      // A turn the harness synthesised, not one a person typed.
-      if (text === '' || text.startsWith('<')) continue;
-      prompts.push(text);
-    }
-    return { id, prompts };
-  },
-
-  resumeArgs(id) {
-    return ['--resume', id];
-  },
-};
-
-/**
- * Claude Code reads `ANTHROPIC_BASE_URL` for the API origin and appends its own `/v1/...` paths,
- * so the proxy url goes in bare.
- *
- * No placeholder key. The placeholder exists for SDK clients that refuse to construct without one,
- * and Claude Code is not one: it carries its own credential store, and most installations sign in
- * to claude.ai rather than setting `ANTHROPIC_API_KEY` at all. Inventing the variable for those
- * costs the recording twice over — Claude Code stops on an interactive "detected a custom API key"
- * prompt before it will start, and answering yes switches it off the subscription credential it
- * was going to authenticate with and onto a key that is not real. Passing the variable through
- * when it is genuinely set keeps the API-key path exactly as it was.
- */
-export const claudeCodeAdapter: Adapter = {
-  id: 'claude-code',
-  // What people type. The binary is `claude`, and so is every example in the docs.
-  aliases: ['claude'],
-  harnessVersions: '>=1.0.0',
-
-  async detect(_cwd: string): Promise<boolean> {
-    return detectAgent(['claude'], ['.claude']);
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    const env: Record<string, string> = { ANTHROPIC_BASE_URL: proxyBase(ctx.proxyUrl) };
-    passThrough(env, ctx.env, 'ANTHROPIC_API_KEY');
-    passThrough(env, ctx.env, 'ANTHROPIC_AUTH_TOKEN');
-    return { command: 'claude', args: [...ctx.userArgs], env };
-  },
-
-  session: claudeSession,
-
-  /**
-   * `--strict-mcp-config` alongside it, so the run uses the instrumented copy *instead of* the
-   * user's own servers rather than as well as them. Without it a project `.mcp.json` is still
-   * loaded, the same server is registered twice, and half its calls go round the shim.
-   */
-  mcpConfigArgs(path) {
-    return ['--mcp-config', path, '--strict-mcp-config'];
-  },
-
-  /** `-p` is how Claude Code takes a prompt without a terminal, which a replay never has. */
-  driveArgs(prompts, recorded) {
-    const first = prompts[0];
-    return first === undefined ? undefined : [...recorded, '-p', first];
-  },
-};

package/packages/adapters/src/codex.ts

@@ -1,135 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { Adapter, Launch, RecordContext, SessionSupport } from '@agenticreplay/plugin-api';
-import { detectAgent, homeDir } from './detect.js';
-import { passThrough, proxyBase, readEnv } from './env.js';
-import { contentText, parseJsonl } from './session.js';
-
-/** Where the Codex CLI keeps `config.toml`, honouring its own override. */
-function codexHome(env: Record<string, string | undefined>): string {
-  return readEnv(env, 'CODEX_HOME') ?? join(homeDir(), '.codex');
-}
-
-/**
- * Which provider `config.toml` selects, defaulting to the built-in `openai`.
- *
- * A hand-rolled read of one key rather than a TOML parser: this is a top-level assignment in a
- * file Codex writes itself, and a dependency for it would be the only one in this package.
- * Anything unparseable falls back to the default, because a malformed config must degrade the
- * capture rather than stop the run.
- */
-export function selectedProvider(configToml: string): string {
-  for (const line of configToml.split(/\r?\n/)) {
-    const text = line.trim();
-    // Stop at the first table header: `model_provider` is a top-level key, and a same-named key
-    // inside `[model_providers.x]` is a different setting entirely.
-    if (text.startsWith('[')) break;
-    const match = /^model_provider\s*=\s*["']([^"']+)["']/.exec(text);
-    if (match?.[1]) return match[1];
-  }
-  return 'openai';
-}
-
-/**
- * Codex's rollout.
- *
- * The user's turns arrive as `response_item` messages whose content is `input_text`. The harness
- * puts its own preamble through the same channel — skills, environment context, multi-agent
- * instructions — and those are wrapped in a tag, which is what separates them from a typed turn.
- */
-export const codexSession: SessionSupport = {
-  dir(_cwd, env) {
-    return join(codexHome(env), 'sessions');
-  },
-
-  parse(bytes) {
-    const prompts: string[] = [];
-    let id: string | undefined;
-    for (const entry of parseJsonl(bytes)) {
-      const payload = entry['payload'];
-      if (payload === null || typeof payload !== 'object') continue;
-      const p = payload as Record<string, unknown>;
-      if (entry['type'] === 'session_meta' && typeof p['id'] === 'string') id ??= p['id'];
-      if (entry['type'] !== 'response_item' || p['type'] !== 'message') continue;
-      if (p['role'] !== undefined && p['role'] !== 'user') continue;
-      const content = p['content'];
-      if (!Array.isArray(content)) continue;
-      const text = content
-        .filter(
-          (b) =>
-            b !== null && typeof b === 'object' && (b as { type?: string }).type === 'input_text',
-        )
-        .map((b) => String((b as { text?: unknown }).text ?? ''))
-        .join('')
-        .trim();
-      if (text === '' || text.startsWith('<')) continue;
-      prompts.push(text);
-    }
-    return { id, prompts };
-  },
-
-  resumeArgs(id) {
-    return ['exec', 'resume', id];
-  },
-};
-
-/**
- * Codex CLI.
- *
- * `OPENAI_BASE_URL` routes the built-in provider. Recent Codex releases reject overrides of
- * reserved built-in provider IDs. Custom providers still require a scoped config override: Codex resolves its origin from `model_providers.<name>.base_url` in `config.toml`, so an
- * installation pointed at a gateway — which is the reason most people have a `config.toml` at all
- * — ignores the variable completely and talks straight to its own endpoint. The recording then
- * ends with `capture.empty` and nothing to replay, having cost a full run of real tokens.
- *
- * `-c` is Codex's own flag for overriding exactly one config value for one invocation, so the
- * override is scoped to the run and the user's file is never touched. The provider name has to be
- * read from that file, because the key to override is named after whichever provider is selected.
- *
- * No placeholder key: Codex carries its own credential store in `auth.json`, and inventing
- * `OPENAI_API_KEY` overrides it with something that is not real.
- */
-export const codexAdapter: Adapter = {
-  id: 'codex',
-
-  async detect(_cwd: string): Promise<boolean> {
-    return detectAgent(['codex'], ['.codex']);
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    const base = proxyBase(ctx.proxyUrl, 'v1');
-    const env: Record<string, string> = { OPENAI_BASE_URL: base };
-    passThrough(env, ctx.env, 'OPENAI_API_KEY');
-
-    let provider = 'openai';
-    try {
-      provider = selectedProvider(await readFile(join(codexHome(ctx.env), 'config.toml'), 'utf8'));
-    } catch {
-      // No config, or unreadable: the built-in provider is the right guess, and `OPENAI_BASE_URL`
-      // covers it as well. Capture must never depend on a file existing.
-    }
-
-    // Ahead of the user's own arguments so that anything they pass explicitly still wins.
-    const args =
-      provider === 'openai'
-        ? ['-c', `openai_base_url=${base}`, ...ctx.userArgs]
-        : ['-c', `model_providers.${provider}.base_url=${base}`, ...ctx.userArgs];
-    return { command: 'codex', args, env };
-  },
-
-  session: codexSession,
-
-  /**
-   * `exec` is Codex's non-interactive form and takes the prompt as its positional argument.
-   *
-   * A run recorded as `codex exec` with the prompt on stdin already carries the subcommand and its
-   * flags, so the prompt is appended to what was recorded; a run recorded bare needs the whole
-   * form. `--skip-git-repo-check` because a replay runs in a scratch directory that is not one.
-   */
-  driveArgs(prompts, recorded) {
-    const first = prompts[0];
-    if (first === undefined) return undefined;
-    if (recorded.includes('exec')) return [...recorded, first];
-    return ['exec', '--skip-git-repo-check', first];
-  },
-};