@auroraflow/code 0.0.6 → 0.0.8

package/README.md

@@ -1,189 +1,67 @@
-# Aurora 编程 Agent
-
-Aurora 编程 Agent 是基于 OpenAI Codex CLI 二开的 Aurora 自有编程代理。它的目标是提供类似 Codex 的本地编程体验，但身份、模型目录、API Key 与运行时路由都接入 Aurora 体系。
-
-这个仓库不是一次性改造项目，而是一个需要长期跟随上游 Codex 演进的下游 fork。实现时应尽量保留 Codex 的核心代码结构，把 Aurora 专属逻辑收敛到小而清晰的适配层，降低后续合并上游更新时的冲突成本。
-
-## 文档语言
-
-本项目的文档系统主要使用中文。
-
-- 面向产品、架构、运行规则、二开策略、发布流程的文档应优先使用中文。
-- 代码中的协议字段、第三方接口名、命令、错误码、包名和配置键保持其原始英文形式。
-- 引用上游 Codex、OpenAI API、Rust/Node 生态文档时，可以保留英文专有名词，必要时补充中文解释。
-- 面向国际化发布的用户文案可以单独维护英文版本，但中文文档是项目内部事实源。
-
-## 文档入口
-
-Aurora 专属维护文档位于 [`aurora-docs/`](aurora-docs/README.md)。
-
-- [`aurora-docs/BOUNDARIES.md`](aurora-docs/BOUNDARIES.md) — 长期二开边界。
-- [`aurora-docs/DECISIONS.md`](aurora-docs/DECISIONS.md) — 架构与产品决策记录。
-- [`aurora-docs/CHANGES.md`](aurora-docs/CHANGES.md) — Aurora patch 变更记录。
-- [`aurora-docs/UPSTREAM.md`](aurora-docs/UPSTREAM.md) — 跟随上游 Codex 的合并流程。
-- [`aurora-docs/UPSTREAM_CLEANUP.md`](aurora-docs/UPSTREAM_CLEANUP.md) — 上游遗留文件与口径的清理矩阵。
-
-上游 Codex 原 README 已保存在 [`README.codex.md`](README.codex.md)。上游 `docs/` 目录尽量保持接近 upstream，避免承载 Aurora 专属产品文档。
-
-## 项目定位
-
-Aurora 编程 Agent 面向希望使用 Aurora 基础设施完成本地编程工作的开发者：
-
-- 使用 Aurora 账号体系替换 Codex/OpenAI 登录授权。
-- 使用 Aurora 模型目录替换 Codex 原模型选择器。
-- 使用 Aurora API Key 选择器决定请求进入哪个运行时资源池。
-- 尽量继续继承 Codex 的核心 agent 能力、TUI 工作流、工具调用、MCP、沙箱和执行能力。
-
-## 首期范围
-
-第一阶段聚焦三个替换面。
-
-### 1. 身份体系
-
-替换 Codex 原有登录与鉴权存储，改为 Aurora 账号登录。CLI 应通过 Aurora control-plane endpoint 完成认证，并只保存后续 Aurora 请求所需的凭证。
-
-### 2. 模型选择
-
-替换 Codex 原来的扁平模型选择器，改为 Aurora 两级选择器：
-
-1. 先选择 provider 分类。
-2. 再选择该 provider 下的具体模型。
-3. 运行时请求发送 Aurora 后端要求的 alias / model id。
-
-### 3. Aurora Key 选择
-
-新增 Aurora API Key 选择器：
-
-1. 先选择 key 类型：`personal`、`platform`、`org`、`market`。
-2. 再选择或创建具体 key。
-3. 持久化已选 key 的必要元数据，供后续运行时请求使用。
-
-## 上游跟随策略
-
-本项目应持续跟随 [`openai/codex`](https://github.com/openai/codex)，把它作为核心 agent 能力的上游来源。
-
-推荐规则：
-
-- 尽量保留上游 Codex 的文件布局和 crate/module 名称，除非包分发确实需要改名。
-- 避免在核心代码里做大范围品牌替换。
-- Aurora 专属逻辑放到清晰命名的 adapter / integration 模块。
-- 保持 Aurora patch 小、集中、可 review，便于上游更新后重新合并。
-- 模型目录和 key 选择使用结构化字段，不把 Aurora 元数据塞进展示文本再解析。
-
-## 长期二开边界
-
-本项目的长期维护基线是：
-
-> Codex core + Aurora identity/model/key/runtime adapter + Aurora distribution。
-
-也就是说，本仓库不是“全仓改名版 Codex”，而是在尽量保留 Codex 核心结构的前提下，把 Aurora 必须拥有的产品接入面替换掉。
-
-### 必须二开的范围
-
-以下范围属于 Aurora 产品边界，应由本项目长期维护。
-
-1. 品牌与分发层
-
-   - CLI 命令名：`aurora`。
-   - npm / Python / 其他发布包名。
-   - 安装脚本、平台二进制包、release artifact 命名。
-   - 面向用户的 Aurora 产品文案。
-
-2. 登录与身份体系
-
-   - Aurora 账号登录。
-   - Aurora session / token 存储。
-   - Aurora API key reveal / create / select。
-   - 移除默认 Codex/OpenAI 登录入口；除非明确设定兼容期，不保留旧登录路径并行支持。
-
-3. Aurora Key 选择
-
-   - 先选择 key 类型：`personal`、`platform`、`org`、`market`。
-   - 再选择或创建具体 key。
-   - 持久化运行时请求所需的 key 元数据。
-   - 客户端只做交互所需判断，资源池和权限判定以 Aurora 后端为准。
-
-4. Aurora 模型目录与模型选择器
-
-   - 使用 Aurora 模型目录接口。
-   - 模型选择器采用 provider -> model 两级选择。
-   - 运行时请求发送 Aurora 后端要求的 alias / model id。
-   - 模型元数据必须是结构化字段，不通过解析展示文本获得业务字段。
-
-5. Aurora runtime 接入
-
-   - 运行时请求走 Aurora endpoint。
-   - 长期优先使用 `POST /v1/responses` 作为标准请求入口。
-   - 鉴权使用已选 Aurora key。
-   - Codex core 产生的请求语义应通过 Aurora adapter 转换，不在 core 里散落 Aurora 特例。
-
-### 尽量不动的范围
-
-以下范围主要承接上游 Codex 能力，应尽量保持接近 upstream，只有 Aurora 接入必须触及时才改。
-
-1. Agent 核心循环
-
-   - session / turn orchestration
-   - context 构建与压缩
-   - tool call 生命周期
-   - rollout / resume / history 机制
-
-2. 通用工具与执行能力
-
-   - shell / exec / sandbox
-   - apply_patch
-   - MCP server / MCP client
-   - skills / plugins
-   - file search / file watcher
-
-3. 通用协议模型
-
-   - Codex 内部 protocol 基础类型。
-   - OpenAI Responses / ChatGPT 相关结构在仍被上游 core 使用时不做无意义改名。
-   - 只在 Aurora 后端契约确实不同的时候新增 adapter 或结构化扩展。
-
-4. TUI 通用交互
-
-   - 聊天主界面。
-   - 底部输入框。
-   - 历史、diff、审批、工具展示。
-   - 只替换登录、模型选择、key 选择等 Aurora 产品面。
-
-5. 上游测试、CI 和构建基础设施
-
-   - 除发布包名、安装路径、artifact 命名外，不主动重写 CI 结构。
-   - 继续使用上游测试习惯和格式化规则。
-
-### 每次改动的边界判断
-
-每个 PR 或开发任务开始前，先判断改动属于哪一类：
-
-- 属于 Aurora 账号、模型、key、runtime endpoint、包分发：可以进入 Aurora patch。
-- 属于 agent 推理循环、通用工具、MCP、sandbox、TUI 通用能力：优先保持 upstream；必须修改时先收敛为小 adapter。
-- 属于纯品牌替换但会扩大 diff：默认不做。
-- 属于上游 bug 或通用能力改进：优先评估是否应该以 upstream-compatible 的方式实现，避免 Aurora 私有分叉扩大。
-
-长期目标是让 Aurora patch 面积稳定、可解释、可重放。每次合并上游 Codex 时，应优先解决这些明确边界内的冲突，避免把临时兼容逻辑扩散到 core。
-
-## Aurora 接入面
-
-预期依赖的 Aurora 后端接口：
-
-- `POST /api/v1/auth/login`
-- `GET /api/v1/aurora-cli/api-keys`
-- `POST /api/v1/aurora-cli/api-keys`
-- `POST /api/v1/aurora-cli/api-keys/{id}/reveal`
-- `GET /v1/aurora-cli/models`
-
-模型目录接口应返回结构化的 `provider`、`model_id`、`alias` 等字段，客户端不应通过解析展示文本获取业务字段。
-
-## 非目标
-
-- 不重写 Codex 核心 agent 行为。
-- Aurora auth 接入后，不保留旧 Codex/OpenAI 登录流程的兼容分支，除非明确需要兼容期。
-- 不为了品牌统一而全仓重命名内部符号，如果这会显著增加上游合并成本。
-- 不在客户端重复实现 Aurora 后端 domain 规则；客户端只保留交互所需的最小判断。
-
-## 当前状态
-
-当前仓库已经导入最新 Codex `main` 作为基线。下一步是在不扩大 core diff 的前提下，依次叠加 Aurora 命令入口、身份、模型选择和 key 选择适配层。
+# Aurora Code
+
+Unified Aurora launcher for official Claude Code and Codex clients.
+
+## Layout
+
+```text
+packages/cli       command entrypoints and init flow
+packages/clients   official Claude/Codex launch adapters
+packages/sidecar   local HTTP proxy for runtime traffic
+packages/protocol  shared rewrite/projection helpers
+packages/state     ~/.aurora state paths and JSON state
+bin/               npm bin shims
+lib/               current MVP support modules
+```
+
+## Install
+
+Installing `@auroraflow/code` as a global npm package attempts to install/update the
+official Claude Code and Codex global commands:
+
+```bash
+npm install -g @auroraflow/code
+```
+
+Aurora does not export `claude` or `codex` bins. The standalone `claude` and
+`codex` commands remain the official clients and keep their official behavior.
+Aurora only wraps them through `aurora-claude` and `aurora-codex`.
+
+To install or update the official clients explicitly:
+
+```bash
+aurora install-clients
+aurora update-clients
+```
+
+## Commands
+
+```bash
+npm run check
+scripts/release_npm.sh 0.0.7
+node bin/aurora.js
+node bin/aurora.js init
+node bin/aurora.js claude
+node bin/aurora.js codex
+node bin/aurora.js install-clients
+node bin/aurora.js update-clients
+node bin/aurora.js status
+```
+
+Running `aurora` without a subcommand opens an interactive client selector. Use
+Up/Down (or `j`/`k`) and Enter to launch Claude or Codex through Aurora.
+
+The launcher stores shared local state under `~/.aurora` and starts a local
+sidecar at `127.0.0.1:17878`. Official clients talk to the sidecar; the sidecar
+injects the selected Aurora key/model and forwards runtime traffic to Aurora
+Gateway.
+
+The Aurora desktop client is the product path for model/key selection. Its local
+runtime workbench writes `~/.aurora/agent-state.json`; `aurora-claude` and
+`aurora-codex` only consume that local runtime state and route official client
+traffic through the sidecar. The clients are launched with the selected Aurora
+model alias, and the sidecar enforces the same selected alias when forwarding
+runtime requests.
+`aurora-codex` also writes `~/.aurora/clients/codex/config.toml` and
+`auth.json` before launch so Codex uses the Aurora sidecar provider instead of
+the OpenAI login flow.

package/bin/aurora-claude.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runAuroraClaude } from "../packages/cli/src/index.js";
+
+await runAuroraClaude(process.argv.slice(2));

package/bin/aurora-codex.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runAuroraCodex } from "../packages/cli/src/index.js";
+
+await runAuroraCodex(process.argv.slice(2));

package/bin/aurora-postinstall.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { installOfficialClients, isGlobalNpmLifecycle, officialClientStatuses } from "../packages/clients/src/index.js";
+
+if (!process.env.AURORA_SKIP_OFFICIAL_CLIENT_INSTALL && isGlobalNpmLifecycle()) {
+  try {
+    await installOfficialClients();
+  } catch (error) {
+    console.error(`[aurora-code] official client install failed: ${error.message}`);
+    console.error("[aurora-code] run `aurora install-clients` after installation.");
+  }
+}
+
+const statuses = officialClientStatuses();
+const missing = statuses.filter((status) => !status.installed);
+
+for (const status of statuses) {
+  const version = status.version ? ` ${status.version}` : "";
+  const marker = status.installed ? "installed" : "missing";
+  console.error(`[aurora-code] ${status.name}${version}: ${marker}`);
+}
+
+if (missing.length) {
+  console.error("[aurora-code] run `aurora install-clients` to install official standalone commands.");
+}

package/bin/aurora-sidecar.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { startSidecar } from "../packages/sidecar/src/index.js";
+
+await startSidecar();

package/bin/aurora.js

@@ -1,384 +1,4 @@
 #!/usr/bin/env node
-// Unified entry point for Aurora Code.
+import { runAuroraCLI } from "../packages/cli/src/index.js";
 
-import { spawn } from "node:child_process";
-import {
-  createReadStream,
-  createWriteStream,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  realpathSync,
-  rmSync,
-} from "fs";
-import { createRequire } from "node:module";
-import { createHash } from "node:crypto";
-import { get as httpsGet } from "node:https";
-import { homedir, tmpdir } from "node:os";
-import path from "path";
-import { fileURLToPath } from "url";
-
-// __dirname equivalent in ESM
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const require = createRequire(import.meta.url);
-const packageRoot = path.join(__dirname, "..");
-const packageVersion = require(path.join(packageRoot, "package.json")).version;
-const downloadBaseUrl = "https://downloads.auroramos.com";
-const terminalTitle = "aurora";
-
-process.title = terminalTitle;
-
-function writeTerminalTitle(title) {
-  if (!process.stdout.isTTY) {
-    return;
-  }
-  const sanitized = title.replace(/[\x00-\x1f\x7f\x9b\x9c]/g, "").trim();
-  if (!sanitized) {
-    return;
-  }
-  process.stdout.write(`\x1b]0;${sanitized}\x07`);
-}
-
-const PLATFORM_PACKAGE_BY_TARGET = {
-  "x86_64-unknown-linux-gnu": "@auroraflow/code-linux-x64",
-  "aarch64-unknown-linux-gnu": "@auroraflow/code-linux-arm64",
-  "x86_64-apple-darwin": "@auroraflow/code-darwin-x64",
-  "aarch64-apple-darwin": "@auroraflow/code-darwin-arm64",
-  "x86_64-pc-windows-msvc": "@auroraflow/code-win32-x64",
-  "aarch64-pc-windows-msvc": "@auroraflow/code-win32-arm64",
-};
-
-const { platform, arch } = process;
-
-let targetTriple = null;
-switch (platform) {
-  case "linux":
-  case "android":
-    switch (arch) {
-      case "x64":
-        targetTriple = "x86_64-unknown-linux-gnu";
-        break;
-      case "arm64":
-        targetTriple = "aarch64-unknown-linux-gnu";
-        break;
-      default:
-        break;
-    }
-    break;
-  case "darwin":
-    switch (arch) {
-      case "x64":
-        targetTriple = "x86_64-apple-darwin";
-        break;
-      case "arm64":
-        targetTriple = "aarch64-apple-darwin";
-        break;
-      default:
-        break;
-    }
-    break;
-  case "win32":
-    switch (arch) {
-      case "x64":
-        targetTriple = "x86_64-pc-windows-msvc";
-        break;
-      case "arm64":
-        targetTriple = "aarch64-pc-windows-msvc";
-        break;
-      default:
-        break;
-    }
-    break;
-  default:
-    break;
-}
-
-if (!targetTriple) {
-  throw new Error(`Unsupported platform: ${platform} (${arch})`);
-}
-
-const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
-if (!platformPackage) {
-  throw new Error(`Unsupported target triple: ${targetTriple}`);
-}
-
-const auroraBinaryName = process.platform === "win32" ? "aurora.exe" : "aurora";
-const localVendorRoot = path.join(__dirname, "..", "vendor");
-const packageBinaryPath = (vendorRoot) =>
-  path.join(vendorRoot, targetTriple, "bin", auroraBinaryName);
-const legacyBinaryPath = (vendorRoot) =>
-  path.join(vendorRoot, targetTriple, "codex", process.platform === "win32" ? "codex.exe" : "codex");
-
-function resolveNativePackage(vendorRoot) {
-  const packageRoot = path.join(vendorRoot, targetTriple);
-  const binaryPath = packageBinaryPath(vendorRoot);
-  if (existsSync(binaryPath)) {
-    return {
-      binaryPath,
-      pathDir: path.join(packageRoot, "aurora-path"),
-    };
-  }
-
-  const legacyPath = legacyBinaryPath(vendorRoot);
-  if (existsSync(legacyPath)) {
-    return {
-      binaryPath: legacyPath,
-      pathDir: path.join(packageRoot, "path"),
-    };
-  }
-
-  return null;
-}
-
-function resolvePlatformNativePackage() {
-  try {
-    const packageJsonPath = require.resolve(`${platformPackage}/package.json`, {
-      paths: [packageRoot],
-    });
-    return resolveNativePackage(path.join(path.dirname(packageJsonPath), "vendor"));
-  } catch {
-    return null;
-  }
-}
-
-let nativePackage =
-  resolvePlatformNativePackage() || resolveNativePackage(localVendorRoot);
-
-async function downloadFile(url, destination) {
-  await new Promise((resolve, reject) => {
-    const file = createWriteStream(destination);
-    const request = httpsGet(url, (response) => {
-      if (
-        response.statusCode >= 300 &&
-        response.statusCode < 400 &&
-        response.headers.location
-      ) {
-        file.close();
-        rmSync(destination, { force: true });
-        downloadFile(response.headers.location, destination)
-          .then(resolve)
-          .catch(reject);
-        return;
-      }
-
-      if (response.statusCode !== 200) {
-        file.close();
-        rmSync(destination, { force: true });
-        reject(new Error(`Download failed with HTTP ${response.statusCode}`));
-        return;
-      }
-
-      response.pipe(file);
-      file.on("finish", () => {
-        file.close(resolve);
-      });
-    });
-    request.on("error", (err) => {
-      file.close();
-      rmSync(destination, { force: true });
-      reject(err);
-    });
-  });
-}
-
-async function sha256File(filePath) {
-  return await new Promise((resolve, reject) => {
-    const hash = createHash("sha256");
-    const stream = createReadStream(filePath);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("error", reject);
-    stream.on("end", () => resolve(hash.digest("hex")));
-  });
-}
-
-async function verifySha256(archivePath, checksumPath) {
-  const checksumText = readFileSync(checksumPath, "utf8").trim();
-  const expected = checksumText.split(/\s+/)[0];
-  const actual = await sha256File(archivePath);
-  if (!expected || actual !== expected) {
-    throw new Error(
-      `Aurora Code native binary checksum mismatch for ${targetTriple}.`,
-    );
-  }
-}
-
-async function installNativePackage() {
-  const archiveUrl =
-    `${downloadBaseUrl}/aurora-code/${packageVersion}/${targetTriple}.tar.xz`;
-  const checksumUrl = `${archiveUrl}.sha256`;
-  const targetDir = path.join(localVendorRoot, targetTriple);
-  const archivePath = path.join(
-    tmpdir(),
-    `aurora-code-${packageVersion}-${targetTriple}.tar.xz`,
-  );
-  const checksumPath = `${archivePath}.sha256`;
-
-  // eslint-disable-next-line no-console
-  console.error(`Downloading Aurora Code native binary from ${archiveUrl}`);
-  mkdirSync(localVendorRoot, { recursive: true });
-  rmSync(targetDir, { recursive: true, force: true });
-  await downloadFile(archiveUrl, archivePath);
-  await downloadFile(checksumUrl, checksumPath);
-  await verifySha256(archivePath, checksumPath);
-  mkdirSync(targetDir, { recursive: true });
-
-  const tar = spawn("tar", ["-xJf", archivePath, "-C", targetDir], {
-    stdio: "inherit",
-  });
-  const exitCode = await new Promise((resolve) => {
-    tar.on("exit", (code) => resolve(code ?? 1));
-    tar.on("error", () => resolve(1));
-  });
-  rmSync(archivePath, { force: true });
-  rmSync(checksumPath, { force: true });
-  if (exitCode !== 0) {
-    rmSync(targetDir, { recursive: true, force: true });
-    throw new Error("Failed to extract Aurora Code native binary.");
-  }
-
-  return resolveNativePackage(localVendorRoot);
-}
-
-if (!nativePackage) {
-  nativePackage = await installNativePackage();
-  if (!nativePackage) {
-    const packageManager = detectPackageManager();
-    const updateCommand =
-      packageManager === "bun"
-        ? "bun install -g @auroraflow/code@latest"
-        : "npm install -g @auroraflow/code@latest";
-    throw new Error(
-      `Missing native binary for ${targetTriple}. Reinstall Aurora Code: ${updateCommand}`,
-    );
-  }
-}
-
-const { binaryPath, pathDir } = nativePackage;
-
-// Use an asynchronous spawn instead of spawnSync so that Node is able to
-// respond to signals (e.g. Ctrl-C / SIGINT) while the native binary is
-// executing. This allows us to forward those signals to the child process
-// and guarantees that when either the child terminates or the parent
-// receives a fatal signal, both processes exit in a predictable manner.
-
-function getUpdatedPath(newDirs) {
-  const pathSep = process.platform === "win32" ? ";" : ":";
-  const existingPath = process.env.PATH || "";
-  const updatedPath = [
-    ...newDirs,
-    ...existingPath.split(pathSep).filter(Boolean),
-  ].join(pathSep);
-  return updatedPath;
-}
-
-/**
- * Use heuristics to detect the package manager that was used to install Aurora Code
- * in order to give the user a hint about how to update it.
- */
-function detectPackageManager() {
-  const userAgent = process.env.npm_config_user_agent || "";
-  if (/\bbun\//.test(userAgent)) {
-    return "bun";
-  }
-
-  const execPath = process.env.npm_execpath || "";
-  if (execPath.includes("bun")) {
-    return "bun";
-  }
-
-  if (
-    __dirname.includes(".bun/install/global") ||
-    __dirname.includes(".bun\\install\\global")
-  ) {
-    return "bun";
-  }
-
-  return userAgent ? "npm" : null;
-}
-
-const additionalDirs = [];
-if (existsSync(pathDir)) {
-  additionalDirs.push(pathDir);
-}
-const updatedPath = getUpdatedPath(additionalDirs);
-
-const env = { ...process.env, PATH: updatedPath };
-const auroraHome =
-  env.AURORA_HOME && env.AURORA_HOME.trim()
-    ? env.AURORA_HOME
-    : path.join(homedir(), ".aurora");
-env.AURORA_HOME = auroraHome;
-env.CODEX_HOME = auroraHome;
-const packageManagerEnvVar =
-  detectPackageManager() === "bun"
-    ? "AURORA_MANAGED_BY_BUN"
-    : "AURORA_MANAGED_BY_NPM";
-env[packageManagerEnvVar] = "1";
-env.AURORA_MANAGED_PACKAGE_ROOT = realpathSync(path.join(__dirname, ".."));
-// Rust install diagnostics still understand the upstream variable names.
-// Set both so Aurora-packaged launches are detected across the inherited core.
-if (packageManagerEnvVar === "AURORA_MANAGED_BY_BUN") {
-  env.CODEX_MANAGED_BY_BUN = "1";
-} else {
-  env.CODEX_MANAGED_BY_NPM = "1";
-}
-env.CODEX_MANAGED_PACKAGE_ROOT = env.AURORA_MANAGED_PACKAGE_ROOT;
-
-writeTerminalTitle(terminalTitle);
-
-const child = spawn(binaryPath, process.argv.slice(2), {
-  stdio: "inherit",
-  env,
-});
-
-child.on("error", (err) => {
-  // Typically triggered when the binary is missing or not executable.
-  // Re-throwing here will terminate the parent with a non-zero exit code
-  // while still printing a helpful stack trace.
-  // eslint-disable-next-line no-console
-  console.error(err);
-  process.exit(1);
-});
-
-// Forward common termination signals to the child so that it shuts down
-// gracefully. In the handler we temporarily disable the default behavior of
-// exiting immediately; once the child has been signaled we simply wait for
-// its exit event which will in turn terminate the parent (see below).
-const forwardSignal = (signal) => {
-  if (child.killed) {
-    return;
-  }
-  try {
-    child.kill(signal);
-  } catch {
-    /* ignore */
-  }
-};
-
-["SIGINT", "SIGTERM", "SIGHUP"].forEach((sig) => {
-  process.on(sig, () => forwardSignal(sig));
-});
-
-// When the child exits, mirror its termination reason in the parent so that
-// shell scripts and other tooling observe the correct exit status.
-// Wrap the lifetime of the child process in a Promise so that we can await
-// its termination in a structured way. The Promise resolves with an object
-// describing how the child exited: either via exit code or due to a signal.
-const childResult = await new Promise((resolve) => {
-  child.on("exit", (code, signal) => {
-    if (signal) {
-      resolve({ type: "signal", signal });
-    } else {
-      resolve({ type: "code", exitCode: code ?? 1 });
-    }
-  });
-});
-
-if (childResult.type === "signal") {
-  // Re-emit the same signal so that the parent terminates with the expected
-  // semantics (this also sets the correct exit code of 128 + n).
-  process.kill(process.pid, childResult.signal);
-} else {
-  process.exit(childResult.exitCode);
-}
+await runAuroraCLI(process.argv.slice(2));