happy-stacks 0.2.0 → 0.4.0

package/scripts/review.mjs

@@ -0,0 +1,217 @@
+import './utils/env/env.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { getComponentDir, getRootDir } from './utils/paths/paths.mjs';
+import { getInvokedCwd, inferComponentFromCwd } from './utils/cli/cwd_scope.mjs';
+import { assertCliPrereqs } from './utils/cli/prereqs.mjs';
+import { resolveBaseRef } from './utils/review/base_ref.mjs';
+import { isStackMode, resolveDefaultStackReviewComponents } from './utils/review/targets.mjs';
+import { runWithConcurrencyLimit } from './utils/proc/parallel.mjs';
+import { runCodeRabbitReview } from './utils/review/runners/coderabbit.mjs';
+import { extractCodexReviewFromJsonl, runCodexReview } from './utils/review/runners/codex.mjs';
+
+const DEFAULT_COMPONENTS = ['happy', 'happy-cli', 'happy-server-light', 'happy-server'];
+const VALID_COMPONENTS = DEFAULT_COMPONENTS;
+const VALID_REVIEWERS = ['coderabbit', 'codex'];
+
+function parseCsv(raw) {
+  return String(raw ?? '')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function normalizeReviewers(list) {
+  const raw = Array.isArray(list) ? list : [];
+  const lower = raw.map((r) => String(r).trim().toLowerCase()).filter(Boolean);
+  const uniq = Array.from(new Set(lower));
+  return uniq.length ? uniq : ['coderabbit'];
+}
+
+function usage() {
+  return [
+    '[review] usage:',
+    '  happys review [component...] [--reviewers=coderabbit,codex] [--base-remote=<remote>] [--base-branch=<branch>] [--base-ref=<ref>] [--concurrency=N] [--json]',
+    '',
+    'components:',
+    `  ${VALID_COMPONENTS.join(' | ')}`,
+    '',
+    'reviewers:',
+    `  ${VALID_REVIEWERS.join(' | ')}`,
+    '',
+    'notes:',
+    '- If run from inside a component checkout/worktree and no components are provided, defaults to that component.',
+    '- In stack mode (invoked via `happys stack review <stack>`), if no components are provided, defaults to stack-pinned non-default components only.',
+    '',
+    'examples:',
+    '  happys review',
+    '  happys review happy-cli --reviewers=coderabbit,codex',
+    '  happys stack review exp1 --reviewers=codex',
+    '  happys review happy --base-remote=upstream --base-branch=main',
+  ].join('\n');
+}
+
+function resolveComponentFromCwdOrNull({ rootDir, invokedCwd }) {
+  return inferComponentFromCwd({ rootDir, invokedCwd, components: DEFAULT_COMPONENTS });
+}
+
+function stackRemoteFallbackFromEnv(env) {
+  return String(env.HAPPY_STACKS_STACK_REMOTE ?? env.HAPPY_LOCAL_STACK_REMOTE ?? '').trim();
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({ json, data: { usage: usage() }, text: usage() });
+    return;
+  }
+
+  const rootDir = getRootDir(import.meta.url);
+  const invokedCwd = getInvokedCwd(process.env);
+  const positionals = argv.filter((a) => !a.startsWith('--'));
+
+  const reviewers = normalizeReviewers(parseCsv(kv.get('--reviewers') ?? ''));
+  for (const r of reviewers) {
+    if (!VALID_REVIEWERS.includes(r)) {
+      throw new Error(`[review] unknown reviewer: ${r} (expected one of: ${VALID_REVIEWERS.join(', ')})`);
+    }
+  }
+
+  await assertCliPrereqs({
+    git: true,
+    coderabbit: reviewers.includes('coderabbit'),
+    codex: reviewers.includes('codex'),
+  });
+
+  const inferred = positionals.length === 0 ? resolveComponentFromCwdOrNull({ rootDir, invokedCwd }) : null;
+  if (inferred) {
+    // Make downstream getComponentDir() resolve to the inferred repo dir for this run.
+    process.env[`HAPPY_STACKS_COMPONENT_DIR_${inferred.component.toUpperCase().replace(/[^A-Z0-9]+/g, '_')}`] = inferred.repoDir;
+  }
+
+  const inStackMode = isStackMode(process.env);
+  const requestedComponents = positionals.length ? positionals : inferred ? [inferred.component] : ['all'];
+  const wantAll = requestedComponents.includes('all');
+
+  let components = wantAll ? DEFAULT_COMPONENTS : requestedComponents;
+  if (!positionals.length && !inferred && inStackMode) {
+    const pinned = resolveDefaultStackReviewComponents({ rootDir, components: DEFAULT_COMPONENTS });
+    components = pinned.length ? pinned : [];
+  }
+
+  for (const c of components) {
+    if (!VALID_COMPONENTS.includes(c)) {
+      throw new Error(`[review] unknown component: ${c} (expected one of: ${VALID_COMPONENTS.join(', ')})`);
+    }
+  }
+
+  if (!components.length) {
+    const msg = inStackMode ? '[review] no non-default stack-pinned components to review' : '[review] no components selected';
+    printResult({ json, data: { ok: true, skipped: true, reason: msg }, text: msg });
+    return;
+  }
+
+  const baseRefOverride = (kv.get('--base-ref') ?? '').trim();
+  const baseRemoteOverride = (kv.get('--base-remote') ?? '').trim();
+  const baseBranchOverride = (kv.get('--base-branch') ?? '').trim();
+  const stackRemoteFallback = stackRemoteFallbackFromEnv(process.env);
+  const concurrency = (kv.get('--concurrency') ?? '').trim();
+  const limit = concurrency ? Number(concurrency) : 4;
+
+  const jobs = [];
+  for (const component of components) {
+    const repoDir = getComponentDir(rootDir, component);
+    jobs.push({ component, repoDir });
+  }
+
+  const jobResults = await runWithConcurrencyLimit({
+    items: jobs,
+    limit,
+    fn: async (job) => {
+      const { component, repoDir } = job;
+      const base = await resolveBaseRef({
+        cwd: repoDir,
+        baseRefOverride,
+        baseRemoteOverride,
+        baseBranchOverride,
+        stackRemoteFallback,
+      });
+
+      const perReviewer = await Promise.all(
+        reviewers.map(async (reviewer) => {
+          if (reviewer === 'coderabbit') {
+            const res = await runCodeRabbitReview({ repoDir, baseRef: base.baseRef, env: process.env });
+            return {
+              reviewer,
+              ok: Boolean(res.ok),
+              exitCode: res.exitCode,
+              signal: res.signal,
+              durationMs: res.durationMs,
+              stdout: res.stdout ?? '',
+              stderr: res.stderr ?? '',
+            };
+          }
+          if (reviewer === 'codex') {
+            const res = await runCodexReview({ repoDir, baseRef: base.baseRef, env: process.env, jsonMode: true });
+            const extracted = extractCodexReviewFromJsonl(res.stdout ?? '');
+            return {
+              reviewer,
+              ok: Boolean(res.ok),
+              exitCode: res.exitCode,
+              signal: res.signal,
+              durationMs: res.durationMs,
+              stdout: res.stdout ?? '',
+              stderr: res.stderr ?? '',
+              review_output: extracted,
+            };
+          }
+          return { reviewer, ok: false, exitCode: null, signal: null, durationMs: 0, stdout: '', stderr: 'unknown reviewer\n' };
+        })
+      );
+
+      return { component, repoDir, base, results: perReviewer };
+    },
+  });
+
+  const ok = jobResults.every((r) => r.results.every((x) => x.ok));
+  if (json) {
+    printResult({ json, data: { ok, reviewers, components, results: jobResults } });
+    if (!ok) process.exit(1);
+    return;
+  }
+
+  const lines = [];
+  lines.push('[review] results:');
+  for (const r of jobResults) {
+    lines.push('============================================================================');
+    lines.push(`component: ${r.component}`);
+    lines.push(`dir: ${r.repoDir}`);
+    lines.push(`baseRef: ${r.base.baseRef}`);
+    for (const rr of r.results) {
+      lines.push('');
+      const status = rr.ok ? '✅ ok' : '❌ failed';
+      lines.push(`[${rr.reviewer}] ${status} (exit=${rr.exitCode ?? 'null'} durMs=${rr.durationMs ?? '?'})`);
+      if (rr.stderr) {
+        lines.push('--- stderr ---');
+        lines.push(String(rr.stderr).trimEnd());
+      }
+      if (rr.stdout) {
+        lines.push('--- stdout ---');
+        lines.push(String(rr.stdout).trimEnd());
+      }
+    }
+    lines.push('');
+  }
+  lines.push(ok ? '[review] ok' : '[review] failed');
+  printResult({ json: false, text: lines.join('\n') });
+  if (!ok) process.exit(1);
+}
+
+main().catch((err) => {
+  console.error('[review] failed:', err);
+  process.exit(1);
+});
+

package/scripts/review_pr.mjs

@@ -0,0 +1,368 @@
+import './utils/env/env.mjs';
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { getRootDir } from './utils/paths/paths.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
+import { getVerbosityLevel } from './utils/cli/verbosity.mjs';
+import { createStepPrinter } from './utils/cli/progress.mjs';
+import { prompt, promptSelect, withRl } from './utils/cli/wizard.mjs';
+import { assertCliPrereqs } from './utils/cli/prereqs.mjs';
+import { randomToken } from './utils/crypto/tokens.mjs';
+import { inferPrStackBaseName } from './utils/stack/pr_stack_name.mjs';
+import { sanitizeStackName } from './utils/stack/names.mjs';
+import { listReviewPrSandboxes, reviewPrSandboxPrefixPath, writeReviewPrSandboxMeta } from './utils/sandbox/review_pr_sandbox.mjs';
+ 
+function supportsAnsi() {
+  if (!process.stdout.isTTY) return false;
+  if (process.env.NO_COLOR) return false;
+  if ((process.env.TERM ?? '').toLowerCase() === 'dumb') return false;
+  return true;
+}
+
+function bold(s) {
+  return supportsAnsi() ? `\x1b[1m${s}\x1b[0m` : String(s);
+}
+
+function dim(s) {
+  return supportsAnsi() ? `\x1b[2m${s}\x1b[0m` : String(s);
+}
+
+function cyan(s) {
+  return supportsAnsi() ? `\x1b[36m${s}\x1b[0m` : String(s);
+}
+
+function usage() {
+  return [
+    '[review-pr] usage:',
+    '  happys review-pr --happy=<pr-url|number> [--happy-cli=<pr-url|number>] [--happy-server=<pr-url|number>|--happy-server-light=<pr-url|number>] [--name=<stack>] [--dev|--start] [--mobile|--no-mobile] [--forks|--upstream] [--seed-auth|--no-seed-auth] [--copy-auth-from=<stack>] [--link-auth|--copy-auth] [--update] [--force] [--keep-sandbox] [--json] [-- <stack dev/start args...>]',
+    '',
+    'What it does:',
+    '- creates a temporary sandbox dir',
+    '- runs `happys setup-pr ...` inside that sandbox (fully isolated state)',
+    '- on exit (including Ctrl+C): stops sandbox processes and deletes the sandbox dir',
+  ].join('\n');
+}
+ 
+function waitForExit(child) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    child.on('error', rejectPromise);
+    child.on('close', (code, signal) => resolvePromise({ code: code ?? 1, signal: signal ?? null }));
+  });
+}
+ 
+async function tryStopSandbox({ rootDir, sandboxDir }) {
+  const bin = join(rootDir, 'bin', 'happys.mjs');
+  const child = spawn(process.execPath, [bin, '--sandbox-dir', sandboxDir, 'stop', '--yes', '--aggressive', '--sweep-owned', '--no-service'], {
+    cwd: rootDir,
+    env: process.env,
+    stdio: 'ignore',
+  });
+  await waitForExit(child);
+}
+ 
+function argvHasFlag(argv, names) {
+  for (const n of names) {
+    if (argv.includes(n)) return true;
+  }
+  return false;
+}
+
+function kvValue(argv, names) {
+  for (const a of argv) {
+    for (const n of names) {
+      if (a === n) {
+        return '';
+      }
+      if (a.startsWith(`${n}=`)) {
+        return a.slice(`${n}=`.length);
+      }
+    }
+  }
+  return null;
+}
+
+async function main() {
+  const rootDir = getRootDir(import.meta.url);
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const verbosity = getVerbosityLevel(process.env);
+  const steps = createStepPrinter({ enabled: Boolean(process.stdout.isTTY && !json && verbosity === 0) });
+ 
+  if (wantsHelp(argv, { flags })) {
+    printResult({ json, data: { usage: usage() }, text: usage() });
+    return;
+  }
+ 
+  await assertCliPrereqs({ git: true, pnpm: true });
+
+  // Determine a stable base stack name from PR inputs (used for sandbox discovery),
+  // and a per-run unique stack name by default (prevents browser storage collisions across deleted sandboxes).
+  const prHappy = (kvValue(argv, ['--happy']) ?? '').trim();
+  const prCli = (kvValue(argv, ['--happy-cli']) ?? '').trim();
+  const prServer = (kvValue(argv, ['--happy-server']) ?? '').trim();
+  const prServerLight = (kvValue(argv, ['--happy-server-light']) ?? '').trim();
+  const explicitName = (kvValue(argv, ['--name']) ?? '').trim();
+
+  const baseStackName = explicitName
+    ? sanitizeStackName(explicitName, { fallback: 'pr', maxLen: 64 })
+    : inferPrStackBaseName({ happy: prHappy, happyCli: prCli, server: prServer, serverLight: prServerLight, fallback: 'pr' });
+
+  const shouldAutoSuffix = !explicitName;
+  const uniqueSuffix = randomToken(4); // short, URL-safe-ish
+  const newStackName = shouldAutoSuffix
+    ? sanitizeStackName(`${baseStackName}-${uniqueSuffix}`, { fallback: baseStackName, maxLen: 64 })
+    : baseStackName;
+
+  // Look for leftover sandboxes for the same PR base name (typically due to --keep-sandbox / failures).
+  const canPrompt = Boolean(process.stdout.isTTY && process.stdin.isTTY && !json);
+  const existingSandboxes = canPrompt ? await listReviewPrSandboxes({ baseStackName }) : [];
+
+  if (process.stdout.isTTY && !json) {
+    const intro = [
+      '',
+      '',
+      bold(`✨ ${cyan('Happy Stacks')} review-pr ✨`),
+      '',
+      'It will help you review a PR for Happy in a completely isolated environment.',
+      dim('Uses `happy-server-light` (no Redis, no Postgres, no Docker).'),
+      dim('Desktop browser + optional mobile review (Expo dev-client).'),
+      '',
+      bold('What will happen:'),
+      `- ${cyan('sandbox')}: temporary isolated Happy install`,
+      `- ${cyan('components')}: clone/install (inside the sandbox only)`,
+      `- ${cyan('start')}: start the Happy stack in sandbox (server, daemon, web, mobile)`,
+      `- ${cyan('login')}: guide you through Happy login for this sandbox`,
+      `- ${cyan('browser')}: open the Happy web app`,
+      `- ${cyan('mobile')}: start Expo dev-client (optional)`,
+      `- ${cyan('cleanup')}: stop processes + delete sandbox on exit`,
+      '',
+      dim('Everything is deleted automatically when you exit.'),
+      dim('Your main Happy installation remains untouched.'),
+      '',
+      dim('Tips:'),
+      dim('- Add `-v` / `-vv` / `-vvv` to show the full logs'),
+      dim('- Add `--keep-sandbox` to keep the sandbox directory between runs'),
+      '',
+      existingSandboxes.length
+        ? bold('Choose how to proceed') + dim(' (or Ctrl+C to cancel).')
+        : bold('Press Enter to proceed') + dim(' (or Ctrl+C to cancel).'),
+    ].join('\n');
+    // eslint-disable-next-line no-console
+    console.log(intro);
+    if (!existingSandboxes.length) {
+      await withRl(async (rl) => {
+        await prompt(rl, '', { defaultValue: '' });
+      });
+    }
+  }
+
+  let sandboxDir = '';
+  let createdNewSandbox = false;
+  let reusedSandboxMeta = null;
+
+  if (existingSandboxes.length) {
+    const picked = await withRl(async (rl) => {
+      const options = [
+        { label: 'Create a new sandbox (recommended)', value: 'new' },
+        ...existingSandboxes.map((s) => {
+          const stackLabel = s.stackName ? `stack=${s.stackName}` : 'stack=?';
+          return { label: `Reuse existing sandbox (${stackLabel}) — ${s.dir}`, value: s.dir };
+        }),
+      ];
+      return await promptSelect(rl, {
+        title: 'Review-pr sandbox:',
+        options,
+        defaultIndex: 0,
+      });
+    });
+    if (picked === 'new') {
+      steps.start('create temporary sandbox');
+      const prefix = reviewPrSandboxPrefixPath(baseStackName);
+      sandboxDir = resolve(await mkdtemp(prefix));
+      createdNewSandbox = true;
+      steps.stop('✓', 'create temporary sandbox');
+    } else {
+      sandboxDir = resolve(String(picked));
+      reusedSandboxMeta = existingSandboxes.find((s) => resolve(s.dir) === sandboxDir) ?? null;
+    }
+  } else {
+    steps.start('create temporary sandbox');
+    const prefix = reviewPrSandboxPrefixPath(baseStackName);
+    sandboxDir = resolve(await mkdtemp(prefix));
+    createdNewSandbox = true;
+    steps.stop('✓', 'create temporary sandbox');
+  }
+
+  // If we're reusing a sandbox, prefer the stack name recorded in its meta file (keeps hostname stable),
+  // but only when the user did not explicitly pass --name.
+  const effectiveStackName =
+    !explicitName && reusedSandboxMeta?.stackName
+      ? sanitizeStackName(reusedSandboxMeta.stackName, { fallback: baseStackName, maxLen: 64 })
+      : newStackName;
+ 
+  // Safety marker to ensure we only delete what we created.
+  const markerPath = join(sandboxDir, '.happy-stacks-sandbox-marker');
+  // Always ensure the marker exists for safety; write meta only for new sandboxes.
+  try {
+    if (!existsSync(markerPath)) {
+      await writeFile(markerPath, 'review-pr\n', 'utf-8');
+    }
+  } catch {
+    // ignore; deletion guard will fail closed later if marker is missing
+  }
+  if (createdNewSandbox && existsSync(markerPath)) {
+    try {
+      await writeReviewPrSandboxMeta({ sandboxDir, baseStackName, stackName: effectiveStackName, argv });
+    } catch {
+      // ignore
+    }
+  }
+ 
+  const bin = join(rootDir, 'bin', 'happys.mjs');
+ 
+  let child = null;
+  let gotSignal = null;
+  let childExitCode = null;
+ 
+  const forwardSignal = (sig) => {
+    const first = gotSignal == null;
+    gotSignal = gotSignal ?? sig;
+    if (first && process.stdout.isTTY && !json) {
+      // eslint-disable-next-line no-console
+      console.log('\n[review-pr] received Ctrl+C — cleaning up sandbox, please wait...');
+    }
+    try {
+      child?.kill(sig);
+    } catch {
+      // ignore
+    }
+  };
+ 
+  const onSigInt = () => forwardSignal('SIGINT');
+  const onSigTerm = () => forwardSignal('SIGTERM');
+  process.on('SIGINT', onSigInt);
+  process.on('SIGTERM', onSigTerm);
+ 
+  try {
+    const wantsStart = flags.has('--start') || flags.has('--prod');
+    const hasMobileFlag = argv.includes('--mobile') || argv.includes('--with-mobile') || argv.includes('--no-mobile');
+    const argvWithDefaults =
+      process.stdout.isTTY && !json && !wantsStart && !hasMobileFlag ? [...argv, '--mobile'] : argv;
+
+    // If the caller did not explicitly name the stack, make it unique per run.
+    // This prevents browser storage collisions when sandboxes are deleted between runs.
+    const hasNameFlag = argvWithDefaults.some((a) => a === '--name' || a.startsWith('--name='));
+    const argvFinal = hasNameFlag ? argvWithDefaults : [...argvWithDefaults, `--name=${effectiveStackName}`];
+
+    child = spawn(process.execPath, [bin, '--sandbox-dir', sandboxDir, 'setup-pr', ...argvFinal], {
+      cwd: rootDir,
+      env: process.env,
+      stdio: 'inherit',
+    });
+ 
+    const { code } = await waitForExit(child);
+    childExitCode = code;
+    process.exitCode = code;
+  } finally {
+    process.off('SIGINT', onSigInt);
+    process.off('SIGTERM', onSigTerm);
+
+    steps.start('stop sandbox processes (best-effort)');
+    try {
+      // Best-effort stop before deleting the sandbox.
+      await tryStopSandbox({ rootDir, sandboxDir });
+      steps.stop('✓', 'stop sandbox processes (best-effort)');
+    } catch {
+      steps.stop('x', 'stop sandbox processes (best-effort)');
+      // eslint-disable-next-line no-console
+      console.warn(`[review-pr] warning: failed to stop all sandbox processes. Attempting cleanup anyway.`);
+    }
+ 
+    // On failure, offer to keep the sandbox for inspection (TTY only).
+    // - `--keep-sandbox` always wins (no prompt)
+    // - on signals, don't prompt (just follow the normal cleanup rules)
+    const keepSandbox = flags.has('--keep-sandbox');
+    const failed = !json && (childExitCode ?? 0) !== 0;
+    const canPromptKeep =
+      failed &&
+      !keepSandbox &&
+      !gotSignal &&
+      Boolean(process.stdout.isTTY && process.stdin.isTTY) &&
+      !json;
+
+    let keepOnFail = false;
+    if (failed && !keepSandbox && !gotSignal) {
+      if (canPromptKeep) {
+        // Default: keep in verbose mode, delete otherwise.
+        const defaultKeep = getVerbosityLevel(process.env) > 0;
+        keepOnFail = await withRl(async (rl) => {
+          return await promptSelect(rl, {
+            title: 'Review-pr failed. Keep the sandbox for inspection?',
+            options: [
+              { label: 'yes (keep sandbox directory)', value: true },
+              { label: 'no (delete sandbox directory)', value: false },
+            ],
+            defaultIndex: defaultKeep ? 0 : 1,
+          });
+        });
+      } else {
+        // Non-interactive: keep old behavior (verbose keeps, otherwise delete).
+        keepOnFail = getVerbosityLevel(process.env) > 0;
+      }
+    }
+
+    const shouldDeleteSandbox = !keepSandbox && !(failed && keepOnFail);
+
+    steps.start('delete sandbox directory');
+    // Only delete if marker exists (paranoia guard).
+    // Note: if marker is missing, we intentionally leave the sandbox dir on disk.
+    try {
+      if (!existsSync(markerPath)) {
+        throw new Error('missing marker');
+      }
+      if (!shouldDeleteSandbox) {
+        steps.stop('!', 'delete sandbox directory');
+        // eslint-disable-next-line no-console
+        console.warn(`[review-pr] sandbox preserved at: ${sandboxDir}`);
+        if (!json && (childExitCode ?? 0) !== 0) {
+          // eslint-disable-next-line no-console
+          console.warn(`[review-pr] tip: inspect stack wiring with:`);
+          // eslint-disable-next-line no-console
+          console.warn(`  npx happy-stacks --sandbox-dir "${sandboxDir}" stack info ${effectiveStackName}`);
+        }
+      } else {
+        await rm(markerPath, { force: false });
+        await rm(sandboxDir, { recursive: true, force: true });
+        steps.stop('✓', 'delete sandbox directory');
+      }
+    } catch {
+      steps.stop('x', 'delete sandbox directory');
+      // eslint-disable-next-line no-console
+      console.warn(`[review-pr] warning: failed to delete sandbox directory: ${sandboxDir}`);
+      // eslint-disable-next-line no-console
+      console.warn(`[review-pr] you can remove it manually after stopping any remaining processes.`);
+      // Preserve conventional exit codes on signals.
+      if (gotSignal) {
+        const code = gotSignal === 'SIGINT' ? 130 : gotSignal === 'SIGTERM' ? 143 : 1;
+        process.exitCode = process.exitCode ?? code;
+      }
+      return;
+    }
+    // Preserve conventional exit codes on signals.
+    if (gotSignal) {
+      const code = gotSignal === 'SIGINT' ? 130 : gotSignal === 'SIGTERM' ? 143 : 1;
+      process.exitCode = process.exitCode ?? code;
+    }
+  }
+}
+ 
+main().catch((err) => {
+  console.error('[review-pr] failed:', err);
+  process.exit(1);
+});
+