@jiayunxie/aerial 0.1.0

package/src/cli.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { startDeviceFlow, pollDeviceFlow } from "./auth.js";
+import { ensureApiKey, loadConfig, saveConfig } from "./config.js";
+import { startServer } from "./server.js";
+import { setupClaude, setupCodex } from "./setup.js";
+import { doctor } from "./doctor.js";
+import { runProbe, formatProbeReport } from "./probe.js";
+import { printVersion } from "./version.js";
+
+function printHelp() {
+  console.log(`Aerial local Copilot proxy
+
+Usage:
+  aerial --version
+  aerial login
+  aerial key generate
+  aerial key print
+  aerial start [--host 127.0.0.1] [--port 18181]
+  aerial setup codex [--model <id>]
+  aerial setup claude [--model <id>]
+  aerial setup all [--model <id>]
+  aerial doctor
+  aerial probe [--live] [--json]
+
+MVP routes:
+  GET  /health
+  GET  /v1/models
+  POST /v1/responses
+  POST /v1/messages
+  POST /v1/messages/count_tokens
+  POST /v1/chat/completions`);
+}
+
+function argValue(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const [command, subcommand, ...rest] = args;
+  if (!command || command === "--help" || command === "-h") return printHelp();
+  if (command === "--version") return printVersion();
+
+  if (command === "login") {
+    const flow = await startDeviceFlow();
+    console.log(`Open: ${flow.verification_uri}`);
+    console.log(`Code: ${flow.user_code}`);
+    console.log("Waiting for GitHub authorization...");
+    await pollDeviceFlow(flow.device_code, flow.interval);
+    console.log("GitHub login saved.");
+    return;
+  }
+
+  if (command === "key") {
+    if (subcommand === "generate") {
+      const result = ensureApiKey();
+      if (result.apiKey) {
+        console.log("Local Aerial key generated and stored privately.");
+      } else {
+        console.log("Aerial API key already configured.");
+      }
+      return;
+    }
+    if (subcommand === "print") {
+      const result = ensureApiKey();
+      if (result.apiKey) console.log(result.apiKey);
+      else throw new Error("Raw API key is not available. Run: aerial key generate");
+      return;
+    }
+  }
+
+  if (command === "start") {
+    const config = loadConfig();
+    const host = argValue(args, "--host") || config.host;
+    const port = Number(argValue(args, "--port") || config.port);
+    ensureApiKey();
+    startServer({ host, port });
+    return;
+  }
+
+  if (command === "setup") {
+    if (subcommand === "codex") {
+      const result = setupCodex({ model: argValue(rest, "--model") });
+      console.log(`Updated Codex config: ${result.file}`);
+      if (result.backup) console.log(`Backup: ${result.backup}`);
+      if (result.env?.persisted) console.log(`Configured ${result.env.name} for new user sessions.`);
+      else if (result.env?.reason) console.log(`Note: ${result.env.name} is available in this process, but was not persisted (${result.env.reason}).`);
+      return;
+    }
+    if (subcommand === "claude") {
+      const result = setupClaude({ model: argValue(rest, "--model") });
+      console.log(`Updated Claude settings: ${result.file}`);
+      if (result.model) console.log(`Configured Claude default model: ${result.model}`);
+      if (result.backup) console.log(`Backup: ${result.backup}`);
+      return;
+    }
+    if (subcommand === "all") {
+      const model = argValue(rest, "--model");
+      const codex = setupCodex({ model });
+      const claude = setupClaude({ model });
+      console.log(`Updated Codex config: ${codex.file}`);
+      if (codex.env?.persisted) console.log(`Configured ${codex.env.name} for new user sessions.`);
+      else if (codex.env?.reason) console.log(`Note: ${codex.env.name} is available in this process, but was not persisted (${codex.env.reason}).`);
+      console.log(`Updated Claude settings: ${claude.file}`);
+      if (claude.model) console.log(`Configured Claude default model: ${claude.model}`);
+      return;
+    }
+  }
+
+  if (command === "doctor") {
+    const result = doctor();
+    for (const check of result.checks) {
+      console.log(`${check.ok ? "OK" : "FAIL"} ${check.name}: ${check.detail}`);
+    }
+    process.exitCode = result.ok ? 0 : 1;
+    return;
+  }
+
+  if (command === "probe") {
+    const report = await runProbe({ live: args.includes("--live") });
+    if (args.includes("--json")) console.log(JSON.stringify(report, null, 2));
+    else console.log(formatProbeReport(report));
+    process.exitCode = report.ok ? 0 : 1;
+    return;
+  }
+
+  if (command === "config") {
+    const config = loadConfig();
+    if (subcommand === "set") {
+      const [key, value] = rest;
+      if (!key || value === undefined) throw new Error("Usage: aerial config set <key> <value>");
+      if (!["host", "port", "defaultModel", "logLevel", "promptCacheRetention", "promptCacheKey"].includes(key)) throw new Error(`Unsupported config key: ${key}`);
+      if (key === "promptCacheRetention" && !["in_memory", "24h", "off"].includes(value)) throw new Error("promptCacheRetention must be one of: in_memory, 24h, off");
+      if (key === "promptCacheKey" && !value.trim()) throw new Error("promptCacheKey must be auto, off, or a non-empty string");
+      config[key] = key === "port" ? Number(value) : value;
+      saveConfig(config);
+      return;
+    }
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+
+  printHelp();
+  process.exitCode = 1;
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/src/config.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import { CONFIG_VERSION, DEFAULT_HOST, DEFAULT_PORT, DEFAULT_VERSIONS } from "./constants.js";
+import { apiKeyPath, configPath, readJsonIfExists, writeJsonPrivate, writePrivateFile } from "./paths.js";
+import { hashApiKey, randomApiKey, verifyApiKey } from "./crypto.js";
+
+export function defaultConfig() {
+  return {
+    version: CONFIG_VERSION,
+    host: DEFAULT_HOST,
+    port: DEFAULT_PORT,
+    apiKeyHash: undefined,
+    defaultModel: undefined,
+    logLevel: "info",
+    promptCacheRetention: "in_memory",
+    promptCacheKey: "auto",
+    versions: DEFAULT_VERSIONS
+  };
+}
+
+export function loadConfig() {
+  const loaded = readJsonIfExists(configPath()) || {};
+  const envRetention = process.env.AERIAL_PROMPT_CACHE_RETENTION;
+  const envCacheKey = process.env.AERIAL_PROMPT_CACHE_KEY;
+  const defaults = defaultConfig();
+  const promptCacheRetention = envRetention === undefined ? (loaded.promptCacheRetention ?? defaults.promptCacheRetention) : envRetention;
+  const promptCacheKey = envCacheKey === undefined ? (loaded.promptCacheKey ?? defaults.promptCacheKey) : envCacheKey;
+  return { ...defaults, ...loaded, promptCacheRetention, promptCacheKey, versions: { ...DEFAULT_VERSIONS, ...(loaded.versions || {}) } };
+}
+
+export function saveConfig(config) {
+  writeJsonPrivate(configPath(), config);
+}
+
+export function readStoredApiKey() {
+  if (!fs.existsSync(apiKeyPath())) return undefined;
+  const apiKey = fs.readFileSync(apiKeyPath(), "utf8").trim();
+  return apiKey || undefined;
+}
+
+function writeStoredApiKey(apiKey) {
+  writePrivateFile(apiKeyPath(), `${apiKey}\n`);
+}
+
+export function ensureApiKey() {
+  const config = loadConfig();
+  const envKey = process.env.AERIAL_API_KEY;
+  if (envKey) {
+    config.apiKeyHash = hashApiKey(envKey);
+    writeStoredApiKey(envKey);
+    saveConfig(config);
+    return { apiKey: envKey, config, created: false, source: "env" };
+  }
+  const storedKey = readStoredApiKey();
+  if (storedKey) {
+    if (!config.apiKeyHash || !verifyApiKey(storedKey, config.apiKeyHash)) {
+      config.apiKeyHash = hashApiKey(storedKey);
+      saveConfig(config);
+    }
+    return { apiKey: storedKey, config, created: false, source: "stored" };
+  }
+  const hadHash = Boolean(config.apiKeyHash);
+  const apiKey = randomApiKey();
+  config.apiKeyHash = hashApiKey(apiKey);
+  writeStoredApiKey(apiKey);
+  saveConfig(config);
+  return { apiKey, config, created: true, source: hadHash ? "rotated" : "generated" };
+}
+
+export function validateLocalAuth(headers, config = loadConfig()) {
+  const lowerHeaders = Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+  const authorization = lowerHeaders.authorization;
+  const bearer = authorization?.startsWith("Bearer ") ? authorization.slice("Bearer ".length).trim() : undefined;
+  const apiKey = lowerHeaders["x-api-key"] || bearer;
+  return verifyApiKey(apiKey, config.apiKeyHash);
+}
+
+export function requireConfigFile() {
+  if (!fs.existsSync(configPath())) {
+    throw new Error(`Aerial is not initialized. Run: aerial key generate`);
+  }
+}

package/src/constants.js

@@ -0,0 +1,11 @@
+export const DEFAULT_HOST = "127.0.0.1";
+export const DEFAULT_PORT = 18181;
+export const CONFIG_VERSION = 1;
+export const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+export const COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
+export const COPILOT_API_ORIGIN = "https://api.githubcopilot.com";
+export const DEFAULT_VERSIONS = {
+  vscode: "1.105.0",
+  copilotChat: "0.45.1"
+};
+export const DEFAULT_ANTHROPIC_VERSION = "2023-06-01";