@rerouter/helper 0.0.0-stage → 0.1.1

package/src/lib/targets.js

@@ -0,0 +1,390 @@
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { DEFAULT_BRIDGE_PORT } from "./bridge-server.js";
+import { DEFAULT_BASE_URL } from "./env.js";
+import { backupFile, expandHome, parseJsonc, readTextIfExists, writeFileEnsured } from "./files.js";
+
+/**
+ * Configuration target registry. Each target returns a "plan":
+ *   { name, description, changes: [{file, summary, content}], notes: [] }
+ * Plan is printed first (preview); writing only happens via `applyPlan` after
+ * confirmation/--yes, and is ALWAYS preceded by a timestamped backup.
+ *
+ * The key is NEVER written to any file — only env/placeholder references.
+ */
+
+export const AUTOMATIC_TARGETS = ["claude", "codex", "opencode", "omp", "continue"];
+export const SNIPPET_TARGETS = ["openai", "anthropic"];
+export const GUIDE_TARGETS = ["cursor", "vscode", "cline", "roo"];
+export const ALL_TARGETS = [...AUTOMATIC_TARGETS, ...SNIPPET_TARGETS, ...GUIDE_TARGETS];
+
+function keyNeverWrittenNote() {
+  return "API key is NOT written to any file. Set env REROUTER_API_KEY (or the env named in the notes) in your shell.";
+}
+
+/** Small/cheap model heuristic for ANTHROPIC_SMALL_FAST_MODEL. */
+export function pickSmallModel(models, mainModel) {
+  const ids = models.map((m) => String(m?.id ?? "")).filter(Boolean);
+  const cheap = ids.find((id) => /haiku|mini|flash|lite|small|nano/i.test(id));
+  return cheap ?? mainModel;
+}
+
+// ---------------------------------------------------------------- claude
+function planClaude({ baseUrl, model, smallModel }) {
+  const file = expandHome("~/.claude/settings.json");
+  return {
+    name: "claude",
+    description: "[CC] — merge env in ~/.claude/settings.json",
+    file,
+    async build() {
+      const existing = await readTextIfExists(file);
+      let settings = {};
+      if (existing !== null) {
+        try {
+          settings = parseJsonc(existing);
+        } catch {
+          throw new Error(
+            `${file} could not be parsed (ambiguous/broken JSONC).\n` +
+              `Manual merge — add:\n` +
+              `  "env": { "ANTHROPIC_BASE_URL": "${baseUrl}", "ANTHROPIC_MODEL": "${model}", "ANTHROPIC_SMALL_FAST_MODEL": "${smallModel}" }`,
+          );
+        }
+        if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+          throw new Error(`${file} is not a JSON object — merge manually.`);
+        }
+      }
+      const env = { ...(settings.env ?? {}) };
+      env.ANTHROPIC_BASE_URL = baseUrl;
+      env.ANTHROPIC_MODEL = model;
+      env.ANTHROPIC_SMALL_FAST_MODEL = smallModel;
+      // Key not written: [CC] reads ANTHROPIC_AUTH_TOKEN from shell env.
+      delete env.ANTHROPIC_AUTH_TOKEN;
+      delete env.ANTHROPIC_API_KEY;
+      const next = { ...settings, env };
+      return JSON.stringify(next, null, 2) + "\n";
+    },
+    notes: [
+      keyNeverWrittenNote(),
+      "Run [CC] with: ANTHROPIC_AUTH_TOKEN filled from REROUTER_API_KEY.",
+      "  POSIX:      export ANTHROPIC_AUTH_TOKEN=\"$REROUTER_API_KEY\"",
+      "  PowerShell: $env:ANTHROPIC_AUTH_TOKEN = $env:REROUTER_API_KEY",
+    ],
+  };
+}
+
+// ---------------------------------------------------------------- opencode
+function planOpencode({ baseUrl, model }) {
+  const file = expandHome("~/.config/opencode/opencode.json");
+  return {
+    name: "opencode",
+    description: "opencode — custom provider in ~/.config/opencode/opencode.json",
+    file,
+    async build() {
+      const existing = await readTextIfExists(file);
+      let config = {};
+      if (existing !== null) {
+        try {
+          config = parseJsonc(existing);
+        } catch {
+          throw new Error(`${file} could not be parsed — merge manually (see Rerouter docs).`);
+        }
+        if (!config || typeof config !== "object" || Array.isArray(config)) {
+          throw new Error(`${file} is not a JSON object — merge manually.`);
+        }
+      }
+      const providers = { ...(config.provider ?? {}) };
+      const prev = providers.rerouter ?? {};
+      providers.rerouter = {
+        npm: "@ai-sdk/openai-compatible",
+        name: "Rerouter",
+        ...prev,
+        options: {
+          ...(prev.options ?? {}),
+          baseURL: `${baseUrl}/v1`,
+          apiKey: "{env:REROUTER_API_KEY}",
+        },
+        models: {
+          ...(prev.models ?? {}),
+          [model]: { name: model },
+        },
+      };
+      const next = {
+        $schema: "https://opencode.ai/config.json",
+        ...config,
+        provider: providers,
+        model: config.model ?? `rerouter/${model}`,
+      };
+      return JSON.stringify(next, null, 2) + "\n";
+    },
+    notes: [keyNeverWrittenNote(), "opencode reads apiKey from env REROUTER_API_KEY ({env:...} reference)."],
+  };
+}
+
+// ---------------------------------------------------------------- omp
+function planOmp({ baseUrl, model }) {
+  const file = expandHome("~/.omp/agent/models.yml");
+  return {
+    name: "omp",
+    description: "OMP — provider entry in ~/.omp/agent/models.yml",
+    file,
+    async build() {
+      const existing = await readTextIfExists(file);
+      let doc = {};
+      if (existing !== null) {
+        try {
+          doc = parseYaml(existing) ?? {};
+        } catch {
+          throw new Error(`${file} YAML broken — merge manually (see Rerouter docs).`);
+        }
+        if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
+          throw new Error(`${file} is not a YAML mapping — merge manually.`);
+        }
+      }
+      const providers = { ...(doc.providers ?? {}) };
+      const prev = providers.rerouter ?? {};
+      const prevModels = Array.isArray(prev.models) ? prev.models : [];
+      const others = prevModels.filter((m) => m?.id !== model);
+      providers.rerouter = {
+        type: "openai-compatible",
+        base_url: `${baseUrl}/v1`,
+        api_key_env: "REROUTER_API_KEY",
+        ...prev,
+        models: [{ id: model, default: true }, ...others.map((m) => ({ ...m, default: false }))],
+      };
+      return stringifyYaml({ ...doc, providers });
+    },
+    notes: [keyNeverWrittenNote(), "OMP reads key from env named by api_key_env."],
+  };
+}
+
+// ---------------------------------------------------------------- codex
+const TOML_PROVIDER_BLOCK = (port) =>
+  `\n[model_providers.rerouter]\nname = "Rerouter (local bridge)"\nbase_url = "http://127.0.0.1:${port}/v1"\nenv_key = "REROUTER_API_KEY"\nwire_api = "responses"\n`;
+
+function planCodex({ model, port = DEFAULT_BRIDGE_PORT }) {
+  const file = expandHome("~/.codex/config.toml");
+  return {
+    name: "codex",
+    description: `Codex CLI — local bridge provider in ~/.codex/config.toml (port ${port})`,
+    file,
+    async build() {
+      const existing = (await readTextIfExists(file)) ?? "";
+
+      // Separate top-scope (key=value before first section) from sections.
+      const firstSection = existing.search(/^\[/m);
+      const topRaw = firstSection >= 0 ? existing.slice(0, firstSection) : existing;
+      const sections = firstSection >= 0 ? existing.slice(firstSection) : "";
+
+      // Validate top-scope: only key=value, comments, or empty lines.
+      // Broken/ambiguous TOML → merge manually (file left intact).
+      for (const line of topRaw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        if (!/^[A-Za-z0-9_.-]+\s*=/.test(trimmed)) {
+          throw new Error(
+            `${file} contains an unrecognized top-level line ("${trimmed}") — merge manually.\n` +
+              `Add it yourself:\n  model_provider = "rerouter"\n  model = "${model}"\n${TOML_PROVIDER_BLOCK(port)}`,
+          );
+        }
+      }
+
+      // Set/replace top-level keys.
+      let top = topRaw;
+      const upsert = (key, value) => {
+        const re = new RegExp(`^${key}\\s*=.*$`, "m");
+        top = re.test(top) ? top.replace(re, `${key} = ${value}`) : `${top.replace(/\s*$/, "")}${top.trim() ? "\n" : ""}${key} = ${value}\n`;
+      };
+      upsert("model_provider", '"rerouter"');
+      upsert("model", JSON.stringify(model));
+
+      // Provider block: append if not present (idempotent — old block left intact).
+      const hasProvider = /^\[model_providers\.rerouter\]\s*$/m.test(sections);
+      const body = hasProvider ? sections : `${sections.replace(/\s*$/, "")}${sections.trim() ? "\n" : ""}${TOML_PROVIDER_BLOCK(port)}`;
+      return `${top.replace(/\s*$/, "")}\n\n${body.replace(/^\n+/, "")}`;
+    },
+    notes: [
+      keyNeverWrittenNote(),
+      "Codex reads key from env REROUTER_API_KEY (env_key in config).",
+      `Codex speaks Responses API — run the local bridge BEFORE codex:`,
+      `  npx @rerouter/helper bridge${port === DEFAULT_BRIDGE_PORT ? "" : ` --port ${port}`}`,
+    ],
+  };
+}
+
+// ---------------------------------------------------------------- continue
+function planContinue({ baseUrl, model }) {
+  const configFile = expandHome("~/.continue/config.yaml");
+  const envFile = expandHome("~/.continue/.env");
+  return {
+    name: "continue",
+    description: "Continue — model entry in ~/.continue/config.yaml (+ .env placeholder)",
+    file: configFile,
+    extraFiles: [envFile],
+    async build() {
+      const existing = await readTextIfExists(configFile);
+      let doc = {};
+      if (existing !== null) {
+        try {
+          doc = parseYaml(existing) ?? {};
+        } catch {
+          throw new Error(`${configFile} YAML broken — merge manually (see Rerouter docs).`);
+        }
+        if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
+          throw new Error(`${configFile} is not a YAML mapping — merge manually.`);
+        }
+      }
+      const models = Array.isArray(doc.models) ? [...doc.models] : [];
+      const entry = {
+        name: `Rerouter ${model}`,
+        provider: "openai",
+        model,
+        apiBase: `${baseUrl}/v1`,
+        apiKey: "${{ secrets.REROUTER_API_KEY }}",
+        roles: ["chat", "edit"],
+        default: true,
+      };
+      const idx = models.findIndex((m) => m?.name === entry.name || m?.apiBase === entry.apiBase);
+      const nextModels =
+        idx >= 0
+          ? models.map((m, i) => (i === idx ? { ...entry, default: true } : { ...m, default: false }))
+          : [...models.map((m) => ({ ...m, default: false })), entry];
+      const next = {
+        name: doc.name ?? "Local Assistant",
+        version: doc.version ?? "1.0.0",
+        schema: doc.schema ?? "v1",
+        ...doc,
+        models: nextModels,
+      };
+      return stringifyYaml(next);
+    },
+    async buildExtra() {
+      // Placeholder secret — NOT the real key. The user fills it in.
+      const existing = await readTextIfExists(envFile);
+      if (existing !== null && /^\s*REROUTER_API_KEY\s*=/m.test(existing)) return null;
+      const line =
+        "# Fill with your Rerouter key (sk-rr-...). Helper never writes the real key.\nREROUTER_API_KEY=\n";
+      return existing === null ? line : `${existing.replace(/\s*$/, "\n")}\n${line}`;
+    },
+    notes: [
+      keyNeverWrittenNote(),
+      `Fill your key in ${envFile} (line REROUTER_API_KEY=) — Continue reads it as a secret.`,
+    ],
+  };
+}
+
+export function planTarget(target, { baseUrl = DEFAULT_BASE_URL, model, smallModel, port } = {}) {
+  if (!AUTOMATIC_TARGETS.includes(target)) {
+    throw new Error(`Target "${target}" is not an automatic target. Options: ${AUTOMATIC_TARGETS.join(", ")}`);
+  }
+  if (!model) throw new Error(`--model is required for target "${target}".`);
+  const ctx = { baseUrl, model, smallModel: smallModel ?? model, port };
+  switch (target) {
+    case "claude":
+      return planClaude(ctx);
+    case "codex":
+      return planCodex(ctx);
+    case "opencode":
+      return planOpencode(ctx);
+    case "omp":
+      return planOmp(ctx);
+    case "continue":
+      return planContinue(ctx);
+  }
+}
+
+/**
+ * Apply plan: timestamped backup first, then write. Returns a list of
+ * {file, backupPath} to report to the user.
+ */
+export async function applyPlan(plan, content) {
+  const results = [];
+  const backupPath = await backupFile(plan.file);
+  await writeFileEnsured(plan.file, content);
+  results.push({ file: plan.file, backupPath });
+
+  if (typeof plan.buildExtra === "function" && Array.isArray(plan.extraFiles)) {
+    const extra = await plan.buildExtra();
+    if (extra !== null && extra !== undefined) {
+      const extraFile = plan.extraFiles[0];
+      const extraBackup = await backupFile(extraFile);
+      await writeFileEnsured(extraFile, extra);
+      results.push({ file: extraFile, backupPath: extraBackup });
+    }
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------- snippets & guides
+export function snippet(target, { baseUrl = DEFAULT_BASE_URL, model } = {}) {
+  const m = model ?? "<MODEL_ID>";
+  if (target === "openai") {
+    return [
+      "# POSIX (bash/zsh)",
+      `export OPENAI_BASE_URL="${baseUrl}/v1"`,
+      `export OPENAI_API_KEY="$REROUTER_API_KEY"`,
+      "",
+      "# PowerShell",
+      `$env:OPENAI_BASE_URL = "${baseUrl}/v1"`,
+      `$env:OPENAI_API_KEY = $env:REROUTER_API_KEY`,
+    ].join("\n");
+  }
+  if (target === "anthropic") {
+    return [
+      "# POSIX (bash/zsh)",
+      `export ANTHROPIC_BASE_URL="${baseUrl}"`,
+      `export ANTHROPIC_AUTH_TOKEN="$REROUTER_API_KEY"`,
+      `export ANTHROPIC_MODEL="${m}"`,
+      `export ANTHROPIC_SMALL_FAST_MODEL="${m}"`,
+      "",
+      "# PowerShell",
+      `$env:ANTHROPIC_BASE_URL = "${baseUrl}"`,
+      `$env:ANTHROPIC_AUTH_TOKEN = $env:REROUTER_API_KEY`,
+      `$env:ANTHROPIC_MODEL = "${m}"`,
+      `$env:ANTHROPIC_SMALL_FAST_MODEL = "${m}"`,
+    ].join("\n");
+  }
+  throw new Error(`No snippet for target "${target}".`);
+}
+
+export function guide(target, { baseUrl = DEFAULT_BASE_URL, model } = {}) {
+  const m = model ?? "<MODEL_ID>";
+  const oaiBase = `${baseUrl}/v1`;
+  switch (target) {
+    case "cursor":
+      return [
+        "Cursor — manual setup (no stable config file):",
+        "  1. Open Settings → Models.",
+        `  2. Fill OpenAI-compatible API Key with your Rerouter key (sk-rr-...).`,
+        `  3. Enable "Override OpenAI-compatible Base URL" → ${oaiBase}`,
+        `  4. Add custom model: ${m}`,
+        "  Note: Cursor verifies the key with a small request — that's normal.",
+      ].join("\n");
+    case "vscode":
+      return [
+        "VS Code (Copilot BYOK):",
+        "  1. Command Palette → \"Manage Language Models\" (or gear icon in model picker).",
+        "  2. Select custom/OpenAI-compatible provider → Custom Endpoint.",
+        `  3. Base URL: ${oaiBase} — API Key: your Rerouter key.`,
+        `  4. Model: ${m}`,
+      ].join("\n");
+    case "cline":
+      return [
+        "Cline (VS Code extension):",
+        "  1. Open Cline → Settings (gear icon).",
+        "  2. API Provider: \"OpenAI-compatible\".",
+        `  3. Base URL: ${oaiBase}`,
+        "  4. API Key: your Rerouter key (sk-rr-...).",
+        `  5. Model ID: ${m}`,
+      ].join("\n");
+    case "roo":
+      return [
+        "Roo Code:",
+        "  1. Open Roo Code → Settings → Providers.",
+        "  2. API Provider: \"OpenAI-compatible\".",
+        `  3. Base URL: ${oaiBase}`,
+        "  4. API Key: your Rerouter key (sk-rr-...).",
+        `  5. Model: ${m}`,
+      ].join("\n");
+    default:
+      throw new Error(`No guide for target "${target}".`);
+  }
+}