67router 1.0.1 → 1.0.2

package/src/cli/commands/connectTools.js

@@ -4,6 +4,8 @@
  * tool configured here looks identical to one applied from the dashboard.
  *
  * Each tool: { id, name, paths(), apply(ctx) → string[] written, reset() → string[] touched }
+ * Optional: route + serverModel(data) to inherit the server's model; needsModel: false
+ * for tools that discover models themselves (omp).
  * ctx: { baseUrl (origin, no /v1), apiKey, model, claudeModels: { envKey: model } }
  */
 
@@ -13,6 +15,7 @@ const os = require("os");
 
 const home = () => os.homedir();
 const v1 = (baseUrl) => (baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`);
+const isStr = (v) => typeof v === "string" && v.length > 0;
 
 // Drop trailing commas (JSONC) outside string literals, so values like "a,}" survive.
 function stripTrailingCommas(text) {
@@ -50,17 +53,17 @@ function writeFile(file, content) {
 
 const writeJson = (file, data) => writeFile(file, JSON.stringify(data, null, 2));
 
-// confbox is ESM-only; loaded lazily so non-codex runs don't need it.
+// confbox (TOML/YAML) is ESM-only; loaded lazily so other tools don't need it.
 async function toml() {
   return import("confbox");
 }
 
 // ── Claude Code ─────────────────────────────────────────────────────────────
 const CLAUDE_MODELS = [
-  { flag: "fable", envKey: "ANTHROPIC_DEFAULT_FABLE_MODEL", defaultValue: "cc/claude-fable-5" },
-  { flag: "opus", envKey: "ANTHROPIC_DEFAULT_OPUS_MODEL", defaultValue: "cc/claude-opus-5" },
-  { flag: "sonnet", envKey: "ANTHROPIC_DEFAULT_SONNET_MODEL", defaultValue: "cc/claude-sonnet-5" },
-  { flag: "haiku", envKey: "ANTHROPIC_DEFAULT_HAIKU_MODEL", defaultValue: "cc/claude-haiku-4-5-20251001" },
+  { flag: "fable", envKey: "ANTHROPIC_DEFAULT_FABLE_MODEL" },
+  { flag: "opus", envKey: "ANTHROPIC_DEFAULT_OPUS_MODEL" },
+  { flag: "sonnet", envKey: "ANTHROPIC_DEFAULT_SONNET_MODEL" },
+  { flag: "haiku", envKey: "ANTHROPIC_DEFAULT_HAIKU_MODEL" },
 ];
 const CLAUDE_RESET_KEYS = ["ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN", ...CLAUDE_MODELS.map((m) => m.envKey)];
 const claudePath = () => path.join(home(), ".claude", "settings.json");
@@ -73,10 +76,23 @@ const claude = {
     const file = claudePath();
     const cur = readJson(file) || {};
     cur.hasCompletedOnboarding = true;
-    cur.env = { ...(cur.env || {}), ANTHROPIC_BASE_URL: v1(baseUrl), ANTHROPIC_AUTH_TOKEN: apiKey, ...claudeModels };
+    cur.env = { ...(cur.env || {}), ANTHROPIC_BASE_URL: v1(baseUrl), ANTHROPIC_AUTH_TOKEN: apiKey };
+    // A tier with no model (null) is removed so Claude Code uses its own default
+    // instead of a stale value from an earlier run.
+    for (const m of CLAUDE_MODELS) {
+      if (claudeModels[m.envKey]) cur.env[m.envKey] = claudeModels[m.envKey];
+      else delete cur.env[m.envKey];
+    }
     writeJson(file, cur);
     return [file];
   },
+  async show() {
+    const env = readJson(claudePath())?.env || {};
+    const models = {};
+    if (isStr(env.ANTHROPIC_MODEL)) models.main = env.ANTHROPIC_MODEL;
+    for (const m of CLAUDE_MODELS) if (isStr(env[m.envKey])) models[m.flag] = env[m.envKey];
+    return { baseUrl: env.ANTHROPIC_BASE_URL, apiKey: env.ANTHROPIC_AUTH_TOKEN, models };
+  },
   async reset() {
     const file = claudePath();
     const cur = readJson(file);
@@ -97,6 +113,14 @@ const codex = {
   id: "codex",
   name: "OpenAI Codex CLI",
   paths: () => [codexPath()],
+  route: "codex-settings",
+  // GET returns raw TOML text; only trust `model` when the provider is 9router.
+  async serverModel(data) {
+    if (!isStr(data?.config)) return null;
+    const { parseTOML } = await toml();
+    const cfg = parseTOML(data.config) || {};
+    return cfg.model_provider === "9router" && isStr(cfg.model) ? cfg.model : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const { parseTOML, stringifyTOML } = await toml();
     const file = codexPath();
@@ -118,6 +142,28 @@ const codex = {
     writeFile(file, stringifyTOML(cfg));
     return [file];
   },
+  async show() {
+    let cfg;
+    try {
+      const { parseTOML } = await toml();
+      cfg = parseTOML(fs.readFileSync(codexPath(), "utf8")) || {};
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      throw new Error(`Cannot parse ${codexPath()}: ${err.message}`);
+    }
+    const p = cfg.model_providers?.["9router"];
+    const auth = p?.http_headers?.Authorization;
+    return {
+      baseUrl: p?.base_url,
+      apiKey: isStr(auth) ? auth.replace(/^Bearer\s+/i, "") : undefined,
+      models: {
+        ...(isStr(cfg.model) ? { main: cfg.model } : {}),
+        ...(isStr(cfg.agents?.default_subagent_model) ? { subagent: cfg.agents.default_subagent_model } : {}),
+      },
+      // Codex only routes through 9router when this provider is the active one.
+      active: cfg.model_provider === "9router",
+    };
+  },
   async reset() {
     const { parseTOML, stringifyTOML } = await toml();
     const file = codexPath();
@@ -141,32 +187,88 @@ const opencode = {
   id: "opencode",
   name: "OpenCode",
   paths: () => [opencodePath()],
+  route: "opencode-settings",
+  serverModel(data) {
+    const m = data?.config?.model;
+    return isStr(m) && m.startsWith("9router/") ? m.slice("9router/".length) : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const file = opencodePath();
     const cfg = readJson(file) || {};
     cfg.provider = cfg.provider || {};
-    const p = cfg.provider["9router"] || { npm: "@ai-sdk/openai-compatible", options: {}, models: {} };
+    delete cfg.provider["9router"];
+    const p = cfg.provider["67router"] || { npm: "@ai-sdk/openai-compatible", name: "67Router", options: {}, models: {} };
     p.options = { ...p.options, baseURL: v1(baseUrl), apiKey };
     p.models = p.models || {};
-    p.models[model] = { name: model, modalities: { input: ["text", "image"], output: ["text"] } };
-    cfg.provider["9router"] = p;
-    cfg.model = `9router/${model}`;
-    cfg.agent = cfg.agent || {};
-    cfg.agent.explorer = {
-      description: "Fast explorer subagent for codebase exploration",
-      mode: "subagent",
-      model: `9router/${model}`,
-    };
+
+    // Fetch all models with full specs from endpoint
+    try {
+      const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+      const res = await fetch(`${v1(baseUrl)}/models`, { headers });
+      if (res.ok) {
+        const json = await res.json();
+        const list = Array.isArray(json?.data) ? json.data : (Array.isArray(json?.models) ? json.models : []);
+        for (const m of list) {
+          const mId = m.id || m.name;
+          if (!mId) continue;
+          const ctx = m.context_length || m.capabilities?.contextWindow || 128000;
+          const out = m.max_completion_tokens || m.capabilities?.maxOutput || 16384;
+          const hasVision = Boolean(m.capabilities?.vision || (Array.isArray(m.modalities?.input) && m.modalities.input.includes("image")));
+          p.models[mId] = {
+            name: mId,
+            limit: { context: Number(ctx) || 128000, output: Number(out) || 16384 },
+            modalities: { input: hasVision ? ["text", "image"] : ["text"], output: ["text"] },
+          };
+        }
+      }
+    } catch (e) {}
+
+    if (model) {
+      if (!p.models[model]) {
+        p.models[model] = {
+          name: model,
+          limit: { context: 128000, output: 16384 },
+          modalities: { input: ["text", "image"], output: ["text"] },
+        };
+      }
+      cfg.model = `67router/${model}`;
+      cfg.agent = cfg.agent || {};
+      cfg.agent.explorer = {
+        description: "Fast explorer subagent for codebase exploration",
+        mode: "subagent",
+        model: `67router/${model}`,
+      };
+    } else {
+      const firstModel = Object.keys(p.models)[0];
+      if (firstModel) {
+        cfg.model = `67router/${firstModel}`;
+      }
+    }
+
+    cfg.provider["67router"] = p;
     writeJson(file, cfg);
     return [file];
   },
+  async show() {
+    const cfg = readJson(opencodePath()) || {};
+    const p = cfg.provider?.["9router"];
+    const models = {};
+    if (isStr(cfg.model)) models.main = cfg.model;
+    if (isStr(cfg.agent?.explorer?.model)) models.explorer = cfg.agent.explorer.model;
+    const listed = Object.keys(p?.models || {});
+    if (listed.length) models.available = listed.join(", ");
+    return { baseUrl: p?.options?.baseURL, apiKey: p?.options?.apiKey, models, active: !!cfg.model?.startsWith("9router/") };
+  },
   async reset() {
     const file = opencodePath();
     const cfg = readJson(file);
     if (!cfg) return [];
-    if (cfg.provider) delete cfg.provider["9router"];
-    if (cfg.model?.startsWith("9router/")) delete cfg.model;
-    if (cfg.agent?.explorer?.model?.startsWith("9router/")) {
+    if (cfg.provider) {
+      delete cfg.provider["67router"];
+      delete cfg.provider["9router"];
+    }
+    if (cfg.model?.startsWith("67router/") || cfg.model?.startsWith("9router/")) delete cfg.model;
+    if (cfg.agent?.explorer?.model?.startsWith("67router/") || cfg.agent?.explorer?.model?.startsWith("9router/")) {
       delete cfg.agent.explorer;
       if (Object.keys(cfg.agent).length === 0) delete cfg.agent;
     }
@@ -183,6 +285,11 @@ const droid = {
   id: "droid",
   name: "Factory Droid",
   paths: () => [droidPath()],
+  route: "droid-settings",
+  serverModel(data) {
+    const m = (data?.settings?.customModels || []).find(isDroid9r)?.model;
+    return isStr(m) ? m : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const file = droidPath();
     const cfg = readJson(file) || {};
@@ -205,6 +312,14 @@ const droid = {
     writeJson(file, cfg);
     return [file];
   },
+  async show() {
+    const ours = (readJson(droidPath())?.customModels || []).filter(isDroid9r);
+    return {
+      baseUrl: ours[0]?.baseUrl,
+      apiKey: ours[0]?.apiKey,
+      models: ours.length ? { main: ours[0].model, ...(ours.length > 1 ? { available: ours.map((m) => m.model).join(", ") } : {}) } : {},
+    };
+  },
   async reset() {
     const file = droidPath();
     const cfg = readJson(file);
@@ -225,6 +340,11 @@ const crush = {
   id: "crush",
   name: "Crush",
   paths: () => [crushPath()],
+  route: "crush-settings",
+  serverModel(data) {
+    const m = data?.config?.providers?.["9router"]?.models?.[0]?.id;
+    return isStr(m) ? m : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const file = crushPath();
     const cfg = readJson(file) || {};
@@ -238,6 +358,11 @@ const crush = {
     writeJson(file, cfg);
     return [file];
   },
+  async show() {
+    const p = readJson(crushPath())?.providers?.["9router"];
+    const ids = (p?.models || []).map((m) => m.id).filter(isStr);
+    return { baseUrl: p?.base_url, apiKey: p?.api_key, models: ids.length ? { main: ids[0] } : {} };
+  },
   async reset() {
     const file = crushPath();
     const cfg = readJson(file);
@@ -256,6 +381,8 @@ const kilo = {
   id: "kilo",
   name: "Kilo Code CLI",
   paths: () => [kiloPath()],
+  // No route: the dashboard GET exposes only auth key names, not the model,
+  // so kilo falls back to the shared model.
   async apply({ baseUrl, apiKey, model }) {
     const file = kiloPath();
     const auth = readJson(file) || {};
@@ -263,6 +390,10 @@ const kilo = {
     writeJson(file, auth);
     return [file];
   },
+  async show() {
+    const a = readJson(kiloPath())?.["openai-compatible"];
+    return { baseUrl: a?.baseUrl, apiKey: a?.apiKey, models: isStr(a?.model) ? { main: a.model } : {} };
+  },
   async reset() {
     const file = kiloPath();
     const auth = readJson(file);
@@ -283,6 +414,11 @@ const cline = {
   id: "cline",
   name: "Cline CLI",
   paths: () => [clineState(), clineSecrets()],
+  route: "cline-settings",
+  serverModel(data) {
+    const st = data?.settings;
+    return st?.actModeApiProvider === "openai" && isStr(st.openAiModelId) ? st.openAiModelId : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const state = readJson(clineState()) || {};
     state.actModeApiProvider = "openai";
@@ -296,6 +432,18 @@ const cline = {
     writeJson(clineSecrets(), secrets);
     return [clineState(), clineSecrets()];
   },
+  async show() {
+    const st = readJson(clineState()) || {};
+    const models = {};
+    if (isStr(st.openAiModelId)) models.act = st.openAiModelId;
+    if (isStr(st.planModeOpenAiModelId)) models.plan = st.planModeOpenAiModelId;
+    return {
+      baseUrl: st.openAiBaseUrl,
+      apiKey: readJson(clineSecrets())?.openAiApiKey,
+      models,
+      active: st.actModeApiProvider === "openai",
+    };
+  },
   async reset() {
     const state = readJson(clineState());
     if (!state) return [];
@@ -318,9 +466,122 @@ const cline = {
   },
 };
 
-const TOOLS = [claude, codex, opencode, droid, crush, kilo, cline];
+// ── Pi (pi-coding-agent) ────────────────────────────────────────────────────
+// Prefers ~/.pi/agent/models.json; an existing legacy ~/.pi/models.json is used instead.
+const piPath = () => {
+  const agent = path.join(home(), ".pi", "agent", "models.json");
+  const root = path.join(home(), ".pi", "models.json");
+  return !fs.existsSync(agent) && fs.existsSync(root) ? root : agent;
+};
+
+const pi = {
+  id: "pi",
+  name: "Pi",
+  paths: () => [piPath()],
+  route: "pi-settings",
+  serverModel(data) {
+    const m = data?.config?.providers?.["9router"]?.models?.[0];
+    const id = typeof m === "string" ? m : m?.id;
+    return isStr(id) ? id : null;
+  },
+  async apply({ baseUrl, apiKey, model }) {
+    const file = piPath();
+    const cfg = readJson(file) || {};
+    cfg.providers = cfg.providers || {};
+    cfg.providers["9router"] = {
+      ...(cfg.providers["9router"] || {}),
+      baseUrl: v1(baseUrl),
+      apiKey,
+      api: "openai-completions",
+      models: [{ id: model, name: model, contextWindow: 128000, maxTokens: 16384 }],
+    };
+    writeJson(file, cfg);
+    return [file];
+  },
+  async show() {
+    const p = readJson(piPath())?.providers?.["9router"];
+    const ids = (p?.models || []).map((m) => (typeof m === "string" ? m : m?.id)).filter(isStr);
+    return {
+      baseUrl: p?.baseUrl,
+      apiKey: p?.apiKey,
+      models: ids.length ? { main: ids[0], ...(ids.length > 1 ? { available: ids.join(", ") } : {}) } : {},
+    };
+  },
+  async reset() {
+    const file = piPath();
+    const cfg = readJson(file);
+    if (!cfg?.providers?.["9router"]) return [];
+    delete cfg.providers["9router"];
+    if (Object.keys(cfg.providers).length === 0) delete cfg.providers;
+    rewriteFile(file, JSON.stringify(cfg, null, 2));
+    return [file];
+  },
+};
+
+// ── Oh My Pi ────────────────────────────────────────────────────────────────
+// Proxy discovery lists every server model under /model, so no model is written.
+// The dashboard also mirrors the key into agent.db; models.yml is the primary
+// source, so that best-effort sqlite write is skipped here.
+const ompPath = () => path.join(home(), ".omp", "agent", "models.yml");
+
+async function readYaml(file) {
+  let text;
+  try { text = fs.readFileSync(file, "utf8"); } catch (err) { if (err.code === "ENOENT") return null; throw err; }
+  try {
+    const { parseYAML } = await toml();
+    return parseYAML(text) || {};
+  } catch (err) {
+    throw new Error(`Cannot parse ${file}: ${err.message}`);
+  }
+}
+
+const omp = {
+  id: "omp",
+  name: "Oh My Pi",
+  paths: () => [ompPath()],
+  needsModel: false,
+  async apply({ baseUrl, apiKey }) {
+    const { stringifyYAML } = await toml();
+    const file = ompPath();
+    const cfg = (await readYaml(file)) || {};
+    cfg.providers = cfg.providers || {};
+    cfg.providers["9router"] = {
+      baseUrl: v1(baseUrl),
+      apiKey,
+      api: "openai-completions",
+      authHeader: true,
+      disableStrictTools: true,
+      discovery: { type: "proxy" },
+    };
+    writeFile(file, stringifyYAML(cfg));
+    return [file];
+  },
+  async show() {
+    const p = (await readYaml(ompPath()))?.providers?.["9router"];
+    return {
+      baseUrl: p?.baseUrl,
+      apiKey: p?.apiKey,
+      models: p?.discovery?.type === "proxy" ? { main: "(all server models, via discovery)" } : {},
+    };
+  },
+  async reset() {
+    const { stringifyYAML } = await toml();
+    const file = ompPath();
+    const cfg = await readYaml(file);
+    if (!cfg?.providers?.["9router"]) return [];
+    delete cfg.providers["9router"];
+    if (Object.keys(cfg.providers).length === 0) delete cfg.providers;
+    rewriteFile(file, Object.keys(cfg).length ? stringifyYAML(cfg) : "");
+    return [file];
+  },
+};
+
+const TOOLS = [claude, codex, opencode, droid, crush, kilo, cline, pi, omp];
 const TOOL_IDS = TOOLS.map((t) => t.id);
-const TOOL_ALIASES = { "claude-code": "claude", "claudecode": "claude", "factory": "droid", "kilocode": "kilo" };
+const TOOL_ALIASES = {
+  "claude-code": "claude", "claudecode": "claude", "factory": "droid", "kilocode": "kilo",
+  "pi-coding-agent": "pi", "oh-my-pi": "omp",
+};
 
 function resolveTools(list) {
   const ids = new Set();

package/src/cli/commands/show.js

@@ -0,0 +1,101 @@
+/**
+ * `9router show [tools…]` — print the 9router settings currently written in
+ * each CLI tool's LOCAL config: base URL, (masked) API key and models.
+ *
+ * Read-only and offline: never contacts a server and never prints a full key.
+ */
+
+const { TOOLS, TOOL_IDS, resolveTools } = require("./connectTools");
+const { __test__: { maskKey } } = require("./connect");
+
+const HELP = `
+Usage: 9router show [tool…] [options]
+
+Show the 9router settings each CLI tool on THIS machine is currently using.
+Read-only: reads local config files, contacts no server.
+
+  9router show                 # every supported tool
+  9router show claude          # one tool
+  9router show claude codex    # several (or: --tools claude,codex)
+
+Tools: ${TOOL_IDS.join(", ")}, all
+
+Options:
+  --tools <list>   Comma-separated tools (same as positional names)
+  --json           Machine-readable output (API key still masked)
+  -h, --help       Show this help
+`;
+
+function parseArgs(argv) {
+  const opts = { tools: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--tools") {
+      const v = argv[++i];
+      if (v === undefined) throw new Error("Missing value for --tools");
+      opts.tools.push(...v.split(","));
+    } else if (a === "--json") opts.json = true;
+    else if (a === "-h" || a === "--help") opts.help = true;
+    else if (!a.startsWith("-")) opts.tools.push(a);
+    else throw new Error(`Unknown option: ${a}`);
+  }
+  return opts;
+}
+
+// Normalise one tool's show() output into a printable, key-safe record.
+async function inspect(tool) {
+  const record = { id: tool.id, name: tool.name, files: tool.paths() };
+  try {
+    const s = await tool.show();
+    record.configured = !!(s.baseUrl || s.apiKey || Object.keys(s.models || {}).length);
+    record.baseUrl = s.baseUrl || null;
+    record.apiKey = s.apiKey ? maskKey(s.apiKey) : null;
+    record.models = s.models || {};
+    // `active` is only reported by tools where 9router can be present but not selected.
+    if (typeof s.active === "boolean") record.active = s.active;
+  } catch (err) {
+    record.error = err.message;
+  }
+  return record;
+}
+
+function printRecord(r) {
+  if (r.error) {
+    console.log(`❌ ${r.name}: ${r.error}`);
+    return;
+  }
+  if (!r.configured) {
+    console.log(`• ${r.name}: not configured for 9router (${r.files[0]})`);
+    return;
+  }
+  const inactive = r.active === false ? "  \x1b[33m(9router present but not the active provider)\x1b[0m" : "";
+  console.log(`✅ ${r.name}${inactive}`);
+  console.log(`   File:     ${r.files.join(", ")}`);
+  console.log(`   Base URL: ${r.baseUrl || "(none)"}`);
+  console.log(`   API key:  ${r.apiKey || "(none)"}`);
+  const entries = Object.entries(r.models);
+  if (!entries.length) console.log("   Models:   (none set — the tool's own default applies)");
+  else {
+    const width = Math.max(...entries.map(([k]) => k.length));
+    console.log("   Models:");
+    for (const [k, v] of entries) console.log(`     ${k.padEnd(width)}  ${v}`);
+  }
+}
+
+async function run(argv) {
+  const opts = parseArgs(argv);
+  if (opts.help) {
+    console.log(HELP);
+    return 0;
+  }
+  const tools = opts.tools.length ? resolveTools(opts.tools) : TOOLS;
+  const records = [];
+  for (const t of tools) records.push(await inspect(t));
+
+  if (opts.json) console.log(JSON.stringify(records, null, 2));
+  else records.forEach((r, i) => { if (i) console.log(""); printRecord(r); });
+
+  return records.some((r) => r.error) ? 1 : 0;
+}
+
+module.exports = { run, __test__: { parseArgs, inspect } };