zyrouter 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,29 @@
-# Temporary Holding Version
+# zyrouter
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Connect your coding tools to [ZyRouter](https://zyrouter.com) with one command:
+
+```bash
+npx -y zyrouter@latest --key sk-zyr-YOUR_KEY
+```
+
+The installer checks the key, detects which tools are installed, backs up their current config
+to `~/.zyrouter/backups/`, writes the ZyRouter settings, and sends one small test request.
+
+| Tool | File it writes |
+| --- | --- |
+| Codex (CLI & VS Code) | `~/.codex/config.toml` and the `ZYROUTER_API_KEY` user environment variable |
+| Claude Code | `~/.claude/settings.json` |
+| OpenCode | `~/.config/opencode/opencode.json` and `ZYROUTER_API_KEY` |
+| OpenClaw | `~/.openclaw/openclaw.json` |
+| Hermes Agent | `~/.hermes/config.yaml` (the `model:` block) and `OPENAI_API_KEY` in `~/.hermes/.env` |
+
+Cline and Continue are detected but stay manual; the installer prints the values to use.
+
+Undo everything:
+
+```bash
+npx -y zyrouter@latest uninstall
+```
+
+Options: `--model <id>`, `--tools codex,claude-code,opencode,openclaw,hermes`, `--yes`, `--no-test`, `--dry-run`.
+No dependencies; needs Node.js 18.17 or newer.

package/bin/cli.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { run } from "../lib/main.mjs";
+
+const major = Number(process.versions.node.split(".")[0]);
+if (major < 18) {
+  console.error(`ZyRouter installer butuh Node.js 18 atau lebih baru (sekarang ${process.versions.node}).`);
+  process.exit(1);
+}
+
+// Set exitCode instead of calling process.exit(): on Windows an exit while fetch sockets are still
+// closing can abort Node with a libuv assertion.
+run(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    console.error(`✖ ${error?.message || error}`);
+    process.exitCode = 1;
+  },
+);

package/lib/configs.mjs

@@ -0,0 +1,147 @@
+// Pure config mergers: each takes the current file content (or parsed JSON) and returns the new one.
+// They only touch ZyRouter's own entries, so the customer's other providers and settings survive.
+
+export const PROVIDER_ID = "zyrouter";
+export const ENV_KEY = "ZYROUTER_API_KEY";
+
+const SAFE_VALUE = /^[A-Za-z0-9._:/\-[\]]+$/;
+
+export function assertSafeValue(label, value) {
+  if (typeof value !== "string" || !SAFE_VALUE.test(value)) throw new Error(`Invalid ${label}: ${value}`);
+  return value;
+}
+
+/**
+ * Codex ~/.codex/config.toml: sets the top-level model/model_provider, keeps an existing
+ * model_reasoning_effort, and replaces any previous [model_providers.zyrouter] table.
+ */
+export function mergeCodexToml(existing, { baseUrl, model }) {
+  assertSafeValue("base URL", baseUrl);
+  assertSafeValue("model", model);
+  const lines = String(existing || "").replace(/\r\n/g, "\n").split("\n");
+  const kept = [];
+  let section = null;
+  let skipping = false;
+  let hasEffort = false;
+  for (const line of lines) {
+    const header = /^\s*\[\[?\s*([^\]]+?)\s*\]\]?\s*(#.*)?$/.exec(line);
+    if (header) {
+      section = header[1].replace(/"/g, "").trim();
+      skipping = section === `model_providers.${PROVIDER_ID}`;
+      if (!skipping) kept.push(line);
+      continue;
+    }
+    if (skipping) continue;
+    if (section === null) {
+      if (/^\s*(model|model_provider)\s*=/.test(line)) continue;
+      if (/^\s*model_reasoning_effort\s*=/.test(line)) hasEffort = true;
+    }
+    kept.push(line);
+  }
+  while (kept.length && kept[0].trim() === "") kept.shift();
+  while (kept.length && kept[kept.length - 1].trim() === "") kept.pop();
+  const head = [`model = "${model}"`, `model_provider = "${PROVIDER_ID}"`];
+  if (!hasEffort) head.push('model_reasoning_effort = "high"');
+  const provider = [
+    `[model_providers.${PROVIDER_ID}]`,
+    'name = "ZyRouter"',
+    `base_url = "${baseUrl}"`,
+    `env_key = "${ENV_KEY}"`,
+    'wire_api = "responses"',
+  ];
+  // Top-level keys must come before the first table, so ours go first and the provider table last.
+  return [...head, ...(kept.length ? ["", ...kept] : []), "", ...provider, ""].join("\n");
+}
+
+/** Claude Code ~/.claude/settings.json: points the Anthropic client at ZyRouter. */
+export function mergeClaudeSettings(data, { anthropicBaseUrl, key, model }) {
+  const next = { ...(data || {}) };
+  next.env = { ...(next.env || {}), ANTHROPIC_BASE_URL: anthropicBaseUrl, ANTHROPIC_AUTH_TOKEN: key, ANTHROPIC_MODEL: model };
+  return next;
+}
+
+/** OpenCode ~/.config/opencode/opencode.json: an OpenAI-compatible provider reading the key from the environment. */
+export function mergeOpenCode(data, { baseUrl, models, model }) {
+  const next = { ...(data || {}) };
+  next.$schema ||= "https://opencode.ai/config.json";
+  next.provider = {
+    ...(next.provider || {}),
+    [PROVIDER_ID]: {
+      npm: "@ai-sdk/openai-compatible",
+      name: "ZyRouter",
+      options: { baseURL: baseUrl, apiKey: `{env:${ENV_KEY}}` },
+      models: Object.fromEntries(models.map((id) => [id, { name: id }])),
+    },
+  };
+  next.model = `${PROVIDER_ID}/${model}`;
+  return next;
+}
+
+/** OpenClaw ~/.openclaw/openclaw.json: same shape as the dashboard guide. */
+export function mergeOpenClaw(data, { baseUrl, key, models, model }) {
+  const next = { ...(data || {}) };
+  next.models = { ...(next.models || {}) };
+  next.models.providers = {
+    ...(next.models.providers || {}),
+    [PROVIDER_ID]: { baseUrl, apiKey: key, api: "openai-completions", models: models.map((id) => ({ id, name: id })) },
+  };
+  next.agents = { ...(next.agents || {}) };
+  next.agents.defaults = { ...(next.agents.defaults || {}) };
+  next.agents.defaults.model = { ...(next.agents.defaults.model || {}), primary: `${PROVIDER_ID}/${model}` };
+  return next;
+}
+
+const RC_START = "# >>> zyrouter >>>";
+const RC_END = "# <<< zyrouter <<<";
+
+/** Shell rc file: one marked block exporting the key, replaced on every run. */
+export function setRcBlock(existing, key) {
+  assertSafeValue("API key", key);
+  const without = removeRcBlock(existing);
+  const block = `${RC_START}\nexport ${ENV_KEY}="${key}"\n${RC_END}\n`;
+  return `${without ? `${without.replace(/\n*$/, "\n")}\n` : ""}${block}`;
+}
+
+export function removeRcBlock(existing) {
+  const text = String(existing || "");
+  const pattern = new RegExp(`\\n?${RC_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${RC_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "g");
+  return text.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
+}
+
+export function maskKey(key) {
+  const value = String(key || "");
+  return value.length > 12 ? `${value.slice(0, 10)}…${value.slice(-4)}` : "sk-zyr-…";
+}
+
+/**
+ * Hermes Agent ~/.hermes/config.yaml: replaces only the top-level `model:` block (the shape the dashboard
+ * guide uses) and leaves every other key untouched.
+ */
+export function mergeHermesConfig(existing, { baseUrl, model }) {
+  assertSafeValue("base URL", baseUrl);
+  assertSafeValue("model", model);
+  const block = ["model:", `  default: "${model}"`, '  provider: "custom"', `  base_url: "${baseUrl}"`];
+  const lines = String(existing || "").replace(/\r\n/g, "\n").split("\n");
+  const start = lines.findIndex((line) => /^model\s*:/.test(line));
+  if (start === -1) {
+    const rest = lines.join("\n").replace(/^\n+/, "").replace(/\n*$/, "");
+    return `${block.join("\n")}\n${rest ? `\n${rest}\n` : ""}`;
+  }
+  let end = start + 1;
+  // The block runs while lines are indented, blank, or comments that belong to it.
+  while (end < lines.length && (lines[end].trim() === "" || /^[ \t]/.test(lines[end]))) end += 1;
+  while (end > start + 1 && lines[end - 1].trim() === "") end -= 1;
+  const merged = [...lines.slice(0, start), ...block, ...lines.slice(end)].join("\n").replace(/\n*$/, "\n");
+  return merged;
+}
+
+/** Hermes Agent ~/.hermes/.env: sets OPENAI_API_KEY, keeping the other variables. */
+export function setDotenvValue(existing, name, value) {
+  assertSafeValue(name, value);
+  const lines = String(existing || "").replace(/\r\n/g, "\n").split("\n").filter((line, index, all) => !(index === all.length - 1 && line === ""));
+  const pattern = new RegExp(`^\s*(export\s+)?${name}\s*=`);
+  const index = lines.findIndex((line) => pattern.test(line));
+  if (index === -1) lines.push(`${name}=${value}`);
+  else lines[index] = `${name}=${value}`;
+  return `${lines.join("\n")}\n`;
+}

package/lib/main.mjs

@@ -0,0 +1,414 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { ENV_KEY, maskKey, mergeClaudeSettings, mergeCodexToml, mergeHermesConfig, mergeOpenClaw, mergeOpenCode, setDotenvValue } from "./configs.mjs";
+import { box, createStyle, groupModels, pickFromMenu, readSecret, withSpinner } from "./ui.mjs";
+import { createBackup, defaultRun, exists, hasEditorExtension, onPath, persistApiKey, readJson, readText, removePersistedApiKey, restoreBackups, restoreWindowsUserEnv, writeText } from "./system.mjs";
+
+export const DEFAULT_BASE_URL = "https://zyrouter.com/v1";
+const FALLBACK_MODELS = ["gpt-6-astra", "gpt-6.1-sol", "gpt-6.1-terra", "gpt-6-sol", "gpt-6-luna"];
+const KEY_PATTERN = /^sk-zyr-[A-Za-z0-9_-]{20,}$/;
+const VERSION = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8")).version;
+  } catch {
+    return "";
+  }
+})();
+
+const HELP = `ZyRouter installer — hubungkan Codex, Claude Code, OpenCode, OpenClaw, dan Hermes Agent ke ZyRouter.
+
+Pakai:
+  npx -y zyrouter@latest --key sk-zyr-...      pasang (deteksi aplikasi otomatis)
+  npx -y zyrouter@latest uninstall             kembalikan semua konfigurasi seperti semula
+
+Opsi:
+  --key <key>        API key ZyRouter (atau env ZYROUTER_API_KEY, atau ditanya)
+  --model <id>       model default, mis. gpt-6.1-terra
+  --tools <list>     codex,claude-code,opencode,openclaw,hermes (default: yang terdeteksi)
+  --yes              tanpa pertanyaan: pakai aplikasi yang terdeteksi dan model pertama
+  --no-test          lewati request tes di akhir
+  --no-env           jangan simpan ZYROUTER_API_KEY ke environment (untuk tes)
+  --dry-run          tampilkan rencana tanpa mengubah file
+  --base-url <url>   endpoint lain (default ${DEFAULT_BASE_URL})
+`;
+
+/** Tools whose config files the installer writes; manual ones only get printed instructions. */
+function toolCatalog(ctx) {
+  const home = ctx.home;
+  return [
+    {
+      id: "codex",
+      name: "Codex (CLI & VS Code)",
+      protocol: "responses",
+      file: path.join(home, ".codex", "config.toml"),
+      detected: () => onPath("codex", ctx) || exists(path.join(home, ".codex")) || hasEditorExtension("openai.chatgpt", ctx),
+      apply(opts, backup) {
+        backup.record(this.file);
+        writeText(this.file, mergeCodexToml(readText(this.file), opts));
+        return { ok: true };
+      },
+      needsEnv: true,
+    },
+    {
+      id: "claude-code",
+      name: "Claude Code",
+      protocol: "messages",
+      // ~/.claude exists for every Claude Code user; redirecting it must be a deliberate choice, never a default.
+      optIn: true,
+      file: path.join(home, ".claude", "settings.json"),
+      detected: () => onPath("claude", ctx) || exists(path.join(home, ".claude")),
+      apply(opts, backup) {
+        return writeJsonConfig(this.file, (data) => mergeClaudeSettings(data, opts), backup);
+      },
+    },
+    {
+      id: "opencode",
+      name: "OpenCode",
+      protocol: "chat",
+      file: path.join(home, ".config", "opencode", "opencode.json"),
+      detected: () => onPath("opencode", ctx) || exists(path.join(home, ".config", "opencode")),
+      apply(opts, backup) {
+        if (exists(path.join(path.dirname(this.file), "opencode.jsonc"))) return { ok: false, reason: "opencode.jsonc dipakai; tambahkan provider secara manual" };
+        return writeJsonConfig(this.file, (data) => mergeOpenCode(data, opts), backup);
+      },
+      needsEnv: true,
+    },
+    {
+      id: "openclaw",
+      name: "OpenClaw",
+      protocol: "chat",
+      file: path.join(home, ".openclaw", "openclaw.json"),
+      detected: () => onPath("openclaw", ctx) || exists(path.join(home, ".openclaw")),
+      apply(opts, backup) {
+        return writeJsonConfig(this.file, (data) => mergeOpenClaw(data, opts), backup);
+      },
+    },
+    {
+      id: "hermes",
+      name: "Hermes Agent",
+      protocol: "chat",
+      file: path.join(home, ".hermes", "config.yaml"),
+      envFile: path.join(home, ".hermes", ".env"),
+      detected: () => onPath("hermes", ctx) || exists(path.join(home, ".hermes")),
+      apply(opts, backup) {
+        backup.record(this.file);
+        backup.record(this.envFile);
+        writeText(this.file, mergeHermesConfig(readText(this.file), opts));
+        writeText(this.envFile, setDotenvValue(readText(this.envFile), "OPENAI_API_KEY", opts.key));
+        return { ok: true };
+      },
+    },
+  ];
+}
+
+const MANUAL_TOOLS = [
+  { id: "cline", name: "Cline", detected: (ctx) => hasEditorExtension("saoudrizwan.claude-dev", ctx), hint: "Settings Cline > API Provider: OpenAI Compatible" },
+  { id: "continue", name: "Continue", detected: (ctx) => hasEditorExtension("continue.continue", ctx) || exists(path.join(ctx.home, ".continue")), hint: "~/.continue/config.yaml, provider openai" },
+];
+
+function writeJsonConfig(file, merge, backup) {
+  const current = readJson(file);
+  if (!current.ok) return { ok: false, reason: `${path.basename(file)} tidak bisa dibaca sebagai JSON (mungkin ada komentar); ubah manual` };
+  backup.record(file);
+  writeText(file, `${JSON.stringify(merge(current.data), null, 2)}\n`);
+  return { ok: true };
+}
+
+async function fetchModels(ctx, baseUrl, key) {
+  try {
+    const response = await ctx.fetch(`${baseUrl}/models`, { headers: { Authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(15_000) });
+    if (response.status === 401 || response.status === 403) return { ok: false, invalidKey: true };
+    if (!response.ok) return { ok: false, status: response.status };
+    const body = await response.json();
+    const models = (Array.isArray(body?.data) ? body.data : []).map((item) => item?.id).filter((id) => typeof id === "string" && id);
+    return models.length ? { ok: true, models } : { ok: false, status: response.status };
+  } catch (error) {
+    return { ok: false, error: error?.name || "Error" };
+  }
+}
+
+const PROTOCOL_TESTS = {
+  chat: {
+    label: "OpenAI Chat Completions",
+    url: (o) => `${o.baseUrl}/chat/completions`,
+    body: (model) => ({ model, messages: [{ role: "user", content: "Reply with exactly: ZyRouter OK" }], max_tokens: 16, stream: false }),
+    text: (b) => b?.choices?.[0]?.message?.content,
+  },
+  responses: {
+    label: "OpenAI Responses (Codex)",
+    url: (o) => `${o.baseUrl}/responses`,
+    body: (model) => ({ model, input: "Reply with exactly: ZyRouter OK", max_output_tokens: 16, stream: false }),
+    text: (b) => b?.output_text || (b?.output || []).flatMap((item) => item?.content || []).map((part) => part?.text).filter(Boolean).join(""),
+  },
+  messages: {
+    label: "Anthropic Messages (Claude Code)",
+    url: (o) => `${o.anthropicBaseUrl}/v1/messages`,
+    headers: { "anthropic-version": "2023-06-01" },
+    body: (model) => ({ model, max_tokens: 16, messages: [{ role: "user", content: "Reply with exactly: ZyRouter OK" }] }),
+    text: (b) => (b?.content || []).map((part) => part?.text).filter(Boolean).join(""),
+  },
+};
+
+async function testProtocol(ctx, protocol, opts) {
+  const spec = PROTOCOL_TESTS[protocol];
+  try {
+    const response = await ctx.fetch(spec.url(opts), {
+      method: "POST",
+      headers: { Authorization: `Bearer ${opts.key}`, "Content-Type": "application/json", ...(spec.headers || {}) },
+      body: JSON.stringify(spec.body(opts.model)),
+      signal: AbortSignal.timeout(90_000),
+    });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok) return { ok: false, label: spec.label, status: response.status, message: body?.error?.message || body?.message };
+    return { ok: true, label: spec.label, text: String(spec.text(body) || "").trim() };
+  } catch (error) {
+    return { ok: false, label: spec.label, error: error?.name || "Error" };
+  }
+}
+
+function parseList(value) {
+  return String(value || "").split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+}
+
+export async function run(argv, overrides = {}) {
+  const stdinTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const ctx = {
+    env: process.env,
+    platform: process.platform,
+    home: process.env.ZYROUTER_INSTALLER_HOME || os.homedir(),
+    fetch: globalThis.fetch,
+    run: defaultRun,
+    out: (line = "") => process.stdout.write(`${line}\n`),
+    ask: null,
+    interactive: stdinTty,
+    ...overrides,
+  };
+  // Arrow-key menus, spinner and colors only on a real terminal; tests and pipes get plain text.
+  ctx.tty = overrides.tty ?? (!overrides.out && !ctx.ask && ctx.interactive && stdinTty);
+  ctx.style = createStyle(overrides.color ?? (ctx.tty && !ctx.env.NO_COLOR));
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      key: { type: "string" },
+      model: { type: "string" },
+      tools: { type: "string" },
+      "base-url": { type: "string" },
+      yes: { type: "boolean", short: "y" },
+      "no-test": { type: "boolean" },
+      "no-env": { type: "boolean" },
+      "dry-run": { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+    },
+  });
+  const out = ctx.out;
+  const s = ctx.style;
+  const ok = (text) => out(`${s.green("✔")} ${text}`);
+  const warn = (text) => out(`${s.yellow("!")} ${text}`);
+  const fail = (text) => out(`${s.red("✖")} ${text}`);
+  const step = (index, total, text) => out(`\n${s.orange(s.bold(`${index}/${total}`))} ${s.bold(text)}`);
+  if (values.help) {
+    out(HELP);
+    return 0;
+  }
+  ctx.dryRun = values["dry-run"] === true;
+
+  // One readline interface per question, closed right away, so raw-mode menus own stdin afterwards.
+  const ask = ctx.ask || (async (question) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      return await rl.question(question);
+    } finally {
+      rl.close();
+    }
+  });
+  const canAsk = !values.yes && Boolean(ctx.ask || ctx.interactive);
+
+  if (positionals[0] === "uninstall") {
+    const result = restoreBackups(ctx);
+    // Windows: put back the value from before the first install. Elsewhere the rc files were restored already.
+    if (ctx.platform === "win32") {
+      if (result.windowsEnv) restoreWindowsUserEnv(ctx, result.windowsEnvPrevious);
+    } else {
+      removePersistedApiKey(ctx);
+    }
+    if (result.sessions) ok(`${result.files} file dikembalikan dari ${result.sessions} backup.`);
+    else out("Tidak ada backup ZyRouter untuk dikembalikan.");
+    out("Tutup lalu buka lagi terminal dan editor supaya perubahan terbaca.");
+    return 0;
+  }
+
+  if (ctx.tty) {
+    out("");
+    box(s, [`${s.orange(s.bold("ZyRouter"))} ${s.bold("installer")} ${s.gray(VERSION ? `v${VERSION}` : "")}`, s.gray("Hubungkan coding agent kamu ke ZyRouter")]).forEach((line) => out(line));
+  }
+
+  const baseUrl = String(values["base-url"] || ctx.env.ZYROUTER_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  if (!/^https:\/\//.test(baseUrl) && !/^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?\//.test(`${baseUrl}/`)) throw new Error("Base URL harus https:// (atau http://localhost untuk tes).");
+  const anthropicBaseUrl = baseUrl.replace(/\/v1$/i, "");
+  const totalSteps = values["no-test"] ? 4 : 5;
+
+  // 1. API key. An existing ZYROUTER_API_KEY is only reused when it is a ZyRouter key; other tools use the name too.
+  if (ctx.tty) step(1, totalSteps, "API key");
+  const envKey = ctx.env[ENV_KEY] || "";
+  let key = values.key || (KEY_PATTERN.test(envKey) ? envKey : "");
+  if (!values.key && envKey && !key) warn(`${ENV_KEY} di environment bukan key ZyRouter; diabaikan.`);
+  // Ask for a missing key even when stdin is not reported as a TTY (editor and app terminals often are not);
+  // only --yes means "never prompt".
+  if (!key && !values.yes) key = ctx.tty ? await readSecret(ctx, "Tempel API key ZyRouter (sk-zyr-...)") : (await ask("Tempel API key ZyRouter (sk-zyr-...): ")).trim();
+  if (!key) throw new Error("API key belum diisi. Salin perintah lengkap dari dashboard ZyRouter, atau pakai --key sk-zyr-...");
+  if (!KEY_PATTERN.test(key)) throw new Error("API key tidak valid. Salin perintah lengkap dari dashboard ZyRouter, atau pakai --key sk-zyr-...");
+
+  if (!ctx.tty) out(`ZyRouter installer · key ${maskKey(key)}`);
+  const listed = await withSpinner(ctx, "Memeriksa API key...", () => fetchModels(ctx, baseUrl, key));
+  if (listed.invalidKey) throw new Error("API key ditolak (401). Cek key di dashboard ZyRouter tab API.");
+  const models = listed.ok ? listed.models : FALLBACK_MODELS;
+  if (listed.ok) ok(`API key valid · ${models.length} model tersedia${ctx.tty ? ` ${s.gray(maskKey(key))}` : ""}`);
+  else warn("Daftar model belum bisa diambil; memakai daftar bawaan.");
+
+  // 2. Tools.
+  if (ctx.tty) step(2, totalSteps, "Aplikasi");
+  const tools = toolCatalog(ctx);
+  const detected = tools.filter((tool) => tool.detected());
+  const preselected = detected.filter((tool) => !tool.optIn);
+  const toolNote = (tool) => (!detected.includes(tool) ? "tidak terdeteksi" : tool.optIn ? "terdeteksi · pilih kalau mau dialihkan ke ZyRouter" : "terdeteksi");
+  let selected;
+  if (values.tools) {
+    const wanted = parseList(values.tools);
+    selected = tools.filter((tool) => wanted.includes(tool.id));
+    const unknown = wanted.filter((id) => !tools.some((tool) => tool.id === id));
+    if (unknown.length) throw new Error(`Aplikasi tidak dikenal: ${unknown.join(", ")}. Pilihan: ${tools.map((tool) => tool.id).join(", ")}`);
+  } else if (canAsk && ctx.tty) {
+    const ids = await pickFromMenu(ctx, {
+      title: "Pilih aplikasi yang mau diatur",
+      hint: "↑↓ pindah · spasi centang · a semua · enter lanjut",
+      multi: true,
+      rows: tools.map((tool) => ({ label: tool.name, value: tool.id, note: toolNote(tool), checked: preselected.includes(tool) })),
+    });
+    selected = tools.filter((tool) => ids.includes(tool.id));
+  } else if (canAsk) {
+    out("\nAplikasi yang bisa diatur otomatis:");
+    tools.forEach((tool, index) => {
+      const note = !detected.includes(tool) ? " (tidak terdeteksi)" : tool.optIn ? " (terdeteksi; pilih nomornya kalau mau dialihkan ke ZyRouter)" : "";
+      out(`  ${index + 1}. [${preselected.includes(tool) ? "x" : " "}] ${tool.name}${note}`);
+    });
+    const answer = (await ask(`Pilih nomor, pisahkan koma (Enter = ${preselected.length ? "yang dicentang" : "lewati"}): `)).trim();
+    selected = answer ? answer.split(",").map((n) => tools[Number(n.trim()) - 1]).filter(Boolean) : preselected;
+  } else {
+    selected = preselected;
+  }
+  if (!selected.length) {
+    out("Tidak ada aplikasi yang dipilih. Pasang dulu Codex/OpenCode/OpenClaw/Hermes, atau pilih langsung dengan --tools codex,claude-code.");
+    return 1;
+  }
+  if (ctx.tty) ok(`Aplikasi: ${selected.map((tool) => s.bold(tool.name)).join(", ")}`);
+
+  // 3. Default model, grouped by family.
+  if (ctx.tty) step(3, totalSteps, "Model default");
+  const families = groupModels(models);
+  const ordered = families.flatMap((group) => group.models);
+  let model = values.model || "";
+  if (!model && canAsk && ctx.tty) {
+    const numbered = new Map(ordered.map((id, index) => [id, index + 1]));
+    model = await pickFromMenu(ctx, {
+      title: "Pilih model default",
+      hint: "↑↓ pindah · enter pilih",
+      initialValue: models[0],
+      rows: families.flatMap((group) => [{ header: `${group.family} Family` }, ...group.models.map((id) => ({ label: `[${numbered.get(id)}] ${id}`, value: id }))]),
+    });
+  } else if (!model && canAsk) {
+    out("\nModel default:");
+    let index = 0;
+    for (const group of families) {
+      out(`${group.family} Family`);
+      group.models.forEach((id) => out(`  [${++index}] ${id}`));
+    }
+    const answer = (await ask(`Pilih nomor (Enter = ${models[0]}): `)).trim();
+    model = (answer && ordered[Number(answer) - 1]) || models[0];
+  }
+  model ||= models[0];
+  if (listed.ok && !models.includes(model)) throw new Error(`Model ${model} tidak tersedia untuk key ini.`);
+  if (ctx.tty) ok(`Model: ${s.bold(model)}`);
+
+  if (ctx.dryRun) {
+    out("\nRencana (dry run, tidak ada file yang diubah):");
+    selected.forEach((tool) => out(`  • ${tool.name} → ${tool.file}`));
+    if (selected.some((tool) => tool.needsEnv)) out(`  • ${ENV_KEY} disimpan untuk terminal baru`);
+    return 0;
+  }
+
+  // 4. Write configs.
+  if (ctx.tty) step(4, totalSteps, "Menulis konfigurasi");
+  const backup = createBackup(ctx);
+  const opts = { baseUrl, anthropicBaseUrl, key, model, models };
+  if (!ctx.tty) out("");
+  let failures = 0;
+  for (const tool of selected) {
+    const result = tool.apply(opts, backup);
+    if (result.ok) ok(`${tool.name} → ${s.gray(tool.file)}`);
+    else {
+      failures += 1;
+      fail(`${tool.name}: ${result.reason}`);
+    }
+  }
+  if (selected.some((tool) => tool.needsEnv) && values["no-env"]) {
+    warn(`${ENV_KEY} tidak disimpan (--no-env). Set sendiri sebelum menjalankan Codex/OpenCode.`);
+  } else if (selected.some((tool) => tool.needsEnv)) {
+    const env = persistApiKey(key, ctx, backup);
+    if (env.ok) ok(`${ENV_KEY} disimpan (${env.where})${env.replaced ? "; nilai lamanya disimpan di backup dan dikembalikan saat uninstall" : ""}`);
+    else {
+      fail(`Gagal menyimpan ${ENV_KEY}; set manual lalu buka terminal baru.`);
+      failures += 1;
+    }
+  }
+
+  // ZyRouter rejects a request whose x-api-key and Bearer token differ, which happens when Claude Code
+  // also picks up an Anthropic key from the environment.
+  if (selected.some((tool) => tool.id === "claude-code") && ctx.env.ANTHROPIC_API_KEY) {
+    warn("ANTHROPIC_API_KEY masih ada di environment. Hapus dulu supaya Claude Code tidak mengirim dua key berbeda.");
+  }
+
+  const manual = MANUAL_TOOLS.filter((tool) => tool.detected(ctx));
+  if (manual.length) {
+    out(`\n${s.bold("Atur manual")} ${s.gray("(nilai di bawah, key ada di dashboard):")}`);
+    manual.forEach((tool) => out(`  ${s.cyan("•")} ${s.bold(tool.name)}: ${tool.hint} · Base URL ${baseUrl} · model ${model}`));
+  }
+
+  // 5. One tiny request per protocol the chosen tools actually use.
+  if (!values["no-test"]) {
+    const protocols = [...new Set(selected.map((tool) => tool.protocol))];
+    if (ctx.tty) step(5, totalSteps, `Tes koneksi ${s.gray(`(${protocols.length} request kecil ke ${model})`)}`);
+    else out(`\nTes koneksi (${protocols.length} request kecil ke ${model})...`);
+    for (const protocol of protocols) {
+      const test = await withSpinner(ctx, `Menguji ${PROTOCOL_TESTS[protocol].label}...`, () => testProtocol(ctx, protocol, opts));
+      const hint = protocol === "messages" && test.status === 400 && /anthropic-compatible/i.test(test.message || "")
+        ? `Model ${model} belum dibuka untuk Claude Code; jalankan lagi dengan --model lain.`
+        : "Cek saldo dan model.";
+      if (test.ok) ok(`${test.label}: ${test.text || "OK"}`);
+      else {
+        fail(`${test.label} gagal (${test.status || test.error}${test.message ? `: ${test.message}` : ""}). ${hint}`);
+        failures += 1;
+      }
+    }
+  }
+
+  const closing = [
+    failures ? s.yellow(s.bold(`Selesai dengan ${failures} catatan di atas`)) : s.green(s.bold("Selesai! ZyRouter siap dipakai")),
+    `Backup konfigurasi lama: ${backup.dir}`,
+    "Tutup lalu buka lagi terminal, VS Code, dan aplikasinya supaya konfigurasi baru terbaca.",
+    "Batalkan kapan saja: npx -y zyrouter@latest uninstall",
+  ];
+  if (ctx.tty) {
+    out("");
+    box(s, closing, failures ? s.yellow : s.green).forEach((line) => out(line));
+  } else {
+    out(`\nBackup konfigurasi lama: ${backup.dir}`);
+    out("Selesai. Tutup lalu buka lagi terminal, VS Code, dan aplikasinya supaya konfigurasi baru terbaca.");
+    out("Batalkan kapan saja: npx -y zyrouter@latest uninstall");
+  }
+  return failures ? 2 : 0;
+}

package/lib/system.mjs

@@ -0,0 +1,184 @@
+// Filesystem, detection, environment variables and backups. Everything takes a context so tests can
+// point it at a temporary home directory and a fake platform.
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { ENV_KEY, removeRcBlock, setRcBlock } from "./configs.mjs";
+
+export function exists(file) {
+  try {
+    fs.accessSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function readText(file) {
+  return exists(file) ? fs.readFileSync(file, "utf8") : null;
+}
+
+export function writeText(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, text, "utf8");
+}
+
+/** Parses a JSON config. Returns { ok: false } for files with comments (JSONC/JSON5) so they are left alone. */
+export function readJson(file) {
+  const text = readText(file);
+  if (text === null) return { ok: true, data: {}, existed: false };
+  if (!text.trim()) return { ok: true, data: {}, existed: true };
+  try {
+    const data = JSON.parse(text.replace(/^/, ""));
+    return data && typeof data === "object" && !Array.isArray(data) ? { ok: true, data, existed: true } : { ok: false };
+  } catch {
+    return { ok: false };
+  }
+}
+
+export function onPath(name, ctx) {
+  const dirs = String(ctx.env.PATH || ctx.env.Path || "").split(ctx.platform === "win32" ? ";" : ":").filter(Boolean);
+  const exts = ctx.platform === "win32" ? ["", ...String(ctx.env.PATHEXT || ".EXE;.CMD;.BAT;.PS1").split(";").map((e) => e.toLowerCase())] : [""];
+  return dirs.some((dir) => exts.some((ext) => exists(path.join(dir, name + ext))));
+}
+
+const EDITOR_DIRS = [".vscode", ".vscode-insiders", ".cursor", ".windsurf", ".vscode-oss"];
+
+export function hasEditorExtension(prefix, ctx) {
+  const wanted = `${prefix.toLowerCase()}-`;
+  return EDITOR_DIRS.some((dir) => {
+    try {
+      return fs.readdirSync(path.join(ctx.home, dir, "extensions")).some((name) => name.toLowerCase().startsWith(wanted));
+    } catch {
+      return false;
+    }
+  });
+}
+
+function rcFiles(ctx) {
+  const candidates = ctx.platform === "darwin" ? [".zshrc", ".bash_profile", ".bashrc"] : [".bashrc", ".zshrc"];
+  const present = candidates.map((name) => path.join(ctx.home, name)).filter(exists);
+  return present.length ? present : [path.join(ctx.home, candidates[0])];
+}
+
+/** Persists the key for new terminals and GUI apps. Windows: user environment (setx). Others: shell rc block. */
+export function persistApiKey(key, ctx, backup) {
+  if (ctx.platform === "win32") {
+    // Keep the value it replaces (e.g. from the manual guide or another tool) so uninstall can put it back.
+    const previous = readWindowsUserEnv(ctx);
+    const result = ctx.run("setx", [ENV_KEY, key]);
+    backup.note({ windowsEnv: true, windowsEnvPrevious: previous });
+    return { ok: result.status === 0, where: "Windows user environment", replaced: previous !== null && previous !== key };
+  }
+  const files = rcFiles(ctx);
+  for (const file of files) {
+    backup.record(file);
+    writeText(file, setRcBlock(readText(file), key));
+  }
+  return { ok: true, where: files.map((file) => path.basename(file)).join(", ") };
+}
+
+/** The user-level (HKCU) value, or null when it is not set. */
+export function readWindowsUserEnv(ctx) {
+  const result = ctx.run("reg", ["query", "HKCU\\Environment", "/v", ENV_KEY], { capture: true });
+  if (result.status !== 0) return null;
+  const line = String(result.stdout || "").split(/\r?\n/).find((row) => row.trim().startsWith(ENV_KEY));
+  const match = line && /REG_(?:EXPAND_)?SZ\s+(.*)$/.exec(line.trim());
+  return match ? match[1].trim() : null;
+}
+
+/** Windows: `previous` is the value from before the first install (null = it was not set). */
+export function restoreWindowsUserEnv(ctx, previous) {
+  if (previous) return ctx.run("setx", [ENV_KEY, previous]).status === 0;
+  return ctx.run("reg", ["delete", "HKCU\\Environment", "/v", ENV_KEY, "/f"]).status === 0;
+}
+
+/** Non-Windows: drops the marked block from the rc files. */
+export function removePersistedApiKey(ctx) {
+  for (const file of rcFiles(ctx)) {
+    const text = readText(file);
+    if (text !== null && text.includes("# >>> zyrouter >>>")) writeText(file, removeRcBlock(text));
+  }
+  return true;
+}
+
+export function defaultRun(command, args, { capture = false } = {}) {
+  // No shell: arguments (the API key included) are passed verbatim and never interpreted.
+  return spawnSync(command, args, { stdio: capture ? ["ignore", "pipe", "ignore"] : "ignore", encoding: "utf8", windowsHide: true });
+}
+
+/** One backup session per run under ~/.zyrouter/backups/<timestamp>, restorable by `uninstall`. */
+export function createBackup(ctx) {
+  const dir = path.join(ctx.home, ".zyrouter", "backups", new Date().toISOString().replace(/[:.]/g, "-"));
+  const manifest = { createdAt: new Date().toISOString(), files: [], restored: false };
+  const seen = new Set();
+  return {
+    dir,
+    record(file) {
+      if (seen.has(file) || ctx.dryRun) return;
+      seen.add(file);
+      fs.mkdirSync(dir, { recursive: true });
+      if (exists(file)) {
+        const copy = path.join(dir, `${manifest.files.length}-${path.basename(file)}`);
+        fs.copyFileSync(file, copy);
+        manifest.files.push({ path: file, backup: copy, existed: true });
+      } else {
+        manifest.files.push({ path: file, existed: false });
+      }
+      this.save();
+    },
+    note(extra) {
+      if (ctx.dryRun) return;
+      Object.assign(manifest, extra);
+      fs.mkdirSync(dir, { recursive: true });
+      this.save();
+    },
+    save() {
+      fs.writeFileSync(path.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2));
+    },
+  };
+}
+
+/** Restores every unrestored session, newest first, so the files end up as they were before the first run. */
+export function restoreBackups(ctx) {
+  const root = path.join(ctx.home, ".zyrouter", "backups");
+  let sessions = [];
+  try {
+    sessions = fs.readdirSync(root).sort().reverse();
+  } catch {
+    return { sessions: 0, files: 0, windowsEnv: false, windowsEnvPrevious: null };
+  }
+  let restoredSessions = 0;
+  let restoredFiles = 0;
+  let windowsEnv = false;
+  let windowsEnvPrevious = null;
+  for (const name of sessions) {
+    const manifestPath = path.join(root, name, "manifest.json");
+    let manifest;
+    try {
+      manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    } catch {
+      continue;
+    }
+    if (manifest.restored) continue;
+    for (const entry of manifest.files || []) {
+      if (entry.existed && exists(entry.backup)) {
+        fs.mkdirSync(path.dirname(entry.path), { recursive: true });
+        fs.copyFileSync(entry.backup, entry.path);
+      } else if (!entry.existed && exists(entry.path)) {
+        fs.rmSync(entry.path, { force: true });
+      }
+      restoredFiles += 1;
+    }
+    if (manifest.windowsEnv === true) {
+      windowsEnv = true;
+      // Sessions run newest first, so the last one seen holds the value from before the first install.
+      windowsEnvPrevious = manifest.windowsEnvPrevious ?? null;
+    }
+    manifest.restored = true;
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    restoredSessions += 1;
+  }
+  return { sessions: restoredSessions, files: restoredFiles, windowsEnv, windowsEnvPrevious };
+}

package/lib/ui.mjs

@@ -0,0 +1,173 @@
+// Terminal UI without dependencies: colors, a spinner, arrow-key menus and masked input.
+// Interactive pieces need a real TTY; callers fall back to numbered prompts everywhere else.
+
+import readline from "node:readline";
+
+export function createStyle(enabled) {
+  const wrap = (open, close) => (text) => (enabled ? `\x1b[${open}m${text}\x1b[${close}m` : String(text));
+  return {
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    red: wrap(31, 39),
+    green: wrap(32, 39),
+    yellow: wrap(33, 39),
+    cyan: wrap(36, 39),
+    magenta: wrap(35, 39),
+    gray: wrap(90, 39),
+    orange: wrap("38;5;208", 39),
+    inverse: wrap(7, 27),
+  };
+}
+
+const FAMILIES = [
+  { name: "OpenAI", match: /^(gpt|o\d|chatgpt|codex)/i },
+  { name: "Anthropic", match: /^claude/i },
+  { name: "Google", match: /gemini/i },
+  { name: "DeepSeek", match: /deepseek/i },
+  { name: "Moonshot", match: /kimi/i },
+  { name: "Zhipu", match: /glm/i },
+  { name: "Alibaba", match: /qwen/i },
+  { name: "MiniMax", match: /minimax/i },
+  { name: "Xiaomi", match: /mimo/i },
+];
+
+export function modelFamily(id) {
+  return FAMILIES.find((family) => family.match.test(id))?.name ?? "Other";
+}
+
+/** Models grouped by family, keeping the catalog order inside each group and of the groups themselves. */
+export function groupModels(models) {
+  const groups = new Map();
+  for (const id of models) {
+    const family = modelFamily(id);
+    if (!groups.has(family)) groups.set(family, []);
+    groups.get(family).push(id);
+  }
+  const other = groups.get("Other");
+  groups.delete("Other");
+  if (other) groups.set("Other", other);
+  return [...groups].map(([family, ids]) => ({ family, models: ids }));
+}
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+/** Spinner on one line while `task` runs; without a TTY it just runs the task. */
+export async function withSpinner(ctx, text, task) {
+  if (!ctx.tty) return task();
+  const { style } = ctx;
+  let frame = 0;
+  const draw = () => process.stdout.write(`\r\x1b[2K${style.cyan(SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length])} ${text}`);
+  draw();
+  const timer = setInterval(draw, 80);
+  try {
+    return await task();
+  } finally {
+    clearInterval(timer);
+    process.stdout.write("\r\x1b[2K");
+  }
+}
+
+function withRawInput(handler) {
+  return new Promise((resolve, reject) => {
+    const input = process.stdin;
+    readline.emitKeypressEvents(input);
+    const wasRaw = input.isRaw;
+    input.setRawMode(true);
+    input.resume();
+    const finish = (error, value) => {
+      input.off("keypress", onKey);
+      input.setRawMode(wasRaw);
+      input.pause();
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const onKey = (text, key = {}) => {
+      if ((key.ctrl && key.name === "c") || key.name === "escape") return finish(new Error("Dibatalkan."));
+      handler(text, key, (value) => finish(null, value));
+    };
+    input.on("keypress", onKey);
+  });
+}
+
+/** Masked input: shows • per character, supports paste and backspace. */
+export async function readSecret(ctx, label) {
+  const { style } = ctx;
+  let value = "";
+  const draw = () => process.stdout.write(`\r\x1b[2K${style.cyan("?")} ${style.bold(label)} ${style.gray("•".repeat(Math.min(value.length, 48)))}`);
+  draw();
+  const result = await withRawInput((text, key, done) => {
+    if (key.name === "return" || key.name === "enter") return done(value);
+    if (key.name === "backspace") value = value.slice(0, -1);
+    else if (text && !key.ctrl && !key.meta) value += text.replace(/[\r\n]/g, "");
+    draw();
+  });
+  process.stdout.write("\n");
+  return result.trim();
+}
+
+/**
+ * Arrow-key menu. `rows` mixes { header } lines with { label, value, note, checked } items.
+ * Single choice returns a value; multi choice returns the checked values.
+ */
+export async function pickFromMenu(ctx, { title, hint, rows, multi = false, initialValue }) {
+  const { style } = ctx;
+  const items = rows.filter((row) => !row.header);
+  let cursor = Math.max(0, items.findIndex((item) => item.value === initialValue));
+  const checked = new Set(items.filter((item) => item.checked).map((item) => item.value));
+  let drawn = 0;
+  process.stdout.write("\x1b[?25l");
+
+  const render = () => {
+    const height = Math.max(8, (process.stdout.rows || 24) - 5);
+    const current = items[cursor];
+    const currentRow = rows.indexOf(current);
+    const start = Math.max(0, Math.min(currentRow - Math.floor(height / 2), rows.length - height));
+    const visible = rows.slice(start, start + height);
+    const lines = [`${style.cyan("?")} ${style.bold(title)} ${style.gray(hint)}`];
+    if (start > 0) lines.push(style.gray("   ↑ lainnya"));
+    for (const row of visible) {
+      if (row.header) {
+        lines.push(`  ${style.orange(style.bold(row.header))}`);
+        continue;
+      }
+      const active = row === current;
+      const pointer = active ? style.cyan("❯") : " ";
+      const box = multi ? (checked.has(row.value) ? style.green("◉") : style.gray("◯")) + " " : "";
+      const label = active ? style.cyan(style.bold(row.label)) : row.label;
+      lines.push(`  ${pointer} ${box}${label}${row.note ? ` ${style.gray(row.note)}` : ""}`);
+    }
+    if (start + height < rows.length) lines.push(style.gray("   ↓ lainnya"));
+    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[0J`);
+    process.stdout.write(`${lines.join("\n")}\n`);
+    drawn = lines.length;
+  };
+
+  render();
+  try {
+    return await withRawInput((text, key, done) => {
+      if (key.name === "up" || key.name === "k") cursor = (cursor - 1 + items.length) % items.length;
+      else if (key.name === "down" || key.name === "j") cursor = (cursor + 1) % items.length;
+      else if (multi && key.name === "space") {
+        const value = items[cursor].value;
+        if (checked.has(value)) checked.delete(value);
+        else checked.add(value);
+      } else if (multi && key.name === "a") {
+        if (checked.size === items.length) checked.clear();
+        else items.forEach((item) => checked.add(item.value));
+      } else if (key.name === "return" || key.name === "enter") {
+        return done(multi ? items.filter((item) => checked.has(item.value)).map((item) => item.value) : items[cursor].value);
+      }
+      render();
+    });
+  } finally {
+    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[0J`);
+    process.stdout.write("\x1b[?25h");
+  }
+}
+
+/** A rounded box around a few lines, sized to the longest one (ANSI codes excluded). */
+export function box(style, lines, color = style.gray) {
+  const width = Math.max(...lines.map((line) => line.replace(/\x1b\[[0-9;]*m/g, "").length));
+  const pad = (line) => line + " ".repeat(width - line.replace(/\x1b\[[0-9;]*m/g, "").length);
+  return [color(`╭${"─".repeat(width + 2)}╮`), ...lines.map((line) => `${color("│")} ${pad(line)} ${color("│")}`), color(`╰${"─".repeat(width + 2)}╯`)];
+}

package/package.json

@@ -1,6 +1,29 @@
 {
   "name": "zyrouter",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Connect Codex, Claude Code, OpenCode, OpenClaw and Hermes Agent to ZyRouter with one command.",
+  "type": "module",
+  "bin": {
+    "zyrouter": "bin/cli.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "keywords": [
+    "zyrouter",
+    "codex",
+    "claude-code",
+    "opencode",
+    "installer"
+  ],
+  "homepage": "https://zyrouter.com",
+  "license": "UNLICENSED"
+}