@linzumi/cli 1.0.275 → 1.0.277

package/scripts/replay-agent-fixture.ts

@@ -1,326 +0,0 @@
-/*
-- Date: 2026-06-29
-  Spec: plans/2026-06-29-claude-code-raw-replay-harness-plan.md
-  Relationship: Local replay entrypoint for raw agent fixtures. It loads one or
-  more NDJSON fixtures, validates coverage, and writes static playground and
-  JSON summary artifacts without starting live providers.
-*/
-import { mkdir, writeFile } from 'node:fs/promises';
-import { basename, join, resolve } from 'node:path';
-import {
-  commanderReplayCoverageRequirements,
-  commanderReplayRealCoverageRequirements,
-  extractAgentReplayCoverage,
-  missingAgentReplayCoverage,
-} from '../src/agentReplayCoverage';
-import {
-  loadAgentReplayFixture,
-  type AgentReplayFixture,
-} from '../src/agentReplayFixture';
-import { renderAgentReplayPlaygroundHtml } from '../src/agentReplayPlayground';
-import { collectAgentReplayDiagnostics } from '../src/agentReplayDiagnostics';
-import {
-  evaluateAgentReplayFeatureReadiness,
-  loadAgentReplayManifestForFixture,
-  summarizeAgentReplayManifest,
-  type AgentReplayFeatureReadiness,
-  type AgentReplayManifestSummary,
-} from '../src/agentReplayManifest';
-
-type ReplayCliOptions = {
-  readonly fixtures: readonly string[];
-  readonly outDir: string;
-  readonly coverageMode: 'none' | 'real' | 'full';
-  readonly html: boolean;
-  readonly summary: boolean;
-  readonly requiredFeatureId: string | undefined;
-};
-
-async function main(): Promise<void> {
-  const args = process.argv.slice(2);
-
-  if (args.includes('--help')) {
-    printHelp();
-    return;
-  }
-
-  const options = parseArgs(args);
-  const fixtures = await Promise.all(options.fixtures.map(loadFixture));
-  const manifestSummaries = await loadManifestSummaries(options.fixtures);
-  const featureReadiness = await loadManifestReadiness(options.fixtures);
-  await mkdir(options.outDir, { recursive: true });
-
-  if (options.html) {
-    for (const fixture of fixtures) {
-      const name = fixtureOutputName(fixture.path);
-      await writeFile(
-        join(options.outDir, `${name}.html`),
-        renderAgentReplayPlaygroundHtml(fixture),
-        'utf8'
-      );
-    }
-  }
-
-  const coverage = extractAgentReplayCoverage(fixtures);
-  const diagnostics = combineDiagnostics(
-    fixtures.map(collectAgentReplayDiagnostics)
-  );
-  const requirements =
-    options.coverageMode === 'real'
-      ? commanderReplayRealCoverageRequirements
-      : commanderReplayCoverageRequirements;
-  const gaps =
-    options.coverageMode === 'none'
-      ? []
-      : missingAgentReplayCoverage(coverage, requirements);
-  const requiredFeatureGate = evaluateRequiredFeatureGate(
-    options.requiredFeatureId,
-    featureReadiness
-  );
-  const summary = {
-    fixtures: fixtures.map((fixture) => ({
-      path: fixture.path,
-      records: fixture.records.length,
-    })),
-    coverageMode: options.coverageMode,
-    coverage: coverageSummary(coverage),
-    featureCoverage: manifestSummaries,
-    featureReadiness,
-    diagnostics,
-    gaps,
-    requiredFeature: requiredFeatureGate,
-  };
-
-  if (options.summary) {
-    await writeFile(
-      join(options.outDir, 'summary.json'),
-      `${JSON.stringify(summary, null, 2)}\n`,
-      'utf8'
-    );
-  }
-
-  process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
-
-  if (
-    gaps.length > 0 ||
-    diagnostics.droppedEvents.length > 0 ||
-    requiredFeatureGate.status === 'failed'
-  ) {
-    process.exitCode = 1;
-  }
-}
-
-function combineDiagnostics(
-  diagnostics: readonly ReturnType<typeof collectAgentReplayDiagnostics>[]
-): ReturnType<typeof collectAgentReplayDiagnostics> {
-  return {
-    droppedEvents: diagnostics.flatMap((entry) => entry.droppedEvents),
-    debugOnlyEvents: diagnostics.flatMap((entry) => entry.debugOnlyEvents),
-  };
-}
-
-function parseArgs(args: readonly string[]): ReplayCliOptions {
-  const fixtures = valuesFor(args, '--fixture').map((path) => resolve(path));
-
-  if (fixtures.length === 0) {
-    throw new Error('provide at least one --fixture <path>');
-  }
-
-  return {
-    fixtures,
-    outDir: resolve(argValue(args, '--out-dir') ?? 'agent-replay-output'),
-    coverageMode: coverageModeValue(argValue(args, '--coverage') ?? 'full'),
-    html: !args.includes('--no-html'),
-    summary: !args.includes('--no-summary'),
-    requiredFeatureId: argValue(args, '--require-feature'),
-  };
-}
-
-function coverageModeValue(value: string): ReplayCliOptions['coverageMode'] {
-  switch (value) {
-    case 'none':
-    case 'real':
-    case 'full':
-      return value;
-    default:
-      throw new Error(`unsupported --coverage value: ${value}`);
-  }
-}
-
-async function loadManifestSummaries(
-  fixturePaths: readonly string[]
-): Promise<readonly AgentReplayManifestSummary[]> {
-  const manifests: AgentReplayManifestSummary[] = [];
-
-  for (const fixturePath of fixturePaths) {
-    const loaded = await loadAgentReplayManifestForFixture(fixturePath);
-
-    if (loaded === undefined) {
-      continue;
-    }
-
-    if (loaded.type === 'error') {
-      throw new Error(JSON.stringify(loaded.error));
-    }
-
-    manifests.push(summarizeAgentReplayManifest(loaded.manifest));
-  }
-
-  return manifests;
-}
-
-async function loadManifestReadiness(
-  fixturePaths: readonly string[]
-): Promise<readonly AgentReplayFeatureReadiness[]> {
-  const readiness: AgentReplayFeatureReadiness[] = [];
-
-  for (const fixturePath of fixturePaths) {
-    const loaded = await loadAgentReplayManifestForFixture(fixturePath);
-
-    if (loaded === undefined) {
-      continue;
-    }
-
-    if (loaded.type === 'error') {
-      throw new Error(JSON.stringify(loaded.error));
-    }
-
-    readiness.push(...evaluateAgentReplayFeatureReadiness(loaded.manifest));
-  }
-
-  return readiness;
-}
-
-type RequiredFeatureGate =
-  | { readonly status: 'not-required' }
-  | {
-      readonly status: 'passed';
-      readonly featureId: string;
-      readonly readiness: AgentReplayFeatureReadiness;
-    }
-  | {
-      readonly status: 'failed';
-      readonly featureId: string;
-      readonly reason: string;
-      readonly readiness?: AgentReplayFeatureReadiness | undefined;
-    };
-
-function evaluateRequiredFeatureGate(
-  featureId: string | undefined,
-  readiness: readonly AgentReplayFeatureReadiness[]
-): RequiredFeatureGate {
-  if (featureId === undefined) {
-    return { status: 'not-required' };
-  }
-
-  if (readiness.length === 0) {
-    return {
-      status: 'failed',
-      featureId,
-      reason: '--require-feature needs a neighboring fixture manifest',
-    };
-  }
-
-  const feature = readiness.find((row) => row.featureId === featureId);
-
-  if (feature === undefined) {
-    return {
-      status: 'failed',
-      featureId,
-      reason: `feature ${featureId} is not present in the fixture manifests`,
-    };
-  }
-
-  switch (feature.status) {
-    case 'implemented':
-    case 'ready-to-implement':
-      return { status: 'passed', featureId, readiness: feature };
-    case 'blocked':
-    case 'missing-proof':
-    case 'not-started':
-      return {
-        status: 'failed',
-        featureId,
-        readiness: feature,
-        reason: feature.reason,
-      };
-  }
-}
-
-async function loadFixture(path: string): Promise<AgentReplayFixture> {
-  const loaded = await loadAgentReplayFixture(path);
-
-  if (loaded.type === 'error') {
-    throw new Error(JSON.stringify(loaded.error));
-  }
-
-  return loaded.fixture;
-}
-
-function valuesFor(args: readonly string[], name: string): readonly string[] {
-  const values: string[] = [];
-
-  for (let index = 0; index < args.length; index += 1) {
-    if (args[index] === name) {
-      const value = args[index + 1];
-
-      if (value === undefined) {
-        throw new Error(`${name} requires a value`);
-      }
-
-      values.push(value);
-    }
-  }
-
-  return values;
-}
-
-function argValue(args: readonly string[], name: string): string | undefined {
-  const index = args.indexOf(name);
-
-  if (index === -1) {
-    return undefined;
-  }
-
-  const value = args[index + 1];
-
-  if (value === undefined) {
-    throw new Error(`${name} requires a value`);
-  }
-
-  return value;
-}
-
-function fixtureOutputName(path: string): string {
-  return basename(path).replace(/\.ndjson$/u, '');
-}
-
-function coverageSummary(
-  coverage: ReturnType<typeof extractAgentReplayCoverage>
-): Record<string, readonly string[]> {
-  return {
-    codexNotificationMethods: sorted(coverage.codexNotificationMethods),
-    codexRequestMethods: sorted(coverage.codexRequestMethods),
-    codexThreadItemTypes: sorted(coverage.codexThreadItemTypes),
-    claudeSdkMessageTags: sorted(coverage.claudeSdkMessageTags),
-    claudeContentBlockTypes: sorted(coverage.claudeContentBlockTypes),
-    claudeToolNames: sorted(coverage.claudeToolNames),
-  };
-}
-
-function sorted(values: ReadonlySet<string>): readonly string[] {
-  return Array.from(values).sort();
-}
-
-function printHelp(): void {
-  process.stdout.write(
-    `Usage: pnpm run replay:agent-fixture -- --fixture <path> [--fixture <path>...] [options]\n\nOptions:\n  --out-dir <path>         Artifact directory. Default: agent-replay-output\n  --coverage none|real|full Coverage gate. Default: full\n  --no-html                Do not write per-fixture playground HTML\n  --no-summary             Do not write summary.json\n\nExamples:\n  pnpm --filter @linzumi/cli run replay:agent-fixture -- \\\n    --fixture test/fixtures/agent-raw-replay/real-probe/codex.ndjson \\\n    --fixture test/fixtures/agent-raw-replay/real-probe/claude.ndjson \\\n    --coverage real \\\n    --out-dir /tmp/agent-replay-real\n`
-  );
-}
-
-main().catch((error) => {
-  process.stderr.write(
-    `${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`
-  );
-  process.exitCode = 1;
-});

package/scripts/typecheck.mjs

@@ -1,42 +0,0 @@
-// Strict typecheck gate for @linzumi/cli: ZERO errors AND ZERO warnings.
-//
-// `tsc --noEmit` exits non-zero on errors, but some diagnostics (e.g.
-// deprecated-option notices, future warning-class output, node runtime
-// warnings from the toolchain) can reach stdout/stderr while tsc still exits
-// 0. This wrapper treats ANY diagnostic output as a failure so the ratchet
-// can never silently loosen: a green check means tsc printed NOTHING.
-import { spawnSync } from 'node:child_process';
-import { createRequire } from 'node:module';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const packageDir = dirname(dirname(fileURLToPath(import.meta.url)));
-const require = createRequire(import.meta.url);
-// Resolve the workspace's own TypeScript (no PATH/npx ambiguity).
-const tscBin = join(dirname(require.resolve('typescript/package.json')), 'bin', 'tsc');
-
-const result = spawnSync(
-  process.execPath,
-  [tscBin, '--noEmit', '--pretty', 'false'],
-  { cwd: packageDir, encoding: 'utf8' }
-);
-
-const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
-
-if (output !== '') {
-  console.error(output);
-  console.error(
-    '\n[typecheck] FAILED: tsc produced diagnostic output above ' +
-      '(zero errors AND zero warnings required).'
-  );
-  process.exit(1);
-}
-
-if (result.status !== 0) {
-  console.error(
-    `[typecheck] FAILED: tsc exited ${result.status} with no output.`
-  );
-  process.exit(result.status ?? 1);
-}
-
-console.log('[typecheck] OK: zero errors, zero warnings.');

package/scripts/vm-smoke.mjs

@@ -1,241 +0,0 @@
-// Local-VM smoke: boot a real microVM via startVmCodexAppServer, drive a codex
-// `initialize` JSON-RPC round-trip through the reverse tunnel, prove the in-VM
-// codex's MODEL traffic actually reaches the Linzumi LLM proxy (a host-side stub
-// proxy in BOTH egress modes), then tear down and confirm `vm gc` reclaims the
-// machine.
-//
-// RUN (from packages/linzumi-cli, smolvm runtime installed via `linzumi vm setup`):
-//
-//   node scripts/vm-smoke.mjs
-//
-// Exit code is non-zero if the in-VM codex could NOT reach the model proxy, so
-// this doubles as a manual red/green check for the VM model-proxy routing path.
-//
-// WHY the model-proxy leg exists: the codex `initialize` round-trip rides the
-// host<->guest REVERSE TUNNEL (vmTunnel) and works regardless of how model
-// traffic is routed. The MODEL call is different: the in-guest codex dials the
-// model_provider.base_url itself. Under smolvm TSI, a guest dial to 127.0.0.1
-// lands on the HOST loopback, so a host-side stub at 127.0.0.1:<port> is the
-// faithful stand-in for the real (public) LLM proxy - and needs NO model creds.
-// This leg ASSERTS the stub received the in-guest model request, in OPEN and in
-// HARDENED egress mode, locking that proxy reachability is independent of the
-// egress allowlist (the V-invariant's live counterpart).
-//
-// BLIND SPOT this smoke does NOT cover (the #2111 RCA): the stub is PLAIN HTTP on
-// 127.0.0.1, so this leg proves the guest reaches the proxy IP+port but does NOT
-// exercise (a) TLS to a PUBLIC HTTPS host - which needs the guest CA bundle
-// (ca-certificates, added to guestProvisionCommand) - or (b) DNS resolution of a
-// public hostname - which needs a guest /etc/resolv.conf nameserver
-// (guestEnsureDnsCommand, run by the supervisor before codex starts). A guest
-// passing THIS smoke could still "No response" against the REAL proxy if either
-// were missing. To confirm those on an HVF Mac, run a REAL VM job against the
-// deployed preview and read the supervisor's GUEST-DIAGNOSTICS block (now dumped
-// to the runner log on a failed/closed turn) for any DNS/TLS error.
-//
-// TWO model-access paths, both mirroring RAW mode (the VM must support each):
-//   1. WAFER: route through the Linzumi LLM proxy. The model_provider.base_url +
-//      LINZUMI_LLM_PROXY_TOKEN are forwarded into the guest; this leg exercises
-//      exactly that dial (the stub stands in for the proxy).
-//   2. USER AUTH (native codex/Claude login): the in-guest codex must read the
-//      user's OWN ~/.codex/auth.json (ChatGPT OAuth tokens / OPENAI_API_KEY),
-//      forwarded into the guest tmpfs at $CODEX_HOME/auth.json (0600, scrubbed on
-//      teardown). buildVmSupervisorConfig.hostCodexAuthJson forwards it; the
-//      deterministic counterpart is vmModelProxyRouting.property.test's
-//      "user-auth path" invariant (auth.json forwarded in both egress modes).
-import { createServer } from 'node:http';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const here = dirname(fileURLToPath(import.meta.url));
-const pkgRoot = dirname(here);
-const cliEntry = join(pkgRoot, 'dist', 'index.js');
-
-// A host-side stub LLM proxy. The in-guest codex (TSI 127.0.0.1 -> host
-// loopback) dials this for any model request. It records that it was hit and
-// answers a minimal OpenAI-`responses`-shaped SSE so codex does not hard-error
-// before we have observed the hit. We only care that the request ARRIVED - that
-// is the proof the in-VM model route reached the proxy.
-function startStubProxy() {
-  const state = { hit: false, lastPath: undefined };
-  const server = createServer((req, res) => {
-    state.hit = true;
-    state.lastPath = req.url;
-    // Drain the body, then return a tiny SSE stream that completes immediately.
-    req.on('data', () => undefined);
-    req.on('end', () => {
-      res.writeHead(200, {
-        'content-type': 'text/event-stream',
-        'cache-control': 'no-cache',
-      });
-      res.write('event: response.completed\n');
-      res.write(
-        'data: {"type":"response.completed","response":{"id":"stub","output":[]}}\n\n'
-      );
-      res.end();
-    });
-  });
-  return new Promise((resolve) => {
-    server.listen(0, '127.0.0.1', () => {
-      const { port } = server.address();
-      resolve({
-        port,
-        wasHit: () => state.hit,
-        lastPath: () => state.lastPath,
-        close: () => server.close(),
-      });
-    });
-  });
-}
-
-// The model-provider config codex needs to dial the stub: a custom provider
-// whose base_url is the host stub (reached from the guest via TSI loopback).
-function stubModelProvider(stubPort) {
-  return {
-    id: 'linzumi',
-    name: 'Linzumi Proxy (smoke stub)',
-    baseUrl: `http://127.0.0.1:${stubPort}/v1`,
-    envKey: 'LINZUMI_LLM_PROXY_TOKEN',
-    wireApi: 'responses',
-  };
-}
-
-// Boot a VM in the given egress mode, drive a model turn, and report whether the
-// host stub proxy was hit by the in-guest codex's model request.
-async function probeModelProxyReachable({
-  startVmCodexAppServer,
-  connectCodexAppServer,
-  egressMode,
-}) {
-  const stub = await startStubProxy();
-  let started;
-  try {
-    // Hardened mode's fail-closed placeholder gate refuses to boot without a
-    // real allowlist override. Supply one that includes the host loopback (where
-    // the stub lives via TSI), so the hardened leg actually boots and we can
-    // assert proxy reachability is independent of the egress allowlist.
-    const env =
-      egressMode === 'hardened'
-        ? { ...process.env, LINZUMI_VM_EGRESS_CIDRS: '127.0.0.0/8,10.0.0.0/8' }
-        : process.env;
-    started = await startVmCodexAppServer({
-      cwd: pkgRoot,
-      kandanThreadId: undefined,
-      appServerOptions: {
-        mcpServers: [],
-        modelProvider: stubModelProvider(stub.port),
-      },
-      // A non-empty token so the guest env file carries LINZUMI_LLM_PROXY_TOKEN
-      // (the bearer codex sends to the proxy) - the stub does not validate it.
-      llmProxyToken: 'smoke-stub-token',
-      egressMode,
-      env,
-      supervisorScriptPath: cliEntry,
-    });
-
-    const client = await connectCodexAppServer(started.url);
-    // Drive a turn so codex makes a model request to base_url. The exact RPC
-    // shape varies by codex version; any turn-start triggers the model dial. We
-    // do not care about the codex-side result - only that the stub was hit.
-    try {
-      await client.request('thread/start', {});
-    } catch (_e) {
-      // Some codex versions name the turn RPC differently; the model dial may
-      // still have fired. Fall through to the stub-hit assertion either way.
-    }
-    // Give the in-guest model request a moment to land on the host stub.
-    await new Promise((r) => setTimeout(r, 3000));
-    client.close();
-    return { hit: stub.wasHit(), path: stub.lastPath() };
-  } finally {
-    if (started !== undefined) {
-      started.stop();
-    }
-    stub.close();
-    await new Promise((r) => setTimeout(r, 2000));
-  }
-}
-
-async function main() {
-  const { startVmCodexAppServer } = await import(
-    join(pkgRoot, 'src', 'vmSandbox', 'startVmCodexAppServer.ts')
-  );
-  const { connectCodexAppServer } = await import(
-    join(pkgRoot, 'src', 'codexAppServer.ts')
-  );
-
-  const t0 = Date.now();
-  console.log('[smoke] booting VM via startVmCodexAppServer...');
-  const started = await startVmCodexAppServer({
-    cwd: pkgRoot,
-    kandanThreadId: undefined,
-    appServerOptions: { mcpServers: [] },
-    llmProxyToken: undefined,
-    supervisorScriptPath: cliEntry,
-  });
-  console.log(
-    `[smoke] supervisor ready in ${Date.now() - t0}ms; url=${started.url} machine=${started.machineName}`
-  );
-
-  console.log(
-    '[smoke] connecting codex app-server client (does initialize)...'
-  );
-  const client = await connectCodexAppServer(started.url);
-  console.log('[smoke] initialize round-trip OK');
-
-  try {
-    const resp = await client.request('thread/list');
-    console.log(
-      '[smoke] thread/list responded:',
-      JSON.stringify(resp).slice(0, 200)
-    );
-  } catch (e) {
-    console.log(
-      '[smoke] thread/list errored (acceptable):',
-      String(e).slice(0, 200)
-    );
-  }
-
-  client.close();
-  console.log('[smoke] stopping initialize-leg supervisor...');
-  started.stop();
-  await new Promise((r) => setTimeout(r, 4000));
-
-  // MODEL-PROXY REACHABILITY LEG (open + hardened). The in-VM codex must reach
-  // the LLM proxy in BOTH egress modes - proxy reachability is independent of
-  // the egress allowlist. A "No response" turn looks exactly like the stub NOT
-  // being hit, so this is the faithful local repro for that class of failure.
-  let allReachable = true;
-  for (const egressMode of ['open', 'hardened']) {
-    console.log(`[smoke] model-proxy leg: booting VM in ${egressMode} mode...`);
-    const result = await probeModelProxyReachable({
-      startVmCodexAppServer,
-      connectCodexAppServer,
-      egressMode,
-    });
-    const verdict = result.hit ? 'yes' : 'no';
-    console.log(
-      `[smoke] MODEL-PROXY REACHABLE (${egressMode}): ${verdict}` +
-        (result.hit ? ` (path=${result.path})` : '')
-    );
-    allReachable = allReachable && result.hit;
-  }
-
-  if (!allReachable) {
-    console.error(
-      '[smoke] FAILED: the in-VM codex could NOT reach the model proxy in one ' +
-        'or more egress modes - this is the "No response" class of failure ' +
-        '(the model call never reached the Linzumi LLM proxy).'
-    );
-    process.exit(1);
-  }
-
-  console.log('[smoke] DONE-OK (model proxy reachable in open + hardened)');
-}
-
-main().then(
-  () => process.exit(0),
-  (err) => {
-    console.error('[smoke] FAILED:', err);
-    process.exit(1);
-  }
-);