pleumrouter 0.5.44 → 0.5.45

package/src/wire.mjs

@@ -2,10 +2,32 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { ROOT, V1, authFetch, getActiveContext } from "./config.mjs";
-import { tomlBasicString } from "./recipes.mjs";
+import { tomlBasicString, RECIPES } from "./recipes.mjs";
 import { t } from "./i18n.mjs";
 
-export const WIRE_TOOLS = ["claude", "codex"];
+export const WIRE_DEFAULT_TOOLS = ["claude", "codex"];
+export const WIRE_TOOLS = [
+  "claude",
+  "codex",
+  "opencode",
+  "aider",
+  "crush",
+  "pi",
+  "agy",
+  "gemini",
+  "qwen",
+  "copilot",
+  "goose",
+  "openhands",
+  "omp",
+  "hermes",
+  "minimax",
+  "mimo",
+  "openclaw",
+  "plandex",
+  "interpreter",
+];
+
 export const WIRE_KEY_NAME = "pleum-desktop";
 export const WIRE_MARKER_START = "# pleum-wire-start";
 export const WIRE_MARKER_END = "# pleum-wire-end";
@@ -17,11 +39,35 @@ const CLAUDE_ENV_KEYS = [
   "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY",
   "API_TIMEOUT_MS",
   "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
+  "ANTHROPIC_CUSTOM_MODEL_OPTION",
+  "ANTHROPIC_CUSTOM_MODEL_OPTION_NAME",
+  "ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION",
+  "CLAUDE_CODE_SUBAGENT_MODEL",
+  "CLAUDE_CODE_SUBAGENT_MODEL_FORCE",
 ];
 
+export const WIRE_WARNINGS = {
+  claude: "Once wired, running `claude` (CLI or Desktop) will route all requests through PleumRouter API credits instead of your Claude Pro/Max subscription until you run `pleum unwire claude`.",
+  codex: "Once wired, running `codex` (CLI or Desktop) will route all requests through PleumRouter API credits instead of your ChatGPT Plus/Pro plan or existing OpenAI key until you run `pleum unwire codex`.",
+  agy: "Once wired, Antigravity CLI (`agy`) will use PleumRouter Gemini API mode and deduct PleumRouter credits instead of Google account login until you run `pleum unwire agy`.",
+  opencode: "Once wired, OpenCode (CLI, Desktop, IDE) will register PleumRouter in ~/.config/opencode/opencode.json and charge PleumRouter credits when Pleum models are used.",
+  default: "Once wired, running `{tool}` will route API calls through PleumRouter and deduct PleumRouter credits until you run `pleum unwire {tool}`.",
+};
+
 export function wirePaths(home = homedir()) {
   const claude = join(home, ".claude", "settings.json");
   const codex = join(home, ".codex", "config.toml");
+  const opencode = join(home, ".config", "opencode", "opencode.json");
+  const opencodeAuth = join(home, ".local", "share", "opencode", "auth.json");
+  const aider = join(home, ".aider.conf.yml");
+  const crush = join(home, ".config", "crush", "crush.json");
+  const pi = join(home, ".pi", "agent", "models.json");
+  const agy = join(home, ".gemini", "antigravity-cli", "settings.json");
+  const shellRc = process.env.SHELL && process.env.SHELL.includes("bash")
+    ? join(home, ".bashrc")
+    : join(home, ".zshrc");
+  const state = join(home, ".pleum", "wired-agents.json");
+
   return {
     home,
     wire: join(home, ".pleum", "wire.json"),
@@ -29,6 +75,19 @@ export function wirePaths(home = homedir()) {
     claudeBak: `${claude}.pleum.bak`,
     codex,
     codexBak: `${codex}.pleum.bak`,
+    opencode,
+    opencodeBak: `${opencode}.pleum.bak`,
+    opencodeAuth,
+    aider,
+    aiderBak: `${aider}.pleum.bak`,
+    crush,
+    crushBak: `${crush}.pleum.bak`,
+    pi,
+    piBak: `${pi}.pleum.bak`,
+    agy,
+    agyBak: `${agy}.pleum.bak`,
+    shellRc,
+    state,
   };
 }
 
@@ -42,15 +101,13 @@ function readText(path) {
 
 export function writeSecretFile(path, contents, mode = 0o600) {
   mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  // 기존 파일이 0644 등으로 있으면 writeFileSync의 mode는 무시된다(#41) —
-  // tmp(강제 chmod) + rename 원자적 교체로 결과물이 항상 mode가 되게 한다.
   const tmp = `${path}.pleum-tmp-${process.pid}`;
   writeFileSync(tmp, contents, { mode });
   try {
     chmodSync(tmp, mode);
     renameSync(tmp, path);
   } catch (e) {
-    try { unlinkSync(tmp); } catch {} // 키 평문 잔여를 남기지 않는다
+    try { unlinkSync(tmp); } catch {}
     throw e;
   }
 }
@@ -97,10 +154,13 @@ function removeRootValue(toml, name) {
   return root.replace(new RegExp(`^${name}\\s*=\\s*.+\\n?`, "m"), "") + rest;
 }
 
-export function wireClaudeSettings(existingJson, { root, key }) {
+// ── Claude settings.json ──────────────────────────────────────────
+export function wireClaudeSettings(existingJson, { root, key, model } = {}) {
   let obj = {};
   if (existingJson && existingJson.trim()) {
-    obj = JSON.parse(existingJson);
+    try {
+      obj = JSON.parse(existingJson);
+    } catch {}
     if (obj === null || typeof obj !== "object" || Array.isArray(obj)) obj = {};
   }
   obj.env = {
@@ -111,12 +171,33 @@ export function wireClaudeSettings(existingJson, { root, key }) {
     CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
   };
   delete obj.env.ANTHROPIC_API_KEY;
+
+  if (model) {
+    const qualified = /^claude-/.test(model) ? `anthropic/${model}` : model;
+    obj.env.ANTHROPIC_CUSTOM_MODEL_OPTION = qualified;
+    obj.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME = `Pleum · ${model}`;
+    obj.env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION = "Selected in Pleum wire";
+    obj.env.CLAUDE_CODE_SUBAGENT_MODEL = "sonnet";
+    obj.env.CLAUDE_CODE_SUBAGENT_MODEL_FORCE = "1";
+    obj.model = qualified;
+  } else {
+    delete obj.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+    delete obj.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
+    delete obj.env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
+    delete obj.env.CLAUDE_CODE_SUBAGENT_MODEL;
+    delete obj.env.CLAUDE_CODE_SUBAGENT_MODEL_FORCE;
+    delete obj.model;
+  }
+
   return `${JSON.stringify(obj, null, 2)}\n`;
 }
 
 export function unwireClaudeSettings(existingJson) {
   if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
-  const obj = JSON.parse(existingJson);
+  let obj = {};
+  try {
+    obj = JSON.parse(existingJson);
+  } catch {}
   if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
     return `${JSON.stringify({}, null, 2)}\n`;
   }
@@ -124,21 +205,28 @@ export function unwireClaudeSettings(existingJson) {
     for (const envKey of CLAUDE_ENV_KEYS) delete obj.env[envKey];
     if (Object.keys(obj.env).length === 0) delete obj.env;
   }
+  if (obj.model && typeof obj.model === "string" && (obj.model.startsWith("anthropic/") || obj.model.startsWith("pleum/"))) {
+    delete obj.model;
+  }
   return `${JSON.stringify(obj, null, 2)}\n`;
 }
 
-export function wireCodexToml(existingToml, { v1, key, model = "gpt-6.1-sol" }) {
+// ── Codex config.toml ─────────────────────────────────────────────
+export function wireCodexToml(existingToml, { v1, key, model = "gpt-6.1-sol", billingOnly = false } = {}) {
   const src = existingToml ?? "";
   const previousProvider = previousValue(src, "model_provider");
   const previousModel = previousValue(src, "model");
+  const targetModel = billingOnly && previousModel ? previousModel : model;
+
   let body = stripWireBlock(src);
   body = removeTomlTable(body, "model_providers.pleum.http_headers");
   body = removeTomlTable(body, "model_providers.pleum");
   body = removeRootValue(removeRootValue(body, "model_provider"), "model");
+
   const rootBlock = `${WIRE_MARKER_START}
 # previous_model_provider = ${previousProvider}
 # previous_model = ${previousModel}
-model = ${tomlBasicString(model)}
+model = ${tomlBasicString(targetModel)}
 model_provider = "pleum"
 ${WIRE_MARKER_END}
 `;
@@ -170,6 +258,356 @@ export function unwireCodexToml(existingToml) {
   return `${restored ? `${restored}\n\n` : ""}${body.trim()}`.replace(/\n{3,}/g, "\n\n").trimStart() + "\n";
 }
 
+// ── OpenCode (opencode.json & auth.json) ──────────────────────────
+export function wireOpenCodeJson(existingJson, { v1, models = [], defaultModel } = {}) {
+  let obj = {};
+  if (existingJson && existingJson.trim()) {
+    try {
+      obj = JSON.parse(existingJson);
+    } catch {}
+  }
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+
+  obj.provider = obj.provider || {};
+  const modelEntries = Object.fromEntries(models.map((id) => [id, {}]));
+  if (defaultModel) modelEntries[defaultModel] = {};
+
+  obj.provider.pleum = {
+    npm: "@ai-sdk/openai-compatible",
+    name: "PleumRouter",
+    options: {
+      baseURL: v1,
+    },
+    models: modelEntries,
+  };
+
+  if (defaultModel) {
+    if (obj.model && !obj.model.startsWith("pleum/")) {
+      obj._pleum_previous_model = obj.model;
+    }
+    obj.model = `pleum/${defaultModel}`;
+  }
+
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+export function unwireOpenCodeJson(existingJson) {
+  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
+  let obj = {};
+  try {
+    obj = JSON.parse(existingJson);
+  } catch {}
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
+
+  if (obj.provider && obj.provider.pleum) {
+    delete obj.provider.pleum;
+    if (Object.keys(obj.provider).length === 0) delete obj.provider;
+  }
+  if (obj.model && typeof obj.model === "string" && obj.model.startsWith("pleum/")) {
+    if (obj._pleum_previous_model) {
+      obj.model = obj._pleum_previous_model;
+      delete obj._pleum_previous_model;
+    } else {
+      delete obj.model;
+    }
+  }
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+export function wireOpenCodeAuth(existingJson, key) {
+  let obj = {};
+  if (existingJson && existingJson.trim()) {
+    try {
+      obj = JSON.parse(existingJson);
+    } catch {}
+  }
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+  obj.pleum = { type: "api", key };
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+export function unwireOpenCodeAuth(existingJson) {
+  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
+  let obj = {};
+  try {
+    obj = JSON.parse(existingJson);
+  } catch {}
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
+  delete obj.pleum;
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+// ── Aider ~/.aider.conf.yml ───────────────────────────────────────
+export function wireAiderYaml(existingYaml = "", { v1, key, model } = {}) {
+  const clean = (existingYaml || "").replace(
+    new RegExp(`${WIRE_MARKER_START}[\\s\\S]*?${WIRE_MARKER_END}\\n?`, "g"),
+    "",
+  ).trim();
+
+  const lines = [
+    WIRE_MARKER_START,
+    `openai-api-base: ${v1}`,
+    `openai-api-key: ${key}`,
+  ];
+  if (model) {
+    const cleanModel = model.replace(/^openai\//, "");
+    lines.push(`model: openai/${cleanModel}`);
+  }
+  lines.push(WIRE_MARKER_END);
+
+  return `${clean ? `${clean}\n\n` : ""}${lines.join("\n")}\n`;
+}
+
+export function unwireAiderYaml(existingYaml = "") {
+  return (existingYaml || "")
+    .replace(new RegExp(`${WIRE_MARKER_START}[\\s\\S]*?${WIRE_MARKER_END}\\n?`, "g"), "")
+    .trimStart();
+}
+
+// ── Crush ~/.config/crush/crush.json ──────────────────────────────
+export function wireCrushConfig(existingJson, { v1, key, models = [] } = {}) {
+  let obj = {};
+  if (existingJson && existingJson.trim()) {
+    try {
+      obj = JSON.parse(existingJson);
+    } catch {}
+  }
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+  obj.providers = obj.providers || {};
+  obj.providers.pleum = {
+    type: "openai-compat",
+    base_url: v1,
+    api_key: key,
+    models: models.map((id) => ({ id, name: id })),
+  };
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+export function unwireCrushConfig(existingJson) {
+  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
+  let obj = {};
+  try {
+    obj = JSON.parse(existingJson);
+  } catch {}
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
+  if (obj.providers && obj.providers.pleum) {
+    delete obj.providers.pleum;
+    if (Object.keys(obj.providers).length === 0) delete obj.providers;
+  }
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+// ── Pi ~/.pi/agent/models.json ────────────────────────────────────
+export function wirePiConfig(existingJson, { v1, key, models = [] } = {}) {
+  let obj = {};
+  if (existingJson && existingJson.trim()) {
+    try {
+      obj = JSON.parse(existingJson);
+    } catch {}
+  }
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+  obj.providers = obj.providers || {};
+  obj.providers.pleum = {
+    baseUrl: v1,
+    api: "openai-completions",
+    apiKey: key,
+    models: models.map((id) => ({ id })),
+  };
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+export function unwirePiConfig(existingJson) {
+  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
+  let obj = {};
+  try {
+    obj = JSON.parse(existingJson);
+  } catch {}
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
+  if (obj.providers && obj.providers.pleum) {
+    delete obj.providers.pleum;
+    if (Object.keys(obj.providers).length === 0) delete obj.providers;
+  }
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+// ── Antigravity ~/.gemini/antigravity-cli/settings.json ────────────
+export function wireAgySettings(existingJson, { model } = {}) {
+  let obj = {};
+  if (existingJson && existingJson.trim()) {
+    try {
+      obj = JSON.parse(existingJson);
+    } catch {}
+  }
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+  obj.modelProvider = "gemini";
+  if (model) obj.model = model;
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+export function unwireAgySettings(existingJson) {
+  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
+  let obj = {};
+  try {
+    obj = JSON.parse(existingJson);
+  } catch {}
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
+  if (obj.modelProvider === "gemini") delete obj.modelProvider;
+  delete obj.model;
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+// ── Shell function wrapper (rc files) ─────────────────────────────
+export function wireShellWrapper(existingRc = "", { tool, bin, envMap = {} } = {}) {
+  const startMarker = `# pleum-wire:${tool}-start`;
+  const endMarker = `# pleum-wire:${tool}-end`;
+  const clean = (existingRc || "")
+    .replace(new RegExp(`${startMarker}[\\s\\S]*?${endMarker}\\n?`, "g"), "")
+    .trim();
+
+  const envAssignments = Object.entries(envMap)
+    .map(([k, v]) => `${k}=${JSON.stringify(String(v))}`)
+    .join(" ");
+
+  const block = `${startMarker}
+${tool}() {
+  ${envAssignments} command ${bin || tool} "$@"
+}
+${endMarker}`;
+
+  return `${clean ? `${clean}\n\n` : ""}${block}\n`;
+}
+
+export function unwireShellWrapper(existingRc = "", tool) {
+  const startMarker = `# pleum-wire:${tool}-start`;
+  const endMarker = `# pleum-wire:${tool}-end`;
+  return (existingRc || "")
+    .replace(new RegExp(`${startMarker}[\\s\\S]*?${endMarker}\\n?`, "g"), "")
+    .trimStart();
+}
+
+// ── Wired State Metadata (~/.pleum/wired-agents.json) ─────────────
+export function readWiredState(paths) {
+  try {
+    const raw = readText(paths.state);
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+export function writeWiredState(paths, state) {
+  writeSecretFile(paths.state, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+// ── Wire Status Check ─────────────────────────────────────────────
+export function getWireStatus(home = homedir()) {
+  const paths = wirePaths(home);
+  const state = readWiredState(paths);
+  const status = {};
+
+  // 1. Claude
+  const claudeText = readText(paths.claude);
+  const claudeWired = Boolean(claudeText && claudeText.includes("ANTHROPIC_BASE_URL"));
+  status.claude = {
+    tool: "claude",
+    label: "Claude Code",
+    wired: claudeWired,
+    mode: state.claude?.mode || (claudeWired ? "billing" : undefined),
+    model: state.claude?.model,
+    targetPath: paths.claude,
+  };
+
+  // 2. Codex
+  const codexText = readText(paths.codex);
+  const codexWired = Boolean(codexText && codexText.includes('model_provider = "pleum"'));
+  status.codex = {
+    tool: "codex",
+    label: "Codex CLI",
+    wired: codexWired,
+    mode: state.codex?.mode || (codexWired ? "billing" : undefined),
+    model: state.codex?.model,
+    targetPath: paths.codex,
+  };
+
+  // 3. OpenCode
+  const opencodeText = readText(paths.opencode);
+  const opencodeWired = Boolean(opencodeText && opencodeText.includes('"PleumRouter"'));
+  status.opencode = {
+    tool: "opencode",
+    label: "OpenCode",
+    wired: opencodeWired,
+    mode: state.opencode?.mode || (opencodeWired ? "list" : undefined),
+    model: state.opencode?.model,
+    targetPath: paths.opencode,
+  };
+
+  // 4. Aider
+  const aiderText = readText(paths.aider);
+  const aiderWired = Boolean(aiderText && aiderText.includes("openai-api-base") && aiderText.includes("apirouter.pleum.ai"));
+  status.aider = {
+    tool: "aider",
+    label: "Aider",
+    wired: aiderWired,
+    mode: state.aider?.mode || (aiderWired ? "billing" : undefined),
+    model: state.aider?.model,
+    targetPath: paths.aider,
+  };
+
+  // 5. Crush
+  const crushText = readText(paths.crush);
+  const crushWired = Boolean(crushText && crushText.includes("apirouter.pleum.ai"));
+  status.crush = {
+    tool: "crush",
+    label: "Crush",
+    wired: crushWired,
+    mode: state.crush?.mode || (crushWired ? "list" : undefined),
+    model: state.crush?.model,
+    targetPath: paths.crush,
+  };
+
+  // 6. Pi
+  const piText = readText(paths.pi);
+  const piWired = Boolean(piText && piText.includes("apirouter.pleum.ai"));
+  status.pi = {
+    tool: "pi",
+    label: "Pi",
+    wired: piWired,
+    mode: state.pi?.mode || (piWired ? "list" : undefined),
+    model: state.pi?.model,
+    targetPath: paths.pi,
+  };
+
+  // 7. Antigravity (agy)
+  const agyText = readText(paths.agy);
+  const rcText = readText(paths.shellRc) || "";
+  const agyWired = Boolean((agyText && agyText.includes('"modelProvider": "gemini"')) || rcText.includes("# pleum-wire:agy-start"));
+  status.agy = {
+    tool: "agy",
+    label: "Antigravity CLI",
+    wired: agyWired,
+    mode: state.agy?.mode || (agyWired ? "billing" : undefined),
+    model: state.agy?.model,
+    targetPath: paths.agy,
+  };
+
+  // Shell-based tools
+  for (const tool of WIRE_TOOLS) {
+    if (status[tool]) continue;
+    const r = RECIPES[tool];
+    const isWired = rcText.includes(`# pleum-wire:${tool}-start`);
+    status[tool] = {
+      tool,
+      label: r?.label || tool,
+      wired: isWired,
+      mode: state[tool]?.mode || (isWired ? "billing" : undefined),
+      model: state[tool]?.model,
+      targetPath: paths.shellRc,
+    };
+  }
+
+  return status;
+}
+
 function parseJsonBody(res) {
   return res.json().catch(() => ({}));
 }
@@ -209,8 +647,6 @@ export async function ensureWireKey({
             writeSecretFile(paths.wire, `${JSON.stringify(movedRecord, null, 2)}\n`);
             return movedRecord;
           }
-          // 이동은 keys.manage_all 보유자(소유자/관리자)만 가능하다 — 일반 멤버는
-          // 아래 새 키 발급으로 공간 귀속 키를 만든다(과금 오귀속보다 키 재발급이 낫다).
         } else {
           return stored;
         }
@@ -245,15 +681,30 @@ export async function ensureWireKey({
   return record;
 }
 
-export function parseWireArgs(args) {
+export function parseWireArgs(args = []) {
   const revoke = args.includes("--revoke-key");
-  const tools = args.filter((arg) => arg !== "--revoke-key");
-  if (tools.length === 0) return { tools: [...WIRE_TOOLS], revoke };
-  const unknown = tools.find((tool) => !WIRE_TOOLS.includes(tool));
+  const billingOnly = args.includes("--billing-only");
+  let model;
+  const filtered = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--revoke-key" || a === "--billing-only") continue;
+    if (a === "--model" || a === "-m") {
+      model = args[++i];
+      continue;
+    }
+    filtered.push(a);
+  }
+
+  const unknown = filtered.find((tool) => !WIRE_TOOLS.includes(tool));
   if (unknown) {
     throw new Error(t("Unsupported tool: {tool}. Use claude or codex.", { tool: unknown }));
   }
-  return { tools: [...new Set(tools)], revoke };
+
+  const res = { tools: filtered.length === 0 ? [...WIRE_DEFAULT_TOOLS] : [...new Set(filtered)], revoke };
+  if (billingOnly) res.billingOnly = true;
+  if (model) res.model = model;
+  return res;
 }
 
 export function wireHelp() {
@@ -285,47 +736,206 @@ function printDesktopHints(record) {
   console.log(t("kept the desktop key on this machine (logout does not delete it)"));
 }
 
-function applyClaude(paths, key) {
-  backupOnce(paths.claude, paths.claudeBak);
-  const next = wireClaudeSettings(readText(paths.claude), { root: ROOT, key });
-  writeSecretFile(paths.claude, next);
-  console.log(t("Wrote {path}", { path: paths.claude }));
-}
+export function applyToolWiring(tool, paths, { key, model, models = [], billingOnly = false, activeContext } = {}) {
+  const state = readWiredState(paths);
+  const mode = billingOnly ? "billing" : (models.length > 0 ? "list" : (model ? "custom" : "billing"));
 
-function applyCodex(paths, key) {
-  backupOnce(paths.codex, paths.codexBak);
-  const next = wireCodexToml(readText(paths.codex) ?? "", { v1: V1, key });
-  writeSecretFile(paths.codex, next);
-  console.log(t("Wrote {path}", { path: paths.codex }));
-}
+  switch (tool) {
+    case "claude": {
+      backupOnce(paths.claude, paths.claudeBak);
+      const next = wireClaudeSettings(readText(paths.claude), { root: ROOT, key, model: billingOnly ? undefined : model });
+      writeSecretFile(paths.claude, next);
+      console.log(t("Wrote {path}", { path: paths.claude }));
+      break;
+    }
+    case "codex": {
+      backupOnce(paths.codex, paths.codexBak);
+      const next = wireCodexToml(readText(paths.codex) ?? "", { v1: V1, key, model: model || "gpt-6.1-sol", billingOnly });
+      writeSecretFile(paths.codex, next);
+      console.log(t("Wrote {path}", { path: paths.codex }));
+      break;
+    }
+    case "opencode": {
+      backupOnce(paths.opencode, paths.opencodeBak);
+      const nextJson = wireOpenCodeJson(readText(paths.opencode), { v1: V1, models, defaultModel: model });
+      writeSecretFile(paths.opencode, nextJson);
+      const nextAuth = wireOpenCodeAuth(readText(paths.opencodeAuth), key);
+      writeSecretFile(paths.opencodeAuth, nextAuth);
+      console.log(t("Wrote {path}", { path: paths.opencode }));
+      break;
+    }
+    case "aider": {
+      backupOnce(paths.aider, paths.aiderBak);
+      const next = wireAiderYaml(readText(paths.aider), { v1: V1, key, model: billingOnly ? undefined : model });
+      writeSecretFile(paths.aider, next);
+      console.log(t("Wrote {path}", { path: paths.aider }));
+      break;
+    }
+    case "crush": {
+      backupOnce(paths.crush, paths.crushBak);
+      const next = wireCrushConfig(readText(paths.crush), { v1: V1, key, models });
+      writeSecretFile(paths.crush, next);
+      console.log(t("Wrote {path}", { path: paths.crush }));
+      break;
+    }
+    case "pi": {
+      backupOnce(paths.pi, paths.piBak);
+      const next = wirePiConfig(readText(paths.pi), { v1: V1, key, models });
+      writeSecretFile(paths.pi, next);
+      console.log(t("Wrote {path}", { path: paths.pi }));
+      break;
+    }
+    case "agy": {
+      backupOnce(paths.agy, paths.agyBak);
+      const nextAgy = wireAgySettings(readText(paths.agy), { model: billingOnly ? undefined : model });
+      writeSecretFile(paths.agy, nextAgy);
+      const rcContent = readText(paths.shellRc) || "";
+      const nextRc = wireShellWrapper(rcContent, {
+        tool: "agy",
+        bin: "agy",
+        envMap: {
+          GOOGLE_GEMINI_BASE_URL: ROOT,
+          GEMINI_API_KEY: key,
+          GOOGLE_API_KEY: key,
+        },
+      });
+      writeSecretFile(paths.shellRc, nextRc, 0o644);
+      console.log(t("Wrote {path}", { path: paths.agy }));
+      break;
+    }
+    default: {
+      const r = RECIPES[tool];
+      if (r) {
+        const rcContent = readText(paths.shellRc) || "";
+        const envMap = r.env(key, model);
+        const nextRc = wireShellWrapper(rcContent, { tool, bin: r.bin, envMap });
+        writeSecretFile(paths.shellRc, nextRc, 0o644);
+        console.log(t("Wrote {path}", { path: paths.shellRc }));
+      }
+      break;
+    }
+  }
 
-function revertClaude(paths) {
-  if (!existsSync(paths.claude)) return;
-  writeSecretFile(paths.claude, unwireClaudeSettings(readText(paths.claude)));
-  console.log(t("Removed PleumRouter settings from {path}.", { path: paths.claude }));
+  state[tool] = {
+    wiredAt: new Date().toISOString(),
+    mode,
+    model,
+    models,
+    workspace_id: activeContext?.workspace_id,
+    workspace_name: activeContext?.workspace_name,
+  };
+  writeWiredState(paths, state);
 }
 
-function revertCodex(paths) {
-  if (!existsSync(paths.codex)) return;
-  writeSecretFile(paths.codex, unwireCodexToml(readText(paths.codex) ?? ""));
-  console.log(t("Removed PleumRouter settings from {path}.", { path: paths.codex }));
+export function revertToolWiring(tool, paths) {
+  const state = readWiredState(paths);
+
+  switch (tool) {
+    case "claude": {
+      if (existsSync(paths.claude)) {
+        writeSecretFile(paths.claude, unwireClaudeSettings(readText(paths.claude)));
+        console.log(t("Removed PleumRouter settings from {path}.", { path: paths.claude }));
+      }
+      break;
+    }
+    case "codex": {
+      if (existsSync(paths.codex)) {
+        writeSecretFile(paths.codex, unwireCodexToml(readText(paths.codex) ?? ""));
+        console.log(t("Removed PleumRouter settings from {path}.", { path: paths.codex }));
+      }
+      break;
+    }
+    case "opencode": {
+      if (existsSync(paths.opencode)) {
+        writeSecretFile(paths.opencode, unwireOpenCodeJson(readText(paths.opencode)));
+      }
+      if (existsSync(paths.opencodeAuth)) {
+        writeSecretFile(paths.opencodeAuth, unwireOpenCodeAuth(readText(paths.opencodeAuth)));
+      }
+      console.log(t("Removed PleumRouter settings from {path}.", { path: paths.opencode }));
+      break;
+    }
+    case "aider": {
+      if (existsSync(paths.aider)) {
+        writeSecretFile(paths.aider, unwireAiderYaml(readText(paths.aider)));
+        console.log(t("Removed PleumRouter settings from {path}.", { path: paths.aider }));
+      }
+      break;
+    }
+    case "crush": {
+      if (existsSync(paths.crush)) {
+        writeSecretFile(paths.crush, unwireCrushConfig(readText(paths.crush)));
+        console.log(t("Removed PleumRouter settings from {path}.", { path: paths.crush }));
+      }
+      break;
+    }
+    case "pi": {
+      if (existsSync(paths.pi)) {
+        writeSecretFile(paths.pi, unwirePiConfig(readText(paths.pi)));
+        console.log(t("Removed PleumRouter settings from {path}.", { path: paths.pi }));
+      }
+      break;
+    }
+    case "agy": {
+      if (existsSync(paths.agy)) {
+        writeSecretFile(paths.agy, unwireAgySettings(readText(paths.agy)));
+      }
+      if (existsSync(paths.shellRc)) {
+        writeSecretFile(paths.shellRc, unwireShellWrapper(readText(paths.shellRc), "agy"), 0o644);
+      }
+      console.log(t("Removed PleumRouter settings from {path}.", { path: paths.agy }));
+      break;
+    }
+    default: {
+      if (existsSync(paths.shellRc)) {
+        writeSecretFile(paths.shellRc, unwireShellWrapper(readText(paths.shellRc), tool), 0o644);
+        console.log(t("Removed PleumRouter settings from {path}.", { path: paths.shellRc }));
+      }
+      break;
+    }
+  }
+
+  delete state[tool];
+  writeWiredState(paths, state);
 }
 
-export async function wire(args, { auth = authFetch, home = homedir() } = {}) {
-  const { tools } = parseWireArgs(args);
+export async function wire(args = [], {
+  auth = authFetch,
+  home = homedir(),
+  model,
+  models,
+  billingOnly = false,
+  activeContext = getActiveContext(),
+} = {}) {
+  const parsed = parseWireArgs(args);
+  const tools = parsed.tools;
+  const isBilling = billingOnly || parsed.billingOnly;
+  const targetModel = model || parsed.model;
   const paths = wirePaths(home);
-  const record = await ensureWireKey({ auth, paths });
-  if (tools.includes("claude")) applyClaude(paths, record.key);
-  if (tools.includes("codex")) applyCodex(paths, record.key);
-  for (const tool of tools) console.log(t("Wired {tool}.", { tool }));
+  const record = await ensureWireKey({ auth, paths, activeContext });
+
+  for (const tool of tools) {
+    applyToolWiring(tool, paths, {
+      key: record.key,
+      model: targetModel,
+      models,
+      billingOnly: isBilling,
+      activeContext,
+    });
+    console.log(t("Wired {tool}.", { tool }));
+  }
+
   printDesktopHints(record);
 }
 
-export async function unwire(args, { auth = authFetch, home = homedir() } = {}) {
+export async function unwire(args = [], { auth = authFetch, home = homedir() } = {}) {
   const { tools, revoke } = parseWireArgs(args);
   const paths = wirePaths(home);
-  if (tools.includes("claude")) revertClaude(paths);
-  if (tools.includes("codex")) revertCodex(paths);
+
+  for (const tool of tools) {
+    revertToolWiring(tool, paths);
+  }
+
   if (!revoke) return;
 
   const stored = (() => {
@@ -346,9 +956,7 @@ export async function unwire(args, { auth = authFetch, home = homedir() } = {})
   if (existsSync(paths.wire)) {
     try {
       unlinkSync(paths.wire);
-    } catch {
-      // already gone
-    }
+    } catch {}
   }
   console.log(t("Revoked desktop API key {id}.", { id: stored.id }));
 }