@auroraflow/code 0.0.5 → 0.0.7

package/packages/clients/src/index.js

@@ -0,0 +1,267 @@
+import { spawn, spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AURORA_SIDECAR_PORT } from "../../protocol/src/index.js";
+import { CLAUDE_HOME, CODEX_HOME, readSidecarInfo, readState, writeSidecarInfo } from "../../state/src/index.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, "..", "..", "..");
+const rootSidecarBin = join(packageRoot, "bin", "aurora-sidecar.js");
+
+const OFFICIAL_CLIENTS = {
+  claude: {
+    name: "Claude Code",
+    packageName: "@anthropic-ai/claude-code",
+    binName: "claude"
+  },
+  codex: {
+    name: "Codex",
+    packageName: "@openai/codex",
+    binName: "codex"
+  }
+};
+
+export async function createClientLaunchSpec(client, args = []) {
+  const sidecar = await ensureSidecar();
+  const state = await readState();
+  const model = selectedModelAlias(state);
+  const key = selectedKey(state);
+  if (client === "claude") {
+    const env = {
+      ...process.env,
+      AURORA_HOME: process.env.AURORA_HOME ?? "",
+      CLAUDE_CONFIG_DIR: CLAUDE_HOME,
+      ANTHROPIC_BASE_URL: sidecar.baseURL,
+      ANTHROPIC_AUTH_TOKEN: sidecar.token,
+      CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+      CLAUDE_CODE_DISABLE_TELEMETRY: "1",
+      DISABLE_AUTOUPDATER: "1"
+    };
+    env.ANTHROPIC_MODEL = model;
+    return { command: officialClientBin("claude"), args, env };
+  }
+  await writeCodexRuntimeFiles({ sidecar, model, key });
+  const env = {
+    ...process.env,
+    AURORA_HOME: process.env.AURORA_HOME ?? "",
+    CODEX_HOME,
+    OPENAI_API_KEY: sidecar.token,
+    OPENAI_BASE_URL: `${sidecar.baseURL}/v1`
+  };
+  env.OPENAI_MODEL = model;
+  return { command: officialClientBin("codex"), args, env };
+}
+
+export async function runClient(client, args = []) {
+  const spec = await createClientLaunchSpec(client, args);
+  await spawnAndExit(spec.command, spec.args, spec.env);
+}
+
+export function officialClientStatuses() {
+  return Object.entries(OFFICIAL_CLIENTS).map(([id, client]) => {
+    const bin = resolveOfficialClientBin(client.binName);
+    const packagePath = officialClientPackageJSONPath(client.packageName);
+    const version = readOfficialClientVersion(bin) ?? (packagePath ? JSON.parse(readFileSync(packagePath, "utf8")).version : null);
+    return {
+      id,
+      name: client.name,
+      packageName: client.packageName,
+      bin,
+      installed: Boolean(bin),
+      version
+    };
+  });
+}
+
+export async function updateOfficialClients() {
+  await installOfficialClients();
+}
+
+export async function installOfficialClients() {
+  const npm = process.env.npm_execpath || "npm";
+  const args = ["install", "-g", "@anthropic-ai/claude-code@latest", "@openai/codex@latest"];
+  await spawnAndWait(npm, args, { ...process.env });
+}
+
+export function isGlobalNpmLifecycle() {
+  return process.env.npm_config_global === "true" || process.env.npm_config_location === "global";
+}
+
+function officialClientBin(client) {
+  const spec = OFFICIAL_CLIENTS[client];
+  if (!spec) throw new Error(`unknown official client: ${client}`);
+  const bin = resolveOfficialClientBin(spec.binName);
+  if (!bin) {
+    throw new Error(`${spec.name} is not installed. Run: aurora install-clients`);
+  }
+  return bin;
+}
+
+function resolveOfficialClientBin(binName) {
+  return findPathCommand(binName) ?? localClientBinPath(binName);
+}
+
+function localClientBinPath(binName) {
+  const suffix = process.platform === "win32" ? ".cmd" : "";
+  const bin = join(packageRoot, "node_modules", ".bin", `${binName}${suffix}`);
+  return existsSync(bin) ? bin : null;
+}
+
+function findPathCommand(binName) {
+  const suffixes = process.platform === "win32" ? [".cmd", ".exe", ""] : [""];
+  for (const dir of String(process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    for (const suffix of suffixes) {
+      const candidate = join(dir, `${binName}${suffix}`);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function officialClientPackageJSONPath(packageName) {
+  const parts = packageName.startsWith("@") ? packageName.split("/") : [packageName];
+  const packagePath = join(packageRoot, "node_modules", ...parts, "package.json");
+  return existsSync(packagePath) ? packagePath : null;
+}
+
+function readOfficialClientVersion(bin) {
+  if (!bin) return null;
+  try {
+    const result = spawnSyncCompat(bin, ["--version"]);
+    if (result.status !== 0) return null;
+    return String(result.stdout || result.stderr || "").trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function ensureSidecar() {
+  try {
+    const info = await readSidecarInfo();
+    if (info?.port && info?.token && await pingSidecar(info)) return normalizedSidecarInfo(info);
+  } catch {
+    // Start below.
+  }
+  const token = `aurora-local-${randomBytes(24).toString("hex")}`;
+  const child = spawn(process.execPath, [process.env.AURORA_SIDECAR_BIN || rootSidecarBin, "--token", token], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.unref();
+  const info = { port: AURORA_SIDECAR_PORT, token, baseURL: `http://127.0.0.1:${AURORA_SIDECAR_PORT}` };
+  await waitForSidecar(info);
+  await writeSidecarInfo(info);
+  return info;
+}
+
+async function writeCodexRuntimeFiles({ sidecar, model }) {
+  await mkdir(CODEX_HOME, { recursive: true });
+  const config = `model = ${tomlString(model)}
+model_provider = "aurora"
+suppress_unstable_features_warning = true
+
+[model_providers.aurora]
+name = "Aurora"
+base_url = ${tomlString(`${sidecar.baseURL}/v1`)}
+env_key = "OPENAI_API_KEY"
+wire_api = "responses"
+requires_openai_auth = false
+request_max_retries = 0
+stream_max_retries = 0
+stream_idle_timeout_ms = 300000
+`;
+  const auth = {
+    OPENAI_API_KEY: sidecar.token,
+    tokens: null,
+    last_refresh: null
+  };
+  await writeFile(join(CODEX_HOME, "config.toml"), config, { mode: 0o600 });
+  await writeFile(join(CODEX_HOME, "auth.json"), `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 });
+}
+
+async function waitForSidecar(info) {
+  const deadline = Date.now() + 2500;
+  while (Date.now() < deadline) {
+    if (await pingSidecar(info)) return;
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error("Aurora sidecar did not become ready on 127.0.0.1:17878");
+}
+
+async function pingSidecar(info) {
+  try {
+    const normalized = normalizedSidecarInfo(info);
+    const response = await fetch(`${normalized.baseURL}/aurora/status`, {
+      headers: { authorization: `Bearer ${normalized.token}` },
+      signal: AbortSignal.timeout(500)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+function normalizedSidecarInfo(info) {
+  return {
+    port: Number(info.port),
+    token: String(info.token),
+    baseURL: info.baseURL || `http://127.0.0.1:${Number(info.port)}`
+  };
+}
+
+function selectedModelAlias(state) {
+  const model = state.selectedModel?.alias;
+  if (!model) throw new Error("Aurora runtime model is not selected. Select a model in Aurora Desktop > 本机调用.");
+  return model;
+}
+
+function selectedKey(state) {
+  const key = state.selectedKey?.presentedKey;
+  if (!key) throw new Error("Aurora runtime key is not selected. Select a key in Aurora Desktop > 本机调用.");
+  return key;
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+async function spawnAndExit(command, args, env) {
+  const child = spawn(command, args, {
+    stdio: "inherit",
+    env,
+    shell: process.platform === "win32" && command.endsWith(".cmd")
+  });
+  child.on("error", error => {
+    console.error(`Failed to start ${command}: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("exit", code => process.exit(code ?? 1));
+}
+
+function spawnAndWait(command, args, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: packageRoot,
+      stdio: "inherit",
+      env,
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("exit", code => {
+      if (code === 0) resolve();
+      else reject(new Error(`${command} exited with code ${code ?? 1}`));
+    });
+  });
+}
+
+function spawnSyncCompat(command, args) {
+  return spawnSync(command, args, {
+    encoding: "utf8",
+    shell: process.platform === "win32" && command.endsWith(".cmd")
+  });
+}

package/packages/protocol/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@aurora/protocol",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  }
+}

package/packages/protocol/src/index.js

@@ -0,0 +1,43 @@
+export const AURORA_SIDECAR_PORT = 17878;
+export const AURORA_LOCALHOST = "127.0.0.1";
+
+export function trimSlash(value) {
+  return String(value).replace(/\/+$/, "");
+}
+
+export function selectedKeyHeaders(state) {
+  const key = state.selectedKey?.presentedKey;
+  return key ? { authorization: `Bearer ${key}`, "x-api-key": key } : {};
+}
+
+export function rewriteRuntimeModel(raw, selectedAlias) {
+  if (!selectedAlias || !raw.trim()) return raw;
+  try {
+    const parsed = JSON.parse(raw);
+    parsed.model = selectedAlias;
+    return JSON.stringify(parsed);
+  } catch {
+    return raw;
+  }
+}
+
+export function toClientModelItem(item) {
+  const provider = String(item.provider ?? "aurora").replace(/[^a-zA-Z0-9_-]/g, "-");
+  const modelID = encodeURIComponent(String(item.model_id ?? item.alias ?? item.id));
+  return {
+    id: `claude-${provider}/${modelID}`,
+    object: "model",
+    owned_by: provider,
+    display_name: item.display_name || `${provider} / ${item.model_id ?? item.alias ?? item.id}`,
+    aurora_alias: item.alias ?? item.id,
+    aurora_provider: item.provider,
+    aurora_model_id: item.model_id
+  };
+}
+
+export function isRuntimePath(pathname) {
+  return pathname === "/v1/messages" ||
+    pathname === "/v1/responses" ||
+    pathname === "/v1/chat/completions" ||
+    pathname === "/v1/messages/count_tokens";
+}

package/packages/sidecar/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@aurora/sidecar",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  }
+}

package/packages/sidecar/src/index.js

@@ -0,0 +1,109 @@
+import { createServer } from "node:http";
+import { AURORA_LOCALHOST, AURORA_SIDECAR_PORT, isRuntimePath, rewriteRuntimeModel, selectedKeyHeaders, toClientModelItem, trimSlash } from "../../protocol/src/index.js";
+import { readState, writeSidecarInfo } from "../../state/src/index.js";
+
+export async function startSidecar(options = {}) {
+  const token = options.token || readArg("--token") || process.env.AURORA_SIDECAR_TOKEN || "aurora-local-dev";
+  const port = Number(options.port || readArg("--port") || process.env.AURORA_SIDECAR_PORT || AURORA_SIDECAR_PORT);
+  const server = createServer((request, response) => {
+    handle(request, response, token).catch(error => {
+      response.writeHead(500, { "content-type": "application/json" });
+      response.end(JSON.stringify({ error: { type: "sidecar_error", message: error.message } }));
+    });
+  });
+  server.listen(port, AURORA_LOCALHOST, async () => {
+    await writeSidecarInfo({ port, token, baseURL: `http://${AURORA_LOCALHOST}:${port}` });
+    console.error(`Aurora sidecar listening on http://${AURORA_LOCALHOST}:${port}`);
+  });
+}
+
+async function handle(request, response, token) {
+  if (!isAuthorized(request, token)) {
+    writeJSON(response, 401, { error: { type: "unauthorized", message: "sidecar token required" } });
+    return;
+  }
+  const url = new URL(request.url, `http://${AURORA_LOCALHOST}`);
+  if (request.method === "GET" && url.pathname === "/aurora/status") {
+    const state = await readState();
+    writeJSON(response, 200, {
+      ok: true,
+      selectedKey: Boolean(state.selectedKey?.presentedKey),
+      selectedModel: state.selectedModel ?? null
+    });
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/v1/models") {
+    await proxyModels(response);
+    return;
+  }
+  if (request.method === "POST" && isRuntimePath(url.pathname)) {
+    await proxyRuntime(request, response, url.pathname + url.search);
+    return;
+  }
+  writeJSON(response, 404, { error: { type: "not_found", message: "unknown sidecar route" } });
+}
+
+async function proxyModels(response) {
+  const state = await readState();
+  const gatewayURL = trimSlash(state.gatewayURL ?? "https://auroramos.com");
+  const upstream = await fetch(`${gatewayURL}/v1/aurora-cli/models`, {
+    headers: selectedKeyHeaders(state)
+  });
+  const payload = await upstream.json().catch(() => ({ object: "list", data: [] }));
+  const data = Array.isArray(payload.data) ? payload.data.map(toClientModelItem) : [];
+  writeJSON(response, upstream.ok ? 200 : upstream.status, { object: "list", data });
+}
+
+async function proxyRuntime(request, response, path) {
+  const state = await readState();
+  const body = await readBody(request);
+  const gatewayURL = trimSlash(state.gatewayURL ?? "https://auroramos.com");
+  const upstream = await fetch(`${gatewayURL}${path}`, {
+    method: request.method,
+    headers: {
+      ...copyForwardHeaders(request.headers),
+      ...selectedKeyHeaders(state),
+      "content-type": request.headers["content-type"] ?? "application/json"
+    },
+    body: rewriteRuntimeModel(body, state.selectedModel?.alias)
+  });
+  response.writeHead(upstream.status, Object.fromEntries(upstream.headers.entries()));
+  if (upstream.body) {
+    for await (const chunk of upstream.body) response.write(chunk);
+  }
+  response.end();
+}
+
+function isAuthorized(request, token) {
+  const auth = String(request.headers.authorization ?? "");
+  const xKey = String(request.headers["x-api-key"] ?? "");
+  return auth === `Bearer ${token}` || xKey === token;
+}
+
+function copyForwardHeaders(headers) {
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (["host", "authorization", "x-api-key", "content-length"].includes(key.toLowerCase())) continue;
+    if (value !== undefined) out[key] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return out;
+}
+
+function readBody(request) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    request.on("data", chunk => chunks.push(chunk));
+    request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    request.on("error", reject);
+  });
+}
+
+function writeJSON(response, status, payload) {
+  response.writeHead(status, { "content-type": "application/json" });
+  response.end(JSON.stringify(payload));
+}
+
+function readArg(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : "";
+}

package/packages/state/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@aurora/state",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  }
+}

package/packages/state/src/index.js

@@ -0,0 +1,57 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const AURORA_HOME = process.env.AURORA_HOME || join(homedir(), ".aurora");
+export const STATE_PATH = join(AURORA_HOME, "agent-state.json");
+export const ACCOUNT_PATH = join(AURORA_HOME, "account.json");
+export const SIDECAR_PATH = join(AURORA_HOME, "sidecar.json");
+export const CLAUDE_HOME = join(AURORA_HOME, "clients", "claude");
+export const CODEX_HOME = join(AURORA_HOME, "clients", "codex");
+
+export async function ensureLayout() {
+  await mkdir(AURORA_HOME, { recursive: true });
+  await mkdir(CLAUDE_HOME, { recursive: true });
+  await mkdir(CODEX_HOME, { recursive: true });
+}
+
+export async function readState() {
+  try {
+    return JSON.parse(await readFile(STATE_PATH, "utf8"));
+  } catch {
+    return {
+      gatewayURL: "https://auroramos.com",
+      controlPlaneURL: "https://auroramos.com/api/v1"
+    };
+  }
+}
+
+export async function writeState(next) {
+  await ensureLayout();
+  await writeFile(STATE_PATH, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+}
+
+export async function readAccount() {
+  try {
+    return JSON.parse(await readFile(ACCOUNT_PATH, "utf8"));
+  } catch {
+    return {
+      controlPlaneURL: "https://auroramos.com/api/v1",
+      gatewayURL: "https://auroramos.com"
+    };
+  }
+}
+
+export async function writeAccount(next) {
+  await ensureLayout();
+  await writeFile(ACCOUNT_PATH, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+}
+
+export async function writeSidecarInfo(info) {
+  await ensureLayout();
+  await writeFile(SIDECAR_PATH, JSON.stringify(info, null, 2) + "\n", { mode: 0o600 });
+}
+
+export async function readSidecarInfo() {
+  return JSON.parse(await readFile(SIDECAR_PATH, "utf8"));
+}

package/scripts/install_posix_launcher.js

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-// Replaces the installed Unix npm shim with a launcher that execs the native binary.
-
-import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-if (process.platform === "win32") {
-  process.exit(0);
-}
-
-const __filename = fileURLToPath(import.meta.url);
-const packageRoot = path.resolve(path.dirname(__filename), "..");
-const binDir = path.join(packageRoot, "bin");
-const entryPath = path.join(binDir, "aurora.js");
-const nodeEntryPath = path.join(binDir, "aurora-node.js");
-
-if (!existsSync(entryPath)) {
-  process.exit(0);
-}
-
-if (!existsSync(nodeEntryPath)) {
-  writeFileSync(nodeEntryPath, readFileSync(entryPath));
-  chmodSync(nodeEntryPath, 0o755);
-}
-
-const launcher = `#!/bin/sh
-# Aurora Code POSIX launcher. Generated at npm install time.
-
-set -e
-
-resolve_dir() {
-  CDPATH= cd -- "$1" 2>/dev/null && pwd -P
-}
-
-SELF=$0
-while [ -L "$SELF" ]; do
-  LINK=$(readlink "$SELF")
-  case "$LINK" in
-    /*) SELF=$LINK ;;
-    *) SELF=$(dirname -- "$SELF")/$LINK ;;
-  esac
-done
-
-BIN_DIR=$(resolve_dir "$(dirname -- "$SELF")")
-PACKAGE_ROOT=$(resolve_dir "$BIN_DIR/..")
-
-case "$(uname -s)" in
-  Darwin) OS=apple-darwin ;;
-  Linux) OS=unknown-linux-gnu ;;
-  *) exec node "$BIN_DIR/aurora-node.js" "$@" ;;
-esac
-
-case "$(uname -m)" in
-  arm64|aarch64) ARCH=aarch64 ;;
-  x86_64|amd64) ARCH=x86_64 ;;
-  *) exec node "$BIN_DIR/aurora-node.js" "$@" ;;
-esac
-
-TARGET="$ARCH-$OS"
-case "$TARGET" in
-  aarch64-apple-darwin) NATIVE_PACKAGE="@auroraflow/code-darwin-arm64" ;;
-  x86_64-apple-darwin) NATIVE_PACKAGE="@auroraflow/code-darwin-x64" ;;
-  aarch64-unknown-linux-gnu) NATIVE_PACKAGE="@auroraflow/code-linux-arm64" ;;
-  x86_64-unknown-linux-gnu) NATIVE_PACKAGE="@auroraflow/code-linux-x64" ;;
-  *) exec node "$BIN_DIR/aurora-node.js" "$@" ;;
-esac
-
-NATIVE_ROOT="$PACKAGE_ROOT/node_modules/$NATIVE_PACKAGE/vendor/$TARGET"
-BINARY="$NATIVE_ROOT/bin/aurora"
-if [ ! -x "$BINARY" ]; then
-  NATIVE_ROOT="$PACKAGE_ROOT/vendor/$TARGET"
-  BINARY="$NATIVE_ROOT/bin/aurora"
-fi
-
-if [ ! -x "$BINARY" ]; then
-  exec node "$BIN_DIR/aurora-node.js" "$@"
-fi
-
-if [ -z "\${AURORA_HOME+x}" ] || [ -z "$AURORA_HOME" ]; then
-  AURORA_HOME="$HOME/.aurora"
-fi
-
-export AURORA_HOME
-export CODEX_HOME="$AURORA_HOME"
-export AURORA_MANAGED_BY_NPM=1
-export CODEX_MANAGED_BY_NPM=1
-export AURORA_MANAGED_PACKAGE_ROOT="$PACKAGE_ROOT"
-export CODEX_MANAGED_PACKAGE_ROOT="$PACKAGE_ROOT"
-
-if [ -d "$NATIVE_ROOT/aurora-path" ]; then
-  PATH="$NATIVE_ROOT/aurora-path:$PATH"
-elif [ -d "$NATIVE_ROOT/path" ]; then
-  PATH="$NATIVE_ROOT/path:$PATH"
-fi
-export PATH
-
-if [ -t 1 ]; then
-  printf '\\033]0;aurora\\007'
-fi
-
-exec "$BINARY" "$@"
-`;
-
-writeFileSync(entryPath, launcher);
-chmodSync(entryPath, 0o755);