@linzumi/cli 1.0.116 → 1.0.118

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

@@ -0,0 +1,313 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 13, onboarding - the gateway slice).
+// Relationship: Builds the TS-side PARITY ORACLE for the onboarding
+// gateway of the ReScript commander port, the sibling of
+// build-auth-parity-oracle.mjs (cluster 3). The oracle bundles the REAL TS
+// modules this slice ports - signupServerClient.ts's mission-control legs
+// (completeMissionControl / startMissionControlTasks) and oauth.ts's
+// browser loopback-callback flow (oauthCallbackTimeoutMs,
+// oauthCallbackHost, isPrivateCallbackHost, authorizationUrl,
+// exchangeCodeForToken, oauthResultHtml, escapeUrlForWindowsStart,
+// acquireLocalRunnerTokenDetails, fetchLocalRunnerStartTarget) - behind
+// the same one-shot stdin/stdout batch driver: a JSON array of cases in, a
+// JSON array of results out.
+//
+// FLOW cases carry a `serviceUrl`/`httpBaseUrl` pointing at the ReScript
+// parity suite's scripted auth HTTP server (ScriptedAuthServer.res), so
+// the REAL TS flow functions run their real fetch legs against the same
+// scripted wire the ReScript port runs against - outcome AND recorded
+// wire-transcript equivalence is asserted on both sides by
+// OnboardingGatewayParityConformance.res.
+//
+// The `browserAcquire` op is the REAL end-to-end loopback leg: it runs
+// acquireLocalRunnerTokenDetails with openAuthorizationUrl injected as a
+// deterministic scripted browser (the same plain-data call script the
+// ReScript suite drives), records every rendered callback page
+// (status + HTML bytes) plus the shape of the authorization URL, and lets
+// the flow's exchange hit the scripted token endpoint. The random state
+// nonce and ephemeral callback port never ride the comparison surface
+// (the conformance normalizes the port; the state is only ever echoed).
+//
+// Determinism: no clocks are consumed beyond timeouts injected per case.
+// SECRETS: the oracle only ever sees the conformance suite's synthetic
+// tokens/codes; nothing here logs case payloads.
+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 { createSignupServerClient } from './src/signupServerClient';
+import {
+  acquireLocalRunnerTokenDetails,
+  authorizationUrl,
+  escapeUrlForWindowsStart,
+  exchangeCodeForToken,
+  fetchLocalRunnerStartTarget,
+  isPrivateCallbackHost,
+  oauthCallbackHost,
+  oauthCallbackTimeoutMs,
+  oauthResultHtml,
+} from './src/oauth';
+
+// --- Shared plumbing (the cluster 3 conventions) -----------------------------------
+
+function outcome(run) {
+  try {
+    const value = run();
+    return value === undefined ? { defined: false } : { defined: true, value };
+  } catch (error) {
+    return errorOutcome(error);
+  }
+}
+
+async function outcomeAsync(run) {
+  try {
+    const value = await run();
+    return value === undefined ? { defined: false } : { defined: true, value };
+  } catch (error) {
+    return errorOutcome(error);
+  }
+}
+
+function errorOutcome(error) {
+  const shaped = {
+    threw: true,
+    message: error instanceof Error ? error.message : String(error),
+  };
+  if (error instanceof Error && error.name === 'SignupServerError') {
+    shaped.name = error.name;
+    shaped.status = error.status;
+    shaped.code = error.code;
+  }
+  return shaped;
+}
+
+// --- Pure transforms -----------------------------------------------------------------
+
+function handleCallbackTimeoutMs(testCase) {
+  return outcome(() =>
+    oauthCallbackTimeoutMs(testCase.override ?? undefined, testCase.env ?? {})
+  );
+}
+
+function handleCallbackHost(testCase) {
+  return outcome(() =>
+    oauthCallbackHost(testCase.kandanUrl, testCase.explicitHost ?? undefined)
+  );
+}
+
+function handlePrivateCallbackHost(testCase) {
+  return outcome(() => isPrivateCallbackHost(testCase.host));
+}
+
+function handleAuthorizationUrl(testCase) {
+  return outcome(() =>
+    authorizationUrl({
+      httpBaseUrl: testCase.httpBaseUrl,
+      redirectUri: testCase.redirectUri,
+      state: testCase.state,
+      workspaceSlug: testCase.workspaceSlug ?? undefined,
+      channelSlug: testCase.channelSlug ?? undefined,
+      onboarding: testCase.onboarding ?? undefined,
+      purpose: testCase.purpose ?? undefined,
+    })
+  );
+}
+
+function handleResultHtml(testCase) {
+  return outcome(() =>
+    oauthResultHtml({
+      title: testCase.title,
+      body: testCase.body,
+      status: testCase.status,
+    })
+  );
+}
+
+function handleWindowsStartUrl(testCase) {
+  return outcome(() => escapeUrlForWindowsStart(testCase.url));
+}
+
+// --- HTTP flow legs (against the scripted auth server) ----------------------------------
+
+async function handleMissionControlComplete(testCase) {
+  const client = createSignupServerClient({ serviceUrl: testCase.serviceUrl });
+  return outcomeAsync(() =>
+    client.completeMissionControl({
+      accessToken: testCase.accessToken,
+      workspaceName: testCase.workspaceName ?? undefined,
+      selectedProjectPaths: testCase.selectedProjectPaths,
+      starterProjectPath: testCase.starterProjectPath ?? undefined,
+      selectedTasks: testCase.selectedTasks,
+    })
+  );
+}
+
+async function handleMissionControlStartTasks(testCase) {
+  const client = createSignupServerClient({ serviceUrl: testCase.serviceUrl });
+  return outcomeAsync(() =>
+    client.startMissionControlTasks({
+      accessToken: testCase.accessToken,
+      workspaceSlug: testCase.workspaceSlug,
+      officeChannelSlug: testCase.officeChannelSlug,
+      runnerId: testCase.runnerId,
+      starterProjectPath: testCase.starterProjectPath,
+      threads: testCase.threads,
+      model: testCase.model ?? undefined,
+      reasoningEffort: testCase.reasoningEffort ?? undefined,
+    })
+  );
+}
+
+async function handleFetchStartTarget(testCase) {
+  return outcomeAsync(() =>
+    fetchLocalRunnerStartTarget({
+      kandanUrl: testCase.kandanUrl,
+      accessToken: testCase.accessToken,
+    })
+  );
+}
+
+async function handleExchangeCode(testCase) {
+  return outcomeAsync(() =>
+    exchangeCodeForToken({
+      httpBaseUrl: testCase.httpBaseUrl,
+      code: testCase.code,
+      redirectUri: testCase.redirectUri,
+    })
+  );
+}
+
+// --- The end-to-end browser loopback leg -------------------------------------------------
+
+// The scripted browser: for each call in the plain-data script, dial the
+// advertised redirect_uri with the scripted query ("$STATE" substitutes
+// the live state nonce) and record the rendered page. This loop is
+// mirrored byte-for-byte by the ReScript conformance's opener.
+async function runScriptedBrowser(authorizeUrl, calls, pages, openedShapes) {
+  const parsed = new URL(authorizeUrl);
+  const redirectUri = parsed.searchParams.get('redirect_uri') ?? '';
+  const state = parsed.searchParams.get('state') ?? '';
+  openedShapes.push({
+    origin: parsed.origin,
+    pathname: parsed.pathname,
+    keys: [...parsed.searchParams.keys()],
+    workspace: parsed.searchParams.get('workspace'),
+    channel: parsed.searchParams.get('channel'),
+    onboarding: parsed.searchParams.get('onboarding'),
+    purpose: parsed.searchParams.get('purpose'),
+    redirectHost: new URL(redirectUri).hostname,
+    redirectPath: new URL(redirectUri).pathname,
+  });
+  for (const call of calls) {
+    const target = new URL(redirectUri);
+    for (const [key, value] of call) {
+      target.searchParams.set(key, value === '$STATE' ? state : value);
+    }
+    try {
+      const response = await fetch(target);
+      pages.push({ status: response.status, body: await response.text() });
+    } catch (error) {
+      pages.push({
+        status: -1,
+        body: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+}
+
+async function handleBrowserAcquire(testCase) {
+  const pages = [];
+  const openedShapes = [];
+  const result = await outcomeAsync(() =>
+    acquireLocalRunnerTokenDetails({
+      kandanUrl: testCase.kandanUrl,
+      workspaceSlug: testCase.workspaceSlug ?? undefined,
+      channelSlug: testCase.channelSlug ?? undefined,
+      onboarding: testCase.onboarding ?? undefined,
+      purpose: testCase.purpose ?? undefined,
+      callbackHost: testCase.callbackHost ?? undefined,
+      waitForTokenTimeoutMs: testCase.waitForTokenTimeoutMs ?? undefined,
+      openAuthorizationUrl: (authorizeUrl) =>
+        runScriptedBrowser(authorizeUrl, testCase.calls ?? [], pages, openedShapes),
+    })
+  );
+  return { result, openedShapes, pages };
+}
+
+// --- Dispatch --------------------------------------------------------------------------------
+
+async function handle(testCase) {
+  switch (testCase.op) {
+    case 'callbackTimeoutMs':
+      return handleCallbackTimeoutMs(testCase);
+    case 'callbackHost':
+      return handleCallbackHost(testCase);
+    case 'privateCallbackHost':
+      return handlePrivateCallbackHost(testCase);
+    case 'authorizationUrl':
+      return handleAuthorizationUrl(testCase);
+    case 'resultHtml':
+      return handleResultHtml(testCase);
+    case 'windowsStartUrl':
+      return handleWindowsStartUrl(testCase);
+    case 'missionControlComplete':
+      return handleMissionControlComplete(testCase);
+    case 'missionControlStartTasks':
+      return handleMissionControlStartTasks(testCase);
+    case 'fetchStartTarget':
+      return handleFetchStartTarget(testCase);
+    case 'exchangeCode':
+      return handleExchangeCode(testCase);
+    case 'browserAcquire':
+      return handleBrowserAcquire(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 = [];
+// Sequential on purpose: the scripted server's per-route response queues
+// assume one case at a time.
+for (const testCase of cases) {
+  results.push(await handle(testCase));
+}
+process.stdout.write(JSON.stringify(results));
+`;
+
+// Renamed banner import (the build-differential-entry.mjs convention): this
+// bundle keeps source-level identifiers and the commander sources import
+// createRequire themselves - a bare banner name would collide.
+const banner = {
+  js: "import { createRequire as __onboardingGatewayOracleCreateRequire } from 'node:module';\nconst require = __onboardingGatewayOracleCreateRequire(import.meta.url);",
+};
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'onboarding-gateway-parity-driver.ts',
+    loader: 'ts',
+  },
+  banner,
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: join(packageRoot, '.differential/onboarding-gateway-parity-oracle.mjs'),
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  // oauth.ts pulls runnerLogger (and its graph); the same runtime externals
+  // as the differential entry build stay external (installed in this
+  // package's node_modules; the oracle only exercises the exports above).
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});