@auroraflow/code 0.0.6 → 0.0.8

package/packages/sidecar/src/index.js

@@ -0,0 +1,177 @@
+import { createServer } from "node:http";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { AURORA_LOCALHOST, AURORA_SIDECAR_PORT, isRuntimePath, rewriteRuntimeModel, selectedKeyHeaders, toClientModelItem, toCodexModelInfo, trimSlash } from "../../protocol/src/index.js";
+import { CODEX_HOME, readState, writeSidecarInfo } from "../../state/src/index.js";
+
+const CODEX_MODEL_CAPABILITIES_PATH = join(CODEX_HOME, "model_capabilities.json");
+
+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, url);
+    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, incomingURL) {
+  const state = await readState();
+  const gatewayURL = trimSlash(state.gatewayURL ?? "https://auroramos.com");
+  const clientVersion = incomingURL.searchParams.get("client_version");
+  const upstreamURL = clientVersion
+    ? `${gatewayURL}/v1/aurora-cli/models?client_version=${encodeURIComponent(clientVersion)}`
+    : `${gatewayURL}/v1/aurora-cli/models`;
+  const upstream = await fetch(upstreamURL, {
+    headers: {
+      ...selectedKeyHeaders(state),
+      "accept-encoding": "identity"
+    }
+  });
+  const payload = await upstream.json().catch(() => ({ object: "list", data: [] }));
+  const sourceModels = Array.isArray(payload.data) ? payload.data : [];
+  if (clientVersion) {
+    await writeCodexModelCapabilities(sourceModels);
+    const models = sourceModels.map((item, index) => toCodexModelInfo(item, index));
+    writeJSON(response, upstream.ok ? 200 : upstream.status, { models });
+    return;
+  }
+  const data = sourceModels.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 capabilitiesByAlias = await readCodexModelCapabilities();
+  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",
+      "accept-encoding": "identity"
+    },
+    body: rewriteRuntimeModel(body, state.selectedModel?.alias, capabilitiesByAlias)
+  });
+  response.writeHead(upstream.status, responseHeaders(upstream.headers));
+  if (upstream.body) {
+    for await (const chunk of upstream.body) response.write(chunk);
+  }
+  response.end();
+}
+
+async function writeCodexModelCapabilities(sourceModels) {
+  const models = {};
+  for (const item of sourceModels) {
+    const alias = String(item.alias ?? item.id ?? item.model_id ?? "");
+    if (!alias) continue;
+    models[alias] = {
+      supports_web_search: item.supports_web_search === true,
+      web_search_tool_type: item.web_search_tool_type ?? null
+    };
+  }
+  await writeFile(CODEX_MODEL_CAPABILITIES_PATH, `${JSON.stringify({
+    generated_at: new Date().toISOString(),
+    models
+  }, null, 2)}\n`, { mode: 0o600 });
+}
+
+async function readCodexModelCapabilities() {
+  try {
+    const payload = JSON.parse(await readFile(CODEX_MODEL_CAPABILITIES_PATH, "utf8"));
+    return payload && typeof payload.models === "object" && payload.models !== null ? payload.models : {};
+  } catch {
+    return {};
+  }
+}
+
+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", "accept-encoding"].includes(key.toLowerCase())) continue;
+    if (value !== undefined) out[key] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return out;
+}
+
+function responseHeaders(headers) {
+  const out = {};
+  for (const [key, value] of headers.entries()) {
+    const normalized = key.toLowerCase();
+    if ([
+      "connection",
+      "content-encoding",
+      "content-length",
+      "keep-alive",
+      "proxy-authenticate",
+      "proxy-authorization",
+      "te",
+      "trailer",
+      "transfer-encoding",
+      "upgrade"
+    ].includes(normalized)) {
+      continue;
+    }
+    out[key] = 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);