virouter 0.2.3 → 0.2.5

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,43 @@ $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 detects the machine (Windows, macOS, Linux or WSL — it no
+longer asks), checks the key against the gateway and shows it masked with its plan, credit and
+expiry, asks for the default model, and configures:
 
 - `ANTHROPIC_BASE_URL=https://virouter.click`
 - `ANTHROPIC_AUTH_TOKEN`
-- `ANTHROPIC_MODEL=claude-sonnet-5`
+- `model` in `~/.claude/settings.json` — `claude-fable-5-1` on a first install
+- `env.ANTHROPIC_DEFAULT_MODEL` in the same file, so the `/model` picker's "Default" row resolves
+  to a VIROUTER model instead of Claude Code's own default (a choice saved with `/model` still wins)
 - `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 key is visible while you type it; afterwards the installer only ever prints it masked
+(`viro_AbCd…UvWx`). Do not record or share the terminal while typing it.
+
+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.
 
 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

package/bin/virouter.mjs

@@ -1,76 +1,210 @@
 #!/usr/bin/env node
 
 import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { arch, homedir, hostname, release } from 'node:os';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
 
 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.`);
+}
+
+// Colour only on a real terminal, and never when NO_COLOR is set (https://no-color.org).
+const USE_COLOR = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+const paint = (code) => (text) => (USE_COLOR ? `\x1b[${code}m${text}\x1b[0m` : String(text));
+const style = {
+  bold: paint('1'),
+  dim: paint('2'),
+  red: paint('31'),
+  green: paint('32'),
+  yellow: paint('33'),
+  cyan: paint('36'),
+};
+
+/** Enough of the key to recognise it, never enough to use it. */
+export function maskKey(key) {
+  return key.length > 16 ? `${key.slice(0, 9)}…${key.slice(-4)}` : `${key.slice(0, 5)}…`;
 }
 
-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();
+/**
+ * The machine the installer is configuring. Detected rather than asked: picking the wrong
+ * number wrote a shell profile on Windows or `setx` on Linux, and neither failed loudly.
+ */
+export function detectMachine(platform = process.platform) {
+  if (platform === 'win32') return { os: '1', name: 'Windows' };
+  if (platform === 'darwin') return { os: '2', name: 'macOS' };
+  let wsl = false;
+  try {
+    wsl = /microsoft/i.test(readFileSync('/proc/version', 'utf8'));
+  } catch {
+    // Not Linux proper, or /proc is unavailable; plain Linux it is.
   }
+  return { os: '3', name: wsl ? 'Linux (WSL)' : 'Linux' };
+}
 
-  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;
-      }
-    };
+function step(label, detail = '') {
+  console.log(`${style.green('✓')} ${label}${detail ? ` ${style.dim(detail)}` : ''}`);
+}
+
+async function readVisibleInput(prompt) {
+  const line = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  const answer = await line.question(prompt);
+  line.close();
+  return answer.trim();
+}
 
-    process.stdout.write(prompt);
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.on('data', onData);
+async function chooseModel(input, currentModel) {
+  console.log(`\n${style.bold('Model mặc định cho Claude Code')} ${style.dim('(đổi lại bất cứ lúc nào bằng /model)')}`);
+  const defaultIndex = Math.max(0, VIROUTER_MODELS.indexOf(currentModel));
+  VIROUTER_MODELS.forEach((model, index) => {
+    const isDefault = index === defaultIndex;
+    const number = style.cyan(String(index + 1).padStart(2));
+    console.log(`  ${number}  ${isDefault ? style.bold(model) : model}${isDefault ? style.green('  ← mặc định') : ''}`);
   });
+  const answer = (await input.question(`Chọn số ${style.dim(`[${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 };
+  }
 }
 
-async function chooseOs(input) {
-  const answer = (await input.question(`Hệ điều hành [${detectedOs()}]: `)).trim() || detectedOs();
-  if (!['1', '2', '3'].includes(answer)) throw new Error('Chọn 1, 2 hoặc 3.');
-  return answer;
+/**
+ * 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, any ANTHROPIC_MODEL pin removed from `env`, and the
+ * picker's "Default" row pointed at VIROUTER's default.
+ *
+ * `/model` always lists a "Default (recommended)" row that resolves to Claude Code's own
+ * runtime default — a model name this gateway may not serve. ANTHROPIC_DEFAULT_MODEL makes
+ * that row resolve to ours instead ("Set by ANTHROPIC_DEFAULT_MODEL"), and unlike
+ * ANTHROPIC_MODEL it does not override a choice the customer saved with /model.
+ */
+export function withRememberedModel(settings, model) {
+  const currentEnv = settings.env && typeof settings.env === 'object' ? settings.env : {};
+  const { ANTHROPIC_MODEL: _pinned, ...env } = currentEnv;
+  if (!VIROUTER_MODELS.includes(env.ANTHROPIC_DEFAULT_MODEL)) env.ANTHROPIC_DEFAULT_MODEL = DEFAULT_MODEL;
+  return { ...settings, model, env };
+}
+
+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;
 }
 
 /**
@@ -85,12 +219,16 @@ 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="claude-sonnet-5"',
+    `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.
@@ -108,11 +246,21 @@ 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: 'claude-sonnet-5',
+    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',
@@ -129,8 +277,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')];
@@ -139,6 +336,7 @@ function configureUnix(os, apiKey) {
   return profiles.join(' and ');
 }
 
+/** `{ ok: true, me }`, `{ ok: false }` when the gateway rejects the key, or null if unreachable. */
 async function validateKey(apiKey) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), 5000);
@@ -147,7 +345,8 @@ async function validateKey(apiKey) {
       headers: { authorization: `Bearer ${apiKey}` },
       signal: controller.signal,
     });
-    return response.ok;
+    if (!response.ok) return { ok: false };
+    return { ok: true, me: await response.json().catch(() => null) };
   } catch {
     return null;
   } finally {
@@ -155,6 +354,38 @@ async function validateKey(apiKey) {
   }
 }
 
+function describeKey(me) {
+  if (!me || typeof me !== 'object') return '';
+  const parts = [];
+  if (me.planCode) parts.push(`gói ${me.planCode}`);
+  if (typeof me.creditsRemaining === 'number') {
+    parts.push(`còn ${me.creditsRemaining.toLocaleString('vi-VN')} credit`);
+  }
+  if (typeof me.expiresAt === 'number') {
+    parts.push(`hết hạn ${new Date(me.expiresAt * 1000).toLocaleDateString('vi-VN')}`);
+  }
+  return parts.join(' · ');
+}
+
+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, '\\$&');
 }
@@ -165,35 +396,92 @@ async function main() {
     return;
   }
 
-  console.log(`\nVIROUTER Claude Code installer\nTarget: ${API_ORIGIN}\n`);
+  const machine = detectMachine();
+  console.log(`\n${style.bold(style.cyan('VIROUTER'))} ${style.bold('· Claude Code installer')}`);
+  console.log(style.dim(`Gateway  ${API_ORIGIN}`));
+  console.log(style.dim(`Máy      ${machine.name} ${release()} · ${arch()} · ${hostname()}`));
+  console.log('');
+  const agentToolkit = detectAgentToolkit();
+  if (agentToolkit) step(`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(`${style.bold('API key')} ${style.dim('(viro_…, 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_.');
     }
 
+    const checked = await validateKey(apiKey);
+    if (checked && !checked.ok) {
+      throw new Error(`API key bị từ chối bởi ${API_ORIGIN}. Kiểm tra key hoặc VIROUTER_API_ORIGIN.`);
+    }
+    if (checked) step(`Key ${style.bold(maskKey(apiKey))} hợp lệ`, describeKey(checked.me));
+    else console.log(`${style.yellow('!')} Key ${maskKey(apiKey)} — không kiểm tra được lúc này, vẫn lưu cấu hình.`);
+
     input = createInterface({ input: process.stdin, output: process.stdout });
-    const os = await chooseOs(input);
+    const { os } = machine;
+    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;
+    console.log('');
 
-    const valid = await validateKey(apiKey);
-    if (valid === false) {
-      throw new Error(`API key bị từ chối bởi ${API_ORIGIN}. Kiểm tra key hoặc VIROUTER_API_ORIGIN.`);
+    // 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(`${style.yellow('!')} Không đọc được ${claudeSettings.path} (không phải JSON hợp lệ).`);
+      console.log(style.dim('  Model sẽ cố định qua biến môi trường; /model sẽ không được ghi nhớ giữa các phiên.'));
     }
-    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);
-    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');
+    const location = os === '1'
+      ? configureWindows(apiKey, pinnedModel)
+      : configureUnix(os, apiKey, pinnedModel);
+    const openCodeConfig = configureOpenCode(apiKey, model);
+    step('Claude Code', location);
+    step(`Model ${style.bold(model)}`, '— đổi bằng /model, lần mở sau giữ model đã chọn');
+    if (openCodeConfig) step('OpenCode', openCodeConfig);
+    if (process.argv.includes('--no-launch')) {
+      console.log(`\nMở terminal mới rồi chạy ${style.cyan('claude')}.\n`);
+    } else {
+      console.log(`\n${style.cyan('→')} Khở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)}`);
+    console.error(`\n${style.red('Lỗi:')} ${error instanceof Error ? error.message : String(error)}`);
     process.exitCode = 1;
   }
 }
 
-await main();
+/**
+ * True when this file is the program being run, not a module imported by a test.
+ *
+ * `npx` runs the package through a symlink (`node_modules/.bin/virouter`). Node reports that
+ * link in `argv[1]` but loads the real file, so comparing the two raw paths never matched on
+ * macOS and Linux: `npx virouter@latest` installed, printed nothing and exited.
+ */
+export function isMainModule(argv1 = process.argv[1], moduleUrl = import.meta.url) {
+  if (!argv1) return false;
+  try {
+    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  await main();
+}

package/package.json

@@ -1,23 +1,14 @@
 {
   "name": "virouter",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Configure Claude Code to use the VIROUTER API gateway",
-  "keywords": [
-    "claude-code",
-    "anthropic",
-    "openai",
-    "api-gateway",
-    "cli"
-  ],
+  "keywords": ["claude-code", "anthropic", "openai", "api-gateway", "cli"],
   "license": "MIT",
   "type": "module",
   "bin": {
     "virouter": "bin/virouter.mjs"
   },
-  "files": [
-    "bin",
-    "README.md"
-  ],
+  "files": ["bin", "README.md"],
   "engines": {
     "node": ">=20"
   },
@@ -25,6 +16,7 @@
     "access": "public"
   },
   "scripts": {
-    "typecheck": "node --check bin/virouter.mjs"
+    "typecheck": "node --check bin/virouter.mjs",
+    "test": "node --test test/*.test.mjs"
   }
-}
+}