virouter 0.2.1 → 0.2.4

package/README.md

@@ -1,11 +1,15 @@
 # virouter
 
-Interactive installer for Claude Code on Windows, macOS and Linux.
+Interactive installer for Claude Code and OpenCode on Windows, macOS and Linux.
 
 ```bash
 npx virouter@latest
 ```
 
+The installer launches Claude Code with the correct VIROUTER environment immediately. Use
+`--no-launch` when you only want to write configuration files. Use `--reuse-key` to deliberately
+reuse `VIROUTER_API_KEY` without prompting.
+
 For a local Worker, override the origin before running the installer:
 
 ```powershell
@@ -13,12 +17,48 @@ $env:VIROUTER_API_ORIGIN="http://127.0.0.1:8787"
 npx virouter@latest
 ```
 
-The installer asks for a `viro_...` API key and configures:
+On the first install, the installer displays the API key while you type it, asks for the operating
+system and default model, and configures:
+
+- `1` = Windows
+- `2` = macOS
+- `3` = Linux
+
+- `ANTHROPIC_BASE_URL=https://virouter.click`
+- `ANTHROPIC_AUTH_TOKEN`
+- `model` in `~/.claude/settings.json` — `claude-fable-5-1` on a first install
+- `ANTHROPIC_SMALL_FAST_MODEL=claude-haiku-4-5`
+- `VIROUTER_API_KEY` for OpenCode
+- `~/.config/opencode/opencode.json` with VIROUTER as the default provider
+
+Interactive runs always ask for the key again and overwrite local configuration with the key you
+paste. The previous key remains active on the server until you revoke it separately. Running with
+the same key keeps the existing model; a new key asks for the model again.
+
+The model is remembered, not pinned. It is written to `model` in `~/.claude/settings.json`, which is
+where Claude Code's `/model` saves a new choice, so every new `claude` session starts on the model
+used last. `ANTHROPIC_MODEL` is deliberately removed (`unset` in the shell profile, deleted from
+the Windows user environment): it applies over the settings file and would send every session
+back to the install-time model. An install that pinned it is migrated — that model moves into
+`settings.json`. Only if `settings.json` is not valid JSON does the installer leave it untouched
+and fall back to pinning `ANTHROPIC_MODEL`.
+
+The installer uses visible input and prints the received key for confirmation. Do not record or
+share that terminal output.
+
+When an OpenCode configuration already exists, its enabled providers and credentials are
+preserved; VIROUTER is appended and selected as the default provider. A new configuration
+enables only VIROUTER. This allows existing ClaudeKit/ECC/OpenCode workflows to continue
+without losing their provider setup.
+
+The installer never replaces `.claude/` skills, rules, agents, or hooks. In `~/.claude/settings.json`
+it sets only the `model` key (and drops an `env.ANTHROPIC_MODEL` pin); every other setting is
+kept. If it detects ClaudeKit or ECC, it reports that configuration and otherwise only writes
+gateway environment variables plus the OpenCode provider entry.
 
-- `ANTHROPIC_BASE_URL=https://virouter-production.nplinh191202.workers.dev`
-- `ANTHROPIC_API_KEY`
-- `ANTHROPIC_MODEL=viro-max`
-- `ANTHROPIC_SMALL_FAST_MODEL=viro-speed`
+The customer key is never stored in this package or repository. Obtain it from the one-time
+claim/recovery flow documented in `docs/claude-code-setup.md`; do not use an upstream
+`OPENCODE_GO_API_KEYS` credential here.
 
 Then open a new terminal and run:
 
@@ -27,4 +67,4 @@ claude
 ```
 
 It does not install a local server or a model. The gateway remains hosted at
-`https://virouter-production.nplinh191202.workers.dev`.
+`https://virouter.click`.

package/bin/virouter.mjs

@@ -1,78 +1,177 @@
 #!/usr/bin/env node
 
 import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline/promises';
+import { pathToFileURL } from 'node:url';
 
-const API_ORIGIN = (process.env.VIROUTER_API_ORIGIN || 'https://virouter-production.nplinh191202.workers.dev').replace(/\/$/, '');
+const API_ORIGIN = (process.env.VIROUTER_API_ORIGIN || 'https://virouter.click').replace(/\/$/, '');
 const MARKER_START = '# >>> VIROUTER CLAUDE CODE CONFIG >>>';
 const MARKER_END = '# <<< VIROUTER CLAUDE CODE CONFIG <<<';
-
-function detectedOs() {
-  if (process.platform === 'win32') return '1';
-  if (process.platform === 'darwin') return '2';
-  return '3';
-}
+const OPENCODE_PROVIDER_ID = 'virouter';
+/** What a first install starts on. After that the customer's own `/model` choice wins. */
+const DEFAULT_MODEL = 'claude-fable-5-1';
+const VIROUTER_MODELS = [
+  'claude-sonnet-5',
+  'claude-fable-5-1',
+  'claude-opus-5-5',
+  'claude-opus-5',
+  'claude-haiku-4-5',
+  'claude-fable-5',
+  'claude-opus-4-8',
+  'claude-opus-4-7',
+  'claude-opus-4-6',
+  'claude-sonnet-4-6',
+  'claude-haiku-4-5-lite',
+  'claude-haiku-4-5-alt',
+];
 
 function printHelp() {
-  console.log(`VIROUTER Claude Code installer
+console.log(`VIROUTER Claude Code + OpenCode installer
 
 Usage:
   npx virouter@latest
   npx virouter@latest --help
+  npx virouter@latest --no-launch
+  npx virouter@latest --reuse-key
 
-The installer configures Claude Code to use ${API_ORIGIN}.
+  The installer configures Claude Code and OpenCode to use ${API_ORIGIN}.
 For local testing, set VIROUTER_API_ORIGIN=http://127.0.0.1:8787.
-It does not install a server or store a local model.`);
+  It does not install a server or store a local model.`);
 }
 
-async function readSecret(prompt) {
-  if (!process.stdin.isTTY || !process.stdin.setRawMode) {
-    const line = createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await line.question(prompt);
-    line.close();
-    return answer.trim();
-  }
-
-  return new Promise((resolve, reject) => {
-    let value = '';
-    const onData = (chunk) => {
-      const text = chunk.toString();
-      for (const char of text) {
-        if (char === '\u0003') {
-          process.stdin.setRawMode(false);
-          process.stdin.pause();
-          reject(new Error('Cancelled.'));
-          return;
-        }
-        if (char === '\r' || char === '\n') {
-          process.stdin.setRawMode(false);
-          process.stdin.pause();
-          process.stdin.off('data', onData);
-          process.stdout.write('\n');
-          resolve(value.trim());
-          return;
-        }
-        if (char === '\u007f') value = value.slice(0, -1);
-        else value += char;
-      }
-    };
-
-    process.stdout.write(prompt);
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.on('data', onData);
-  });
+async function readVisibleInput(prompt) {
+  const line = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  const answer = await line.question(prompt);
+  line.close();
+  const value = answer.trim();
+  console.log(`\nĐã nhận customer key: ${value}`);
+  return value;
 }
 
 async function chooseOs(input) {
-  const answer = (await input.question(`Hệ điều hành [${detectedOs()}]: `)).trim() || detectedOs();
+  console.log('Hệ điều hành:');
+  console.log('  ● 1 = Windows');
+  console.log('  ● 2 = macOS');
+  console.log('  ● 3 = Linux');
+  const answer = (await input.question('Chọn số (1/2/3): ')).trim();
   if (!['1', '2', '3'].includes(answer)) throw new Error('Chọn 1, 2 hoặc 3.');
   return answer;
 }
 
+async function chooseModel(input, currentModel) {
+  console.log('\nModel mặc định cho Claude Code:');
+  VIROUTER_MODELS.forEach((model, index) => console.log(`  ${index + 1} = ${model}`));
+  const defaultIndex = Math.max(0, VIROUTER_MODELS.indexOf(currentModel));
+  const answer = (await input.question(`Chọn số [${defaultIndex + 1}]: `)).trim() || String(defaultIndex + 1);
+  const selected = VIROUTER_MODELS[Number(answer) - 1];
+  if (!selected) throw new Error('Lựa chọn model không hợp lệ.');
+  return selected;
+}
+
+function existingConfig() {
+  const candidates = process.platform === 'win32'
+    ? []
+    : process.platform === 'darwin'
+      ? [join(homedir(), '.zshrc'), join(homedir(), '.bashrc')]
+      : [join(homedir(), '.bashrc'), join(homedir(), '.zshrc')];
+  const sources = candidates
+    .filter((path) => existsSync(path))
+    .map((path) => readFileSync(path, 'utf8'));
+  const combined = sources.join('\n');
+  const key = combined.match(/export VIROUTER_API_KEY="([^"]+)"/)?.[1]
+    || process.env.VIROUTER_API_KEY
+    || null;
+  const model = combined.match(/export ANTHROPIC_MODEL="([^"]+)"/)?.[1]
+    || process.env.ANTHROPIC_MODEL
+    || null;
+  return { key, model: VIROUTER_MODELS.includes(model) ? model : null };
+}
+
+/**
+ * Claude Code's user settings. `/model` writes the customer's pick to `model` here and every
+ * new session starts on it — unless `ANTHROPIC_MODEL` is set, which applies over the `model`
+ * key from any file. Earlier installers exported ANTHROPIC_MODEL, so every new `claude` went
+ * back to the install-time model whatever the customer had switched to. The model now lives
+ * only here, where `/model` can change it.
+ */
+function claudeSettingsPath() {
+  return join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), 'settings.json');
+}
+
+function readClaudeSettings() {
+  const path = claudeSettingsPath();
+  if (!existsSync(path)) return { path, settings: {}, writable: true };
+  try {
+    const settings = JSON.parse(readFileSync(path, 'utf8'));
+    return settings && typeof settings === 'object' && !Array.isArray(settings)
+      ? { path, settings, writable: true }
+      : { path, settings: {}, writable: false };
+  } catch {
+    // Never overwrite a file we could not parse; the caller falls back to the env variable.
+    return { path, settings: {}, writable: false };
+  }
+}
+
+/**
+ * The model a (re)install should keep: the customer's last `/model` choice, else the one an
+ * older installer pinned in ANTHROPIC_MODEL, else nothing (first install → DEFAULT_MODEL).
+ */
+export function resolveStartingModel(settingsModel, legacyModel) {
+  if (VIROUTER_MODELS.includes(settingsModel)) return settingsModel;
+  if (VIROUTER_MODELS.includes(legacyModel)) return legacyModel;
+  return null;
+}
+
+/** Returns new settings with `model` set and any ANTHROPIC_MODEL pin removed from `env`. */
+export function withRememberedModel(settings, model) {
+  const next = { ...settings, model };
+  if (next.env && typeof next.env === 'object' && 'ANTHROPIC_MODEL' in next.env) {
+    const { ANTHROPIC_MODEL: _pinned, ...env } = next.env;
+    next.env = env;
+  }
+  return next;
+}
+
+function writeClaudeSettings(path, settings) {
+  mkdirSync(join(path, '..'), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600 });
+}
+
+function detectAgentToolkit() {
+  const candidates = [
+    join(process.cwd(), '.claude', '.ck.json'),
+    join(process.cwd(), '.claude', 'metadata.json'),
+    join(homedir(), '.claude', '.ck.json'),
+    join(homedir(), '.claude', 'metadata.json'),
+  ];
+
+  for (const path of candidates) {
+    if (!existsSync(path)) continue;
+    try {
+      const config = JSON.parse(readFileSync(path, 'utf8'));
+      if (config.kits?.engineer || config.kits?.['ClaudeKit Engineer'] || config.plan) {
+        return 'ClaudeKit';
+      }
+    } catch {
+      // A malformed optional toolkit file must not block gateway installation.
+    }
+  }
+
+  const eccManifest = join(process.cwd(), '.claude', 'plugin.json');
+  if (existsSync(eccManifest)) {
+    try {
+      if (JSON.parse(readFileSync(eccManifest, 'utf8')).name === 'ecc') return 'ECC';
+    } catch {
+      // Keep installation independent from optional local agent configuration.
+    }
+  }
+
+  return null;
+}
+
 /**
  * Claude Code needs ANTHROPIC_AUTH_TOKEN, not ANTHROPIC_API_KEY.
  *
@@ -85,13 +184,21 @@ async function chooseOs(input) {
  * The unset matters: an ANTHROPIC_API_KEY left over from an earlier install keeps
  * shadowing the token, so the fix has to remove it rather than just add the right variable.
  */
-function configLines(apiKey) {
+function configLines(apiKey, pinnedModel) {
   return [
+    'export PATH="$HOME/.local/bin:$PATH"',
     'unset ANTHROPIC_API_KEY',
     `export ANTHROPIC_BASE_URL="${API_ORIGIN}"`,
     `export ANTHROPIC_AUTH_TOKEN="${apiKey}"`,
-    'export ANTHROPIC_MODEL="viro-max"',
-    'export ANTHROPIC_SMALL_FAST_MODEL="viro-speed"',
+    `export VIROUTER_API_KEY="${apiKey}"`,
+    // The model lives in ~/.claude/settings.json so `/model` is remembered. Only when that
+    // file could not be written is it pinned here instead.
+    pinnedModel ? `export ANTHROPIC_MODEL="${pinnedModel}"` : 'unset ANTHROPIC_MODEL',
+    'export ANTHROPIC_SMALL_FAST_MODEL="claude-haiku-4-5"',
+    // Lets Claude Code's /model picker list our models from /v1/models. Nonessential
+    // traffic must stay enabled or discovery is skipped.
+    'export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY="1"',
+    'unset CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC',
   ];
 }
 
@@ -104,15 +211,29 @@ function updateProfile(path, lines) {
   return path;
 }
 
-function configureWindows(apiKey) {
+function configureWindows(apiKey, pinnedModel) {
+  if (!pinnedModel) {
+    // An empty `setx` value is still a variable; delete the old pin outright so `/model` in
+    // ~/.claude/settings.json decides. Absent already is fine.
+    try {
+      execFileSync('reg', ['delete', 'HKCU\\Environment', '/v', 'ANTHROPIC_MODEL', '/f'], { stdio: 'ignore' });
+    } catch {
+      // Nothing to delete.
+    }
+  }
   const values = {
     ANTHROPIC_BASE_URL: API_ORIGIN,
     ANTHROPIC_AUTH_TOKEN: apiKey,
-    ANTHROPIC_MODEL: 'viro-max',
-    ANTHROPIC_SMALL_FAST_MODEL: 'viro-speed',
+    VIROUTER_API_KEY: apiKey,
+    ...(pinnedModel ? { ANTHROPIC_MODEL: pinnedModel } : {}),
+    ANTHROPIC_SMALL_FAST_MODEL: 'claude-haiku-4-5',
+    // Lets Claude Code's /model picker list our models from /v1/models.
+    CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
     // Blanked rather than left alone — see configLines. A value here shadows the token and
     // sends the user round the /login loop. `setx` has no delete, so empty is the removal.
     ANTHROPIC_API_KEY: '',
+    // Discovery is skipped while this is set; clear it.
+    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '',
   };
 
   for (const [name, value] of Object.entries(values)) {
@@ -121,8 +242,57 @@ function configureWindows(apiKey) {
   return 'Windows user environment';
 }
 
-function configureUnix(os, apiKey) {
-  const lines = configLines(apiKey);
+export function mergeEnabledProviders(value) {
+  const enabledProviders = Array.isArray(value)
+    ? value.filter((entry) => typeof entry === 'string')
+    : [];
+  return enabledProviders.includes(OPENCODE_PROVIDER_ID)
+    ? enabledProviders
+    : [...enabledProviders, OPENCODE_PROVIDER_ID];
+}
+
+function configureOpenCode(apiKey, model) {
+  const directory = join(homedir(), '.config', 'opencode');
+  const path = join(directory, 'opencode.json');
+  let config = {};
+
+  if (existsSync(path)) {
+    try {
+      config = JSON.parse(readFileSync(path, 'utf8'));
+    } catch {
+      console.log(`Không tự cập nhật OpenCode vì ${path} không phải JSON thuần (có thể là JSONC).`);
+      console.log('Thêm enabled_providers: ["virouter"] thủ công để ẩn provider khác.');
+      return null;
+    }
+  }
+
+  mkdirSync(directory, { recursive: true });
+  const provider = config.provider && typeof config.provider === 'object' ? config.provider : {};
+  // Keep existing ClaudeKit/ECC/OpenCode providers available. VIROUTER remains the
+  // default provider below, but installing it must not erase the user's setup.
+  config.enabled_providers = mergeEnabledProviders(config.enabled_providers);
+  config.provider = {
+    ...provider,
+    [OPENCODE_PROVIDER_ID]: {
+      ...(provider[OPENCODE_PROVIDER_ID] ?? {}),
+      npm: '@ai-sdk/openai-compatible',
+      name: 'VIROUTER',
+      options: {
+        ...(provider[OPENCODE_PROVIDER_ID]?.options ?? {}),
+        baseURL: `${API_ORIGIN}/v1`,
+        apiKey: '{env:VIROUTER_API_KEY}',
+      },
+      whitelist: VIROUTER_MODELS,
+    },
+  };
+  config.model = `${OPENCODE_PROVIDER_ID}/${model}`;
+  config.small_model = `${OPENCODE_PROVIDER_ID}/claude-haiku-4-5`;
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+  return path;
+}
+
+function configureUnix(os, apiKey, pinnedModel) {
+  const lines = configLines(apiKey, pinnedModel);
   const profiles = os === '2'
     ? [join(homedir(), '.zshrc'), join(homedir(), '.bashrc')]
     : [join(homedir(), '.bashrc'), join(homedir(), '.zshrc')];
@@ -147,6 +317,25 @@ async function validateKey(apiKey) {
   }
 }
 
+function launchClaude(apiKey, pinnedModel) {
+  const env = {
+    ...process.env,
+    ANTHROPIC_BASE_URL: API_ORIGIN,
+    ANTHROPIC_AUTH_TOKEN: apiKey,
+    ANTHROPIC_SMALL_FAST_MODEL: 'claude-haiku-4-5',
+    CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
+  };
+  delete env.ANTHROPIC_API_KEY;
+  // Inherited from an older install's shell, this would override settings.json for this run.
+  if (pinnedModel) env.ANTHROPIC_MODEL = pinnedModel;
+  else delete env.ANTHROPIC_MODEL;
+  execFileSync(process.platform === 'win32' ? 'claude.cmd' : 'claude', [], {
+    env,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+}
+
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -158,16 +347,31 @@ async function main() {
   }
 
   console.log(`\nVIROUTER Claude Code installer\nTarget: ${API_ORIGIN}\n`);
+  const agentToolkit = detectAgentToolkit();
+  if (agentToolkit) {
+    console.log(`Phát hiện ${agentToolkit}. Giữ nguyên skills, rules và hooks hiện có.`);
+  }
   let input;
 
   try {
-    const apiKey = process.env.VIROUTER_API_KEY || await readSecret('Auth Token / API Key: ');
+    const previous = existingConfig();
+    const reuseEnvironmentKey = process.argv.includes('--reuse-key') || !process.stdin.isTTY;
+    const apiKey = reuseEnvironmentKey && process.env.VIROUTER_API_KEY
+      ? process.env.VIROUTER_API_KEY
+      : await readVisibleInput('Auth Token / API Key (sẽ hiển thị khi nhập): ');
     if (!/^viro_[A-Za-z0-9_-]{20,}$/.test(apiKey)) {
       throw new Error('API key không hợp lệ. Key phải bắt đầu bằng viro_.');
     }
 
     input = createInterface({ input: process.stdin, output: process.stdout });
     const os = await chooseOs(input);
+    const keyChanged = previous.key !== null && previous.key !== apiKey;
+    const claudeSettings = readClaudeSettings();
+    // Re-running the installer keeps whatever the customer last picked with /model.
+    const remembered = resolveStartingModel(claudeSettings.settings.model, previous.model);
+    const model = !keyChanged && remembered
+      ? remembered
+      : await chooseModel(input, remembered ?? DEFAULT_MODEL);
     input.close();
     input = undefined;
 
@@ -177,10 +381,30 @@ async function main() {
     }
     if (valid === null) console.log('Không kiểm tra được API lúc này. Vẫn tiếp tục lưu cấu hình.');
 
-    const location = os === '1' ? configureWindows(apiKey) : configureUnix(os, apiKey);
+    // Remember the model in settings.json; pin it in the environment only if that file is not
+    // ours to rewrite (unparseable), since a session with no model at all would be worse.
+    let pinnedModel = null;
+    if (claudeSettings.writable) {
+      writeClaudeSettings(claudeSettings.path, withRememberedModel(claudeSettings.settings, model));
+    } else {
+      pinnedModel = model;
+      console.log(`Không đọc được ${claudeSettings.path} (không phải JSON hợp lệ).`);
+      console.log('Model sẽ cố định qua biến môi trường; /model sẽ không được ghi nhớ giữa các phiên.');
+    }
+
+    const location = os === '1'
+      ? configureWindows(apiKey, pinnedModel)
+      : configureUnix(os, apiKey, pinnedModel);
+    const openCodeConfig = configureOpenCode(apiKey, model);
     console.log(`\nĐã cấu hình Claude Code trong ${location}.`);
-    console.log('Đóng terminal này, mở terminal mới rồi chạy:');
-    console.log('  claude\n');
+    console.log(`Model: ${model}. Đổi bằng /model trong Claude Code — lần mở sau sẽ giữ model đã chọn.`);
+    if (openCodeConfig) console.log(`Đã cấu hình OpenCode chỉ dùng alias VIROUTER trong ${openCodeConfig}.`);
+    if (process.argv.includes('--no-launch')) {
+      console.log('Chạy `claude` trong terminal mới để dùng cấu hình vừa tạo.\n');
+    } else {
+      console.log('\nKhởi chạy Claude Code với VIROUTER...\n');
+      launchClaude(apiKey, pinnedModel);
+    }
   } catch (error) {
     input?.close();
     console.error(`\nLỗi: ${error instanceof Error ? error.message : String(error)}`);
@@ -188,4 +412,6 @@ async function main() {
   }
 }
 
-await main();
+if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) {
+  await main();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "virouter",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "description": "Configure Claude Code to use the VIROUTER API gateway",
   "keywords": ["claude-code", "anthropic", "openai", "api-gateway", "cli"],
   "license": "MIT",
@@ -16,6 +16,7 @@
     "access": "public"
   },
   "scripts": {
-    "typecheck": "node --check bin/virouter.mjs"
+    "typecheck": "node --check bin/virouter.mjs",
+    "test": "node --test test/*.test.mjs"
   }
 }