@linzumi/cli 1.0.116 → 1.0.118

package/scripts/build-onboarding-flow-parity-oracle.mjs

@@ -0,0 +1,562 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 13, onboarding).
+// Relationship: Builds the TS-side PARITY ORACLE for the signup-flow port -
+// the interactive first-run flow. ONE esbuild bundle imports the REAL
+// signup-flow module exports behind the cluster 1/2 stdin/stdout batch
+// driver (a JSON array of cases in, a JSON array of results out). The
+// ReScript package's OnboardingFlowParityConformance drives the SAME
+// inputs through src/onboarding/CommanderOnboarding* and asserts
+// byte-equal terminal transcripts, deep-equal recorded side effects, and
+// byte-equal debug launch payloads.
+//
+// The crown op is `flow_walk`: run the REAL runSignupFlow end-to-end with
+// fully scripted deps (prompt answer queues, scripted preflight tools,
+// scripted discovery/task/server/launcher seams, an in-memory draft
+// store, a fixed-width fake terminal) and return every byte the flow
+// wrote plus every recorded side effect. `flow_walk_tty` goes one layer
+// deeper: NO scripted prompts - the flow renders through the REAL
+// @inquirer/prompts + the raw-keypress project picker over scripted
+// PassThrough TTYs, driven by a seeded key schedule (the cluster 11
+// interactive-parity pattern). `picker_walk` drives the raw project
+// picker alone through a key schedule.
+//
+// Determinism: clocks never reach rendered output (the draft store
+// normalizes updatedAt; auth writes use pinned timestamps); scripted
+// scenarios use absolute scratch paths so the fs/git probes the flow runs
+// inline (project resolution, git emails) behave identically for both
+// impls over the same trees; each case runs in a fresh module-cache
+// process, and walk cases clear the git-head cache via the exported hook.
+//
+// SECRETS: scripted tokens are synthetic; the launch payload op exists
+// precisely to pin the [redacted] behavior byte-for-byte.
+//
+// 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 { PassThrough } from 'node:stream';
+import {
+  runSignupFlow,
+  signupHelpText,
+  signupPromptCancelMessage,
+  parseSignupTuiOptions,
+  signupAuthMatchesServiceUrl,
+  comparableServiceUrl,
+  autocompletePathSuggestions,
+  signupProjectPickerFrameForTest,
+  projectPickerKeyIsPrintableForTest,
+  toggleProjectPickerSelectionForTest,
+  signupEmailPickerChoiceNamesForTest,
+  signupSuggestedEmailIsUsefulForTest,
+  signupSpinnerLinesForTest,
+  signupTaskSuggestionWaitMessageForTest,
+  signupLaunchPayloadForTest,
+  clearSignupGitHeadSummaryCacheForTest,
+  signupProjectGitHeadForPathForTest,
+  signupDiscoverProjectsForStartForTest,
+  signupReadTaskCacheForTest,
+  resolveSignupCodexCommandForTest,
+  signupCodexTaskSuggestionProcessForTest,
+  signupSuggestTasksForProjectForTest,
+  runProjectPickerPromptForTest,
+} from './src/signupFlow';
+import { SignupServerError } from './src/signupServerClient';
+
+const orNull = (value) => (value === undefined ? null : value);
+
+// --- Scripted terminal ------------------------------------------------------------------
+
+function makeFakeWriter(columns) {
+  let bytes = '';
+  return {
+    writer: {
+      columns: columns === null ? undefined : columns,
+      write: (chunk) => {
+        bytes += chunk;
+        return true;
+      },
+    },
+    transcript: () => bytes,
+  };
+}
+
+// --- Scripted prompts ---------------------------------------------------------------------
+
+function makeScriptedPrompts(script, log) {
+  let index = 0;
+  const next = (kind, detail) => {
+    const entry = script[index];
+    index += 1;
+    if (entry === undefined) {
+      throw new Error('prompt script exhausted at ' + kind);
+    }
+    if (entry.kind !== kind) {
+      throw new Error('prompt script expected ' + entry.kind + ' got ' + kind);
+    }
+    log.push({ kind, detail });
+    if (entry.reject !== undefined) {
+      throw new Error(entry.reject);
+    }
+    return entry.value;
+  };
+  return {
+    input: async (args) => next('input', { message: args.message, defaultValue: args.defaultValue }),
+    projectPicker: async (args) =>
+      next('projectPicker', {
+        message: args.message,
+        projectPaths: args.projects.map((project) => project.path),
+        defaultSelectedPaths: args.defaultSelectedPaths,
+      }),
+    starterProjectPicker: async (args) =>
+      next('starterProjectPicker', {
+        message: args.message,
+        projectPaths: args.projects.map((project) => project.path),
+        defaultValue: args.defaultValue,
+      }),
+    emailPicker: async (args) =>
+      next('emailPicker', {
+        suggestedEmails: args.suggestedEmails,
+        defaultValue: args.defaultValue,
+      }),
+    checkbox: async (args) =>
+      next('checkbox', {
+        message: args.message,
+        choices: args.choices,
+        required: args.required,
+        minSelected: args.minSelected,
+        maxSelected: orNull(args.maxSelected),
+      }),
+    confirm: async (args) => next('confirm', { message: args.message, defaultValue: args.defaultValue }),
+  };
+}
+
+// --- Scripted server client -----------------------------------------------------------------
+
+function scriptedFailure(spec) {
+  if (spec.serverCode !== undefined) {
+    // The real client's structured-code error carries the code AS the
+    // message (signupServerClient's error split).
+    return new SignupServerError({
+      status: spec.status ?? 422,
+      code: spec.serverCode,
+      message: spec.serverCode,
+    });
+  }
+  return new Error(spec.message ?? 'scripted failure');
+}
+
+function makeScriptedClient(script, log) {
+  const take = (leg, detail) => {
+    const queue = script[leg] ?? [];
+    const entry = queue.shift();
+    log.push({ leg, detail });
+    if (entry === undefined) {
+      throw new Error('server script exhausted at ' + leg);
+    }
+    if (entry.failure !== undefined) {
+      throw scriptedFailure(entry.failure);
+    }
+    return entry.value;
+  };
+  return {
+    startEmailCode: async (args) => take('startEmailCode', args),
+    verifyEmailCode: async (args) => take('verifyEmailCode', args),
+    validateAuth: async (args) => take('validateAuth', { accessToken: '[recorded]' }),
+    completeMissionControl: async (args) => take('completeMissionControl', args),
+    startMissionControlTasks: async (args) => take('startMissionControlTasks', args),
+  };
+}
+
+// --- Scripted stores + seams -------------------------------------------------------------------
+
+function makeScriptedDraftStore(initial, writes) {
+  let draft = initial ?? undefined;
+  return {
+    read: () => draft,
+    write: (next) => {
+      draft = next;
+      writes.push({ ...next, updatedAt: '[normalized]' });
+    },
+    clear: () => {
+      draft = undefined;
+      writes.push('cleared');
+    },
+  };
+}
+
+function makePreflightRuntime(spec) {
+  const tools = spec.tools ?? {};
+  return {
+    cwd: spec.cwd,
+    homeDir: spec.homeDir,
+    probeTool: async (command) => {
+      const tool = tools[command];
+      if (tool === undefined) {
+        return { command, available: false };
+      }
+      return { command, available: tool.available, version: tool.version ?? undefined };
+    },
+    readGitEmail: async () => (spec.gitEmail === undefined ? undefined : spec.gitEmail),
+    discoverCodeRoots: async () => spec.codeRoots ?? [],
+    checkBrowserHandoff: async () => spec.browserHandoff !== false,
+    ...(spec.bundledCodexBin === undefined
+      ? {}
+      : { resolveBundledCodexBin: () => spec.bundledCodexBin }),
+  };
+}
+
+function reviveProjects(projects) {
+  return (projects ?? []).map((project) => ({
+    path: project.path,
+    language: project.language,
+    source: project.source,
+    ...(project.gitHead === undefined || project.gitHead === null
+      ? {}
+      : { gitHead: project.gitHead }),
+  }));
+}
+
+// --- flow_walk -------------------------------------------------------------------------------------
+
+async function handleFlowWalk(testCase) {
+  clearSignupGitHeadSummaryCacheForTest();
+  const { writer, transcript } = makeFakeWriter(testCase.columns ?? 80);
+  const promptLog = [];
+  const serverLog = [];
+  const draftWrites = [];
+  const authWrites = [];
+  const completionWrites = [];
+  const launcherCalls = [];
+  const openedUrls = [];
+  const scriptedClient =
+    testCase.server === undefined ? false : makeScriptedClient(testCase.server, serverLog);
+  const pinnedNow = '2026-07-14T00:00:00.000Z';
+  let outcome = { ok: true };
+  try {
+    await runSignupFlow({
+      input: { isTTY: testCase.inputIsTty === true },
+      output: writer,
+      prompts: makeScriptedPrompts(testCase.prompts ?? [], promptLog),
+      preflight: makePreflightRuntime(testCase.preflight),
+      projectDiscovery: {
+        discoverProjects: async () => reviveProjects(testCase.projects),
+      },
+      taskSuggestion: {
+        suggestTasks: async () => testCase.suggestedTasks ?? [],
+      },
+      forceSignup: testCase.forceSignup === true,
+      serviceUrl: testCase.serviceUrl,
+      ...(testCase.codeServerBin === undefined ? {} : { codeServerBin: testCase.codeServerBin }),
+      openBrowser: testCase.openBrowser !== false,
+      debugLaunchPayload: testCase.debugLaunchPayload !== false,
+      openUrl: async (url) => {
+        openedUrls.push(url);
+        if (testCase.openUrlFails === true) {
+          throw new Error('scripted open failure');
+        }
+      },
+      readSignupAuth: () => (testCase.existingAuth === undefined ? undefined : testCase.existingAuth),
+      readConfiguredProjectPaths: () => testCase.configuredPaths ?? [],
+      signupServerClient: scriptedClient,
+      commanderLauncher: async (args) => {
+        launcherCalls.push(args);
+        const launch = testCase.launch;
+        if (launch === undefined) {
+          throw new Error('scripted launcher without a launch result');
+        }
+        if (launch.throws !== undefined) {
+          throw new Error(launch.throws);
+        }
+        return launch;
+      },
+      signupDraftStore:
+        testCase.draft === undefined && testCase.useDraftStore !== true
+          ? false
+          : makeScriptedDraftStore(testCase.draft, draftWrites),
+      signupTaskCacheStore: false,
+      retryPolicy: false,
+      writeSignupAuth: (args) => {
+        authWrites.push(args.email);
+        return {
+          email: args.email,
+          serviceUrl: testCase.serviceUrl,
+          createdAt: pinnedNow,
+          updatedAt: pinnedNow,
+        };
+      },
+      writeSignupCompletion: (args) => {
+        completionWrites.push({
+          ...args,
+          accessToken: '[recorded]',
+          refreshToken: '[recorded]',
+        });
+        return {
+          email: args.email,
+          serviceUrl: args.serviceUrl,
+          accessToken: args.accessToken,
+          refreshToken: args.refreshToken,
+          ...(args.expiresInSeconds === undefined
+            ? {}
+            : { expiresInSeconds: args.expiresInSeconds }),
+          ...(args.userId === undefined ? {} : { userId: args.userId }),
+          ...(args.workspaceSlug === undefined ? {} : { workspaceSlug: args.workspaceSlug }),
+          ...(args.launchUrl === undefined ? {} : { launchUrl: args.launchUrl }),
+          createdAt: pinnedNow,
+          updatedAt: pinnedNow,
+        };
+      },
+    });
+  } catch (error) {
+    outcome = { ok: false, message: error instanceof Error ? error.message : String(error) };
+  }
+  return {
+    outcome,
+    transcript: transcript(),
+    promptLog,
+    serverLog,
+    draftWrites,
+    authWrites,
+    completionWrites,
+    launcherCalls,
+    openedUrls,
+  };
+}
+
+// --- Key-schedule plumbing (flow_walk_tty + picker_walk) ------------------------------------------
+
+function makeFakeTtyInput() {
+  const stream = new PassThrough();
+  stream.isTTY = true;
+  stream.setRawMode = () => stream;
+  return stream;
+}
+
+const NAMED_KEYS = {
+  up: '\\u001b[A',
+  down: '\\u001b[B',
+  left: '\\u001b[D',
+  right: '\\u001b[C',
+  tab: '\\t',
+  enter: '\\r',
+  space: ' ',
+  backspace: '\\u007f',
+  'ctrl-c': '\\u0003',
+};
+
+function keyBytes(key) {
+  if (key.startsWith('text:')) {
+    return key.slice(5);
+  }
+  const bytes = NAMED_KEYS[key];
+  if (bytes === undefined) {
+    throw new Error('unknown scheduled key ' + key);
+  }
+  return bytes;
+}
+
+const settle = () => new Promise((resolve) => setTimeout(resolve, 15));
+
+async function driveSchedule(input, schedule) {
+  for (const key of schedule) {
+    await settle();
+    input.write(keyBytes(key));
+  }
+  await settle();
+}
+
+async function handlePickerWalk(testCase) {
+  clearSignupGitHeadSummaryCacheForTest();
+  const input = makeFakeTtyInput();
+  const { writer, transcript } = makeFakeWriter(testCase.columns ?? 80);
+  // The outcome handler attaches BEFORE the schedule drives: a ctrl-c
+  // cancellation rejects mid-schedule, and an unhandled rejection would
+  // take the whole oracle process down.
+  const guarded = runProjectPickerPromptForTest(input, writer, {
+    message: testCase.message,
+    projects: reviveProjects(testCase.projects),
+    defaultSelectedPaths: testCase.defaultSelectedPaths ?? [],
+  }).then(
+    (selected) => ({ ok: true, selected }),
+    (error) => ({ ok: false, message: error instanceof Error ? error.message : String(error) })
+  );
+  await driveSchedule(input, testCase.schedule ?? []);
+  return { outcome: await guarded, transcript: transcript() };
+}
+
+// --- Unit ops ----------------------------------------------------------------------------------------
+
+async function handle(testCase) {
+  switch (testCase.op) {
+    case 'help_text':
+      return signupHelpText();
+    case 'cancel_message':
+      return orNull(signupPromptCancelMessage(new Error(testCase.message)));
+    case 'parse_options':
+      try {
+        const options = parseSignupTuiOptions(testCase.args);
+        return {
+          ok: true,
+          serviceUrl: options.serviceUrl,
+          forceSignup: options.forceSignup,
+          codeServerBin: orNull(options.codeServerBin),
+          openBrowser: options.openBrowser,
+          debugLaunchPayload: options.debugLaunchPayload,
+        };
+      } catch (error) {
+        return { ok: false, message: error instanceof Error ? error.message : String(error) };
+      }
+    case 'auth_matches':
+      return signupAuthMatchesServiceUrl(testCase.auth, testCase.serviceUrl);
+    case 'comparable_url':
+      return comparableServiceUrl(testCase.value);
+    case 'autocomplete':
+      return autocompletePathSuggestions(testCase.pathInput);
+    case 'picker_frame':
+      return signupProjectPickerFrameForTest({
+        columns: testCase.columns,
+        projects: reviveProjects(testCase.projects),
+        selectedPaths: testCase.selectedPaths,
+      });
+    case 'printable_key':
+      return projectPickerKeyIsPrintableForTest(
+        testCase.value === null ? undefined : testCase.value
+      );
+    case 'toggle_selection':
+      return toggleProjectPickerSelectionForTest({
+        pathInput: testCase.state.pathInput,
+        cursor: testCase.state.cursor,
+        highlightIndex: testCase.state.highlightIndex,
+        selectedPaths: testCase.state.selectedPaths,
+        highlightedPath:
+          testCase.state.highlightedPath === null ? undefined : testCase.state.highlightedPath,
+      });
+    case 'email_picker_choices':
+      return signupEmailPickerChoiceNamesForTest(testCase.suggestedEmails);
+    case 'useful_email':
+      return signupSuggestedEmailIsUsefulForTest(testCase.email);
+    case 'spinner_lines':
+      return signupSpinnerLinesForTest(testCase.mark, testCase.message, testCase.columns);
+    case 'wait_message':
+      return signupTaskSuggestionWaitMessageForTest(testCase.projectPath);
+    case 'launch_payload':
+      return JSON.stringify(signupLaunchPayloadForTest(testCase.state), null, 2);
+    case 'project_git_head': {
+      clearSignupGitHeadSummaryCacheForTest();
+      return orNull(signupProjectGitHeadForPathForTest(testCase.path));
+    }
+    case 'discover_projects': {
+      clearSignupGitHeadSummaryCacheForTest();
+      return signupDiscoverProjectsForStartForTest({
+        homeDir: testCase.homeDir,
+        cwd: testCase.cwd,
+      }).map((project) => ({
+        path: project.path,
+        language: project.language,
+        source: project.source,
+        gitHead: orNull(project.gitHead),
+      }));
+    }
+    case 'read_task_cache':
+      return signupReadTaskCacheForTest(testCase.path);
+    case 'resolve_codex_command':
+      try {
+        return {
+          ok: true,
+          command: await resolveSignupCodexCommandForTest({
+            env: testCase.env,
+            homeDir: testCase.homeDir,
+            executablePaths: testCase.executablePaths,
+          }),
+        };
+      } catch (error) {
+        return { ok: false, message: error instanceof Error ? error.message : String(error) };
+      }
+    case 'codex_process': {
+      const spec = signupCodexTaskSuggestionProcessForTest(testCase.args);
+      return {
+        command: spec.command,
+        args: spec.args,
+        cwd: spec.cwd,
+        stdin: spec.stdin,
+        timeoutMs: spec.timeoutMs,
+        env: orNull(spec.env),
+      };
+    }
+    case 'suggest_tasks_cached': {
+      const { writer, transcript } = makeFakeWriter(testCase.columns ?? 80);
+      const cacheWrites = [];
+      const runnerCalls = [];
+      const store = {
+        read: (key) => {
+          runnerCalls.push({ read: key });
+          const entry = (testCase.cache ?? {})[key];
+          return entry === undefined ? undefined : entry;
+        },
+        write: (key, tasks) => {
+          cacheWrites.push({ key, tasks });
+        },
+      };
+      const tasks = await signupSuggestTasksForProjectForTest({
+        project: reviveProjects([testCase.project])[0],
+        output: writer,
+        taskCacheStore: store,
+        codexTaskRunner: async () => testCase.runnerTasks ?? [],
+      });
+      return { tasks, transcript: transcript(), cacheWrites, runnerCalls };
+    }
+    case 'flow_walk':
+      return handleFlowWalk(testCase);
+    case 'picker_walk':
+      return handlePickerWalk(testCase);
+    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);
+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 });
+
+// Renamed banner import (the build-auth-parity-oracle.mjs convention): CJS
+// transitive deps (@inquirer's yoctocolors) require() node builtins at
+// module scope, and a bare `createRequire` name would collide with modules
+// that import it themselves.
+const banner = {
+  js: "import { createRequire as __onboardingFlowOracleCreateRequire } from 'node:module';\nconst require = __onboardingFlowOracleCreateRequire(import.meta.url);",
+};
+
+await build({
+  banner,
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'onboarding-flow-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: join(packageRoot, '.differential/onboarding-flow-parity-oracle.mjs'),
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});