@linzumi/cli 1.0.106 → 1.0.108

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.106",
+  "version": "1.0.108",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {

package/scripts/build-harness-codex-parity-oracle.mjs

@@ -0,0 +1,465 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 7, harness-codex-adapter / workstream H.2).
+// Relationship: Builds the TS-side PARITY ORACLE for the codex-adapter
+// cluster of the ReScript commander port, the sibling of
+// build-session-registry-parity-oracle.mjs (cluster 6). The oracle bundles
+// the REAL TS codex-adapter surface - the app-server module's exported
+// builders (argv/config/env/provider args, stdio, the forwardable-key
+// resolver), the isolated-codex-home module (config.toml, the auth.json
+// carry-through, the effective-auth probes), the parent-death watchdog
+// module (program bytes, config codec, the reap trigger), the shared
+// engine-child reaper, the dev-server reap-exemption read slice, the
+// attach-wait module (tracker semantics, bounded-wait error text, the
+// rollout probe), the runtime-options mapping (approval-policy gates,
+// thread/turn override rendering), the turn-fate status classifier, and
+// runner.ts's exported thread-start runtime param renderer +
+// resumeCodexThreadForReconnect - behind two drivers:
+//
+//   * the cluster 1/2 one-shot BATCH driver (a JSON array of cases on
+//     stdin, a JSON array of results on stdout) for the pure transforms;
+//   * a --flow line driver (the cluster 4 transport-oracle convention:
+//     one JSON op per stdin line, {id,...} replies + {obs:...} events on
+//     stdout) that runs the REAL connectCodexAppServer client - and the
+//     REAL resumeCodexThreadForReconnect recovery flow - against a live
+//     scripted codex app-server double URL, for the dual-impl wire
+//     differential in @linzumi/commander-harness.
+//
+// Determinism: clocks are injected per case (the tracker takes now()), the
+// scratch dirs ride the case inputs, and nothing here reads wall time
+// except the flow driver's transport waits (sequenced on awaited replies).
+//
+// SECRETS: the oracle only ever sees the conformance suite's synthetic
+// payloads; auth flow cases use distinctive synthetic credentials minted by
+// the suite. The output is a local test artifact (.differential/ is
+// gitignored, never published) and stays unminified for debuggability.
+import { copyFile, mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+const driverSource = `
+import {
+  codexAppServerArgs,
+  codexAppServerConfigArgs,
+  codexAppServerStdio,
+  codexModelProviderConfigArgs,
+  connectCodexAppServer,
+  resolveForwardableOpenAiApiKey,
+} from './src/codexAppServer';
+import {
+  codexCredentialStoreFileArgs,
+  ensureIsolatedCodexHome,
+  inheritUserCodexAuth,
+  isolatedCodexHomePath,
+  resolveOpenAiAuthState,
+  userCodexHomePath,
+} from './src/codexHome';
+import {
+  encodeParentDeathWatchdogConfig,
+  parseParentDeathWatchdogConfig,
+  parentDeathWatchdogProgram,
+  parentDeathWatchdogShouldReap,
+  parentDeathWatchdogSpawn,
+} from './src/engineParentDeathWatchdog';
+import {
+  killProcessGroupWithProtectedListeners,
+  parsePidPgidRows,
+  protectedListenerFreshnessMs,
+  readProtectedPidsFromDir,
+} from './src/devServerReapExemption';
+import {
+  CODEX_ATTACH_WAIT_HARD_CAP_MS,
+  CODEX_ATTACH_WAIT_HEARTBEAT_MS,
+  CodexAttachWaitHardCapError,
+  CodexAttachWaitNoProgressError,
+  CodexSessionAttachFailedError,
+  awaitCodexSessionAttach,
+  codexAttachWaitHardCapMs,
+  codexRolloutFileBytesForThread,
+  createCodexAttachProgressTracker,
+} from './src/codexAttachWait';
+import {
+  codexApprovalPolicyForRequest,
+  codexThreadRuntimeOverrides,
+  codexTurnRuntimeOverrides,
+  codexWireApprovalPolicy,
+} from './src/codexRuntimeOptions';
+import { upstreamHttpStatusFate } from './src/terminalFailureRetry';
+import {
+  codexThreadStartRuntimeParams,
+  resumeCodexThreadForReconnect,
+} from './src/runner';
+import { readFileSync, statSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+
+function tryCall(run) {
+  try {
+    return { ok: true, value: run() };
+  } catch (error) {
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : String(error),
+      name: error instanceof Error ? error.name : 'Error',
+    };
+  }
+}
+
+function fileSnapshot(path) {
+  try {
+    return {
+      exists: true,
+      contents: readFileSync(path, 'utf8'),
+      mode: statSync(path).mode & 0o777,
+    };
+  } catch {
+    return { exists: false };
+  }
+}
+
+function runCase(input) {
+  switch (input.kind) {
+    case 'appServerArgs':
+      return codexAppServerArgs(input.listenUrl, input.options ?? {});
+    case 'configArgs':
+      return codexAppServerConfigArgs(input.options ?? {});
+    case 'modelProviderArgs':
+      return codexModelProviderConfigArgs(input.provider);
+    case 'credentialStoreArgs':
+      return [...codexCredentialStoreFileArgs()];
+    case 'stdio':
+      return codexAppServerStdio();
+    case 'watchdogProgram':
+      return parentDeathWatchdogProgram();
+    case 'watchdogEncode':
+      return encodeParentDeathWatchdogConfig(input.config);
+    case 'watchdogParse':
+      return tryCall(() => parseParentDeathWatchdogConfig(input.raw));
+    case 'watchdogShouldReap':
+      return parentDeathWatchdogShouldReap(input.originalParentPid, input.currentParentPid);
+    case 'watchdogSpawn':
+      return parentDeathWatchdogSpawn(input.nodeExecPath, input.config);
+    case 'parsePidPgidRows':
+      return parsePidPgidRows(input.output);
+    case 'freshnessMs':
+      return protectedListenerFreshnessMs;
+    case 'readProtectedPids':
+      return [...readProtectedPidsFromDir(input.dir, input.nowMs)].sort((a, b) => a - b);
+    case 'groupKill': {
+      const kills = [];
+      const outcome = killProcessGroupWithProtectedListeners(
+        input.groupLeaderPid,
+        input.signal,
+        (pid, signal) => {
+          kills.push({ pid, signal });
+          const failure = (input.killFailures ?? {})[String(pid)];
+          if (failure !== undefined) {
+            const error = new Error(failure);
+            error.code = failure;
+            throw error;
+          }
+        },
+        () => (input.groupPids === null ? undefined : input.groupPids),
+        new Set(input.protectedPids ?? [])
+      );
+      return {
+        mode: outcome.mode,
+        sparedPids: [...outcome.sparedPids],
+        failureCodes: outcome.failures.map((failure) =>
+          failure.error instanceof Error && 'code' in failure.error
+            ? { pid: failure.pid, code: failure.error.code }
+            : { pid: failure.pid, code: null }
+        ),
+        kills: kills.sort((a, b) => a.pid - b.pid),
+      };
+    }
+    case 'attachConstants':
+      return {
+        hardCapMs: CODEX_ATTACH_WAIT_HARD_CAP_MS,
+        heartbeatMs: CODEX_ATTACH_WAIT_HEARTBEAT_MS,
+        hardCapOfEnv: codexAttachWaitHardCapMs(),
+      };
+    case 'attachMessages':
+      return {
+        attachFailed: new CodexSessionAttachFailedError(
+          input.method,
+          input.codexThreadId,
+          input.failure
+        ).message,
+        noProgress: new CodexAttachWaitNoProgressError({
+          method: input.method,
+          codexThreadId: input.codexThreadId,
+          timeoutMs: input.timeoutMs,
+          waitedMs: input.waitedMs,
+          blocker: input.blocker,
+          rollout: input.rollout,
+        }).message,
+        hardCap: new CodexAttachWaitHardCapError({
+          method: input.method,
+          codexThreadId: input.codexThreadId,
+          hardCapMs: input.hardCapMs,
+          blocker: input.blocker,
+          rollout: input.rollout,
+        }).message,
+      };
+    case 'attachTracker': {
+      // Scripted note/fail/clear/snapshot sequence with an injected clock.
+      let nowMs = 0;
+      const tracker = createCodexAttachProgressTracker(() => nowMs);
+      const snapshots = [];
+      for (const op of input.ops) {
+        nowMs = op.nowMs ?? nowMs;
+        if (op.op === 'note') tracker.note(op.id, op.stage, op.detail ?? undefined);
+        if (op.op === 'fail') tracker.fail(op.id, op.failure);
+        if (op.op === 'clear') tracker.clear(op.id);
+        if (op.op === 'snapshot') {
+          const snapshot = tracker.snapshot(op.id);
+          snapshots.push(
+            snapshot === undefined
+              ? null
+              : {
+                  stage: snapshot.stage,
+                  detail: snapshot.detail ?? null,
+                  atMs: snapshot.atMs,
+                  failure: snapshot.failure ?? null,
+                }
+          );
+        }
+      }
+      return snapshots;
+    }
+    case 'attachWaitOutcome': {
+      // The bounded wait driven with a scripted clock: the underlying wait
+      // never settles, so the poller's verdict (fail-fast, no-progress,
+      // hard cap) is the observable. Poll cadence 1ms against a virtual
+      // clock stepped by the poll itself.
+      let nowMs = 0;
+      const tracker = createCodexAttachProgressTracker(() => nowMs);
+      for (const op of input.ops ?? []) {
+        nowMs = op.nowMs ?? nowMs;
+        if (op.op === 'note') tracker.note(input.codexThreadId, op.stage, op.detail ?? undefined);
+        if (op.op === 'fail') tracker.fail(input.codexThreadId, op.failure);
+      }
+      nowMs = input.startMs ?? 0;
+      const logs = [];
+      return awaitCodexSessionAttach({
+        method: input.method,
+        codexThreadId: input.codexThreadId,
+        wait: new Promise(() => {}),
+        tracker,
+        log: (event, payload) => logs.push({ event, payload }),
+        rolloutBytes: () => input.rolloutBytes ?? undefined,
+        noProgressTimeoutMs: input.noProgressTimeoutMs,
+        hardCapMs: input.hardCapMs,
+        heartbeatMs: input.heartbeatMs,
+        pollMs: 1,
+        now: () => {
+          nowMs += input.msPerPoll ?? 25;
+          return nowMs;
+        },
+      }).then(
+        () => ({ settled: 'resolved', logs }),
+        (error) => ({
+          settled: 'rejected',
+          name: error instanceof Error ? error.name : 'Error',
+          message: error instanceof Error ? error.message : String(error),
+          heartbeats: logs.length,
+        })
+      );
+    }
+    case 'rolloutBytes':
+      return codexRolloutFileBytesForThread(input.codexHome, input.codexThreadId) ?? null;
+    case 'approvalPolicyForRequest':
+      return tryCall(() =>
+        codexApprovalPolicyForRequest(input.approvalPolicy ?? undefined, input.sandbox ?? undefined, {
+          sandboxedNeverDefault: input.sandboxedNeverDefault,
+        })
+      );
+    case 'wireApprovalPolicy':
+      return tryCall(() =>
+        codexWireApprovalPolicy(input.approvalPolicy ?? undefined, input.sandbox ?? undefined, {
+          sandboxedNeverDefault: input.sandboxedNeverDefault,
+        })
+      );
+    case 'threadRuntimeOverrides':
+      return tryCall(() => codexThreadRuntimeOverrides(input.options));
+    case 'turnRuntimeOverrides':
+      return tryCall(() => codexTurnRuntimeOverrides(input.options));
+    case 'threadStartRuntimeParams':
+      return tryCall(() => codexThreadStartRuntimeParams(input.runtimeSettings));
+    case 'statusFate':
+      return upstreamHttpStatusFate(input.status);
+    case 'isolatedHomePath':
+      return isolatedCodexHomePath(input.env ?? {});
+    case 'userHomePath':
+      return userCodexHomePath(input.env ?? {});
+    case 'ensureIsolatedHome': {
+      const home = ensureIsolatedCodexHome(input.env ?? {});
+      return { home, config: fileSnapshot(home + '/config.toml') };
+    }
+    case 'inheritAuth': {
+      const installed = inheritUserCodexAuth(input.isolatedHome, input.env ?? {});
+      return { installed, dest: fileSnapshot(input.isolatedHome + '/auth.json') };
+    }
+    case 'authState':
+      return resolveOpenAiAuthState(input.env ?? {});
+    case 'forwardableKey':
+      return resolveForwardableOpenAiApiKey(input.env ?? {}) ?? null;
+    default:
+      return { unknownCase: input.kind };
+  }
+}
+
+async function runBatch() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const cases = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+  const results = [];
+  for (const item of cases) {
+    const outcome = runCase(item);
+    if (outcome instanceof Promise) {
+      // The attach-wait poller is unref'd by design; hold the event loop
+      // open while the case settles or node would exit mid-await.
+      const keepAlive = setInterval(() => {}, 1000);
+      try {
+        results.push(await outcome);
+      } finally {
+        clearInterval(keepAlive);
+      }
+    } else {
+      results.push(outcome);
+    }
+  }
+  process.stdout.write(JSON.stringify(results));
+}
+
+// --- The flow driver (the dual-impl wire differential's TS leg) -------------
+
+async function runFlow() {
+  let client;
+  const obs = [];
+  const emit = (entry) => process.stdout.write(JSON.stringify({ obs: entry }) + '\\n');
+  const reply = (id, payload) =>
+    process.stdout.write(JSON.stringify({ id, ...payload }) + '\\n');
+
+  const rl = createInterface({ input: process.stdin });
+  for await (const line of rl) {
+    if (line.trim() === '') continue;
+    const op = JSON.parse(line);
+    try {
+      switch (op.op) {
+        case 'connect': {
+          client = await connectCodexAppServer(op.url);
+          client.onNotification((message) =>
+            emit({ kind: 'notification', method: message.method, params: message.params ?? null })
+          );
+          client.onClose?.(() => emit({ kind: 'closed' }));
+          reply(op.id, { ok: true });
+          break;
+        }
+        case 'armApproval': {
+          client.onRequest?.((request) => {
+            emit({ kind: 'server_request', method: request.method, params: request.params ?? null });
+            return { decision: op.decision };
+          });
+          reply(op.id, { ok: true });
+          break;
+        }
+        case 'request': {
+          const response = await client.request(op.method, op.params ?? undefined);
+          emit({ kind: 'reply', method: op.method, response });
+          reply(op.id, { ok: true });
+          break;
+        }
+        case 'resumeReconnect': {
+          const outcome = await resumeCodexThreadForReconnect(
+            client,
+            op.codexThreadId,
+            op.resumeOverrides ?? {},
+            {
+              forceRehydrate: op.forceRehydrate === true,
+              buildRehydrationText: async () => op.rehydrationText ?? 'scripted rehydration text',
+              log: (event, payload) => emit({ kind: 'log', event, payload }),
+            }
+          ).then(
+            (value) => ({ ok: true, value }),
+            (error) => ({
+              ok: false,
+              message: error instanceof Error ? error.message : String(error),
+            })
+          );
+          emit({ kind: 'resume_outcome', outcome });
+          reply(op.id, { ok: true });
+          break;
+        }
+        case 'close': {
+          client?.close();
+          reply(op.id, { ok: true });
+          rl.close();
+          return;
+        }
+        default:
+          reply(op.id, { ok: false, error: 'unknown op ' + op.op });
+      }
+    } catch (error) {
+      reply(op.id, {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+}
+
+if (process.argv.includes('--flow')) {
+  runFlow().then(
+    () => process.exit(0),
+    (error) => {
+      process.stderr.write(String(error && error.stack ? error.stack : error) + '\\n');
+      process.exit(1);
+    }
+  );
+} else {
+  runBatch().then(
+    () => process.exit(0),
+    (error) => {
+      process.stderr.write(String(error && error.stack ? error.stack : error) + '\\n');
+      process.exit(1);
+    }
+  );
+}
+`;
+
+const outDir = join(packageRoot, '.differential');
+const outPath = join(outDir, 'harness-codex-parity-oracle.mjs');
+
+await mkdir(outDir, { recursive: true });
+// runner.ts's graph resolves assets/ relative to the bundle at import time
+// (the hello-project scaffold's inlined logo), so the asset must sit next
+// to the emitted oracle - the build-auth-parity-oracle precedent.
+await mkdir(join(outDir, 'assets'), { recursive: true });
+await copyFile(
+  join(packageRoot, 'src/assets/linzumi-logo.svg'),
+  join(outDir, 'assets/linzumi-logo.svg')
+);
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'harness-codex-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: outPath,
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  logLevel: 'silent',
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});
+
+process.stdout.write(outPath + '\n');