@jiayunxie/aerial 0.1.5 → 0.1.7

package/src/cli.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
-import { startDeviceFlow, pollDeviceFlow } from "./auth.js";
+import { startDeviceFlow, pollDeviceFlow, readGitHubToken, gitHubTokenSource } from "./auth.js";
 import { ensureApiKey, loadConfig, saveConfig } from "./config.js";
 import { startServer } from "./server.js";
 import { setupClaude, setupCodex, setupStatus, restoreClient, restoreAllClients } from "./setup.js";
 import { serviceInstall, serviceStart, serviceStop, serviceRestart, serviceUninstall, serviceStatus } from "./service.js";
 import { doctor } from "./doctor.js";
 import { runProbe, formatProbeReport } from "./probe.js";
+import { chooseSetupModel, formatModelChoices } from "./model-selection.js";
 import { printVersion } from "./version.js";
+import { computeAppStatus } from "./app-status.js";
 
 const CLI_ENTRY = fileURLToPath(import.meta.url);
 
@@ -20,36 +22,35 @@ function codexAuthCommand() {
   };
 }
 
+function quoteCommandPart(value) {
+  return `"${String(value).replace(/"/g, '\\"')}"`;
+}
+
+function claudeApiKeyHelper() {
+  return [process.execPath, CLI_ENTRY, "key", "print"].map(quoteCommandPart).join(" ");
+}
+
 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 service install
+  aerial status [--json]
+
+Diagnostics and rollback:
   aerial setup status [--json]
   aerial setup restore <codex|claude|all> --latest
-  aerial service install
-  aerial service start
-  aerial service stop
-  aerial service restart
   aerial service status [--json]
-  aerial service uninstall
   aerial disable
   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`);
+Debug:
+  aerial start [--host 127.0.0.1] [--port 18181]`);
 }
 
 function argValue(args, name) {
@@ -57,13 +58,96 @@ function argValue(args, name) {
   return index >= 0 ? args[index + 1] : undefined;
 }
 
+async function selectSetupModel(target, route, args) {
+  const selected = await chooseSetupModel({ target, route, explicitModel: argValue(args, "--model") });
+  if (!selected.displayed) {
+    for (const line of formatModelChoices({ target, route, choices: selected.choices, selectedModel: selected.model, source: selected.source, recommended: selected.recommended })) {
+      console.log(line);
+    }
+  } else {
+    console.log(`Selected ${target} model: ${selected.model}`);
+  }
+  return selected.model;
+}
+
+function printSetupSummary(status) {
+  console.log("clients:");
+  for (const client of Object.values(status.clients)) {
+    const model = client.model ? ` model=${client.model}` : "";
+    console.log(`  ${client.target}: ${client.state}${model}`);
+  }
+  console.log(`api key: ${status.auth.api_key.exists ? "present" : "missing"}`);
+  const ghSource = status.auth.github_token.source;
+  const ghText = ghSource === "missing" ? "missing" : `present (${ghSource})`;
+  console.log(`github login: ${ghText}`);
+}
+
+function printServiceSummary(status) {
+  console.log(`service: ${status.summary}`);
+  if (status.supported === false) {
+    console.log(`platform: ${status.platform} (service unsupported)`);
+    return;
+  }
+  const health = status.health?.aerial ? `ok (${status.health.supervisor})`
+    : status.health?.portConflict ? `port conflict (${status.health.conflictReason})`
+    : status.health?.ok ? "ok"
+    : `unreachable (${status.health?.error || `http ${status.health?.status}`})`;
+  console.log(`health: ${health}`);
+}
+
+async function appStatus({ json = false } = {}) {
+  const setup = setupStatus();
+  const service = await serviceStatus();
+  const status = computeAppStatus(setup, service);
+  if (json) {
+    console.log(JSON.stringify(status, null, 2));
+    return status;
+  }
+  console.log("Aerial status");
+  printSetupSummary(setup);
+  printServiceSummary(service);
+  if (status.nextSteps.length) {
+    console.log("next:");
+    for (const step of status.nextSteps) console.log(`  - ${step}`);
+  }
+  if (status.hints.length) {
+    console.log("hints:");
+    for (const hint of status.hints) console.log(`  - ${hint}`);
+  }
+  return status;
+}
+
 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 === "status") {
+    const status = await appStatus({ json: args.includes("--json") });
+    process.exitCode = status.ok ? 0 : 1;
+    return;
+  }
 
   if (command === "login") {
+    const loginArgs = args.slice(1);
+    const force = loginArgs.includes("--force");
+    const source = gitHubTokenSource();
+    if (force && source === "env") {
+      console.error("AERIAL_GITHUB_TOKEN is set; unset it before running `aerial login --force`, otherwise the env value will continue to shadow any new file token.");
+      process.exit(1);
+    }
+    if (!force && source === "env") {
+      console.log("GitHub login is provided by AERIAL_GITHUB_TOKEN (not verified). To use a different account, unset it or run with a different environment.");
+      return;
+    }
+    if (!force && source === "file") {
+      console.log("GitHub login already exists (not verified). To sign in again, run aerial login --force.");
+      return;
+    }
+    if (process.env.AERIAL_TEST_LOGIN_NO_NETWORK === "1") {
+      console.log("AERIAL_TEST_LOGIN_NO_NETWORK=1 set; skipping GitHub device flow (test mode).");
+      return;
+    }
     const flow = await startDeviceFlow();
     console.log(`Open: ${flow.verification_uri}`);
     console.log(`Code: ${flow.user_code}`);
@@ -102,16 +186,20 @@ async function main() {
 
   if (command === "setup") {
     if (subcommand === "codex") {
-      const result = setupCodex({ model: argValue(rest, "--model"), authCommand: codexAuthCommand() });
+      const model = await selectSetupModel("Codex", "responses", rest);
+      const result = setupCodex({ model, authCommand: codexAuthCommand() });
       console.log(`Updated Codex config: ${result.file}`);
+      console.log(`Configured Codex model: ${result.model}`);
       if (result.backup) console.log(`Backup: ${result.backup}`);
       console.log("Configured Codex to read the local Aerial key automatically.");
       return;
     }
     if (subcommand === "claude") {
-      const result = setupClaude({ model: argValue(rest, "--model") });
+      const model = await selectSetupModel("Claude Code", "messages", rest);
+      const result = setupClaude({ model, apiKeyHelper: claudeApiKeyHelper() });
       console.log(`Updated Claude settings: ${result.file}`);
       if (result.model) console.log(`Configured Claude default model: ${result.model}`);
+      console.log("Configured Claude Code to read the local Aerial key automatically.");
       if (result.backup) console.log(`Backup: ${result.backup}`);
       return;
     }
@@ -126,7 +214,12 @@ async function main() {
       }
       console.log(`Aerial: http://${status.config.host}:${status.config.port}  (platform: ${status.platform})`);
       console.log(`API key file:    ${status.auth.api_key.file}  (${status.auth.api_key.exists ? "present" : "missing"})`);
-      console.log(`GitHub token:    ${status.auth.github_token.file}  (${status.auth.github_token.exists ? "present" : "missing"})`);
+      const ghSourceText = status.auth.github_token.source === "missing"
+        ? `(missing)`
+        : status.auth.github_token.source === "env"
+          ? `(present, source=env; file path ${status.auth.github_token.file} is not consulted while AERIAL_GITHUB_TOKEN is set)`
+          : `${status.auth.github_token.file}  (present, source=file)`;
+      console.log(`GitHub token:    ${ghSourceText}`);
       for (const cs of Object.values(status.clients)) {
         const head = `${cs.target.padEnd(7)} state=${cs.state}`;
         console.log(`${head}  file=${cs.file}`);
@@ -221,6 +314,17 @@ async function main() {
         if (r.bootstrap?.stderr) console.log(`  bootstrap stderr: ${r.bootstrap.stderr.trim()}`);
         if (r.create?.stderr) console.log(`  schtasks stderr: ${r.create.stderr.trim()}`);
         if (r.run?.stderr) console.log(`  schtasks /Run stderr: ${r.run.stderr.trim()}`);
+        if (r.diagnostics) {
+          if (r.diagnostics.stdioLog) console.log(`  stdio log: ${r.diagnostics.stdioLog}`);
+          if (r.diagnostics.aerialLog) console.log(`  aerial log: ${r.diagnostics.aerialLog}`);
+          if (r.diagnostics.wrapperNode) console.log(`  wrapper node: ${r.diagnostics.wrapperNode}`);
+          if (r.diagnostics.health) {
+            const h = r.diagnostics.health;
+            const tail = h.lastError ? `, last error: ${h.lastError}` : (h.lastStatus !== undefined ? `, last status: ${h.lastStatus}` : "");
+            console.log(`  health probe: ${h.attempts} attempts over ${h.elapsedMs}ms${tail}`);
+          }
+          console.log(`  Run: aerial service status --json`);
+        }
         if (r.warning) console.log(`  WARNING: ${r.warning.message}`);
         process.exitCode = r.ok ? 0 : 1;
       } catch (err) {
@@ -236,6 +340,17 @@ async function main() {
         else if (r.ok) console.log(`Service start: ok (${r.platform})`);
         else console.log(`Service start: FAILED (${r.reason || `status=${r.status}`})${r.message ? ": " + r.message : ""}`);
         if (r.stderr) console.log(`  ${r.stderr.trim()}`);
+        if (r.diagnostics) {
+          if (r.diagnostics.stdioLog) console.log(`  stdio log: ${r.diagnostics.stdioLog}`);
+          if (r.diagnostics.aerialLog) console.log(`  aerial log: ${r.diagnostics.aerialLog}`);
+          if (r.diagnostics.wrapperNode) console.log(`  wrapper node: ${r.diagnostics.wrapperNode}`);
+          if (r.diagnostics.health) {
+            const h = r.diagnostics.health;
+            const tail = h.lastError ? `, last error: ${h.lastError}` : (h.lastStatus !== undefined ? `, last status: ${h.lastStatus}` : "");
+            console.log(`  health probe: ${h.attempts} attempts over ${h.elapsedMs}ms${tail}`);
+          }
+          console.log(`  Run: aerial service status --json`);
+        }
         if (r.warning) console.log(`  WARNING: ${r.warning.message}`);
         process.exitCode = r.ok ? 0 : 1;
       } catch (err) {

package/src/copilot.js

@@ -179,23 +179,50 @@ function withSupportedAnthropicEffort(payload) {
   if (effort === undefined) return payload;
   const model = typeof payload?.model === "string" ? payload.model : "";
   if (!/^claude-opus-4[.-]7(?:-|$)/.test(model)) return payload;
-  const routes = {
-    low: "claude-opus-4.7-1m-internal",
-    medium: "claude-opus-4.7",
-    high: "claude-opus-4.7-high",
-    xhigh: "claude-opus-4.7-xhigh",
-    max: "claude-opus-4.7-xhigh"
-  };
-  const nextModel = routes[effort];
   const nextEffort = effort === "max" ? "xhigh" : effort;
-  if (!nextModel) return payload;
+  if (!["low", "medium", "high", "xhigh"].includes(nextEffort)) return payload;
+  const baseModel = /^claude-opus-4[.-]7$/.test(model);
+  const legacyEffortModel = /^claude-opus-4[.-]7-(?:high|xhigh)$/.test(model);
+  const nextModel = legacyEffortModel || (baseModel && nextEffort !== "medium")
+    ? "claude-opus-4.7-1m-internal"
+    : model;
   if (model === nextModel && effort === nextEffort) return payload;
   logEvent("anthropic_effort_route", { model, effort, routedModel: nextModel, routedEffort: nextEffort });
   return { ...payload, model: nextModel, output_config: { ...payload.output_config, effort: nextEffort } };
 }
 
+function legacyThinkingEffort(thinking) {
+  if (typeof thinking?.effort === "string" && thinking.effort.trim()) return thinking.effort.trim();
+  const budget = Number(thinking?.budget_tokens);
+  if (!Number.isFinite(budget) || budget <= 0) return "medium";
+  if (budget <= 4096) return "low";
+  if (budget <= 16000) return "medium";
+  if (budget <= 64000) return "high";
+  return "xhigh";
+}
+
+function isLegacyThinkingEnabled(thinking) {
+  if (!thinking || typeof thinking !== "object" || Array.isArray(thinking)) return false;
+  if (thinking.type === "enabled") return true;
+  return Boolean(thinking.type && typeof thinking.type === "object" && thinking.type.enabled);
+}
+
+function withSupportedAnthropicThinking(payload) {
+  if (!isLegacyThinkingEnabled(payload?.thinking)) return payload;
+  const outputConfig = payload?.output_config && typeof payload.output_config === "object" && !Array.isArray(payload.output_config)
+    ? payload.output_config
+    : {};
+  const effort = outputConfig.effort ?? legacyThinkingEffort(payload.thinking);
+  logEvent("anthropic_thinking_route", { model: payload.model, routedType: "adaptive", routedEffort: effort });
+  return {
+    ...payload,
+    thinking: { type: "adaptive" },
+    output_config: { ...outputConfig, effort }
+  };
+}
+
 function withAnthropicDefaults(payload) {
-  return withSupportedAnthropicEffort(withDefaultAnthropicCache(payload));
+  return withSupportedAnthropicEffort(withSupportedAnthropicThinking(withDefaultAnthropicCache(payload)));
 }
 
 function parseJsonBody(body, contentType) {

package/src/model-selection.js

@@ -0,0 +1,144 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { proxyModels } from "./copilot.js";
+
+const MAX_LISTED_MODELS = 20;
+const GPT_VERSION_RE = /^gpt-(\d+)(?:\.(\d+))?/i;
+const STABLE_GPT_RE = /^gpt-\d+(?:\.\d+)?$/i;
+
+async function readJson(response) {
+  const text = await response.text();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+
+function modelRoutes(model) {
+  return Array.isArray(model?.aerial?.routes) ? model.aerial.routes : [];
+}
+
+export function modelsForRoute(models, route) {
+  return models
+    .filter((model) => typeof model?.id === "string" && modelRoutes(model).includes(route))
+    .map((model) => ({ id: model.id, routes: modelRoutes(model), notes: model.aerial?.notes || [] }));
+}
+
+function gptVersionScore(id) {
+  const match = GPT_VERSION_RE.exec(id);
+  if (!match) return undefined;
+  const major = Number(match[1]);
+  const minor = match[2] === undefined ? 0 : Number(match[2]);
+  return major * 1000 + minor;
+}
+
+export function rankModels(choices) {
+  return [...choices]
+    .map((choice, index) => ({ choice, index, score: gptVersionScore(choice.id) }))
+    .sort((a, b) => {
+      if (a.score !== undefined && b.score !== undefined && a.score !== b.score) return b.score - a.score;
+      if (a.score !== undefined && b.score === undefined) return -1;
+      if (a.score === undefined && b.score !== undefined) return 1;
+      return a.index - b.index;
+    })
+    .map((entry) => entry.choice);
+}
+
+export function pickRecommended(choices) {
+  if (!choices.length) return { recommended: undefined, source: "first_available" };
+  const ranked = rankModels(choices);
+  const stable = ranked.filter((c) => STABLE_GPT_RE.test(c.id));
+  if (stable.length) return { recommended: stable[0].id, source: "recommended_stable", ranked };
+  return { recommended: ranked[0].id, source: "recommended_fallback", ranked };
+}
+
+export function orderForPrompt(ranked, recommended) {
+  if (!recommended) return [...ranked];
+  const found = ranked.find((c) => c.id === recommended);
+  if (!found) return [...ranked];
+  return [found, ...ranked.filter((c) => c.id !== recommended)];
+}
+
+export async function discoverModelsForRoute(route) {
+  const response = await proxyModels(new Request("http://aerial.local/v1/models", { method: "GET" }));
+  const payload = await readJson(response);
+  if (!response.ok) {
+    const detail = payload.error || payload.raw || JSON.stringify(payload);
+    throw new Error(`Could not load Copilot models (${response.status}): ${detail}`);
+  }
+  const models = Array.isArray(payload.data) ? payload.data : [];
+  return modelsForRoute(models, route);
+}
+
+function parseChoice(value, max) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) return 1;
+  if (!/^\d+$/.test(trimmed)) return undefined;
+  const n = Number(trimmed);
+  return n >= 1 && n <= max ? n : undefined;
+}
+
+export async function chooseSetupModel({ target, route, explicitModel, prompt = input.isTTY }) {
+  if (explicitModel) return { model: explicitModel, choices: [], source: "explicit" };
+  let raw;
+  try {
+    raw = await discoverModelsForRoute(route);
+  } catch (err) {
+    throw new Error(`${err.message}\nRun \`aerial login\` first, or pass \`--model <id>\` if you already know which ${target} model to use.`);
+  }
+  if (!raw.length) {
+    throw new Error(`No Copilot models currently advertise the ${route} route needed by ${target}. Run \`aerial probe\` to inspect the full model list.`);
+  }
+  const { recommended, source: recommendedSource, ranked } = pickRecommended(raw);
+  const choices = ranked;
+  const promptListed = orderForPrompt(ranked, recommended).slice(0, MAX_LISTED_MODELS);
+  if (!prompt) return { model: recommended, choices, source: recommendedSource, recommended };
+
+  const rl = createInterface({ input, output });
+  try {
+    output.write(`Available ${target} models (${route} route):\n`);
+    if (recommendedSource === "recommended_fallback") {
+      output.write(`  No stable gpt-N.M model available; recommending ${recommended} as a fallback. Pass --model <id> to override.\n`);
+    }
+    for (const [index, choice] of promptListed.entries()) {
+      const marker = choice.id === recommended ? "  (recommended)" : "";
+      output.write(`  ${index + 1}. ${choice.id}${marker}\n`);
+    }
+    if (choices.length > MAX_LISTED_MODELS) output.write(`  ... ${choices.length - MAX_LISTED_MODELS} more\n`);
+    while (true) {
+      const answer = await rl.question(`Choose ${target} model [1-${promptListed.length}, default 1 = ${recommended}]: `);
+      const selected = parseChoice(answer, promptListed.length);
+      if (selected) return { model: promptListed[selected - 1].id, choices, source: "prompt", displayed: true, recommended };
+      output.write(`Enter a number from 1 to ${promptListed.length}, or press Enter for 1.\n`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+export function formatModelChoices({ target, route, choices, selectedModel, source, recommended }) {
+  if (!choices.length) return [];
+  const lines = [
+    `Available ${target} models (${route} route):`
+  ];
+  for (const [index, choice] of choices.slice(0, MAX_LISTED_MODELS).entries()) {
+    const markers = [];
+    if (choice.id === recommended) markers.push("recommended");
+    if (choice.id === selectedModel) markers.push("selected");
+    const suffix = markers.length ? `  (${markers.join(", ")})` : "";
+    lines.push(`  ${index + 1}. ${choice.id}${suffix}`);
+  }
+  if (choices.length > MAX_LISTED_MODELS) lines.push(`  ... ${choices.length - MAX_LISTED_MODELS} more`);
+  if (source === "first_available") {
+    lines.push(`No interactive terminal detected; selected ${selectedModel}. Pass --model <id> to choose a different model.`);
+  } else if (source === "recommended_stable") {
+    lines.push(`No interactive terminal detected; selected ${selectedModel}. Pass --model <id> to choose a different model.`);
+  } else if (source === "recommended_fallback") {
+    lines.push(`No stable gpt-N.M model available; selected ${selectedModel}. Pass --model <id> to override.`);
+  } else {
+    lines.push(`Selected ${target} model: ${selectedModel}`);
+  }
+  return lines;
+}

package/src/server.js

@@ -2,12 +2,53 @@ import http from "node:http";
 import { DEFAULT_HOST, DEFAULT_PORT } from "./constants.js";
 import { loadConfig, validateLocalAuth } from "./config.js";
 import { proxyChatCompletions, proxyMessages, proxyModels, proxyResponses, localCountTokens } from "./copilot.js";
+import { readGitHubToken } from "./auth.js";
 import { logEvent } from "./log.js";
 
 function json(status, body) {
   return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
 }
 
+function aerialLoginRequired() {
+  return json(401, {
+    error: {
+      type: "authentication_error",
+      message: "GitHub login required. Run aerial login.",
+      aerial: { status: "login_required" }
+    }
+  });
+}
+
+async function modelsRouteOrUpstreamAuthFailed(fetchRequest) {
+  if (!readGitHubToken()) return aerialLoginRequired();
+  let response;
+  try {
+    response = await proxyModels(fetchRequest);
+  } catch (err) {
+    const status = err?.aerialUpstreamStatus;
+    if (status === 401 || status === 403) {
+      return json(status, {
+        error: {
+          type: "authentication_error",
+          message: "GitHub login was rejected by Copilot. Run aerial login --force.",
+          aerial: { status: "upstream_auth_failed", upstream_status: status }
+        }
+      });
+    }
+    throw err;
+  }
+  if (response.status === 401 || response.status === 403) {
+    return json(response.status, {
+      error: {
+        type: "authentication_error",
+        message: "GitHub login was rejected by Copilot. Run aerial login --force.",
+        aerial: { status: "upstream_auth_failed", upstream_status: response.status }
+      }
+    });
+  }
+  return response;
+}
+
 function nodeRequestToFetch(req, body, signal) {
   return new Request(`http://${req.headers.host}${req.url}`, { method: req.method, headers: req.headers, body: body.length ? body : undefined, duplex: "half", signal });
 }
@@ -24,12 +65,23 @@ async function handle(fetchRequest, runtime = {}) {
   if (fetchRequest.method === "GET" && url.pathname === "/health") {
     return Response.json({ ok: true, service: "aerial", host: runtime.host || config.host, port: runtime.port || config.port });
   }
+  if (fetchRequest.method === "GET" && url.pathname === "/") {
+    return Response.json({
+      service: "aerial",
+      ok: true,
+      message: "Aerial is running. This is a local-only Copilot proxy; inference routes require the local Aerial API key.",
+      endpoints: { health: "/health", models: "/v1/models" },
+      next_steps: ["Open /health for an unauthenticated check", "Run `aerial status` for a full diagnostic"]
+    });
+  }
+  if (fetchRequest.method === "GET" && url.pathname === "/v1/models") {
+    return modelsRouteOrUpstreamAuthFailed(fetchRequest);
+  }
 
   if (!validateLocalAuth(Object.fromEntries(fetchRequest.headers), config)) {
     return json(401, { error: { type: "authentication_error", message: "Invalid or missing Aerial API key" } });
   }
 
-  if (fetchRequest.method === "GET" && url.pathname === "/v1/models") return proxyModels(fetchRequest);
   if (fetchRequest.method === "POST" && url.pathname === "/v1/responses") return proxyResponses(fetchRequest);
   if (fetchRequest.method === "POST" && url.pathname === "/v1/messages") return proxyMessages(fetchRequest);
   if (fetchRequest.method === "POST" && url.pathname === "/v1/messages/count_tokens") return localCountTokens(fetchRequest);