@jiayunxie/aerial 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jiayunxie/aerial",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Local-only GitHub Copilot proxy for Codex CLI and Claude Code.",
   "type": "module",
   "private": false,

package/src/cli.js

@@ -314,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) {
@@ -329,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

@@ -174,28 +174,99 @@ function withDefaultAnthropicCache(payload) {
   return next;
 }
 
-function withSupportedAnthropicEffort(payload) {
+function canonicalClaudeOpus47Family(model) {
+  return /^claude-opus-4[.-]7(?:-|$)/.test(model) ? "claude-opus-4.7" : undefined;
+}
+
+function modelHasMessagesRoute(model) {
+  const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
+  const routes = Array.isArray(model?.aerial?.routes) ? model.aerial.routes : [];
+  return endpoints.includes("/v1/messages") || routes.includes("messages");
+}
+
+function supportedReasoningEfforts(model) {
+  const supports = model?.capabilities?.supports;
+  const values = supports?.reasoning_effort ?? supports?.reasoning_efforts;
+  if (Array.isArray(values)) return values.map(String);
+  if (typeof values === "string") return [values];
+  return [];
+}
+
+function modelSupportsAdaptiveThinking(model) {
+  const supports = model?.capabilities?.supports;
+  return supports?.adaptive_thinking === true || supports?.thinking?.adaptive === true;
+}
+
+function findAnthropicEffortModel(modelId, effort, models) {
+  if (!Array.isArray(models)) return undefined;
+  const family = canonicalClaudeOpus47Family(modelId);
+  if (!family) return undefined;
+  const candidates = models.filter((model) => {
+    const id = typeof model?.id === "string" ? model.id : "";
+    return canonicalClaudeOpus47Family(id) === family &&
+      modelHasMessagesRoute(model) &&
+      modelSupportsAdaptiveThinking(model) &&
+      supportedReasoningEfforts(model).includes(effort);
+  });
+  return candidates.find((model) => model.id === modelId) || candidates[0];
+}
+
+function withSupportedAnthropicEffort(payload, models) {
   const effort = payload?.output_config?.effort;
   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];
+  if (!canonicalClaudeOpus47Family(model)) return payload;
   const nextEffort = effort === "max" ? "xhigh" : effort;
-  if (!nextModel) return payload;
+  if (!["low", "medium", "high", "xhigh"].includes(nextEffort)) return payload;
+  const routed = findAnthropicEffortModel(model, nextEffort, models);
+  const nextModel = routed?.id || 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 withAnthropicDefaults(payload) {
-  return withSupportedAnthropicEffort(withDefaultAnthropicCache(payload));
+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 shouldLoadAnthropicCatalog(payload) {
+  const effort = payload?.output_config?.effort;
+  const model = typeof payload?.model === "string" ? payload.model : "";
+  return effort !== undefined && Boolean(canonicalClaudeOpus47Family(model));
+}
+
+async function withAnthropicDefaults(payload) {
+  const next = withSupportedAnthropicThinking(withDefaultAnthropicCache(payload));
+  const models = shouldLoadAnthropicCatalog(next)
+    ? await fetchModelsCatalog().catch(() => undefined)
+    : undefined;
+  return withSupportedAnthropicEffort(next, models);
 }
 
 function parseJsonBody(body, contentType) {
@@ -380,7 +451,7 @@ function wrapResponseWithCacheObserver(upstream, route, requestCache) {
 
 async function requestWithJsonBody(request, transform) {
   const payload = await request.json();
-  const nextPayload = transform(payload);
+  const nextPayload = await transform(payload);
   return new Request(request.url, {
     method: request.method,
     headers: request.headers,
@@ -408,7 +479,7 @@ async function proxyFetch(path, request, { extraHeaders = {}, bodyOverride } = {
   return wrapResponseWithCacheObserver(upstream, path, requestCache);
 }
 
-async function fetchModelsForResponseSelection() {
+async function fetchModelsCatalog() {
   const token = await getCopilotToken();
   const response = await fetch(`${COPILOT_API_ORIGIN}/models`, { method: "GET", headers: upstreamHeaders(token) });
   if (!response.ok) return undefined;
@@ -434,7 +505,7 @@ export async function proxyResponses(request) {
   // per-request /models lookup to avoid an extra upstream call and let the
   // shared HTTP path handle cache_request logging via proxyFetch.
   if (payload?.stream && isResponsesWebSocketOptIn()) {
-    const models = await fetchModelsForResponseSelection().catch(() => undefined);
+    const models = await fetchModelsCatalog().catch(() => undefined);
     const model = models ? responseModelFromCatalog(payload.model, models) : undefined;
     if (shouldUseResponsesWebSocket(payload, model)) {
       const requestCache = cacheRequestFields(payload);

package/src/service.js

@@ -15,6 +15,7 @@ const DEFAULT_WRAPPER_LOG_MAX_BYTES = 5 * 1024 * 1024;
 const DEFAULT_WRAPPER_LOG_BACKUPS = 3;
 const HEALTH_TIMEOUT_MS = 1500;
 const HEALTH_START_TIMEOUT_MS = 5000;
+const HEALTH_POLL_INTERVAL_MS = 250;
 
 function wrapperLogConfig() {
   const out = { maxBytes: DEFAULT_WRAPPER_LOG_MAX_BYTES, backups: DEFAULT_WRAPPER_LOG_BACKUPS };
@@ -339,6 +340,53 @@ function classifyHealth(probe) {
   return { mode: "aerial_running", body: probe.body };
 }
 
+async function pollForAerialUp(host, port, healthFetch, deadlineMs = HEALTH_START_TIMEOUT_MS) {
+  const fetcher = healthFetch || defaultHealthFetch;
+  const start = Date.now();
+  let lastProbe;
+  let lastCls;
+  let attempts = 0;
+  while (Date.now() - start < deadlineMs) {
+    attempts += 1;
+    lastProbe = await fetcher(host, port);
+    lastCls = classifyHealth(lastProbe);
+    if (lastCls.mode === "aerial_running" || lastCls.mode === "port_conflict") {
+      return { cls: lastCls, probe: lastProbe, attempts, elapsedMs: Date.now() - start };
+    }
+    await new Promise((r) => setTimeout(r, HEALTH_POLL_INTERVAL_MS));
+  }
+  return { cls: lastCls || { mode: "absent" }, probe: lastProbe, attempts, elapsedMs: Date.now() - start };
+}
+
+function readWrapperNodePath(wrapperFile) {
+  if (!wrapperFile) return undefined;
+  try {
+    if (!fs.existsSync(wrapperFile)) return undefined;
+    const data = fs.readFileSync(wrapperFile, "utf8");
+    if (wrapperFile.endsWith(".sh")) {
+      const m = data.match(/^NODE_BIN='([^']*)'/m);
+      return m ? m[1] : undefined;
+    }
+    if (wrapperFile.endsWith(".ps1")) {
+      const m = data.match(/^\$node\s*=\s*'([^']*)'/m);
+      return m ? m[1] : undefined;
+    }
+  } catch {}
+  return undefined;
+}
+
+function healthFailedDiagnostics({ wrapper, probe, attempts, elapsedMs }) {
+  const out = {
+    stdioLog: stdioLogPath(),
+    aerialLog: aerialLogPath(),
+    wrapperNode: readWrapperNodePath(wrapper),
+    health: { attempts, elapsedMs }
+  };
+  if (probe && probe.error) out.health.lastError = probe.error;
+  if (probe && probe.status !== undefined) out.health.lastStatus = probe.status;
+  return out;
+}
+
 function authFileStatus(file) {
   if (!fs.existsSync(file)) return { file, state: "missing" };
   try {
@@ -461,11 +509,12 @@ function tokenWarning() {
       if (data && data.trim()) return undefined;
     } catch {}
   }
-  return {
-    level: "warning",
-    code: "github_token_missing",
-    message: "GitHub token is not configured. Service will start, but proxy requests return 503 until you run `aerial login`."
-  };
+  const envToken = process.env.AERIAL_GITHUB_TOKEN;
+  const envOnly = envToken && envToken.trim();
+  const message = envOnly
+    ? "AERIAL_GITHUB_TOKEN is set in this shell only; the background service does not inherit it. Run `aerial login` to persist a service-readable GitHub token, otherwise proxy requests return 503."
+    : "GitHub token is not configured. Service will start, but proxy requests return 503 until you run `aerial login`.";
+  return { level: "warning", code: "github_token_missing", message };
 }
 
 function darwinWriteDefinition() {
@@ -534,7 +583,7 @@ async function describeRunning(ctx, host, port, healthFetch) {
   return { cls, probe, supervisor };
 }
 
-export async function serviceInstall({ run = defaultRunCommand, healthFetch } = {}) {
+export async function serviceInstall({ run = defaultRunCommand, healthFetch, healthDeadlineMs } = {}) {
   if (isUnsupportedPlatform()) throw unsupportedError("install");
   const ctx = { run };
   const config = loadConfig();
@@ -634,12 +683,34 @@ export async function serviceInstall({ run = defaultRunCommand, healthFetch } =
       if (!ok) result.reason = "run_failed";
     }
   }
+  if (result.ok) {
+    if (process.env.AERIAL_SERVICE_DRYRUN === "1") {
+      result.health = { ok: true, attempts: 0, elapsedMs: 0, dryRun: true };
+    } else {
+      const poll = await pollForAerialUp(config.host, config.port, healthFetch, healthDeadlineMs);
+      if (poll.cls.mode === "aerial_running") {
+        result.health = { ok: true, attempts: poll.attempts, elapsedMs: poll.elapsedMs };
+      } else if (poll.cls.mode === "port_conflict") {
+        result.ok = false;
+        result.reason = "port_conflict";
+        result.message = `After install, port ${config.port} is responding as a non-Aerial process: ${poll.cls.reason}. Free the port and rerun.`;
+        result.diagnostics = healthFailedDiagnostics({ wrapper: result.wrapper, probe: poll.probe, attempts: poll.attempts, elapsedMs: poll.elapsedMs });
+      } else {
+        result.ok = false;
+        result.reason = "health_check_failed";
+        result.definitionWritten = true;
+        result.startAttempted = true;
+        result.message = `Service definition was written and start was triggered, but /health did not become Aerial within ${poll.elapsedMs}ms (${poll.attempts} attempts). Inspect logs and rerun \`aerial service status --json\`.`;
+        result.diagnostics = healthFailedDiagnostics({ wrapper: result.wrapper, probe: poll.probe, attempts: poll.attempts, elapsedMs: poll.elapsedMs });
+      }
+    }
+  }
   result.warning = tokenWarning();
-  logEvent("service_install", { platform: process.platform, ok: result.ok });
+  logEvent("service_install", { platform: process.platform, ok: result.ok, reason: result.reason });
   return result;
 }
 
-export async function serviceStart({ run = defaultRunCommand, healthFetch } = {}) {
+export async function serviceStart({ run = defaultRunCommand, healthFetch, healthDeadlineMs } = {}) {
   if (isUnsupportedPlatform()) throw unsupportedError("start");
   const ctx = { run };
   const config = loadConfig();
@@ -687,16 +758,50 @@ export async function serviceStart({ run = defaultRunCommand, healthFetch } = {}
   } else {
     r = ctx.run("schtasks.exe", buildSchtasksArgs("run"));
   }
-  const ok = r.status === 0;
-  logEvent("service_start", { platform: process.platform, status: r.status });
-  return {
-    ok,
+  const triggerOk = r.status === 0;
+  const base = {
+    ok: triggerOk,
     action: "start",
     platform: process.platform,
     status: r.status,
     stderr: r.stderr,
     warning: tokenWarning(),
-    ...(ok ? {} : { reason: process.platform === "darwin" ? "bootstrap_failed" : "run_failed" })
+    ...(triggerOk ? {} : { reason: process.platform === "darwin" ? "bootstrap_failed" : "run_failed" })
+  };
+  if (!triggerOk) {
+    logEvent("service_start", { platform: process.platform, status: r.status, reason: base.reason });
+    return base;
+  }
+  if (process.env.AERIAL_SERVICE_DRYRUN === "1") {
+    base.health = { ok: true, attempts: 0, elapsedMs: 0, dryRun: true };
+    logEvent("service_start", { platform: process.platform, status: r.status, ok: true, dryRun: true });
+    return base;
+  }
+  const poll = await pollForAerialUp(config.host, config.port, healthFetch, healthDeadlineMs);
+  if (poll.cls.mode === "aerial_running") {
+    base.health = { ok: true, attempts: poll.attempts, elapsedMs: poll.elapsedMs };
+    logEvent("service_start", { platform: process.platform, status: r.status, ok: true });
+    return base;
+  }
+  const wrapper = process.platform === "darwin" ? darwinWrapperPath() : winWrapperPath();
+  if (poll.cls.mode === "port_conflict") {
+    logEvent("service_start", { platform: process.platform, ok: false, reason: "port_conflict" });
+    return {
+      ...base,
+      ok: false,
+      reason: "port_conflict",
+      message: `After start, port ${config.port} is responding as a non-Aerial process: ${poll.cls.reason}. Free the port and rerun.`,
+      diagnostics: healthFailedDiagnostics({ wrapper, probe: poll.probe, attempts: poll.attempts, elapsedMs: poll.elapsedMs })
+    };
+  }
+  logEvent("service_start", { platform: process.platform, ok: false, reason: "health_check_failed" });
+  return {
+    ...base,
+    ok: false,
+    reason: "health_check_failed",
+    startAttempted: true,
+    message: `Start was triggered, but /health did not become Aerial within ${poll.elapsedMs}ms (${poll.attempts} attempts). Inspect logs and rerun \`aerial service status --json\`.`,
+    diagnostics: healthFailedDiagnostics({ wrapper, probe: poll.probe, attempts: poll.attempts, elapsedMs: poll.elapsedMs })
   };
 }