@jiayunxie/aerial 0.2.5 → 0.2.7

package/src/service/platform.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import { loadConfig } from "../shared/config.js";
 import { logEvent } from "../shared/log.js";
-import { atomicWriteFile } from "../shared/file-utils.js";
+import { atomicWriteFile } from "../shared/utils.js";
 import {
   SERVICE_LABEL,
   WIN_TASK_NAME,

package/src/setup/clients.js

@@ -4,10 +4,10 @@ import path from "node:path";
 import { parse as parseToml } from "smol-toml";
 import { ensureApiKey, loadConfig, saveConfig } from "../shared/config.js";
 import { logEvent } from "../shared/log.js";
-import { atomicWriteFile } from "../shared/file-utils.js";
-import { assertValidEffort, normalizeEffort } from "../shared/effort.js";
-import { backupIfExists, backupPathsFor } from "./backup.js";
-import { setTomlRootString, upsertTomlSection } from "./toml.js";
+import { atomicWriteFile } from "../shared/utils.js";
+import { assertValidCodexEffort, assertValidEffort, normalizeCodexEffort, normalizeEffort } from "../shared/effort.js";
+import { backupIfExists, backupPathsFor } from "./restore.js";
+import { setTomlRootString, upsertTomlSection, removeTomlSection } from "./toml.js";
 
 const DEFAULT_CODEX_AUTH = Object.freeze({
   command: "aerial",
@@ -38,7 +38,7 @@ function claudeEnvForAerial(currentEnv, config) {
 }
 
 export function setupCodex({ model, effort, authCommand = DEFAULT_CODEX_AUTH } = {}) {
-  const normalizedEffort = effort === undefined ? undefined : assertValidEffort(effort);
+  const normalizedEffort = effort === undefined ? undefined : assertValidCodexEffort(effort);
   ensureApiKey();
   const config = loadConfig();
   const selectedModel = model || config.defaultModel;
@@ -51,6 +51,7 @@ export function setupCodex({ model, effort, authCommand = DEFAULT_CODEX_AUTH } =
   let content = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
   content = setTomlRootString(content, "model_provider", "aerial");
   content = setTomlRootString(content, "model", selectedModel);
+  if (normalizedEffort) content = setTomlRootString(content, "model_reasoning_effort", normalizedEffort);
   content = upsertTomlSection(content, "model_providers.aerial", {
     name: "Aerial",
     base_url: `http://${config.host}:${config.port}/v1`,
@@ -62,13 +63,8 @@ export function setupCodex({ model, effort, authCommand = DEFAULT_CODEX_AUTH } =
     timeout_ms: authCommand.timeout_ms || DEFAULT_CODEX_AUTH.timeout_ms,
     refresh_interval_ms: authCommand.refresh_interval_ms ?? DEFAULT_CODEX_AUTH.refresh_interval_ms
   });
-  const profileValues = { model_provider: "aerial", model: selectedModel };
-  if (normalizedEffort) profileValues.model_reasoning_effort = normalizedEffort;
-  content = upsertTomlSection(content, "profiles.aerial", profileValues);
+  content = removeTomlSection(content, "profiles.aerial");
   atomicWriteFile(file, content);
-  if (normalizedEffort && config.defaultEffort !== normalizedEffort) {
-    saveConfig({ ...config, defaultEffort: normalizedEffort });
-  }
   logEvent("setup_write", { target: "codex", file, backup, auth: "command", effort: normalizedEffort });
   return { file, backup, model: selectedModel, effort: normalizedEffort, auth: { type: "command", command: authCommand.command, args: authCommand.args || [] } };
 }
@@ -146,9 +142,23 @@ export function codexStatus() {
   const baseUrl = typeof doc?.model_providers?.aerial?.base_url === "string"
     ? doc.model_providers.aerial.base_url
     : undefined;
-  const profileEffort = doc?.profiles?.aerial?.model_reasoning_effort;
-  const effort = typeof profileEffort === "string" ? (normalizeEffort(profileEffort) || "missing") : "missing";
-  return { target: "codex", state, file, backups, model, baseUrl, effort };
+  const rootEffort = doc?.model_reasoning_effort;
+  const effort = typeof rootEffort === "string" ? (normalizeCodexEffort(rootEffort) || "missing") : "missing";
+  const legacyProfile = doc?.profiles?.aerial && typeof doc.profiles.aerial === "object";
+  const legacyProfileLooksAerial = legacyProfile
+    && (doc.profiles.aerial.model_provider === "aerial"
+      || typeof doc.profiles.aerial.model_reasoning_effort === "string");
+  const needsMigration = legacyProfile && (state !== "not-aerial" || legacyProfileLooksAerial);
+  return {
+    target: "codex",
+    state,
+    file,
+    backups,
+    model,
+    baseUrl,
+    effort,
+    ...(needsMigration ? { migration: "run aerial setup codex" } : {})
+  };
 }
 
 function claudeStateFromDoc(doc, expectedBaseUrl) {

package/src/setup/index.js

@@ -1,4 +1,27 @@
-export { findLatestBackup } from "./backup.js";
+import fs from "node:fs";
+import { loadConfig } from "../shared/config.js";
+import { apiKeyPath, githubTokenPath } from "../shared/paths.js";
+import { gitHubTokenSource } from "../shared/auth.js";
+import { CLIENTS, setupCodex, setupClaude, codexStatus, claudeStatus } from "./clients.js";
+
 export { setupCodex, setupClaude, codexStatus, claudeStatus } from "./clients.js";
-export { setupStatus } from "./status.js";
-export { restoreClient, restoreAllClients } from "./restore.js";
+export { findLatestBackup, restoreClient, restoreAllClients } from "./restore.js";
+
+export function setupStatus() {
+  const config = loadConfig();
+  const apiKeyFile = apiKeyPath();
+  const githubTokenFile = githubTokenPath();
+  return {
+    schema: "aerial.setup-status.v1",
+    platform: process.platform,
+    config: { host: config.host, port: config.port },
+    auth: {
+      api_key: { file: apiKeyFile, exists: fs.existsSync(apiKeyFile) },
+      github_token: (() => {
+        const source = gitHubTokenSource();
+        return { file: githubTokenFile, exists: source !== "missing", source };
+      })()
+    },
+    clients: Object.fromEntries(Object.entries(CLIENTS).map(([target, client]) => [target, client.status()]))
+  };
+}

package/src/setup/restore.js

@@ -1,9 +1,45 @@
 import fs from "node:fs";
+import path from "node:path";
 import { logEvent } from "../shared/log.js";
-import { atomicWriteFile } from "../shared/file-utils.js";
-import { findLatestBackup } from "./backup.js";
+import { atomicWriteFile } from "../shared/utils.js";
 import { CLIENTS } from "./clients.js";
 
+const BACKUP_PREFIX = ".aerial-backup-";
+const ISO_STAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z$/;
+
+export function backupIfExists(file) {
+  if (!fs.existsSync(file)) return undefined;
+  const backup = `${file}.aerial-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+  fs.copyFileSync(file, backup);
+  return backup;
+}
+
+function listBackups(file) {
+  const dir = path.dirname(file);
+  const base = path.basename(file);
+  if (!fs.existsSync(dir)) return [];
+  const prefix = `${base}${BACKUP_PREFIX}`;
+  const entries = fs.readdirSync(dir);
+  const matches = [];
+  for (const entry of entries) {
+    if (!entry.startsWith(prefix)) continue;
+    const stamp = entry.slice(prefix.length);
+    if (!ISO_STAMP_RE.test(stamp)) continue;
+    matches.push({ name: entry, path: path.join(dir, entry), stamp });
+  }
+  matches.sort((a, b) => (a.stamp < b.stamp ? -1 : a.stamp > b.stamp ? 1 : 0));
+  return matches;
+}
+
+export function findLatestBackup(file) {
+  const all = listBackups(file);
+  return all.length ? all[all.length - 1] : undefined;
+}
+
+export function backupPathsFor(file) {
+  return listBackups(file).map((entry) => entry.path);
+}
+
 const PRE_RESTORE_PREFIX = ".aerial-pre-restore-";
 
 function clientDescriptor(target) {

package/src/setup/toml.js

@@ -1,41 +1,92 @@
-function tomlValue(value) {
-  if (Array.isArray(value)) return `[${value.map(tomlValue).join(", ")}]`;
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  return JSON.stringify(String(value));
-}
+import { stringify as stringifyToml } from "smol-toml";
 
 function escapeRegExp(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+function tomlScalar(value) {
+  return stringifyToml({ value }).trim().replace(/^value\s*=\s*/, "");
+}
+
+function serializeBlock(values) {
+  const text = stringifyToml(values).trimEnd();
+  return text ? text.split("\n") : [];
+}
+
+function sectionName(line) {
+  const match = /^\s*\[\[?(.+?)\]?\]\s*(?:#.*)?$/.exec(line);
+  if (!match) return undefined;
+  const inner = match[1].trim();
+  if (!inner) return undefined;
+  const segment = `(?:"[^"]*"|'[^']*'|[A-Za-z0-9_-]+)`;
+  return new RegExp(`^${segment}(?:\\s*\\.\\s*${segment})*$`).test(inner) ? inner : undefined;
+}
+
+function isSectionHeader(line) {
+  return sectionName(line) !== undefined;
+}
+
+function isSectionOrChild(line, section) {
+  const name = sectionName(line);
+  return name === section || name?.startsWith(`${section}.`);
+}
+
 export function setTomlRootString(content, key, value) {
-  const line = `${key} = ${tomlValue(value)}`;
+  const line = `${key} = ${tomlScalar(value)}`;
   const source = content.split(/\r?\n/);
-  const firstSection = source.findIndex((sourceLine) => /^\s*\[.*\]\s*(?:#.*)?$/.test(sourceLine));
+  const firstSection = source.findIndex(isSectionHeader);
   const rootLines = firstSection === -1 ? source : source.slice(0, firstSection);
   const restLines = firstSection === -1 ? [] : source.slice(firstSection);
-  const root = rootLines.join("\n");
-  const rest = restLines.join("\n");
-  const re = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=.*$`, "m");
-  const nextRoot = re.test(root) ? root.replace(re, line) : `${root.trimEnd()}${root.trimEnd() ? "\n" : ""}${line}`;
-  if (!rest) return `${nextRoot.trimEnd()}\n`;
-  return `${nextRoot.trimEnd()}\n${rest}`;
+  const re = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`);
+  const existing = rootLines.findIndex((rootLine) => re.test(rootLine));
+  if (existing === -1) {
+    let insertAt = rootLines.length;
+    while (insertAt > 0 && !rootLines[insertAt - 1].trim()) insertAt -= 1;
+    rootLines.splice(insertAt, 0, line);
+  } else {
+    rootLines[existing] = line;
+  }
+  const merged = [...rootLines, ...restLines].join("\n");
+  return `${merged.trimEnd()}\n`;
 }
 
 export function upsertTomlSection(content, section, values) {
   const heading = `[${section}]`;
-  const lines = Object.entries(values).map(([key, value]) => `${key} = ${tomlValue(value)}`).join("\n");
-  const block = `${heading}\n${lines}\n`;
+  const block = [heading, ...serializeBlock(values)];
   const source = content.split(/\r?\n/);
-  const start = source.findIndex((line) => line.trim() === heading);
-  if (start === -1) return `${content.trimEnd()}\n\n${block}`;
+  const start = source.findIndex((line) => sectionName(line) === section);
+  if (start === -1) {
+    const base = content.trimEnd();
+    return `${base ? `${base}\n\n` : ""}${block.join("\n")}\n`;
+  }
   let end = source.length;
   for (let i = start + 1; i < source.length; i += 1) {
-    if (/^\s*\[.*\]\s*$/.test(source[i])) {
+    if (isSectionHeader(source[i])) {
       end = i;
       break;
     }
   }
-  source.splice(start, end - start, ...block.trimEnd().split("\n"));
+  while (end > start + 1 && !source[end - 1].trim()) end -= 1;
+  source.splice(start, end - start, ...block);
   return `${source.join("\n").trimEnd()}\n`;
 }
+
+export function removeTomlSection(content, section) {
+  const source = content.split(/\r?\n/);
+  const kept = [];
+  let removed = false;
+  for (let i = 0; i < source.length;) {
+    if (isSectionOrChild(source[i], section)) {
+      removed = true;
+      i += 1;
+      while (i < source.length && !isSectionHeader(source[i])) i += 1;
+      while (i < source.length && !source[i].trim()) i += 1;
+    } else {
+      kept.push(source[i]);
+      i += 1;
+    }
+  }
+  if (!removed) return content.trim() ? `${content.trimEnd()}\n` : "";
+  const merged = kept.join("\n").trim();
+  return merged ? `${merged}\n` : "";
+}

package/src/shared/effort.js

@@ -1,15 +1,29 @@
 export const EFFORT_VALUES = Object.freeze(["low", "medium", "high", "xhigh"]);
+export const CODEX_EFFORT_VALUES = Object.freeze(["minimal", "low", "medium", "high", "xhigh", "max", "ultra"]);
 export const DEFAULT_EFFORT = "medium";
 
-export function normalizeEffort(value) {
+function lower(value) {
   if (value === undefined || value === null) return undefined;
   const trimmed = String(value).trim().toLowerCase();
+  return trimmed || undefined;
+}
+
+export function normalizeEffort(value) {
+  const trimmed = lower(value);
   if (!trimmed) return undefined;
   if (trimmed === "max") return "xhigh";
   if (EFFORT_VALUES.includes(trimmed)) return trimmed;
   return undefined;
 }
 
+export function normalizeCodexEffort(value) {
+  const trimmed = lower(value);
+  if (!trimmed) return undefined;
+  if (trimmed === "none") return "minimal";
+  if (CODEX_EFFORT_VALUES.includes(trimmed)) return trimmed;
+  return undefined;
+}
+
 export function assertValidEffort(raw) {
   const normalized = normalizeEffort(raw);
   if (!normalized) {
@@ -17,3 +31,58 @@ export function assertValidEffort(raw) {
   }
   return normalized;
 }
+
+export function assertValidCodexEffort(raw) {
+  const normalized = normalizeCodexEffort(raw);
+  if (!normalized) {
+    throw new Error(`Invalid --effort ${JSON.stringify(raw)} for Codex. Allowed: ${CODEX_EFFORT_VALUES.join(", ")} (or alias 'none' for minimal).`);
+  }
+  return normalized;
+}
+
+function codexCatalogEfforts(values) {
+  if (!Array.isArray(values)) return [];
+  const seen = new Set();
+  const efforts = [];
+  for (const value of values) {
+    const wireEffort = lower(value);
+    const resolvedEffort = normalizeCodexEffort(wireEffort);
+    if (!resolvedEffort || seen.has(resolvedEffort)) continue;
+    seen.add(resolvedEffort);
+    efforts.push({ resolvedEffort, wireEffort, rank: CODEX_EFFORT_VALUES.indexOf(resolvedEffort) });
+  }
+  return efforts.sort((a, b) => a.rank - b.rank);
+}
+
+export function resolveCodexEffort(requested, supportedEfforts) {
+  const requestedEffort = normalizeCodexEffort(requested);
+  if (!requestedEffort) return undefined;
+  const requestedRank = CODEX_EFFORT_VALUES.indexOf(requestedEffort);
+  const supported = codexCatalogEfforts(supportedEfforts);
+
+  if (supported.length) {
+    const exact = supported.find((entry) => entry.resolvedEffort === requestedEffort);
+    const lowerOrEqual = supported.filter((entry) => entry.rank <= requestedRank);
+    const selected = exact || lowerOrEqual.at(-1) || supported[0];
+    let reason = "exact";
+    if (selected.resolvedEffort !== requestedEffort) {
+      reason = selected.rank < requestedRank ? "downgraded" : "nearest_supported";
+    } else if (selected.wireEffort !== requestedEffort) {
+      reason = "alias";
+    }
+    return {
+      requestedEffort,
+      resolvedEffort: selected.resolvedEffort,
+      wireEffort: selected.wireEffort,
+      reason
+    };
+  }
+
+  if (requestedEffort === "minimal") {
+    return { requestedEffort, resolvedEffort: "minimal", wireEffort: "none", reason: "alias" };
+  }
+  if (requestedEffort === "ultra") {
+    return { requestedEffort, resolvedEffort: "max", wireEffort: "max", reason: "fallback" };
+  }
+  return { requestedEffort, resolvedEffort: requestedEffort, wireEffort: requestedEffort, reason: "exact" };
+}

package/src/shared/paths.js

@@ -1,7 +1,7 @@
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs";
-import { atomicWriteFile } from "./file-utils.js";
+import { atomicWriteFile } from "./utils.js";
 
 export function configDir() {
   if (process.env.AERIAL_CONFIG_DIR) return process.env.AERIAL_CONFIG_DIR;

package/src/shared/{file-utils.js → utils.js}

@@ -1,6 +1,25 @@
 import fs from "node:fs";
 import path from "node:path";
 
+export function parseNumberChoice(value, { max, defaultIndex = 0, oneBased = false } = {}) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) return defaultIndex;
+  if (!/^\d+$/.test(trimmed)) return undefined;
+  const n = Number(trimmed);
+  if (n < 1 || n > max) return undefined;
+  return oneBased ? n : n - 1;
+}
+
+export async function readJsonSafely(response) {
+  const text = await response.text();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+
 function ensureParentDir(file) {
   fs.mkdirSync(path.dirname(file), { recursive: true });
 }

package/src/cli/app-status.js

@@ -1,23 +0,0 @@
-export function computeAppStatus(setup, service) {
-  const githubTokenPresent = setup.auth.github_token.source !== "missing";
-  const apiKeyPresent = setup.auth.api_key.exists;
-  const hasAerialClient = setup.clients.codex.state === "aerial" || setup.clients.claude.state === "aerial";
-  const serviceHealthy = service.supported !== false && service.health?.aerial === true;
-  const ok = apiKeyPresent && githubTokenPresent && hasAerialClient && serviceHealthy;
-  const nextSteps = [];
-  const hints = [];
-  if (!githubTokenPresent) nextSteps.push("run: aerial login");
-  if (!hasAerialClient) nextSteps.push("run: aerial setup codex or aerial setup claude");
-  if (hasAerialClient && !apiKeyPresent) nextSteps.push("run: aerial setup codex or aerial setup claude to recreate the local Aerial key");
-  if (service.supported !== false && !service.service?.loaded) {
-    if (serviceHealthy) {
-      hints.push("Aerial is running in the foreground but no background service is installed; run `aerial service install` so it starts on reboot.");
-    } else {
-      nextSteps.push("run: aerial service install");
-    }
-  }
-  if (setup.auth.github_token.source === "env") {
-    hints.push("AERIAL_GITHUB_TOKEN is set for this process only; run aerial login without that env var to persist a service-readable login.");
-  }
-  return { schema: "aerial.status.v1", ok, setup, service, nextSteps, hints };
-}

package/src/cli/args.js

@@ -1,28 +0,0 @@
-export function argValue(args, name) {
-  const index = args.indexOf(name);
-  return index >= 0 ? args[index + 1] : undefined;
-}
-
-export function requiredArgValue(args, name) {
-  const index = args.indexOf(name);
-  if (index < 0) return undefined;
-  const value = args[index + 1];
-  if (value === undefined || value.startsWith("--")) {
-    throw new Error(`${name} requires a value.`);
-  }
-  return value;
-}
-
-export function parseConfigPort(value) {
-  const text = String(value).trim();
-  if (!/^\d+$/.test(text)) throw new Error("port must be an integer between 1 and 65535");
-  const port = Number(text);
-  if (port < 1 || port > 65535) throw new Error("port must be an integer between 1 and 65535");
-  return port;
-}
-
-export function parseConfigHost(value) {
-  const host = String(value).trim().toLowerCase();
-  if (host === "127.0.0.1" || host === "localhost" || host === "::1") return host;
-  throw new Error("host must be a loopback address: 127.0.0.1, localhost, or ::1");
-}

package/src/cli/help.js

@@ -1,23 +0,0 @@
-export function printHelp() {
-  console.log(`Aerial local Copilot proxy
-
-Usage:
-  aerial --version
-  aerial login
-  aerial setup codex [--model <id>] [--effort <low|medium|high|xhigh|max>]
-  aerial setup claude [--model <id>] [--effort <low|medium|high|xhigh|max>]
-  aerial service install
-  aerial status [--json]
-  aerial proxy status|enable|disable [--json]
-
-Diagnostics and rollback:
-  aerial setup status [--json]
-  aerial setup restore <codex|claude|all> --latest
-  aerial service status [--json]
-  aerial disable
-  aerial doctor
-  aerial probe [--live] [--json]
-
-Debug:
-  aerial start [--host 127.0.0.1] [--port 18181]`);
-}

package/src/cli/model-selection.js

@@ -1,119 +0,0 @@
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-import { proxyModels } from "../proxy/index.js";
-import { readJsonSafely } from "../shared/http-utils.js";
-import { modelsForRoute } from "../proxy/model-utils.js";
-import { parseNumberChoice } from "../shared/prompt-utils.js";
-
-const MAX_LISTED_MODELS = 20;
-const GPT_VERSION_RE = /^gpt-(\d+)(?:\.(\d+))?/i;
-const STABLE_GPT_RE = /^gpt-\d+(?:\.\d+)?$/i;
-
-export { modelsForRoute } from "../proxy/model-utils.js";
-
-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 readJsonSafely(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);
-}
-
-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 = parseNumberChoice(answer, { max: promptListed.length, defaultIndex: 1, oneBased: true });
-      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" || 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/cli/runtime-auth.js

@@ -1,21 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const CLI_ENTRY = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
-
-export function codexAuthCommand() {
-  return {
-    command: process.execPath,
-    args: [CLI_ENTRY, "key", "print"],
-    timeout_ms: 5000,
-    refresh_interval_ms: 0
-  };
-}
-
-function quoteCommandPart(value) {
-  return `"${String(value).replace(/"/g, '\\"')}"`;
-}
-
-export function claudeApiKeyHelper() {
-  return [process.execPath, CLI_ENTRY, "key", "print"].map(quoteCommandPart).join(" ");
-}

package/src/cli/setup-selection.js

@@ -1,47 +0,0 @@
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-import { parseNumberChoice } from "../shared/prompt-utils.js";
-import { DEFAULT_EFFORT, EFFORT_VALUES, assertValidEffort } from "../shared/effort.js";
-
-export { DEFAULT_EFFORT, EFFORT_VALUES, normalizeEffort, assertValidEffort } from "../shared/effort.js";
-
-export async function chooseSetupEffort({
-  target,
-  explicitEffort,
-  prompt,
-  input: inputStream = input,
-  output: outputStream = output
-} = {}) {
-  if (explicitEffort !== undefined) {
-    return { effort: assertValidEffort(explicitEffort), source: "explicit", displayed: false };
-  }
-  const shouldPrompt = prompt === undefined ? Boolean(inputStream.isTTY) : prompt;
-  if (!shouldPrompt) {
-    return { effort: DEFAULT_EFFORT, source: "default_non_tty", displayed: false };
-  }
-  const defaultIndex = EFFORT_VALUES.indexOf(DEFAULT_EFFORT);
-  const rl = createInterface({ input: inputStream, output: outputStream });
-  try {
-    outputStream.write(`Choose ${target} reasoning effort:\n`);
-    for (const [index, value] of EFFORT_VALUES.entries()) {
-      const marker = index === defaultIndex ? "  (default)" : "";
-      outputStream.write(`  ${index + 1}. ${value}${marker}\n`);
-    }
-    while (true) {
-      const answer = await rl.question(`Choose effort [1-${EFFORT_VALUES.length}, default ${defaultIndex + 1} = ${DEFAULT_EFFORT}]: `);
-      const selectedIndex = parseNumberChoice(answer, { max: EFFORT_VALUES.length, defaultIndex });
-      if (selectedIndex !== undefined) {
-        return { effort: EFFORT_VALUES[selectedIndex], source: "prompt", displayed: true };
-      }
-      outputStream.write(`Enter a number from 1 to ${EFFORT_VALUES.length}, or press Enter for ${defaultIndex + 1}.\n`);
-    }
-  } finally {
-    rl.close();
-  }
-}
-
-export function formatEffortSelection({ target, effort, source }) {
-  if (source === "explicit") return `Selected ${target} effort: ${effort}`;
-  if (source === "prompt") return `Selected ${target} effort: ${effort}`;
-  return `No interactive terminal detected; selected ${target} effort: ${effort}. Pass --effort <low|medium|high|xhigh|max> to choose a different effort.`;
-}