@linzumi/cli 1.0.93 → 1.0.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.93",
+  "version": "1.0.95",
   "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-protocol-parity-oracle.mjs

@@ -0,0 +1,192 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 1, protocol-types).
+// Relationship: Builds the TS-side PARITY ORACLE for the protocol/type
+// cluster of the ReScript commander port. The oracle bundles the REAL TS
+// protocol modules (protocol.ts, json.ts, localCodexMessageState.ts,
+// terminalFailureRetry.ts, localConfig.ts) behind a one-shot batch driver:
+// it reads a JSON array of cases on stdin and writes a JSON array of
+// results on stdout. The ReScript package's parity conformance
+// (packages/linzumi-cli-rescript/src/parity/ProtocolParityConformance.res)
+// drives the SAME inputs through the sury schemas/functions and asserts
+// accept/reject/normalized-output equivalence - so the two protocol layers
+// cannot drift silently.
+//
+// Like build-differential-entry.mjs, the output is a local test artifact
+// (.differential/ is gitignored, never published) and stays unminified for
+// debuggability.
+import { 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 { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  isJsonObject,
+  parseJsonObject,
+  requireString,
+  requirePositiveInteger,
+  extractCodexIds,
+} from './src/protocol';
+import {
+  objectValue,
+  arrayValue,
+  stringValue,
+  integerValue,
+  stringListValue,
+  parseJsonObjectOrUndefined,
+} from './src/json';
+import {
+  approvalRequestKey,
+  codexApprovalMessageState,
+  fleetBreakerHoldReason,
+  parkedAsOwnTurnQueuedReason,
+  parkedAsOwnTurnReasonDetail,
+  processingReasonForCodexNotification,
+  queuedBehindEarlierMessagesReason,
+  queuedBehindRunningTurnReason,
+  queuedBehindReasonPrefix,
+  queuedBehindRunningTurnReasonPrefix,
+  resumingAfterStreamStallReason,
+  steeredIntoRunningTurnReason,
+} from './src/localCodexMessageState';
+import { parseFleetBreakerPayload } from './src/fleetBreaker';
+import {
+  fateRetryable,
+  isTerminalFailureFate,
+  terminalFailureClasses,
+  terminalFailureFate,
+  terminalFailureFates,
+  terminalFailureRetryableStamp,
+} from './src/terminalFailureRetry';
+import { readLocalConfig, readLocalSignupAuth } from './src/localConfig';
+
+const jsonHelpers = {
+  isJsonObject,
+  parseJsonObject,
+  requireString,
+  requirePositiveInteger,
+  extractCodexIds,
+  objectValue,
+  arrayValue,
+  stringValue,
+  integerValue,
+  stringListValue,
+  parseJsonObjectOrUndefined,
+};
+
+const messageStateFns = {
+  approvalRequestKey,
+  codexApprovalMessageState,
+  parkedAsOwnTurnQueuedReason,
+  parkedAsOwnTurnReasonDetail,
+  processingReasonForCodexNotification,
+  queuedBehindEarlierMessagesReason,
+  queuedBehindRunningTurnReason,
+};
+
+// Encode a call outcome so undefined stays distinguishable from null after
+// JSON serialization.
+function outcome(run) {
+  try {
+    const value = run();
+    return value === undefined ? { defined: false } : { defined: true, value };
+  } catch (error) {
+    return { threw: true, message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function handle(testCase) {
+  switch (testCase.op) {
+    case 'jsonHelper': {
+      const fn = jsonHelpers[testCase.fn];
+      if (fn === undefined) {
+        return { threw: true, message: 'unknown jsonHelper ' + testCase.fn };
+      }
+      return outcome(() => fn(...testCase.args));
+    }
+    case 'messageState': {
+      const fn = messageStateFns[testCase.fn];
+      if (fn === undefined) {
+        return { threw: true, message: 'unknown messageState fn ' + testCase.fn };
+      }
+      return outcome(() => fn(...testCase.args));
+    }
+    case 'constants':
+      return {
+        resumingAfterStreamStallReason,
+        steeredIntoRunningTurnReason,
+        queuedBehindReasonPrefix,
+        queuedBehindRunningTurnReasonPrefix,
+        fleetBreakerHoldReason,
+      };
+    case 'fleetBreakerParse':
+      return outcome(() => parseFleetBreakerPayload(testCase.value));
+    case 'fateTables': {
+      const retryableByFate = {};
+      for (const fate of terminalFailureFates) {
+        retryableByFate[fate] = fateRetryable(fate);
+      }
+      const fateByClass = {};
+      const stampByClass = {};
+      for (const failureClass of terminalFailureClasses) {
+        fateByClass[failureClass] = terminalFailureFate(failureClass);
+        stampByClass[failureClass] = terminalFailureRetryableStamp(failureClass);
+      }
+      return {
+        fates: [...terminalFailureFates],
+        retryableByFate,
+        classes: [...terminalFailureClasses],
+        fateByClass,
+        stampByClass,
+      };
+    }
+    case 'isFate':
+      return outcome(() => isTerminalFailureFate(testCase.value));
+    case 'localConfig': {
+      const dir = mkdtempSync(join(tmpdir(), 'linzumi-protocol-parity-'));
+      const path = join(dir, 'config.json');
+      writeFileSync(path, testCase.contents, 'utf8');
+      const config = outcome(() => readLocalConfig(path));
+      const signupAuth = outcome(() => readLocalSignupAuth(path));
+      return { config, signupAuth };
+    }
+    default:
+      return { threw: true, message: 'unknown op ' + String(testCase.op) };
+  }
+}
+
+let stdin = '';
+process.stdin.setEncoding('utf8');
+for await (const chunk of process.stdin) {
+  stdin += chunk;
+}
+const cases = JSON.parse(stdin);
+process.stdout.write(JSON.stringify(cases.map(handle)));
+`;
+
+await mkdir(join(packageRoot, '.differential'), { recursive: true });
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'protocol-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: join(packageRoot, '.differential/protocol-parity-oracle.mjs'),
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  // The protocol modules are dependency-light; anything that leaks in from
+  // the wider commander graph stays external exactly like the entry build.
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});