agenticreplay 0.1.0 → 0.1.2

package/packages/adapters/src/detect.ts

@@ -1,132 +0,0 @@
-import { execFile } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { access, stat } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { delimiter, extname, join } from 'node:path';
-
-/**
- * Detection runs before every recording, and a detector that throws would take the whole run with
- * it. Every helper here answers false instead of failing.
- */
-export async function hasBinary(name: string): Promise<boolean> {
-  if (process.platform === 'win32') {
-    return (await resolveWindowsBinary(name, process.env.PATH ?? '')) !== undefined;
-  }
-
-  return new Promise((resolve) => {
-    // execFile, never a shell: `name` reaches the lookup as one argv element, so an agent id
-    // carrying shell metacharacters cannot become a command.
-    execFile('which', [name], { timeout: 5_000 }, (err, stdout) => {
-      resolve(!err && stdout.trim().length > 0);
-    });
-  });
-}
-
-/**
- * The path a launcher must actually spawn, or undefined when the name is not on PATH.
- *
- * Detection and launching have to agree. On Windows an npm-installed agent is three shims —
- * `claude`, `claude.cmd`, `claude.ps1` — and only the `.cmd` is something `CreateProcess` will
- * run. `spawn` does no PATHEXT resolution of its own, so a launcher handed the bare name finds
- * the extensionless shell script, cannot execute it, and reports ENOENT for an agent that
- * `agenticreplay doctor` had just called present. Resolving here, against the same PATHEXT walk detection
- * uses, is what keeps the two answers the same.
- *
- * Not `shell: true`: that would hand the agent's own arguments to a command interpreter.
- */
-export async function resolveBinary(name: string): Promise<string | undefined> {
-  if (process.platform !== 'win32') return name;
-  // An explicit path is already the answer; PATH does not enter into it.
-  if (name.includes('/') || name.includes('\\')) return name;
-  return resolveWindowsBinary(name, process.env.PATH ?? '');
-}
-
-/** What `spawn` must actually be given to launch `command` with `args`. */
-export interface LaunchTarget {
-  file: string;
-  args: string[];
-  /** True only for a Windows batch shim, which `spawn` refuses to run any other way. */
-  shell: boolean;
-}
-
-/** cmd.exe reads these before the program does, so they have to be escaped for it first. */
-const CMD_META = /([()\][%!^"`<>&|;, *?])/g;
-
-/**
- * Quote one argument so that cmd.exe hands the program back exactly the string we started with.
- *
- * Two parsers run in sequence: cmd.exe strips `^` escapes, then the program's own CommandLineToArgv
- * splits what is left. So the backslash-before-quote doubling has to happen first, and the `^`
- * escaping of everything — the quotes we just added included — second.
- */
-function quoteForCmd(arg: string): string {
-  let quoted = arg.replace(/(\\*)"/g, '$1$1\\"');
-  quoted = quoted.replace(/(\\*)$/, '$1$1');
-  return `"${quoted}"`.replace(CMD_META, '^$&');
-}
-
-/**
- * Resolve a command to something `spawn` can launch on this platform.
- *
- * Windows makes this three cases rather than one. An npm-installed agent is a set of shims —
- * `claude`, `claude.cmd`, `claude.ps1` — and `spawn` does no PATHEXT resolution, so the bare name
- * finds the extensionless shell script and fails ENOENT. Resolving to the `.cmd` then hits the
- * second wall: since the batch-injection fix, Node refuses to spawn `.cmd` or `.bat` without a
- * shell and answers EINVAL. Only a batch shim needs that shell, and only then do the arguments
- * have to survive cmd.exe, which is what the quoting is for. A real `.exe` still spawns directly.
- */
-export async function resolveLaunch(command: string, args: string[]): Promise<LaunchTarget> {
-  if (process.platform !== 'win32') return { file: command, args, shell: false };
-  const file = (await resolveBinary(command)) ?? command;
-  if (!/\.(cmd|bat)$/i.test(file)) return { file, args, shell: false };
-  return { file: quoteForCmd(file), args: args.map(quoteForCmd), shell: true };
-}
-
-async function resolveWindowsBinary(name: string, pathVar: string): Promise<string | undefined> {
-  const extensions =
-    extname(name) !== ''
-      ? ['']
-      : (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean);
-  for (const entry of pathVar.split(delimiter)) {
-    if (entry === '') continue;
-    for (const extension of extensions) {
-      const candidate = join(entry, `${name}${extension.toLowerCase()}`);
-      try {
-        if ((await stat(candidate)).isFile()) {
-          await access(candidate);
-          return candidate;
-        }
-      } catch {
-        // Keep searching the rest of PATH. Detection must never take the CLI down.
-      }
-    }
-  }
-  return undefined;
-}
-
-/**
- * The home directory as the *child process* will see it. A host that hands us a rebuilt env object
- * detaches `process.env` from the OS environment, and `os.homedir()` then answers for a home the
- * agent will never be launched with — so the JS-visible value wins where it is set.
- */
-export function homeDir(): string {
-  return process.env['HOME'] || process.env['USERPROFILE'] || homedir();
-}
-
-/** True when `~/<relative>` exists — the cheap "this agent has been run here before" signal. */
-export function homeDirHas(relative: string): boolean {
-  try {
-    return existsSync(join(homeDir(), relative));
-  } catch {
-    return false;
-  }
-}
-
-/** True when any of the given binaries or home-relative config paths is present. */
-export async function detectAgent(binaries: string[], homePaths: string[]): Promise<boolean> {
-  if (homePaths.some(homeDirHas)) return true;
-  for (const bin of binaries) {
-    if (await hasBinary(bin)) return true;
-  }
-  return false;
-}

package/packages/adapters/src/env.ts

@@ -1,118 +0,0 @@
-import { decodeForwardPath, forwardBasePath } from '@agenticreplay/proxy';
-
-/**
- * Placeholder key for runs where the user has no credential in the environment. The proxy is
- * holding the real one (or serving from a trace), but SDK clients refuse to start without
- * *something* — so an obviously-fake value beats an empty string that looks like a real key.
- */
-export const PLACEHOLDER_KEY = 'agenticreplay-recorded';
-
-/** An env var set to the empty string is unset for our purposes: an empty key breaks clients. */
-export function readEnv(env: Record<string, string | undefined>, name: string): string | undefined {
-  const value = env[name];
-  return value !== undefined && value !== '' ? value : undefined;
-}
-
-/** Joins a path onto the proxy url without producing `//`, whether or not the base ends in `/`. */
-export function proxyBase(proxyUrl: string, path = ''): string {
-  const base = proxyUrl.replace(/\/+$/, '');
-  return path ? `${base}/${path.replace(/^\/+/, '')}` : base;
-}
-
-/**
- * A proxy base URL that carries `original` as its destination — but only where it can be carried.
- *
- * `forwardBasePath` encodes whatever it is handed; `decodeForwardPath` deliberately refuses a
- * decoded URL with credentials, a query, a fragment or a non-http(s) scheme. Encoding without
- * asking produced a `/forward/` segment nothing could read, and that failed in the worst available
- * way: the proxy could not recover the announced origin, so the call went to the configured
- * upstream — or to `api.openai.com` — carrying the harness's credential for a *different* gateway,
- * which is the exact failure this rewrite exists to prevent. Worse, the undecodable segment is the
- * request path, so a base URL like `https://tenant:pw@gw.example/v1` wrote the gateway password
- * into the trace verbatim, where `agenticreplay show`, `agenticreplay export` and any attached bug report carry it.
- *
- * So: ask the decoder first, and where the answer is no, fall back to the plain proxy path. That
- * is what this did before origins could be carried at all — the call reaches the proxy and is
- * forwarded to the configured upstream, which fails loudly against the wrong origin instead of
- * quietly leaking. Carrying it *without* the credential is not an option: the client reads this
- * value to build its request, so dropping the userinfo would simply stop it authenticating.
- */
-export function forwardOrProxyBase(
-  proxyUrl: string,
-  original: string,
-  fallbackPath = 'v1',
-): string {
-  const forward = forwardBasePath(original);
-  // Round-tripped through the decoder itself, rather than restating its rules here, so the two
-  // sides of the encoding cannot drift apart again.
-  if (decodeForwardPath(forward) !== undefined) return proxyBase(proxyUrl, forward);
-  return proxyBase(proxyUrl, fallbackPath);
-}
-
-/** Copies `name` from the run environment into the launch overlay, or a placeholder if unset. */
-export function passKey(
-  target: Record<string, string>,
-  env: Record<string, string | undefined>,
-  name: string,
-): void {
-  target[name] = readEnv(env, name) ?? PLACEHOLDER_KEY;
-}
-
-/** Copies `name` only if it is actually set — used for optional tokens we must not invent. */
-export function passThrough(
-  target: Record<string, string>,
-  env: Record<string, string | undefined>,
-  name: string,
-): void {
-  const value = readEnv(env, name);
-  if (value !== undefined) target[name] = value;
-}
-
-/**
- * Point base-URL variables agenticreplay does not know about at the proxy.
- *
- * Read from `AGENTICREPLAY_BASE_URL_VARS`: a comma-separated list of variable names, each optionally with
- * `=<path>` when the origin is not OpenAI-shaped. `/v1` is the default suffix because that is what
- * an OpenAI-compatible override wants, and it is what every example in the wild ends in.
- *
- * This exists because enumerating them is hopeless. Hermes alone overrides per provider —
- * `NOVITA_BASE_URL`, `GLM_BASE_URL`, `KIMI_BASE_URL`, `MINIMAX_BASE_URL`, `HF_BASE_URL`,
- * `NEBIUS_BASE_URL` and a dozen more in one `.env.example` — and a list of names baked in here
- * would be stale the week after it was written. A harness the author has never heard of is the
- * normal case, so it gets a mechanism rather than a pull request.
- *
- * The variable is consumed, never forwarded: it names other variables and means nothing downstream.
- *
- * Where the variable already held an origin and the user did not spell out a path, the rewrite
- * goes through `/forward/` so the request arrives carrying the destination agenticreplay took it away
- * from. That matters as soon as a run has two of them. A retrieval stack is the ordinary case —
- * chat through a gateway, embeddings at a dedicated provider or a local Ollama — and agenticreplay's
- * upstream map is keyed by wire dialect, so "the same dialect at two origins" is a configuration
- * `--upstream-openai` cannot express. Without the original target the second origin's calls were
- * forwarded to the first one's, or, with no override configured at all, to `api.openai.com`
- * carrying the second provider's credential. With it, `passthroughOrigin` restores the address
- * the client announced and nothing has to be guessed.
- */
-export function applyNamedBaseUrls(
-  target: Record<string, string>,
-  env: Record<string, string | undefined>,
-  proxyUrl: string,
-): void {
-  for (const entry of (readEnv(env, 'AGENTICREPLAY_BASE_URL_VARS') ?? '').split(',')) {
-    const [rawName, rawPath] = entry.split('=');
-    const name = (rawName ?? '').trim();
-    if (name === '') continue;
-    const original = readEnv(env, name);
-    // An explicit `=<path>` is the user saying where on the proxy this variable should point, and
-    // it still wins: it is how someone names a non-OpenAI-shaped origin, and rewriting it as a
-    // forward would silently ignore what they typed.
-    if (rawPath === undefined && original !== undefined) {
-      target[name] = forwardOrProxyBase(proxyUrl, original);
-      continue;
-    }
-    // A path of `/` means the bare origin. `proxyBase` would otherwise leave the separator behind
-    // and hand the harness `http://host:port/`, which some clients then join into a double slash.
-    const path = (rawPath ?? 'v1').trim().replace(/^\/+|\/+$/g, '');
-    target[name] = proxyBase(proxyUrl, path);
-  }
-}

package/packages/adapters/src/exec.ts

@@ -1,59 +0,0 @@
-import type { Adapter, Launch, RecordContext } from '@agenticreplay/plugin-api';
-import { applyNamedBaseUrls } from './env.js';
-
-/**
- * Any agent at all, captured at the transport.
- *
- * The other adapters here each name a harness and the variable it reads. This one names neither,
- * because the cases it exists for have nothing to name:
- *
- *   - a bot with its origin hardcoded in source — a Grok bot posting to `https://api.x.ai/v1`
- *     because someone typed that string, which no environment variable will ever move;
- *   - an agent in a language the fetch hook cannot reach, which is every language except JS;
- *   - an editor that spawns the real agent as a child, where agenticreplay launches the editor and the
- *     agent inherits the capture two processes down.
- *
- * For all three the redirect happens below the agent, at the socket: `--tls-intercept` terminates
- * the TLS the agent established itself. That is applied by the run rather than by this adapter,
- * which is why `prepare` looks nearly empty — the emptiness is the design.
- *
- * It is deliberately not `generic-openai` with a better name. That adapter sets `OPENAI_BASE_URL`,
- * `OPENAI_API_BASE` and `ANTHROPIC_BASE_URL` at once, which is right when you know your agent
- * reads one of them and actively wrong when you do not: an injected origin silently repoints a
- * harness that would otherwise have called somewhere else, and the trace then describes a run the
- * user never asked for. Pointing an unknown agent nowhere is the honest default.
- */
-export const execAdapter: Adapter = {
-  id: 'exec',
-  // `any` is what someone types when their agent is not on the list, which is the whole audience.
-  aliases: ['any'],
-
-  // Redirecting nothing is the intent, not a defect. See the `capture` field on `Adapter`.
-  capture: 'transport',
-
-  async detect(_cwd: string): Promise<boolean> {
-    // Never automatic. An adapter that does not know what it would be launching must not claim a
-    // workspace — the same rule `generic-openai` and `node` follow, for the same reason.
-    return false;
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    const [command, ...args] = ctx.userArgs;
-    if (command === undefined || command === '') {
-      throw new Error(
-        'exec needs the command to run: agenticreplay record exec --tls-intercept -- <command> [args...], ' +
-          'e.g. agenticreplay record exec --tls-intercept -- python bot.py',
-      );
-    }
-
-    // Nothing is invented: no origin, and no credential. An agent recorded this way authenticates
-    // with whatever it already had, because agenticreplay never learned which provider it talks to.
-    const env: Record<string, string> = {};
-    // The one exception, and only because the operator asked for it by name. This is what makes
-    // `exec` useful for a harness that reads an unusual variable but has no adapter yet, without
-    // needing interception at all.
-    applyNamedBaseUrls(env, ctx.env, ctx.proxyUrl);
-
-    return { command, args, env };
-  },
-};

package/packages/adapters/src/generic-openai.ts

@@ -1,36 +0,0 @@
-import type { Adapter, Launch, RecordContext } from '@agenticreplay/plugin-api';
-import { applyNamedBaseUrls, passKey, passThrough, proxyBase } from './env.js';
-
-/**
- * The escape hatch for any agent nobody has written an adapter for: the user supplies the command,
- * and every base-url variable in common use is redirected at once. `detect` is always false — an
- * adapter that cannot know what it is launching must never be chosen automatically.
- */
-export const genericOpenAiAdapter: Adapter = {
-  id: 'generic-openai',
-
-  async detect(_cwd: string): Promise<boolean> {
-    return false;
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    const [command, ...args] = ctx.userArgs;
-    if (command === undefined || command === '') {
-      throw new Error(
-        'generic-openai needs the command to run: agenticreplay record generic-openai -- <command> [args...]',
-      );
-    }
-    const env: Record<string, string> = {
-      OPENAI_BASE_URL: proxyBase(ctx.proxyUrl, 'v1'),
-      // Pre-1.0 OpenAI SDKs and many ports read OPENAI_API_BASE instead.
-      OPENAI_API_BASE: proxyBase(ctx.proxyUrl, 'v1'),
-      ANTHROPIC_BASE_URL: proxyBase(ctx.proxyUrl),
-    };
-    passKey(env, ctx.env, 'OPENAI_API_KEY');
-    // Only passed on if the user already had one: an invented Anthropic key could flip an unknown
-    // agent's provider auto-selection and change which model it calls.
-    passThrough(env, ctx.env, 'ANTHROPIC_API_KEY');
-    applyNamedBaseUrls(env, ctx.env, ctx.proxyUrl);
-    return { command, args, env };
-  },
-};

package/packages/adapters/src/goose.ts

@@ -1,87 +0,0 @@
-import type { Adapter, Launch, RecordContext } from '@agenticreplay/plugin-api';
-import { detectAgent } from './detect.js';
-import { passKey, passThrough, proxyBase, readEnv } from './env.js';
-
-/**
- * goose — Block's agent, and the one harness so far that reads a *different* set of variables
- * than every other OpenAI-shaped client.
- *
- * Three facts decided this adapter, each measured against goose 1.49.0 rather than inferred, by
- * pointing it at a sink server and reading back the request line:
- *
- * 1. **`OPENAI_HOST` outranks `OPENAI_BASE_URL`.** `openai_def.rs` resolves the origin in priority
- *    order — `OPENAI_HOST` from the environment first, `OPENAI_BASE_URL` second — so a user who
- *    has `OPENAI_HOST` set for some other tool keeps it, and the run goes to their origin while
- *    agenticreplay reports a successful recording with an empty trace. Setting only `OPENAI_BASE_URL` is
- *    the `capture.empty` shape the adapter contract exists to prevent, so this adapter sets both.
- *    Pointed at the same proxy they agree, and neither a stale value nor the priority order can
- *    route around it.
- *
- * 2. **goose does not read `ANTHROPIC_BASE_URL`.** Its Anthropic provider reads `ANTHROPIC_HOST`
- *    (`anthropic_def.rs`), and a sink pointed at by `ANTHROPIC_BASE_URL` alone receives nothing at
- *    all. This is precisely why `generic-openai` is not good enough for goose: it sets the
- *    variable the rest of the ecosystem reads, which here is the one variable that does nothing.
- *
- * 3. **The traffic is the Responses API.** With either variable set, goose issues
- *    `POST /v1/responses`, not `/v1/chat/completions` — plus one `GET /v1/models` on start-up. The
- *    proxy's `openai-responses` dialect claims it (`matches: (p) => p.endsWith('/responses')`), so
- *    no path rewriting is needed; it is recorded here because "it happens to work" and "it is
- *    known to work" are different claims, and only the second survives an upstream refactor.
- *
- * `Config::get_param` reads the environment before the config file for every key it resolves
- * (`config/base.rs`), which is what makes per-process redirection possible at all — goose's
- * persisted `~/.config/goose/config.yaml` cannot win against the overlay agenticreplay sets.
- *
- * **What this adapter does not capture.** goose runs its shell without going through agenticreplay's PATH
- * shim, so a run full of `shell` tool calls still reports `shell.ineffective`: the commands appear
- * as tool calls with their output, but the real exit code, the real duration and the
- * stdout/stderr split are not in the trace. Record with `--no-shell` to claim nothing rather than
- * to claim that.
- */
-export const gooseAdapter: Adapter = {
-  id: 'goose',
-  harnessVersions: '>=1.49.0',
-
-  async detect(_cwd: string): Promise<boolean> {
-    return detectAgent(['goose'], ['.config/goose']);
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    const env: Record<string, string> = {
-      // Both, deliberately — see fact 1. `OPENAI_HOST` takes an origin and goose appends the
-      // endpoint itself; `OPENAI_BASE_URL` takes the `/v1` form the rest of the ecosystem uses.
-      OPENAI_HOST: proxyBase(ctx.proxyUrl),
-      OPENAI_BASE_URL: proxyBase(ctx.proxyUrl, 'v1'),
-      // Not `ANTHROPIC_BASE_URL`: goose reads neither that nor `ANTHROPIC_API_BASE`. See fact 2.
-      ANTHROPIC_HOST: proxyBase(ctx.proxyUrl),
-    };
-
-    // Same credential rule as the other adapters. Which keys the harness can see decides which
-    // provider it picks, so inventing one 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. A placeholder stands in only when there is
-    // nothing to disturb.
-    const hasAny =
-      readEnv(ctx.env, 'OPENAI_API_KEY') !== undefined ||
-      readEnv(ctx.env, 'ANTHROPIC_API_KEY') !== undefined;
-    if (hasAny) {
-      passThrough(env, ctx.env, 'OPENAI_API_KEY');
-      passThrough(env, ctx.env, 'ANTHROPIC_API_KEY');
-    } else {
-      passKey(env, ctx.env, 'OPENAI_API_KEY');
-    }
-
-    // Passed on, never invented: goose has no default provider or model for a custom endpoint, and
-    // which one the recording is meant to exercise is the operator's to say. Inventing either
-    // would make `agenticreplay record goose` launch a different agent than `goose` does.
-    passThrough(env, ctx.env, 'GOOSE_PROVIDER');
-    passThrough(env, ctx.env, 'GOOSE_MODEL');
-    // `OPENAI_BASE_PATH` is read from the environment ahead of the config file whenever the host
-    // came from `OPENAI_BASE_URL`, so a value left over from a Docker Model Runner setup would
-    // move the path agenticreplay serves. Passing it through keeps the recording faithful to the command
-    // the user actually ran; the proxy matches `/chat/completions` with or without a `/v1`.
-    passThrough(env, ctx.env, 'OPENAI_BASE_PATH');
-
-    return { command: 'goose', args: [...ctx.userArgs], env };
-  },
-};

package/packages/adapters/src/grok.ts

@@ -1,60 +0,0 @@
-import {
-  HOOK_FILENAME,
-  bunOptionsWithHook,
-  nodeOptionsWithHook,
-  writeFetchHook,
-} from '@agenticreplay/node-instrument';
-import type { Adapter, Launch, RecordContext } from '@agenticreplay/plugin-api';
-import { applyNamedBaseUrls, passThrough, proxyBase, readEnv } from './env.js';
-import { detectAgent } from './detect.js';
-
-/** xAI's origin, which grok-cli reaches whenever something bypasses `GROK_BASE_URL`. */
-const XAI_HOST = 'api.x.ai';
-
-/**
- * grok-cli — the community coding agent for xAI's Grok API.
- *
- * It documents `GROK_BASE_URL` (default `https://api.x.ai/v1`), so the ordinary redirect works and
- * this adapter is mostly that one variable. Two details are not ordinary:
- *
- * The `/v1` is part of the documented default, so the replacement carries it — drop it and every
- * request lands one path segment short.
- *
- * And it runs on Bun with sub-agents on by default. A sub-agent that builds its own client would
- * slip past a variable its parent read, so the fetch hook goes in as well, with `api.x.ai` added
- * to the allowlist — it is not one of the hook's default hosts, so without that line the hook
- * would be installed and inert. Bun ignores `--require` inside `NODE_OPTIONS`, which is why
- * `BUN_OPTIONS` is set alongside it.
- *
- * Its Telegram remote control is the same process reading the same variable, so "the grok bot" is
- * captured by this adapter too, with nothing extra.
- */
-export const grokAdapter: Adapter = {
-  id: 'grok',
-  aliases: ['grok-cli'],
-
-  async detect(_cwd: string): Promise<boolean> {
-    return detectAgent(['grok'], ['.grok']);
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    const hookPath = await writeFetchHook(ctx.runDir);
-    const hosts = readEnv(ctx.env, 'AGENTICREPLAY_INSTRUMENT_HOSTS');
-    const env: Record<string, string> = {
-      GROK_BASE_URL: proxyBase(ctx.proxyUrl, 'v1'),
-      AGENTICREPLAY_PROXY_URL: ctx.proxyUrl,
-      // Added to whatever the operator asked for rather than replacing it: naming one host should
-      // not silently drop xAI, which is the only host this adapter exists to catch.
-      AGENTICREPLAY_INSTRUMENT_HOSTS: hosts === undefined ? XAI_HOST : `${hosts},${XAI_HOST}`,
-      NODE_OPTIONS: nodeOptionsWithHook(hookPath, readEnv(ctx.env, 'NODE_OPTIONS')),
-      BUN_OPTIONS: bunOptionsWithHook(hookPath, readEnv(ctx.env, 'BUN_OPTIONS')),
-    };
-    // Never invented: grok-cli refuses to start without a key and says so clearly, which is a
-    // better failure than a run that silently authenticates as nobody.
-    passThrough(env, ctx.env, 'GROK_API_KEY');
-    applyNamedBaseUrls(env, ctx.env, ctx.proxyUrl);
-    return { command: 'grok', args: [...ctx.userArgs], env, tempFiles: [hookPath] };
-  },
-};
-
-export { HOOK_FILENAME };

package/packages/adapters/src/hermes.ts

@@ -1,92 +0,0 @@
-import type { Adapter, Launch, RecordContext } from '@agenticreplay/plugin-api';
-import { detectAgent } from './detect.js';
-
-/**
- * Hermes, Nous Research's agent — the first Python harness agenticreplay records.
- *
- * Every other adapter here fronts a Node harness, and that difference is the whole reason this
- * one exists. Nothing is redirected: `OPENAI_BASE_URL` is not a route into Hermes. Its origin
- * lives in `config.yaml` under `model.base_url`, and the environment variable is read in only one
- * place -- an advisory warning that fires when it is set and the provider is *not* `custom`.
- * Verified against a logging listener rather than inferred: with `model.base_url` pointed at a
- * dead port and `OPENAI_BASE_URL` at a live one, the run dies on the dead port and the listener
- * records nothing, `--provider custom` included.
- *
- * What does work is the transport. Hermes honours `HTTPS_PROXY` all the way down -- through a
- * proxy that logs CONNECT targets, a single question sends two of them to the model origin, the
- * model-catalogue read and the completion -- so `--tls-intercept` reaches it.
- *
- * TLS trust is process-local. Standard Python clients use SSL_CERT_FILE; current Hermes
- * additionally uses OS-backed truststore contexts that ignore that variable. The recording
- * bootstrap adds the run CA to those contexts, preserving platform roots and certificate
- * verification. No system trust store or Hermes configuration is modified.
- *
- * `inference-api.nousresearch.com` is in `DEFAULT_TLS_HOSTS`, so Hermes on Nous' own models needs
- * no extra `--tls-hosts`. Deliberately not in that list: `portal.nousresearch.com`, which is
- * billing and subscription management and where the API key is issued.
- *
- * The fixture below was verified against `--provider opencode-free`, whose tier is served
- * anonymously -- no key, so no credential to leak into a recording. That origin needs
- * `--tls-hosts '+opencode.ai'` and does not get a default entry: unlike `api.kilo.ai` or
- * `api.xiaomimimo.com` it is a website as much as a gateway, and a default that decrypted it would
- * decrypt whatever else is served there.
- *
- *     agenticreplay record hermes --tls-intercept --tls-hosts '+opencode.ai' -- \
- *       --provider opencode-free -m nemotron-3.5-lightning-free -z 'your question'
- *
- * `-z` is the non-interactive flag; without it Hermes opens a session and waits.
- *
- * Three things about a Hermes recording that are worth knowing before reading one, all measured
- * against v0.21.0 rather than reasoned about:
- *
- * **It does not work in the directory agenticreplay launched it in.** `_restore_session_cwd` in Hermes'
- * own CLI chdirs to the cwd stored in its session metadata, so a run started in a project reports
- * the home directory when asked, and writes land there. Per-turn filesystem diffs are taken of
- * the directory agenticreplay recorded from, so they read `0 changed` on a run that did change files --
- * the evidence is still in the trace, as the absolute path inside the `write_file` tool call.
- * `TERMINAL_CWD` is the lever, and the adapter deliberately does not pull it: forcing it would
- * make a recorded run write somewhere different from the same command uninstrumented, which is
- * the one thing an adapter here must never do. Export it yourself when you want the diffs.
- *
- * **How much of a multi-turn run replays depends on the recording, not on you.** Hermes makes a
- * one-message background call and abandons it, and where that lands decides the outcome. Landing
- * after the turns, a three-exchange recording replays `reused=3/3 exact=3 divergences=0`. Landing
- * between them, the matcher meets it where the recording has a three-message turn and strict
- * replay stops at `reused=1/3`; `--loose` carries the run to the same answer. Recording the same
- * task four times gave two of each, and each recording then replays the same way every time --
- * deterministic per recording, roughly even across them. The `unmatched=1` is that call in both
- * cases: the recording holds no answer for it, deliberately, because an exchange with no response
- * cannot be replayed.
- *
- * **The prompt carries Hermes' own skills catalogue, so a short one means a broken install.** It
- * is 14,058 characters and 19 tools, byte-identical across runs, and about 6,300 of that is an
- * `<available_skills>` block listing the 51 skills `hermes skills list` calls builtin -- Hermes'
- * content, not the operator's. A split install can hide it: `HERMES_HOME` is a persisted user
- * variable here, and a shell whose environment predates the install falls back to a home with no
- * skills directory, where the same prompt comes out 7,742 characters. That also degrades replay,
- * from `3/3 exact=3` to `1/3` on the same task -- which is worth knowing, because it looks
- * exactly like a matcher bug. Check `hermes skills list` first: 0 builtin means the harness cannot
- * find itself.
- */
-export const hermesAdapter: Adapter = {
-  id: 'hermes',
-  aliases: ['hermes-agent', 'nous-hermes'],
-  harnessVersions: '>=0.21.0',
-
-  // Redirecting nothing is the intent, not a defect. See the `capture` field on `Adapter`.
-  capture: 'transport',
-
-  async detect(_cwd: string): Promise<boolean> {
-    // `AppData/Local/hermes` is where the Windows install keeps `config.yaml`; the XDG paths are
-    // the same directory on the other platforms. Home-relative, so an install moved with
-    // `HERMES_HOME` is still found by its binary.
-    return detectAgent(['hermes'], ['AppData/Local/hermes', '.config/hermes', '.hermes']);
-  },
-
-  async prepare(ctx: RecordContext): Promise<Launch> {
-    // No origin and no credential. Hermes keeps both in `config.yaml` and its own secret store,
-    // and an adapter that injected either would override a choice made there -- for the origin it
-    // could not anyway, per the note above.
-    return { command: 'hermes', args: [...ctx.userArgs], env: {} };
-  },
-};

package/packages/adapters/src/index.ts

@@ -1,24 +0,0 @@
-export * from './claude-code.js';
-export * from './codex.js';
-export * from './contract.js';
-export * from './cursor.js';
-export * from './detect.js';
-export * from './env.js';
-export * from './exec.js';
-export * from './generic-openai.js';
-export * from './goose.js';
-export * from './grok.js';
-export * from './hermes.js';
-export * from './indexrag.js';
-export * from './node.js';
-export * from './openclaw.js';
-export * from './mcp-config.js';
-export * from './kilo.js';
-export * from './mcode.js';
-export * from './mimo.js';
-export * from './opencode.js';
-export * from './qwen.js';
-export * from './registry.js';
-export * from './scaffold.js';
-export * from './session.js';
-export * from './zcode.js';