pleumrouter 0.5.44 → 0.5.46

package/src/wire.mjs

@@ -1,11 +1,46 @@
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  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";
+import { selectAndBindWorkspace, workspaceLabel } from "./workspace.mjs";
+
+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_TOOLS = ["claude", "codex"];
 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 +52,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 +88,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,
   };
 }
 
@@ -40,17 +112,44 @@ function readText(path) {
   }
 }
 
+// 파싱이 깨진 설정 파일은 덮어쓰지 않고 멈춘다(사용자 설정을 {}로 날리지 않게).
+class InvalidConfigError extends Error {}
+
+function parseJsonObject(text) {
+  if (!text || !text.trim()) return {};
+  let obj;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    throw new InvalidConfigError("invalid JSON");
+  }
+  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+    throw new InvalidConfigError("not a JSON object");
+  }
+  return obj;
+}
+
+// 설정 파일을 읽어 변환한다. 깨졌으면 경로를 붙여 던지고, 호출자는 백업·쓰기 전에 이것을 쓴다.
+function transformConfig(path, transform) {
+  try {
+    return transform(readText(path));
+  } catch (e) {
+    if (e instanceof InvalidConfigError) {
+      throw new Error(t("{path}: not valid JSON — fix or remove it, nothing was written", { path }));
+    }
+    throw e;
+  }
+}
+
 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,12 +196,9 @@ function removeRootValue(toml, name) {
   return root.replace(new RegExp(`^${name}\\s*=\\s*.+\\n?`, "m"), "") + rest;
 }
 
-export function wireClaudeSettings(existingJson, { root, key }) {
-  let obj = {};
-  if (existingJson && existingJson.trim()) {
-    obj = JSON.parse(existingJson);
-    if (obj === null || typeof obj !== "object" || Array.isArray(obj)) obj = {};
-  }
+// ── Claude settings.json ──────────────────────────────────────────
+export function wireClaudeSettings(existingJson, { root, key, model } = {}) {
+  const obj = parseJsonObject(existingJson);
   obj.env = {
     ...(obj.env && typeof obj.env === "object" && !Array.isArray(obj.env) ? obj.env : {}),
     ANTHROPIC_BASE_URL: root,
@@ -111,35 +207,59 @@ 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);
-  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
-    return `${JSON.stringify({}, null, 2)}\n`;
-  }
+  const obj = parseJsonObject(existingJson);
   if (obj.env && typeof obj.env === "object" && !Array.isArray(obj.env)) {
     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");
+
   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");
+
+  // billing-only는 사용자 모델을 유지한다. previousModel은 이미 TOML 값("...")이라 따옴표를 다시 씌우지 않고,
+  // 원래 모델이 없었으면 model 줄을 생략해 Codex 기본값을 쓴다.
+  const modelLine = billingOnly
+    ? (previousModel ? `model = ${previousModel}\n` : "")
+    : `model = ${tomlBasicString(model)}\n`;
   const rootBlock = `${WIRE_MARKER_START}
 # previous_model_provider = ${previousProvider}
 # previous_model = ${previousModel}
-model = ${tomlBasicString(model)}
-model_provider = "pleum"
+${modelLine}model_provider = "pleum"
 ${WIRE_MARKER_END}
 `;
   const providerBlock = `[model_providers.pleum]
@@ -170,17 +290,405 @@ 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 } = {}) {
+  const obj = parseJsonObject(existingJson);
+
+  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) {
+  const obj = parseJsonObject(existingJson);
+
+  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) {
+  const obj = parseJsonObject(existingJson);
+  obj.pleum = { type: "api", key };
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+export function unwireOpenCodeAuth(existingJson) {
+  const obj = parseJsonObject(existingJson);
+  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 = [] } = {}) {
+  const obj = parseJsonObject(existingJson);
+  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) {
+  const obj = parseJsonObject(existingJson);
+  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 = [] } = {}) {
+  const obj = parseJsonObject(existingJson);
+  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) {
+  const obj = parseJsonObject(existingJson);
+  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 } = {}) {
+  const obj = parseJsonObject(existingJson);
+  obj.modelProvider = "gemini";
+  if (model) obj.model = model;
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+export function unwireAgySettings(existingJson) {
+  const obj = parseJsonObject(existingJson);
+  if (obj.modelProvider === "gemini") delete obj.modelProvider;
+  delete obj.model;
+  return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+// ── Shell function wrapper (rc files) ─────────────────────────────
+// POSIX single quotes. `'\''` ends the quote, inserts a literal quote, and reopens it.
+export function posixSingleQuote(value) {
+  return "'" + String(value).replace(/'/g, "'\\''") + "'";
+}
+
+export function formatShellEnv(envMap = {}) {
+  const lines = Object.entries(envMap).map(
+    ([key, value]) => `export ${key}=${posixSingleQuote(value)}`,
+  );
+  return lines.length ? `${lines.join("\n")}\n` : "";
+}
+
+function shellEnvFile(paths, tool) {
+  const safe = String(tool).replace(/[^A-Za-z0-9._-]/g, "_");
+  return join(paths.home, ".pleum", "wire-env", `${safe}.env`);
+}
+
+function shellRcTarget(path) {
+  let st;
+  try {
+    st = lstatSync(path);
+  } catch {
+    return { dest: path, mode: 0o600, present: false };
+  }
+  if (!st.isSymbolicLink()) {
+    return { dest: path, mode: st.mode & 0o777, present: true };
+  }
+  let dest;
+  try {
+    dest = realpathSync(path);
+  } catch {
+    const link = readlinkSync(path);
+    dest = isAbsolute(link) ? link : resolve(dirname(path), link);
+  }
+  let mode = 0o600;
+  try {
+    mode = statSync(dest).mode & 0o777;
+  } catch {
+    // Dangling link: the file we create is new, so it gets the new-file mode.
+  }
+  return { dest, mode, present: true };
+}
+
+function readShellRc(path) {
+  const { dest, present } = shellRcTarget(path);
+  if (!present) return "";
+  return readText(dest) || "";
+}
+
+function writeShellRc(path, contents) {
+  // Rename onto the symlink path would replace the link. Write the target.
+  const { dest, mode } = shellRcTarget(path);
+  writeSecretFile(dest, contents, mode);
+}
+
+function wireShellTool(paths, tool, { bin, envMap }) {
+  const envFile = shellEnvFile(paths, tool);
+  writeSecretFile(envFile, formatShellEnv(envMap));
+  const nextRc = wireShellWrapper(readShellRc(paths.shellRc), { tool, bin, envFile });
+  writeShellRc(paths.shellRc, nextRc);
+}
+
+function unwireShellTool(paths, tool) {
+  if (shellRcTarget(paths.shellRc).present) {
+    writeShellRc(paths.shellRc, unwireShellWrapper(readShellRc(paths.shellRc), tool));
+  }
+  try {
+    unlinkSync(shellEnvFile(paths, tool));
+  } catch {
+    // Already removed.
+  }
+}
+
+export function wireShellWrapper(existingRc = "", { tool, bin, envFile } = {}) {
+  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 source = envFile ? `. ${posixSingleQuote(envFile)}\n    ` : "";
+  const block = `${startMarker}
+${tool}() {
+  (
+    ${source}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(() => ({}));
 }
 
+// 개인 과금은 소유자의 기본 공간이다. 조회가 실패하거나 없으면 null.
+async function findDefaultWorkspaceId(auth) {
+  try {
+    const res = await auth("/workspaces");
+    if (!res.ok) return null;
+    const data = await parseJsonBody(res);
+    const items = Array.isArray(data) ? data : [];
+    return items.find((w) => w.is_default === true && w.role === "owner")?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// 개인 키 레코드에는 workspace_id 필드를 두지 않는다(공유 공간일 때만 남긴다).
+function withWorkspace(record, workspaceId) {
+  const next = { ...record };
+  delete next.workspace_id;
+  if (workspaceId) next.workspace_id = workspaceId;
+  return next;
+}
+
 export async function ensureWireKey({
   auth = authFetch,
   paths = wirePaths(),
   activeContext = getActiveContext(),
 } = {}) {
-  const targetWorkspaceId =
-    activeContext?.type === "workspace" ? activeContext.workspace_id : null;
+  // 과금 귀속은 키의 workspace_id가 정한다. 공유 공간이면 그 공간, 개인이면 소유자의 기본 공간.
+  const shared = activeContext?.type === "workspace" ? activeContext.workspace_id : null;
   const stored = (() => {
     try {
       return JSON.parse(readText(paths.wire) ?? "");
@@ -195,25 +703,23 @@ export async function ensureWireKey({
       const items = Array.isArray(data.items) ? data.items : [];
       const found = items.find((item) => String(item.id) === String(stored.id));
       if (found && found.is_active !== false) {
-        if (
-          targetWorkspaceId &&
-          String(found.workspace_id ?? "") !== String(targetWorkspaceId)
-        ) {
+        const target = shared ?? (await findDefaultWorkspaceId(auth));
+        const current = String(found.workspace_id ?? "");
+        if (target && current !== String(target)) {
           const moved = await auth(`/workspaces/keys/${stored.id}/move`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ target_workspace_id: targetWorkspaceId }),
+            body: JSON.stringify({ target_workspace_id: target }),
           });
           if (moved.ok) {
-            const movedRecord = { ...stored, workspace_id: targetWorkspaceId };
+            const movedRecord = withWorkspace(stored, shared);
             writeSecretFile(paths.wire, `${JSON.stringify(movedRecord, null, 2)}\n`);
             return movedRecord;
           }
-          // 이동은 keys.manage_all 보유자(소유자/관리자)만 가능하다 — 일반 멤버는
-          // 아래 새 키 발급으로 공간 귀속 키를 만든다(과금 오귀속보다 키 재발급이 낫다).
-        } else {
+        } else if (target || !current) {
           return stored;
         }
+        // 그 밖(개인인데 기본 공간을 못 찾았고 키가 공유 공간에 묶인 경우)은 아래에서 새로 발급한다.
       }
     } else if (listed.status !== 404) {
       return stored;
@@ -223,9 +729,10 @@ export async function ensureWireKey({
   const created = await auth("/keys", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
+    // workspace_id를 생략하면 서버가 소유자의 기본 공간에 키를 만든다.
     body: JSON.stringify({
       name: WIRE_KEY_NAME,
-      ...(targetWorkspaceId ? { workspace_id: targetWorkspaceId } : {}),
+      ...(shared ? { workspace_id: shared } : {}),
     }),
   });
   if (!created.ok) {
@@ -239,21 +746,36 @@ export async function ensureWireKey({
     id: data.id,
     key: data.key,
     name: data.name ?? WIRE_KEY_NAME,
-    ...(targetWorkspaceId ? { workspace_id: targetWorkspaceId } : {}),
+    ...(shared ? { workspace_id: shared } : {}),
   };
   writeSecretFile(paths.wire, `${JSON.stringify(record, null, 2)}\n`);
   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 +807,223 @@ 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": {
+      // 파싱이 끝나야 백업·쓰기로 간다 — 깨진 파일이면 .pleum.bak도 남기지 않는다.
+      const next = transformConfig(paths.claude, (text) => wireClaudeSettings(text, { root: ROOT, key, model: billingOnly ? undefined : model }));
+      backupOnce(paths.claude, paths.claudeBak);
+      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": {
+      const nextJson = transformConfig(paths.opencode, (text) => wireOpenCodeJson(text, { v1: V1, models, defaultModel: model }));
+      const nextAuth = transformConfig(paths.opencodeAuth, (text) => wireOpenCodeAuth(text, key));
+      backupOnce(paths.opencode, paths.opencodeBak);
+      writeSecretFile(paths.opencode, nextJson);
+      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": {
+      const next = transformConfig(paths.crush, (text) => wireCrushConfig(text, { v1: V1, key, models }));
+      backupOnce(paths.crush, paths.crushBak);
+      writeSecretFile(paths.crush, next);
+      console.log(t("Wrote {path}", { path: paths.crush }));
+      break;
+    }
+    case "pi": {
+      const next = transformConfig(paths.pi, (text) => wirePiConfig(text, { v1: V1, key, models }));
+      backupOnce(paths.pi, paths.piBak);
+      writeSecretFile(paths.pi, next);
+      console.log(t("Wrote {path}", { path: paths.pi }));
+      break;
+    }
+    case "agy": {
+      const nextAgy = transformConfig(paths.agy, (text) => wireAgySettings(text, { model: billingOnly ? undefined : model }));
+      backupOnce(paths.agy, paths.agyBak);
+      writeSecretFile(paths.agy, nextAgy);
+      wireShellTool(paths, "agy", {
+        bin: "agy",
+        envMap: {
+          GOOGLE_GEMINI_BASE_URL: ROOT,
+          GEMINI_API_KEY: key,
+          GOOGLE_API_KEY: key,
+        },
+      });
+      console.log(t("Wrote {path}", { path: paths.agy }));
+      break;
+    }
+    default: {
+      const r = RECIPES[tool];
+      if (r) {
+        wireShellTool(paths, tool, { bin: r.bin, envMap: r.env(key, model) });
+        console.log(t("Wrote {path}", { path: paths.shellRc }));
+      }
+      break;
+    }
+  }
+
+  state[tool] = {
+    wiredAt: new Date().toISOString(),
+    mode,
+    model,
+    models,
+    workspace_id: activeContext?.workspace_id,
+    workspace_name: activeContext?.workspace_name,
+  };
+  writeWiredState(paths, state);
 }
 
-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 }));
+export function revertToolWiring(tool, paths) {
+  const state = readWiredState(paths);
+
+  switch (tool) {
+    case "claude": {
+      if (existsSync(paths.claude)) {
+        writeSecretFile(paths.claude, transformConfig(paths.claude, unwireClaudeSettings));
+        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": {
+      // 두 파일 모두 파싱이 끝난 뒤에 쓴다(하나만 깨졌을 때 반쪽만 바뀌지 않게).
+      const nextJson = existsSync(paths.opencode) ? transformConfig(paths.opencode, unwireOpenCodeJson) : null;
+      const nextAuth = existsSync(paths.opencodeAuth) ? transformConfig(paths.opencodeAuth, unwireOpenCodeAuth) : null;
+      if (nextJson !== null) writeSecretFile(paths.opencode, nextJson);
+      if (nextAuth !== null) writeSecretFile(paths.opencodeAuth, nextAuth);
+      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, transformConfig(paths.crush, unwireCrushConfig));
+        console.log(t("Removed PleumRouter settings from {path}.", { path: paths.crush }));
+      }
+      break;
+    }
+    case "pi": {
+      if (existsSync(paths.pi)) {
+        writeSecretFile(paths.pi, transformConfig(paths.pi, unwirePiConfig));
+        console.log(t("Removed PleumRouter settings from {path}.", { path: paths.pi }));
+      }
+      break;
+    }
+    case "agy": {
+      if (existsSync(paths.agy)) {
+        writeSecretFile(paths.agy, transformConfig(paths.agy, unwireAgySettings));
+      }
+      unwireShellTool(paths, "agy");
+      console.log(t("Removed PleumRouter settings from {path}.", { path: paths.agy }));
+      break;
+    }
+    default: {
+      const hadRc = shellRcTarget(paths.shellRc).present;
+      unwireShellTool(paths, tool);
+      if (hadRc) {
+        console.log(t("Removed PleumRouter settings from {path}.", { path: paths.shellRc }));
+      }
+      break;
+    }
+  }
+
+  delete state[tool];
+  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 }));
+// 과금 공간은 wire 때 고른다. 대화형 터미널이면 묻고, 파이프·CI에서는 저장된 값을 쓴다.
+async function pickBillingContext(auth) {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && typeof process.stdin.setRawMode === "function");
+  return interactive ? selectAndBindWorkspace({ auth }) : getActiveContext();
 }
 
-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,
+} = {}) {
+  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 billing = activeContext ?? (await pickBillingContext(auth));
+  const record = await ensureWireKey({ auth, paths, activeContext: billing });
+
+  // 한 도구가 깨져도 나머지는 배선한다. 실패 목록은 마지막에 한 번에 던져 exit 1이 되게 한다.
+  const failures = [];
+  for (const tool of tools) {
+    try {
+      applyToolWiring(tool, paths, {
+        key: record.key,
+        model: targetModel,
+        models,
+        billingOnly: isBilling,
+        activeContext: billing,
+      });
+      console.log(t("Wired {tool}.", { tool }));
+    } catch (e) {
+      failures.push(e.message);
+    }
+  }
+
+  console.log(`ℹ ${t("Credit workspace")}: ${workspaceLabel(billing)}`);
+  console.log(t("The wire key is shared by all wired tools and launch, so a billing workspace change applies to all of them."));
   printDesktopHints(record);
+  if (failures.length) throw new Error(failures.join("\n"));
 }
 
-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);
+
+  const failures = [];
+  for (const tool of tools) {
+    try {
+      revertToolWiring(tool, paths);
+    } catch (e) {
+      failures.push(e.message);
+    }
+  }
+  // 실패가 있으면 키는 폐기하지 않는다(고친 뒤 다시 unwire할 수 있게).
+  if (failures.length) throw new Error(failures.join("\n"));
+
   if (!revoke) return;
 
   const stored = (() => {
@@ -346,9 +1044,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 }));
 }