zyrouter 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,28 @@
-# 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` |
+
+Cline, Continue and Hermes Agent 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`, `--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,114 @@
+// 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-…";
+}

package/lib/main.mjs

@@ -0,0 +1,323 @@
+import os from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "node:util";
+import { ENV_KEY, maskKey, mergeClaudeSettings, mergeCodexToml, mergeOpenClaw, mergeOpenCode } from "./configs.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 HELP = `ZyRouter installer — hubungkan Codex, Claude Code, OpenCode, dan OpenClaw 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 (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);
+      },
+    },
+  ];
+}
+
+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" },
+  { id: "hermes", name: "Hermes Agent", detected: (ctx) => onPath("hermes", ctx) || exists(path.join(ctx.home, ".hermes")), hint: "~/.hermes/config.yaml + OPENAI_API_KEY di ~/.hermes/.env" },
+];
+
+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 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: Boolean(process.stdin.isTTY),
+    ...overrides,
+  };
+  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;
+  if (values.help) {
+    out(HELP);
+    return 0;
+  }
+  ctx.dryRun = values["dry-run"] === true;
+
+  let rl = null;
+  const ask = ctx.ask || (async (question) => {
+    rl ||= createInterface({ input: process.stdin, output: process.stdout });
+    return rl.question(question);
+  });
+  const canAsk = !values.yes && (ctx.ask || ctx.interactive);
+
+  try {
+    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);
+      }
+      out(result.sessions ? `✔ ${result.files} file dikembalikan dari ${result.sessions} backup.` : "Tidak ada backup ZyRouter untuk dikembalikan.");
+      out("Tutup lalu buka lagi terminal dan editor supaya perubahan terbaca.");
+      return 0;
+    }
+
+    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, "");
+
+    // An existing ZYROUTER_API_KEY is only reused when it is a ZyRouter key; other tools use the name too.
+    const envKey = ctx.env[ENV_KEY] || "";
+    let key = values.key || (KEY_PATTERN.test(envKey) ? envKey : "");
+    if (!values.key && envKey && !key) out(`! ${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 = (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-...");
+
+    out(`ZyRouter installer · key ${maskKey(key)}`);
+    const listed = await 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;
+    out(listed.ok ? `✔ API key valid · ${models.length} model tersedia` : "! Daftar model belum bisa diambil; memakai daftar bawaan.");
+
+    const tools = toolCatalog(ctx);
+    const detected = tools.filter((tool) => tool.detected());
+    const preselected = detected.filter((tool) => !tool.optIn);
+    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) {
+      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, atau pilih langsung dengan --tools codex,claude-code.");
+      return 1;
+    }
+
+    let model = values.model || "";
+    if (!model && canAsk) {
+      out("\nModel default:");
+      models.forEach((id, index) => out(`  ${index + 1}. ${id}`));
+      const answer = (await ask(`Pilih nomor (Enter = ${models[0]}): `)).trim();
+      model = (answer && models[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.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;
+    }
+
+    const backup = createBackup(ctx);
+    const opts = { baseUrl, anthropicBaseUrl, key, model, models };
+    out("");
+    let failures = 0;
+    for (const tool of selected) {
+      const result = tool.apply(opts, backup);
+      if (result.ok) out(`✔ ${tool.name} → ${tool.file}`);
+      else {
+        failures += 1;
+        out(`✖ ${tool.name}: ${result.reason}`);
+      }
+    }
+    if (selected.some((tool) => tool.needsEnv) && values["no-env"]) {
+      out(`! ${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);
+      out(env.ok ? `✔ ${ENV_KEY} disimpan (${env.where})${env.replaced ? "; nilai lamanya disimpan di backup dan dikembalikan saat uninstall" : ""}` : `✖ Gagal menyimpan ${ENV_KEY}; set manual lalu buka terminal baru.`);
+      if (!env.ok) 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) {
+      out("! 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("\nAtur manual (nilai di bawah, key ada di dashboard):");
+      manual.forEach((tool) => out(`  • ${tool.name}: ${tool.hint} · Base URL ${baseUrl} · model ${model}`));
+    }
+
+    if (!values["no-test"]) {
+      // One tiny request per protocol the chosen tools actually use.
+      const protocols = [...new Set(selected.map((tool) => tool.protocol))];
+      out(`\nTes koneksi (${protocols.length} request kecil ke ${model})...`);
+      for (const protocol of protocols) {
+        const test = await 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.";
+        out(test.ok ? `✔ ${test.label}: ${test.text || "OK"}` : `✖ ${test.label} gagal (${test.status || test.error}${test.message ? `: ${test.message}` : ""}). ${hint}`);
+        if (!test.ok) failures += 1;
+      }
+    }
+
+    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;
+  } finally {
+    rl?.close();
+  }
+}

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/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.0",
+  "description": "Connect Codex, Claude Code, OpenCode and OpenClaw 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"
+}