@jiayunxie/aerial 0.1.7 → 0.1.9

package/package.json

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

package/src/cli.js

@@ -5,7 +5,7 @@ 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 { doctor, renderDoctorText } from "./doctor.js";
 import { runProbe, formatProbeReport } from "./probe.js";
 import { chooseSetupModel, formatModelChoices } from "./model-selection.js";
 import { printVersion } from "./version.js";
@@ -449,11 +449,10 @@ async function main() {
   }
 
   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;
+    const report = await doctor();
+    if (args.includes("--json")) console.log(JSON.stringify(report, null, 2));
+    else console.log(renderDoctorText(report));
+    process.exitCode = report.ok ? 0 : 1;
     return;
   }
 

package/src/copilot.js

@@ -4,6 +4,12 @@ import { loadConfig } from "./config.js";
 import { getCopilotToken } from "./auth.js";
 import { logEvent } from "./log.js";
 import { isResponsesWebSocketOptIn, proxyResponsesWebSocket, shouldUseResponsesWebSocket } from "./responses-websocket.js";
+import {
+  fetchModelsCatalog as fetchModelsCatalogShared,
+  findCompatibleModel as findCompatibleModelShared,
+  canonicalClaudeFamily,
+  tokenFingerprintOf
+} from "./model-catalog.js";
 
 function upstreamHeaders(token, extra = {}) {
   const config = loadConfig();
@@ -174,18 +180,23 @@ function withDefaultAnthropicCache(payload) {
   return next;
 }
 
-function withSupportedAnthropicEffort(payload) {
+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 family = canonicalClaudeFamily(model);
+  if (!family) return payload;
   const nextEffort = effort === "max" ? "xhigh" : effort;
   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;
+  const routed = findCompatibleModelShared({
+    models,
+    family,
+    route: "/v1/messages",
+    adaptiveThinking: true,
+    effort: nextEffort,
+    preferredId: model
+  });
+  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 } };
@@ -221,8 +232,31 @@ function withSupportedAnthropicThinking(payload) {
   };
 }
 
-function withAnthropicDefaults(payload) {
-  return withSupportedAnthropicEffort(withSupportedAnthropicThinking(withDefaultAnthropicCache(payload)));
+function shouldLoadAnthropicCatalog(payload) {
+  const effort = payload?.output_config?.effort;
+  const model = typeof payload?.model === "string" ? payload.model : "";
+  return effort !== undefined && Boolean(canonicalClaudeFamily(model));
+}
+
+async function fetchModelsCatalogForCopilot() {
+  const token = await getCopilotToken();
+  return fetchModelsCatalogShared({
+    tokenFingerprint: tokenFingerprintOf(token),
+    fetchImpl: async () => {
+      const response = await fetch(`${COPILOT_API_ORIGIN}/models`, { method: "GET", headers: upstreamHeaders(token) });
+      if (!response.ok) return undefined;
+      const payload = await response.json().catch(() => ({}));
+      return Array.isArray(payload?.data) ? payload.data : undefined;
+    }
+  });
+}
+
+async function withAnthropicDefaults(payload) {
+  const next = withSupportedAnthropicThinking(withDefaultAnthropicCache(payload));
+  const models = shouldLoadAnthropicCatalog(next)
+    ? await fetchModelsCatalogForCopilot().catch(() => undefined)
+    : undefined;
+  return withSupportedAnthropicEffort(next, models);
 }
 
 function parseJsonBody(body, contentType) {
@@ -407,7 +441,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,
@@ -435,12 +469,8 @@ async function proxyFetch(path, request, { extraHeaders = {}, bodyOverride } = {
   return wrapResponseWithCacheObserver(upstream, path, requestCache);
 }
 
-async function fetchModelsForResponseSelection() {
-  const token = await getCopilotToken();
-  const response = await fetch(`${COPILOT_API_ORIGIN}/models`, { method: "GET", headers: upstreamHeaders(token) });
-  if (!response.ok) return undefined;
-  const payload = await response.json().catch(() => ({}));
-  return Array.isArray(payload.data) ? payload.data : undefined;
+async function fetchModelsCatalog() {
+  return fetchModelsCatalogForCopilot();
 }
 
 function responseModelFromCatalog(modelId, models) {
@@ -461,7 +491,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/doctor.js

@@ -1,15 +1,195 @@
-import fs from "node:fs";
-import { apiKeyPath, configPath, githubTokenPath } from "./paths.js";
-import { loadConfig } from "./config.js";
+import { setupStatus } from "./setup.js";
+import { serviceStatus } from "./service.js";
+import { computeAppStatus } from "./app-status.js";
 
-export function doctor() {
-  const config = loadConfig();
+const REPAIRS = Object.freeze({
+  LOGIN: Object.freeze({ command: "aerial", args: ["login"] }),
+  SETUP_CODEX: Object.freeze({ command: "aerial", args: ["setup", "codex"] }),
+  SERVICE_INSTALL: Object.freeze({ command: "aerial", args: ["service", "install"] }),
+  SERVICE_STATUS_JSON: Object.freeze({ command: "aerial", args: ["service", "status", "--json"] })
+});
+
+function buildAuthChecks(setup) {
+  const checks = [];
+  const apiKey = setup.auth.api_key;
+  if (!apiKey.exists) {
+    checks.push({
+      id: "auth.api_key",
+      ok: false,
+      severity: "fail",
+      message: "Aerial local API key is missing. Run setup for the client you use; this repair shows the Codex path.",
+      repair: REPAIRS.SETUP_CODEX
+    });
+  } else {
+    checks.push({ id: "auth.api_key", ok: true, severity: "info", message: "Aerial local API key is present." });
+  }
+  const gh = setup.auth.github_token;
+  if (gh.source === "missing") {
+    checks.push({
+      id: "auth.github_token",
+      ok: false,
+      severity: "fail",
+      message: "GitHub token is not configured. Aerial cannot reach Copilot until you log in.",
+      repair: REPAIRS.LOGIN
+    });
+  } else if (gh.source === "env") {
+    checks.push({
+      id: "auth.github_token",
+      ok: true,
+      severity: "warn",
+      message: "AERIAL_GITHUB_TOKEN is set in this shell only. The background service does not inherit it; run `aerial login` to persist a service-readable token.",
+      repair: REPAIRS.LOGIN
+    });
+  } else {
+    checks.push({ id: "auth.github_token", ok: true, severity: "info", message: "GitHub token is present in the persisted credential file." });
+  }
+  return checks;
+}
+
+function buildClientChecks(setup) {
+  const checks = [];
+  const codex = setup.clients.codex;
+  const claude = setup.clients.claude;
+  const aerialCodex = codex.state === "aerial";
+  const aerialClaude = claude.state === "aerial";
+  if (!aerialCodex && !aerialClaude) {
+    checks.push({
+      id: "clients.aerial_client",
+      ok: false,
+      severity: "fail",
+      message: "No client is wired to Aerial. Run setup for the client you use; this repair shows the Codex path.",
+      repair: REPAIRS.SETUP_CODEX
+    });
+  } else {
+    const wired = [aerialCodex && "codex", aerialClaude && "claude"].filter(Boolean).join(", ");
+    checks.push({ id: "clients.aerial_client", ok: true, severity: "info", message: `Client wired to Aerial: ${wired}.` });
+  }
+  return checks;
+}
+
+function buildServiceChecks(service) {
+  const checks = [];
+  if (service.supported === false) {
+    checks.push({
+      id: "service.supported",
+      ok: false,
+      severity: "warn",
+      message: `Background service is not supported on ${service.platform}; Aerial must run in the foreground.`
+    });
+    return checks;
+  }
+  const installed = Boolean(service.service?.installed);
+  const loaded = Boolean(service.service?.loaded);
+  const healthy = service.health?.aerial === true;
+  if (healthy && !installed) {
+    checks.push({
+      id: "service.foreground_only",
+      ok: true,
+      severity: "warn",
+      message: "Aerial is running in the foreground but no background service is installed; it will not start on reboot.",
+      repair: REPAIRS.SERVICE_INSTALL
+    });
+  } else if (installed && !healthy) {
+    checks.push({
+      id: "service.health",
+      ok: false,
+      severity: "fail",
+      message: loaded
+        ? "Service manager reports the task running, but Aerial /health is not responding."
+        : "Service is installed but not running.",
+      repair: REPAIRS.SERVICE_STATUS_JSON
+    });
+  } else if (!installed && !healthy) {
+    checks.push({
+      id: "service.health",
+      ok: false,
+      severity: "fail",
+      message: "Aerial is not running and no background service is installed.",
+      repair: REPAIRS.SERVICE_INSTALL
+    });
+  } else {
+    checks.push({ id: "service.health", ok: true, severity: "info", message: "Aerial /health is responding." });
+  }
+  if (service.health?.portConflict) {
+    checks.push({
+      id: "service.port_conflict",
+      ok: false,
+      severity: "fail",
+      message: `Port ${service.config?.port} is held by a non-Aerial process: ${service.health.conflictReason || "unknown"}.`,
+      repair: REPAIRS.SERVICE_STATUS_JSON
+    });
+  }
+  const wrapper = service.service?.wrapper;
+  if (wrapper && wrapper.stale === true) {
+    const reasons = Array.isArray(wrapper.staleReasons) ? wrapper.staleReasons.join(", ") : "unknown";
+    checks.push({
+      id: "service.wrapper_stale",
+      ok: true,
+      severity: "warn",
+      message: `Installed service wrapper is stale (${reasons}); reinstall to regenerate it.`,
+      repair: REPAIRS.SERVICE_INSTALL
+    });
+  }
+  return checks;
+}
+
+function summarize(ok, checks) {
+  const fails = checks.filter((c) => c.severity === "fail").length;
+  const warns = checks.filter((c) => c.severity === "warn").length;
+  if (ok && warns === 0) return "All checks passed.";
+  if (ok && warns > 0) return `Aerial is functional with ${warns} warning(s).`;
+  return `${fails} check(s) failed; ${warns} warning(s).`;
+}
+
+export async function doctor({ run, healthFetch, setup, service } = {}) {
+  const setupOut = setup ?? setupStatus();
+  const serviceOut = service ?? await serviceStatus({ ...(run ? { run } : {}), ...(healthFetch ? { healthFetch } : {}) });
+  const app = computeAppStatus(setupOut, serviceOut);
   const checks = [
-    { name: "config", ok: fs.existsSync(configPath()), detail: configPath() },
-    { name: "api_key", ok: Boolean(config.apiKeyHash), detail: fs.existsSync(apiKeyPath()) ? apiKeyPath() : config.apiKeyHash ? "hash configured" : "run: aerial setup codex or aerial setup claude" },
-    { name: "github_token", ok: fs.existsSync(githubTokenPath()) || Boolean(process.env.AERIAL_GITHUB_TOKEN), detail: fs.existsSync(githubTokenPath()) ? githubTokenPath() : "run: aerial login" },
-    { name: "node", ok: Number(process.versions.node.split(".")[0]) >= 22, detail: process.version },
-    { name: "bind", ok: config.host === "127.0.0.1", detail: `${config.host}:${config.port}` }
+    ...buildAuthChecks(setupOut),
+    ...buildClientChecks(setupOut),
+    ...buildServiceChecks(serviceOut)
+  ];
+  const ok = app.ok && checks.every((c) => c.severity !== "fail");
+  return {
+    schema: "aerial.doctor.v1",
+    ok,
+    summary: summarize(ok, checks),
+    checks,
+    status: {
+      schema: app.schema,
+      ok: app.ok,
+      setup: app.setup,
+      service: app.service
+    }
+  };
+}
+
+export function renderRepairCommand(repair) {
+  if (!repair || typeof repair !== "object") return "";
+  const args = Array.isArray(repair.args) ? repair.args : [];
+  return [repair.command, ...args].join(" ");
+}
+
+export function renderDoctorText(report) {
+  const lines = [];
+  lines.push(`aerial doctor: ${report.summary}`);
+  const groups = [
+    ["fail", "Failures"],
+    ["warn", "Warnings"],
+    ["info", "Info"]
   ];
-  return { ok: checks.every((check) => check.ok), checks };
+  for (const [severity, label] of groups) {
+    const items = report.checks.filter((c) => c.severity === severity);
+    if (items.length === 0) continue;
+    lines.push("");
+    lines.push(`${label}:`);
+    for (const check of items) {
+      const tag = severity.toUpperCase();
+      let line = `  ${tag} ${check.id}: ${check.message}`;
+      if (check.repair) line += ` -> run: ${renderRepairCommand(check.repair)}`;
+      lines.push(line);
+    }
+  }
+  return lines.join("\n");
 }

package/src/model-catalog.js

@@ -0,0 +1,69 @@
+import crypto from "node:crypto";
+
+const TTL_MS = 30000;
+const cache = new Map();
+
+export function tokenFingerprintOf(token) {
+  if (typeof token !== "string" || token.length === 0) return "anonymous";
+  return crypto.createHash("sha256").update(token).digest("hex").slice(0, 16);
+}
+
+export async function fetchModelsCatalog({ fetchImpl, tokenFingerprint } = {}) {
+  if (typeof fetchImpl !== "function") return undefined;
+  const key = tokenFingerprint || "anonymous";
+  const cached = cache.get(key);
+  const now = Date.now();
+  if (cached && cached.expiresAt > now) return cached.models;
+  const models = await fetchImpl();
+  if (!Array.isArray(models)) return undefined;
+  cache.set(key, { models, expiresAt: now + TTL_MS });
+  return models;
+}
+
+export function clearModelCatalogCacheForTests() {
+  cache.clear();
+}
+
+export function canonicalClaudeFamily(modelId) {
+  if (typeof modelId !== "string") return undefined;
+  if (/^claude-opus-4[.-]7(?:-|$)/.test(modelId)) return "claude-opus-4.7";
+  return undefined;
+}
+
+function modelHasRoute(model, route) {
+  const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
+  const routes = Array.isArray(model?.aerial?.routes) ? model.aerial.routes : [];
+  if (route === "/v1/messages") return endpoints.includes("/v1/messages") || routes.includes("messages");
+  return endpoints.includes(route);
+}
+
+function modelSupportsAdaptiveThinking(model) {
+  const supports = model?.capabilities?.supports;
+  return supports?.adaptive_thinking === true || supports?.thinking?.adaptive === true;
+}
+
+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 [];
+}
+
+export function findCompatibleModel({ models, family, route, adaptiveThinking, effort, preferredId } = {}) {
+  if (!Array.isArray(models) || !family) return undefined;
+  const candidates = models.filter((model) => {
+    const id = typeof model?.id === "string" ? model.id : "";
+    if (canonicalClaudeFamily(id) !== family) return false;
+    if (route && !modelHasRoute(model, route)) return false;
+    if (adaptiveThinking === true && !modelSupportsAdaptiveThinking(model)) return false;
+    if (effort && !supportedReasoningEfforts(model).includes(effort)) return false;
+    return true;
+  });
+  if (candidates.length === 0) return undefined;
+  if (preferredId) {
+    const preferred = candidates.find((model) => model.id === preferredId);
+    if (preferred) return preferred;
+  }
+  return candidates[0];
+}

package/src/service.js

@@ -358,21 +358,147 @@ async function pollForAerialUp(host, port, healthFetch, deadlineMs = HEALTH_STAR
   return { cls: lastCls || { mode: "absent" }, probe: lastProbe, attempts, elapsedMs: Date.now() - start };
 }
 
-function readWrapperNodePath(wrapperFile) {
-  if (!wrapperFile) return undefined;
+function unescapeShSingleQuoted(line, prefix) {
+  if (!line.startsWith(prefix)) return undefined;
+  const rest = line.slice(prefix.length);
+  if (!rest.startsWith("'")) return undefined;
+  let i = 1;
+  let out = "";
+  while (i < rest.length) {
+    const ch = rest[i];
+    if (ch === "'") {
+      if (rest.slice(i, i + 4) === "'\\''") {
+        out += "'";
+        i += 4;
+        continue;
+      }
+      return out;
+    }
+    out += ch;
+    i += 1;
+  }
+  return undefined;
+}
+
+function unescapePsSingleQuoted(line, prefix) {
+  if (!line.startsWith(prefix)) return undefined;
+  const rest = line.slice(prefix.length);
+  if (!rest.startsWith("'")) return undefined;
+  let i = 1;
+  let out = "";
+  while (i < rest.length) {
+    const ch = rest[i];
+    if (ch === "'") {
+      if (rest[i + 1] === "'") {
+        out += "'";
+        i += 2;
+        continue;
+      }
+      return out;
+    }
+    out += ch;
+    i += 1;
+  }
+  return undefined;
+}
+
+function parseWrapperPaths(wrapperFile) {
+  if (!wrapperFile) return { node: undefined, cli: undefined };
   try {
-    if (!fs.existsSync(wrapperFile)) return undefined;
+    if (!fs.existsSync(wrapperFile)) return { node: undefined, cli: undefined };
     const data = fs.readFileSync(wrapperFile, "utf8");
+    const lines = data.split(/\r?\n/);
     if (wrapperFile.endsWith(".sh")) {
-      const m = data.match(/^NODE_BIN='([^']*)'/m);
-      return m ? m[1] : undefined;
+      let node;
+      let cli;
+      for (const line of lines) {
+        if (node === undefined) {
+          const candidate = unescapeShSingleQuoted(line, "NODE_BIN=");
+          if (candidate !== undefined) node = candidate;
+        }
+        if (cli === undefined) {
+          const candidate = unescapeShSingleQuoted(line, "CLI_ENTRY=");
+          if (candidate !== undefined) cli = candidate;
+        }
+        if (node !== undefined && cli !== undefined) break;
+      }
+      return { node, cli };
     }
     if (wrapperFile.endsWith(".ps1")) {
-      const m = data.match(/^\$node\s*=\s*'([^']*)'/m);
-      return m ? m[1] : undefined;
+      let node;
+      let cli;
+      for (const line of lines) {
+        if (node === undefined) {
+          const m = line.match(/^\$node\s*=\s*(.*)$/);
+          if (m) {
+            const candidate = unescapePsSingleQuoted(m[1].trim(), "");
+            if (candidate !== undefined) node = candidate;
+          }
+        }
+        if (cli === undefined) {
+          const m = line.match(/^\$cli\s*=\s*(.*)$/);
+          if (m) {
+            const candidate = unescapePsSingleQuoted(m[1].trim(), "");
+            if (candidate !== undefined) cli = candidate;
+          }
+        }
+        if (node !== undefined && cli !== undefined) break;
+      }
+      return { node, cli };
     }
   } catch {}
-  return undefined;
+  return { node: undefined, cli: undefined };
+}
+
+function readWrapperNodePath(wrapperFile) {
+  return parseWrapperPaths(wrapperFile).node;
+}
+
+export const STALE_REASONS = Object.freeze({
+  WRAPPER_MISSING: "wrapper_missing",
+  WRAPPER_NODE_MISSING: "wrapper_node_missing",
+  WRAPPER_CLI_MISSING: "wrapper_cli_missing",
+  WRAPPER_LOG_CONFIG_UNPARSEABLE: "wrapper_log_config_unparseable"
+});
+
+function wrapperBlock(state) {
+  if (!state || state.installed !== true) {
+    return { stale: false, staleReasons: [] };
+  }
+  let wrapperPath;
+  if (process.platform === "darwin") wrapperPath = darwinWrapperPath();
+  else if (process.platform === "win32") wrapperPath = winWrapperPath();
+  const wrapperFileExists = wrapperPath ? fs.existsSync(wrapperPath) : false;
+  const staleReasons = [];
+  if (!wrapperFileExists) {
+    return {
+      path: wrapperPath,
+      nodePath: undefined,
+      nodeExists: undefined,
+      cliPath: undefined,
+      cliExists: undefined,
+      logConfigParseable: undefined,
+      stale: true,
+      staleReasons: [STALE_REASONS.WRAPPER_MISSING]
+    };
+  }
+  const { node: nodePath, cli: cliPath } = parseWrapperPaths(wrapperPath);
+  const nodeExists = nodePath ? fs.existsSync(nodePath) : false;
+  const cliExists = cliPath ? fs.existsSync(cliPath) : false;
+  const logConfigParseable = parseWrapperLogValues(wrapperPath) !== null;
+  if (!nodeExists) staleReasons.push(STALE_REASONS.WRAPPER_NODE_MISSING);
+  if (!cliExists) staleReasons.push(STALE_REASONS.WRAPPER_CLI_MISSING);
+  if (!logConfigParseable) staleReasons.push(STALE_REASONS.WRAPPER_LOG_CONFIG_UNPARSEABLE);
+  return {
+    path: wrapperPath,
+    nodePath,
+    nodeExists,
+    cliPath,
+    cliExists,
+    logConfigParseable,
+    stale: staleReasons.length > 0,
+    staleReasons
+  };
 }
 
 function healthFailedDiagnostics({ wrapper, probe, attempts, elapsedMs }) {
@@ -904,7 +1030,7 @@ export async function serviceStatus({ run = defaultRunCommand, healthFetch } = {
       platform: process.platform,
       supported: false,
       config: { host: config.host, port: config.port },
-      service: { installed: false, loaded: false, reason: "unsupported_platform", platform: process.platform },
+      service: { installed: false, loaded: false, reason: "unsupported_platform", platform: process.platform, wrapper: wrapperBlock({ installed: false }) },
       health: { ok: false, error: "unsupported_platform" },
       logs: logsBlock(),
       auth: authBlock(),
@@ -914,6 +1040,7 @@ export async function serviceStatus({ run = defaultRunCommand, healthFetch } = {
   const state = serviceState(ctx);
   const probe = await (healthFetch || defaultHealthFetch)(config.host, config.port);
   const cls = classifyHealth(probe);
+  const wrapper = wrapperBlock(state);
   let supervisor;
   if (cls.mode === "aerial_running") {
     supervisor = state.installed && state.loaded ? "service-managed" : "foreground";
@@ -939,7 +1066,7 @@ export async function serviceStatus({ run = defaultRunCommand, healthFetch } = {
     platform: process.platform,
     supported: true,
     config: { host: config.host, port: config.port },
-    service: { platform: process.platform, ...state },
+    service: { platform: process.platform, ...state, wrapper },
     health,
     logs: logsBlock(),
     auth: authBlock(),
@@ -956,6 +1083,8 @@ export const _internal = {
   aerialLogPath,
   stdioLogPath,
   parseWrapperLogValues,
+  parseWrapperPaths,
+  wrapperBlock,
   buildSchtasksArgs,
   quoteSchtasksTR,
   classifyHealth

package/src/setup.js

@@ -89,7 +89,7 @@ export function setupCodex({ model, authCommand = DEFAULT_CODEX_AUTH } = {}) {
   content = setTomlString(content, "model_provider", "aerial");
   content = setTomlString(content, "model", selectedModel);
   content = upsertTomlSection(content, "model_providers.aerial", {
-    name: "Aerial Copilot Local",
+    name: "Aerial",
     base_url: `http://${config.host}:${config.port}/v1`,
     wire_api: "responses"
   });