@linzumi/cli 1.0.272 → 1.0.274

package/scripts/build-core-lock-parity-oracle.mjs

@@ -1,462 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 10, runner core - the workspace lock + operator takeover flow).
-// Relationship: Builds the TS-side PARITY ORACLE for the commander
-// workspace-lock port, the sibling of build-config-identity-parity-oracle.mjs
-// (cluster 2). The oracle bundles the REAL runnerLock.ts +
-// runnerLockTakeover.ts behind a one-shot batch driver: a JSON array of cases
-// on stdin, a JSON array of results on stdout. The ReScript package's
-// CoreLockParityConformance drives the SAME inputs through
-// src/core/CommanderLock.res / CommanderLockTakeover.res in its own scratch
-// directories and asserts accept/reject/value equivalence, pinned contract
-// error strings, log/prompt/signal trace parity AND byte-identical lock-file
-// trees - the cross-impl contract that lets both commanders share the
-// ~/.linzumi/runners locks through M4.
-//
-// Determinism: every source of nondeterminism is pinned per case - the clock
-// is a scripted per-case cell read through the injected `now`, pid liveness
-// is a scripted set, SIGKILL/SIGTERM outcomes are scripted (per-pid /
-// per-signal failure codes), prompts are scripted answer queues, and the
-// takeover waits run on a virtual clock advanced by the injected `sleep`.
-// Scratch paths are normalized through the "$DIR" placeholder in both
-// directions.
-//
-// Like the sibling oracles, 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,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  realpathSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, relative } from 'node:path';
-import {
-  acquireIncomingGenerationRunnerLock,
-  acquireRunnerLock,
-  assessRunnerLockHolder,
-  compareCliVersions,
-  electronAutoConnectLaunchSource,
-  incomingGenerationRunnerLockPath,
-  readRunnerLockOwner,
-  RunnerLockHeldError,
-  runnerLockHeartbeatIntervalMs,
-  runnerLockHeldErrorName,
-  runnerLockPath,
-  runnerLockTakeoverAfterMs,
-  shouldAutoTakeOverForUpdate,
-} from './src/runnerLock';
-import {
-  isRunnerLockConflictReportedError,
-  resolveRunnerLockConflict,
-  RunnerLockConflictReportedError,
-  runnerLockConflictReport,
-  runnerLockConflictReportedErrorName,
-  runnerLockTakeoverForcefulStopMs,
-  runnerLockTakeoverGracefulStopMs,
-  runnerLockTakeoverPollMs,
-  runnerLockTakeoverSleep,
-  shouldResolveRunnerLockConflict,
-} from './src/runnerLockTakeover';
-
-// --- Placeholder + snapshot plumbing --------------------------------------------
-
-const dirPlaceholder = '$DIR';
-
-function scratch() {
-  // realpath so macOS /var -> /private/var never splits the two impls'
-  // placeholder substitution.
-  return realpathSync(mkdtempSync(join(tmpdir(), 'linzumi-core-lock-oracle-')));
-}
-
-function substitute(value, from, to) {
-  if (typeof value === 'string') {
-    return value.split(from).join(to);
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => substitute(entry, from, to));
-  }
-  if (typeof value === 'object' && value !== null) {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [
-        substitute(key, from, to),
-        substitute(entry, from, to),
-      ])
-    );
-  }
-  return value;
-}
-
-function snapshotFiles(dir) {
-  const files = {};
-  const walk = (current) => {
-    for (const name of readdirSync(current).sort()) {
-      const full = join(current, name);
-      if (statSync(full).isDirectory()) {
-        walk(full);
-      } else {
-        files[relative(dir, full)] = readFileSync(full, 'utf8');
-      }
-    }
-  };
-  walk(dir);
-  return files;
-}
-
-function outcome(run) {
-  try {
-    const value = run();
-    return value === undefined ? { defined: false } : { defined: true, value };
-  } catch (error) {
-    return {
-      threw: true,
-      name: error instanceof Error ? error.name : 'Error',
-      message: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-// --- Pure surfaces ----------------------------------------------------------------
-
-function handleLockPath(testCase) {
-  const dir = scratch();
-  const configPath = join(dir, 'config.json');
-  const result = outcome(() =>
-    runnerLockPath(testCase.machineId, configPath, testCase.linzumiUrl)
-  );
-  return substitute(result, dir, dirPlaceholder);
-}
-
-function handleAssessHolder(testCase) {
-  const alive = new Set(testCase.alivePids ?? []);
-  return outcome(() =>
-    assessRunnerLockHolder(
-      testCase.record,
-      (pid) => alive.has(pid),
-      () => new Date(testCase.nowMs)
-    )
-  );
-}
-
-function handleShouldAutoTakeOver(testCase) {
-  return outcome(() =>
-    shouldAutoTakeOverForUpdate(
-      testCase.existing,
-      testCase.myVersion,
-      testCase.myLaunchSource,
-      testCase.holderState
-    )
-  );
-}
-
-function handleHeldMessage(testCase) {
-  return outcome(() => {
-    const error = new RunnerLockHeldError(testCase.lockPath, testCase.record);
-    return { name: error.name, message: error.message };
-  });
-}
-
-async function handleConstants() {
-  await runnerLockTakeoverSleep(0);
-  const reported = new RunnerLockConflictReportedError();
-  return {
-    heartbeatIntervalMs: runnerLockHeartbeatIntervalMs,
-    takeoverAfterMs: runnerLockTakeoverAfterMs,
-    heldErrorName: runnerLockHeldErrorName,
-    electronAutoConnectLaunchSource,
-    gracefulStopMs: runnerLockTakeoverGracefulStopMs,
-    forcefulStopMs: runnerLockTakeoverForcefulStopMs,
-    pollMs: runnerLockTakeoverPollMs,
-    conflictReportedErrorName: runnerLockConflictReportedErrorName,
-    conflictReportedError: {
-      name: reported.name,
-      message: reported.message,
-      guard: isRunnerLockConflictReportedError(reported),
-    },
-    sleepResolved: true,
-  };
-}
-
-// --- Lock lifecycle ------------------------------------------------------------------
-
-function handleLockLifecycle(testCase) {
-  const dir = scratch();
-  const configPath = join(dir, 'config.json');
-  const actions = substitute(testCase.actions ?? [], dirPlaceholder, dir);
-  const killFailures = testCase.killFailures ?? {};
-  let clockMs = 0;
-  const alive = new Set();
-  const events = [];
-  const handles = new Map();
-  const now = () => new Date(clockMs);
-  const isPidAlive = (pid) => alive.has(pid);
-  const killPid = (pid) => {
-    events.push({ type: 'kill', pid });
-    const code = killFailures[String(pid)];
-    if (code !== undefined) {
-      const error = new Error(code);
-      error.code = code;
-      throw error;
-    }
-    alive.delete(pid);
-  };
-  const onTakeover = (takeover) => {
-    events.push({
-      type: 'takeover',
-      lockPath: takeover.lockPath,
-      holderPid: takeover.holderPid,
-      holderRunnerId: takeover.holderRunnerId,
-      reason: takeover.reason,
-    });
-  };
-  const runSetup = (setup) => {
-    for (const sub of setup ?? []) {
-      runAction(sub);
-    }
-  };
-  const acquireOptions = (action) => ({
-    machineId: action.machineId,
-    runnerId: action.runnerId,
-    cwd: action.cwd,
-    workspace: action.workspace ?? null,
-    ...(action.linzumiUrl === undefined ? {} : { linzumiUrl: action.linzumiUrl }),
-    configPath,
-    pid: action.pid,
-    ...(action.launchSource === undefined ? {} : { launchSource: action.launchSource }),
-    ...(action.processGroupLeader === undefined
-      ? {}
-      : { processGroupLeader: action.processGroupLeader }),
-    now,
-    isPidAlive,
-    cliVersion: action.cliVersion,
-    ...(action.gracefulUpdateDrain === undefined
-      ? {}
-      : { gracefulUpdateDrain: action.gracefulUpdateDrain }),
-    killPid,
-    onTakeover,
-    ...(action.beforeReadExistingLock === undefined
-      ? {}
-      : { beforeReadExistingLock: () => runSetup(action.beforeReadExistingLock) }),
-    ...(action.beforeReplaceStaleLock === undefined
-      ? {}
-      : { beforeReplaceStaleLock: () => runSetup(action.beforeReplaceStaleLock) }),
-  });
-  const runAction = (action) => {
-    switch (action.act) {
-      case 'setClock':
-        return outcome(() => {
-          clockMs = action.ms;
-        });
-      case 'setAlive':
-        return outcome(() => {
-          alive.clear();
-          for (const pid of action.pids) {
-            alive.add(pid);
-          }
-        });
-      case 'mkdir':
-        return outcome(() => {
-          mkdirSync(action.path, { recursive: true });
-        });
-      case 'writeFile':
-        return outcome(() => writeFileSync(action.path, action.contents, 'utf8'));
-      case 'unlink':
-        return outcome(() => unlinkSync(action.path));
-      case 'acquire':
-        return outcome(() => {
-          const handle = acquireRunnerLock(acquireOptions(action));
-          handles.set(action.id, handle);
-          return { path: handle.path };
-        });
-      case 'acquireIncoming':
-        return outcome(() => {
-          const handle = acquireIncomingGenerationRunnerLock({
-            ...acquireOptions(action),
-            handoffHolderPid: action.handoffHolderPid,
-          });
-          handles.set(action.id, handle);
-          return { path: handle.path, promoted: handle.promoted() };
-        });
-      case 'heartbeat':
-        return outcome(() => handles.get(action.id).heartbeat());
-      case 'release':
-        return outcome(() => handles.get(action.id).release());
-      case 'promote':
-        return outcome(() => handles.get(action.id).promote());
-      case 'promoted':
-        return outcome(() => handles.get(action.id).promoted());
-      case 'handlePath':
-        return outcome(() => handles.get(action.id).path);
-      case 'readOwner':
-        return outcome(() => readRunnerLockOwner(action.path));
-      default:
-        return { threw: true, name: 'Error', message: 'unknown lock action ' + String(action.act) };
-    }
-  };
-  const results = actions.map((action) => runAction(action));
-  return substitute(
-    { results, files: snapshotFiles(dir), events },
-    dir,
-    dirPlaceholder
-  );
-}
-
-// --- Takeover flow ----------------------------------------------------------------------
-
-async function handleTakeoverFlow(testCase) {
-  const holder = testCase.holder;
-  const schedule = testCase.schedule ?? {};
-  let virtualMs = schedule.startMs ?? 0;
-  const sleeps = [];
-  const signals = [];
-  const reports = [];
-  const questions = [];
-  const logs = [];
-  const answers = [...(testCase.promptAnswers ?? [])];
-  const signalFailures = testCase.signalFailures ?? {};
-  const lockReleased = () =>
-    schedule.lockReleasedAtMs !== undefined && virtualMs >= schedule.lockReleasedAtMs;
-  const deps = {
-    isPidAlive: (pid) =>
-      pid < 0 && schedule.groupDeadAtMs !== undefined
-        ? virtualMs < schedule.groupDeadAtMs
-        : schedule.pidDeadAtMs === undefined
-          ? true
-          : virtualMs < schedule.pidDeadAtMs,
-    signalPid: (pid, signal) => {
-      signals.push({ pid, signal, atMs: virtualMs });
-      const code = signalFailures[signal];
-      if (code !== undefined) {
-        const error = new Error('scripted ' + signal + ' failure');
-        error.code = code;
-        throw error;
-      }
-    },
-    lockReleased,
-    currentLockOwner: () => {
-      if (schedule.ownerChange !== undefined && virtualMs >= schedule.ownerChange.atMs) {
-        return schedule.ownerChange.owner === null ? undefined : schedule.ownerChange.owner;
-      }
-      return holder;
-    },
-    sleep: (ms) => {
-      sleeps.push(ms);
-      virtualMs += ms;
-      return Promise.resolve();
-    },
-    now: () => virtualMs,
-    log: (event, payload) => {
-      logs.push({ event, payload });
-    },
-  };
-  const prompt = {
-    isInteractive: () => testCase.interactive === true,
-    writeReport: (text) => {
-      reports.push(text);
-    },
-    promptYesNo: (question) => {
-      questions.push(question);
-      return Promise.resolve(answers.length > 0 ? answers.shift() === true : false);
-    },
-  };
-  let result;
-  try {
-    const value = await resolveRunnerLockConflict({
-      holder,
-      lockPath: testCase.lockPath,
-      baseMessage: testCase.baseMessage,
-      takeOverWithoutPrompt: testCase.takeOverWithoutPrompt === true,
-      prompt,
-      takeover: deps,
-    });
-    result = { defined: true, value };
-  } catch (error) {
-    result = {
-      threw: true,
-      name: error instanceof Error ? error.name : 'Error',
-      message: error instanceof Error ? error.message : String(error),
-    };
-  }
-  return { outcome: result, sleeps, signals, reports, questions, logs, endMs: virtualMs };
-}
-
-// --- Dispatch --------------------------------------------------------------------------------
-
-async function handle(testCase) {
-  switch (testCase.op) {
-    case 'constants':
-      return await handleConstants();
-    case 'lockPath':
-      return handleLockPath(testCase);
-    case 'incomingPath':
-      return outcome(() => incomingGenerationRunnerLockPath(testCase.primaryPath));
-    case 'compareVersions':
-      return outcome(() => compareCliVersions(testCase.a, testCase.b));
-    case 'assessHolder':
-      return handleAssessHolder(testCase);
-    case 'shouldAutoTakeOver':
-      return handleShouldAutoTakeOver(testCase);
-    case 'heldMessage':
-      return handleHeldMessage(testCase);
-    case 'conflictReport':
-      return outcome(() => runnerLockConflictReport(testCase.baseMessage));
-    case 'shouldResolve':
-      return outcome(() =>
-        shouldResolveRunnerLockConflict(testCase.defined === true ? {} : undefined)
-      );
-    case 'lockLifecycle':
-      return handleLockLifecycle(testCase);
-    case 'takeoverFlow':
-      return await handleTakeoverFlow(testCase);
-    default:
-      return { threw: true, name: 'Error', 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);
-const results = [];
-for (const testCase of cases) {
-  results.push(await handle(testCase));
-}
-process.stdout.write(JSON.stringify(results));
-`;
-
-await mkdir(join(packageRoot, '.differential'), { recursive: true });
-
-await build({
-  stdin: {
-    contents: driverSource,
-    resolveDir: packageRoot,
-    sourcefile: 'core-lock-parity-driver.ts',
-    loader: 'ts',
-  },
-  bundle: true,
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  outfile: join(packageRoot, '.differential/core-lock-parity-oracle.mjs'),
-  minify: false,
-  sourcemap: false,
-  legalComments: 'none',
-  // runnerLock.ts pulls localConfig/oauth; the same runtime externals as the
-  // sibling oracle builds stay external (installed in this package's
-  // node_modules; the oracle only exercises the lock/takeover exports).
-  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
-});