bizrouter 0.1.0

package/dist/commands/setup.js

@@ -0,0 +1,173 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fetchCatalog } from '../api.js';
+import { pickDefaultModel, FALLBACK_DEFAULT } from '../catalog.js';
+import { apiBase, ENV_KEY_NAME } from '../config.js';
+import { claudeEnv } from '../harness/claude.js';
+import { CODEX_PROVIDER_ID } from '../harness/codex.js';
+import { OPENCODE_PROVIDER_ID, opencodeProvider } from '../harness/opencode.js';
+import { c, CliError, info, ok, print, warn } from '../ui.js';
+import { requireApiKey } from './shared.js';
+export function claudeSettingsPath() {
+    return join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'settings.json');
+}
+export function codexConfigPath() {
+    return join(process.env.CODEX_HOME ?? join(homedir(), '.codex'), 'config.toml');
+}
+export function opencodeConfigPath() {
+    const base = process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config');
+    return join(base, 'opencode', 'opencode.json');
+}
+function backup(path) {
+    if (!existsSync(path))
+        return undefined;
+    const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '');
+    const target = `${path}.bak-${stamp}`;
+    copyFileSync(path, target);
+    return target;
+}
+function writeText(path, text) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, text);
+}
+/** Merge BizRouter's env block into a Claude Code settings.json object. */
+export function mergeClaudeSettings(existing, env) {
+    const currentEnv = (existing.env && typeof existing.env === 'object' ? existing.env : {});
+    return { ...existing, env: { ...currentEnv, ...env } };
+}
+/**
+ * Rewrite ~/.codex/config.toml so `codex` alone uses BizRouter: top-level
+ * `model_provider`/`model` are replaced in the preamble (before the first
+ * table header) and a fresh `[model_providers.bizrouter]` block replaces any
+ * previous one. Other tables are left byte-for-byte.
+ */
+export function upsertCodexConfig(text, options) {
+    const lines = text.split(/\r?\n/);
+    const firstHeader = lines.findIndex((l) => /^\s*\[/.test(l));
+    const preambleEnd = firstHeader === -1 ? lines.length : firstHeader;
+    const preamble = lines.slice(0, preambleEnd).filter((l) => !/^\s*(model_provider|model)\s*=/.test(l));
+    const rest = lines.slice(preambleEnd);
+    // Drop an existing [model_providers.bizrouter] table (header through the line before the next header).
+    const cleaned = [];
+    let skipping = false;
+    for (const line of rest) {
+        if (/^\s*\[/.test(line))
+            skipping = new RegExp(`^\\s*\\[model_providers\\.${CODEX_PROVIDER_ID}\\]`).test(line);
+        if (!skipping)
+            cleaned.push(line);
+    }
+    while (cleaned.length && cleaned[cleaned.length - 1]?.trim() === '')
+        cleaned.pop();
+    while (preamble.length && preamble[preamble.length - 1]?.trim() === '')
+        preamble.pop();
+    const block = [
+        `[model_providers.${CODEX_PROVIDER_ID}]`,
+        'name = "BizRouter"',
+        `base_url = "${options.apiBase}/v1"`,
+        `env_key = "${ENV_KEY_NAME}"`,
+        'wire_api = "responses"',
+    ];
+    const out = [
+        ...preamble,
+        `model_provider = "${CODEX_PROVIDER_ID}"`,
+        `model = "${options.model}"`,
+        ...(cleaned.length ? ['', ...cleaned] : []),
+        '',
+        ...block,
+        '',
+    ];
+    return out.join('\n');
+}
+function readJsonObject(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = readFileSync(path, 'utf8');
+    if (!raw.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            throw new Error('object expected');
+        return parsed;
+    }
+    catch {
+        throw new CliError(`${path} 를 JSON 으로 읽을 수 없어 수정하지 않았습니다.`, {
+            hint: '주석이나 문법 오류가 있으면 먼저 정리한 뒤 다시 실행하세요.',
+        });
+    }
+}
+export async function setupCommand(argv) {
+    const [target, ...rest] = argv;
+    const dryRun = rest.includes('--dry-run');
+    const modelFlagIndex = rest.findIndex((a) => a === '--model' || a === '-m');
+    const pinned = modelFlagIndex >= 0 ? rest[modelFlagIndex + 1] : rest.find((a) => a.startsWith('--model='))?.slice(8);
+    const known = ['claude', 'codex', 'opencode'];
+    if (!target || !known.includes(target)) {
+        throw new CliError('설정을 남길 도구를 지정하세요: bizrouter setup <claude|codex|opencode> [--model ID] [--dry-run]', {
+            hint: 'Hermes 는 `bizrouter hermes` 로 실행할 때마다 연결되므로 별도 설정이 없습니다.',
+        });
+    }
+    const apiKey = requireApiKey();
+    const base = apiBase();
+    if (target === 'claude') {
+        const path = claudeSettingsPath();
+        const next = mergeClaudeSettings(readJsonObject(path), claudeEnv({ apiKey, apiBase: base, closedNetwork: false }));
+        const text = `${JSON.stringify(next, null, 2)}\n`;
+        if (dryRun) {
+            print(text);
+            return 0;
+        }
+        const bak = backup(path);
+        writeText(path, text);
+        ok(`${path} 의 env 블록에 BizRouter 설정을 넣었습니다.${bak ? ` (백업: ${bak})` : ''}`);
+        warn('이 파일에는 API 키가 그대로 저장됩니다. 저장소에 커밋되는 프로젝트 .claude/settings.json 이 아니라 사용자 설정이라 안전하지만, 기기를 공유한다면 `bizrouter claude` 실행 방식을 권장합니다.');
+        info('이제 `claude` 만 실행해도 BizRouter 로 연결됩니다. 되돌리려면 백업 파일을 복원하세요.');
+        return 0;
+    }
+    const catalog = await fetchCatalog(apiKey, { allowStale: true }).catch(() => undefined);
+    const models = catalog?.models ?? [];
+    if (target === 'codex') {
+        const model = pinned ?? pickDefaultModel('codex', models) ?? FALLBACK_DEFAULT.codex;
+        const path = codexConfigPath();
+        const current = existsSync(path) ? readFileSync(path, 'utf8') : '';
+        const text = upsertCodexConfig(current, { model, apiBase: base });
+        if (dryRun) {
+            print(text);
+            return 0;
+        }
+        const bak = backup(path);
+        writeText(path, text);
+        ok(`${path} 에 BizRouter provider 를 넣고 기본 모델을 ${model} 로 맞췼습니다.${bak ? ` (백업: ${bak})` : ''}`);
+        printEnvHint();
+        return 0;
+    }
+    const model = pinned ?? pickDefaultModel('opencode', models) ?? FALLBACK_DEFAULT.opencode;
+    const path = opencodeConfigPath();
+    const existing = readJsonObject(path);
+    const provider = (existing.provider && typeof existing.provider === 'object' ? existing.provider : {});
+    const next = {
+        $schema: 'https://opencode.ai/config.json',
+        ...existing,
+        provider: { ...provider, [OPENCODE_PROVIDER_ID]: opencodeProvider(models, undefined, base) },
+        model: `${OPENCODE_PROVIDER_ID}/${model}`,
+    };
+    const text = `${JSON.stringify(next, null, 2)}\n`;
+    if (dryRun) {
+        print(text);
+        return 0;
+    }
+    const bak = backup(path);
+    writeText(path, text);
+    ok(`${path} 에 BizRouter provider(모델 ${Object.keys(next.provider[OPENCODE_PROVIDER_ID]?.models ?? {}).length}개)를 넣고 기본 모델을 ${model} 로 맞췼습니다.${bak ? ` (백업: ${bak})` : ''}`);
+    if (models.length === 0)
+        warn('모델 목록을 가져오지 못해 provider 의 모델 표가 비어 있습니다. 네트워크가 되면 다시 실행하세요.');
+    printEnvHint();
+    return 0;
+}
+function printEnvHint() {
+    print();
+    print(`이 설정은 셸의 ${c.bold(ENV_KEY_NAME)} 환경 변수에서 키를 읽습니다. 셸 프로필(~/.zshrc 등)에 한 줄을 추가하세요:`);
+    print(`  ${c.cyan(`eval "$(bizrouter env)"`)}`);
+    print(c.dim('또는 매번 `bizrouter codex` / `bizrouter opencode` 로 실행하면 이 단계가 필요 없습니다.'));
+}

package/dist/commands/shared.js

@@ -0,0 +1,11 @@
+import { ENV_KEY_NAME, resolveCredential } from '../config.js';
+import { CliError } from '../ui.js';
+export function requireApiKey() {
+    const cred = resolveCredential();
+    if (!cred.apiKey) {
+        throw new CliError('BizRouter API 키가 없습니다.', {
+            hint: `\`bizrouter login\` 으로 키를 저장하거나 ${ENV_KEY_NAME} 환경 변수를 설정하세요.`,
+        });
+    }
+    return cred.apiKey;
+}

package/dist/config.js

@@ -0,0 +1,98 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const DEFAULT_API_BASE = 'https://api.bizrouter.ai';
+export const DEFAULT_CONSOLE_URL = 'https://bizrouter.ai';
+export const KEYS_PAGE_PATH = '/settings/keys';
+export const ENV_KEY_NAME = 'BIZROUTER_API_KEY';
+export const KEY_PREFIX = 'sk-br-';
+export const HARNESSES = ['claude', 'codex', 'opencode', 'hermes'];
+export function configDir() {
+    return process.env.BIZROUTER_CONFIG_DIR ?? join(homedir(), '.bizrouter');
+}
+export function credentialsPath() {
+    return join(configDir(), 'credentials.json');
+}
+export function configPath() {
+    return join(configDir(), 'config.json');
+}
+export function cacheDir() {
+    return join(configDir(), 'cache');
+}
+export function tmpDir() {
+    return join(configDir(), 'tmp');
+}
+function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+export function readJsonFile(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writePrivateJson(path, value) {
+    ensureDir(join(path, '..'));
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // Windows has no POSIX mode bits; the file is still user-private by default.
+    }
+}
+export function loadUserConfig() {
+    return readJsonFile(configPath()) ?? {};
+}
+export function saveUserConfig(config) {
+    writePrivateJson(configPath(), config);
+}
+export function apiBase() {
+    const fromEnv = process.env.BIZROUTER_API_BASE;
+    const base = fromEnv || loadUserConfig().api_base || DEFAULT_API_BASE;
+    return base.replace(/\/+$/, '');
+}
+export function consoleUrl() {
+    const base = process.env.BIZROUTER_CONSOLE_URL || loadUserConfig().console_url || DEFAULT_CONSOLE_URL;
+    return base.replace(/\/+$/, '');
+}
+/** Environment first (CI, containers), then the key saved by `bizrouter login`. */
+export function resolveCredential() {
+    const fromEnv = process.env[ENV_KEY_NAME]?.trim();
+    if (fromEnv)
+        return { apiKey: fromEnv, source: 'env' };
+    const stored = readJsonFile(credentialsPath());
+    if (stored?.api_key)
+        return { apiKey: stored.api_key, source: 'stored', path: credentialsPath() };
+    return { source: 'none' };
+}
+export function saveCredential(apiKey) {
+    const path = credentialsPath();
+    writePrivateJson(path, { api_key: apiKey, saved_at: new Date().toISOString() });
+    return path;
+}
+export function clearCredential() {
+    const path = credentialsPath();
+    if (!existsSync(path))
+        return false;
+    unlinkSync(path);
+    return true;
+}
+export function looksLikeApiKey(value) {
+    return value.startsWith(KEY_PREFIX) && value.length >= 20 && !/\s/.test(value);
+}
+export function ensureTmpDir() {
+    const dir = tmpDir();
+    ensureDir(dir);
+    return dir;
+}
+export function ensureCacheDir() {
+    const dir = cacheDir();
+    ensureDir(dir);
+    return dir;
+}

package/dist/harness/claude.js

@@ -0,0 +1,61 @@
+import { unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { hasFlag } from '../args.js';
+import { isAnthropicModelId } from '../catalog.js';
+import { ensureTmpDir } from '../config.js';
+import { CliError } from '../ui.js';
+/**
+ * Environment Claude Code needs to talk to BizRouter. Mirrors what the
+ * integration guide documents; `ANTHROPIC_API_KEY` must be present and empty
+ * so Claude Code never falls back to a saved claude.ai login.
+ */
+export function claudeEnv(options) {
+    const env = {
+        ANTHROPIC_BASE_URL: `${options.apiBase}/claude`,
+        ANTHROPIC_AUTH_TOKEN: options.apiKey,
+        ANTHROPIC_API_KEY: '',
+        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
+    };
+    if (options.closedNetwork)
+        env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
+    return env;
+}
+export function assertClaudeModel(model) {
+    if (!isAnthropicModelId(model)) {
+        throw new CliError(`Claude Code 는 Claude 모델만 실행할 수 있습니다: ${model}`, {
+            hint: 'Claude Code 는 thinking·cache_control 같은 Anthropic 전용 필드를 항상 보내서 다른 모델은 400 으로 거절됩니다. GPT·Gemini 는 `bizrouter codex` 또는 `bizrouter opencode` 로 실행하세요.',
+        });
+    }
+}
+export function buildClaudePlan(options) {
+    if (options.model)
+        assertClaudeModel(options.model);
+    const env = claudeEnv(options);
+    const args = [];
+    let cleanup;
+    // A user-level settings.json `env` block outranks shell variables, so a
+    // stale ANTHROPIC_BASE_URL there would silently win. The command-line
+    // settings level beats every file, so we hand the same env block over as a
+    // private temp file. The key never appears in the process arguments.
+    if (options.settingsFile !== false && !hasFlag(options.passthrough, '--settings')) {
+        const path = join(ensureTmpDir(), `claude-settings-${process.pid}-${Date.now()}.json`);
+        writeFileSync(path, JSON.stringify({ env }), { mode: 0o600 });
+        args.push('--settings', path);
+        cleanup = () => {
+            try {
+                unlinkSync(path);
+            }
+            catch {
+                // already gone
+            }
+        };
+    }
+    if (options.model && !hasFlag(options.passthrough, '--model'))
+        args.push('--model', options.model);
+    args.push(...options.passthrough);
+    const notes = [
+        `Claude Code → ${env.ANTHROPIC_BASE_URL}` + (options.model ? ` · 모델 ${options.model}` : ' · 모델은 Claude Code 기본값(sonnet/opus 별칭 자동 매핑)'),
+        '`/model` 선택창에 이 키로 쓸 수 있는 Claude 모델이 자동으로 채워집니다.',
+    ];
+    return { bin: 'claude', args, env, notes, cleanup };
+}

package/dist/harness/codex.js

@@ -0,0 +1,45 @@
+import { ENV_KEY_NAME } from '../config.js';
+/** True when a Codex config.toml sets service_tier, which BizRouter rejects as an unpriced tier. */
+export function codexConfigPinsServiceTier(configText) {
+    return /^\s*service_tier\s*=/m.test(configText);
+}
+export const CODEX_PROVIDER_ID = 'bizrouter';
+/** TOML string literal for a `-c key=value` override. */
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Codex reads `~/.codex/config.toml`, but `-c key=value` overrides win over the
+ * file, so the launch never has to edit the user's config. The provider block
+ * is exactly what the integration guide documents for a persistent setup.
+ */
+export function codexOverrides(options) {
+    const overrides = [
+        `model_provider=${tomlString(CODEX_PROVIDER_ID)}`,
+        `model_providers.${CODEX_PROVIDER_ID}.name=${tomlString('BizRouter')}`,
+        `model_providers.${CODEX_PROVIDER_ID}.base_url=${tomlString(`${options.apiBase}/v1`)}`,
+        `model_providers.${CODEX_PROVIDER_ID}.env_key=${tomlString(ENV_KEY_NAME)}`,
+        `model_providers.${CODEX_PROVIDER_ID}.wire_api=${tomlString('responses')}`,
+        `model=${tomlString(options.model)}`,
+    ];
+    if (options.reasoningEffort) {
+        // Codex knows minimal/low/medium/high/xhigh; map the two ends Ori also accepts.
+        const effort = options.reasoningEffort === 'max' ? 'xhigh' : options.reasoningEffort === 'none' ? 'minimal' : options.reasoningEffort;
+        overrides.push(`model_reasoning_effort=${tomlString(effort)}`);
+    }
+    if (options.resetServiceTier)
+        overrides.push(`service_tier=${tomlString('default')}`);
+    return overrides.flatMap((o) => ['-c', o]);
+}
+export function buildCodexPlan(options) {
+    const args = [...codexOverrides(options), ...options.passthrough];
+    return {
+        bin: 'codex',
+        args,
+        env: { [ENV_KEY_NAME]: options.apiKey },
+        notes: [
+            `Codex → ${options.apiBase}/v1 (Responses API) · 모델 ${options.model}` + (options.reasoningEffort ? ` · 추론 강도 ${options.reasoningEffort}` : ''),
+            ...(options.resetServiceTier ? ['config.toml 의 service_tier 는 BizRouter 에 요금 계약이 없어 이번 실행에서는 기본 등급으로 되돌립니다.'] : []),
+        ],
+    };
+}

package/dist/harness/hermes.js

@@ -0,0 +1,27 @@
+const HERMES_SUBCOMMANDS = new Set(['chat']);
+/**
+ * Hermes reaches any OpenAI-compatible endpoint through its `custom` provider,
+ * which reads `CUSTOM_BASE_URL` / `CUSTOM_API_KEY`. `--provider` and `--model`
+ * apply to this invocation only, so the user's config.yaml is left alone.
+ */
+export function hermesArgs(options) {
+    const flags = ['--provider', 'custom', '--model', options.model];
+    const [first, ...rest] = options.passthrough;
+    if (first === undefined)
+        return ['chat', ...flags];
+    if (HERMES_SUBCOMMANDS.has(first))
+        return [first, ...flags, ...rest];
+    // Global flags (e.g. `-z "prompt"`, `--tui`) accept the overrides in front.
+    return [...flags, ...options.passthrough];
+}
+export function buildHermesPlan(options) {
+    return {
+        bin: 'hermes',
+        args: hermesArgs(options),
+        env: {
+            CUSTOM_BASE_URL: `${options.apiBase}/v1`,
+            CUSTOM_API_KEY: options.apiKey,
+        },
+        notes: [`Hermes → custom provider ${options.apiBase}/v1 · 모델 ${options.model}`],
+    };
+}

package/dist/harness/opencode.js

@@ -0,0 +1,55 @@
+import { chatModels } from '../api.js';
+import { ENV_KEY_NAME } from '../config.js';
+export const OPENCODE_PROVIDER_ID = 'bizrouter';
+// The generic OpenAI-compatible provider against /v1 finishes turns cleanly.
+// @bizrouter/ai-sdk-provider over /ai-sdk kept OpenCode looping after the
+// answer (no terminal finish reason) in the 2026-09-06 run, so it is not used.
+export const OPENCODE_PROVIDER_NPM = '@ai-sdk/openai-compatible';
+/**
+ * Provider block for opencode.json. Every chat model the key may use is listed
+ * so the `/models` picker shows the full BizRouter catalog with real context
+ * and output limits instead of a hand-maintained sample.
+ */
+export function opencodeProvider(models, reasoningEffort, apiBase = 'https://api.bizrouter.ai') {
+    const entries = {};
+    for (const m of chatModels(models)) {
+        const entry = {
+            name: m.name,
+            limit: { context: m.context_length, output: m.max_output_tokens },
+        };
+        if (reasoningEffort && m.supported_parameters.includes('reasoning_effort') && !/claude|anthropic/i.test(m.id)) {
+            const effort = reasoningEffort === 'max' ? 'xhigh' : reasoningEffort === 'none' ? 'minimal' : reasoningEffort;
+            entry.options = { reasoningEffort: effort };
+        }
+        entries[m.id] = entry;
+    }
+    return {
+        npm: OPENCODE_PROVIDER_NPM,
+        name: 'BizRouter',
+        options: { baseURL: `${apiBase}/v1`, apiKey: `{env:${ENV_KEY_NAME}}` },
+        models: entries,
+    };
+}
+export function opencodeConfigContent(options) {
+    return JSON.stringify({
+        $schema: 'https://opencode.ai/config.json',
+        provider: { [OPENCODE_PROVIDER_ID]: opencodeProvider(options.models, options.reasoningEffort, options.apiBase) },
+        model: `${OPENCODE_PROVIDER_ID}/${options.model}`,
+    });
+}
+/**
+ * OpenCode merges `OPENCODE_CONFIG_CONTENT` on top of the user's global and
+ * project config, so the BizRouter provider is added for this launch without
+ * touching any file on disk.
+ */
+export function buildOpencodePlan(options) {
+    return {
+        bin: 'opencode',
+        args: [...options.passthrough],
+        env: {
+            [ENV_KEY_NAME]: options.apiKey,
+            OPENCODE_CONFIG_CONTENT: opencodeConfigContent(options),
+        },
+        notes: [`OpenCode → provider "${OPENCODE_PROVIDER_ID}" (${chatModels(options.models).length}개 모델) · 기본 모델 ${options.model}`],
+    };
+}

package/dist/index.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import { fetchCatalog } from './api.js';
+import { ArgError, parseLaunchArgs } from './args.js';
+import { FALLBACK_DEFAULT, pickDefaultModel, suggestModels } from './catalog.js';
+import { authCommand, loginCommand, logoutCommand } from './commands/login.js';
+import { doctorCommand } from './commands/doctor.js';
+import { envCommand, helpText, updateCommand, VERSION } from './commands/misc.js';
+import { modelsCommand } from './commands/models.js';
+import { setupCommand } from './commands/setup.js';
+import { requireApiKey } from './commands/shared.js';
+import { apiBase, loadUserConfig } from './config.js';
+import { buildClaudePlan } from './harness/claude.js';
+import { buildCodexPlan, codexConfigPinsServiceTier } from './harness/codex.js';
+import { codexConfigPath } from './commands/setup.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { buildHermesPlan } from './harness/hermes.js';
+import { buildOpencodePlan } from './harness/opencode.js';
+import { runPlan } from './spawn.js';
+import { CliError, fail, info, maskKey, print, warn } from './ui.js';
+const LAUNCH_HELP = {
+    claude: 'bizrouter claude [--model ID] [--closed-network] [--dry-run] [claude 옵션…]',
+    codex: 'bizrouter codex [--model ID] [--reasoning-effort 단계] [--dry-run] [codex 옵션…]',
+    opencode: 'bizrouter opencode [--model ID] [--reasoning-effort 단계] [--dry-run] [opencode 옵션…]',
+    hermes: 'bizrouter hermes [--model ID] [--dry-run] [hermes 옵션…]',
+};
+async function resolveModel(harness, args, apiKey) {
+    const pinned = args.model ?? loadUserConfig().defaults?.[harness];
+    let models = [];
+    try {
+        models = (await fetchCatalog(apiKey, { allowStale: true })).models;
+    }
+    catch (error) {
+        // A rejected key is fatal for a real launch; a dry run only prints the plan.
+        if (!args.dryRun && error instanceof CliError && /유효하지 않/.test(error.message))
+            throw error;
+        warn(`모델 목록을 가져오지 못해 기본값으로 진행합니다. (${error instanceof Error ? error.message : String(error)})`);
+    }
+    if (pinned) {
+        if (models.length && !models.some((m) => m.id === pinned)) {
+            const suggestions = suggestModels(models, pinned);
+            warn(`「${pinned}」 는 이 키로 쓸 수 있는 모델 목록에 없습니다.${suggestions.length ? ` 비슷한 모델: ${suggestions.join(', ')}` : ''}`);
+            info('그대로 시도합니다. 키의 「API key 사용 범위」나 조직의 모델 정책이 막고 있으면 요청이 거절됩니다.');
+        }
+        return { model: pinned, models };
+    }
+    if (harness === 'claude')
+        return { models };
+    return { model: pickDefaultModel(harness, models) ?? FALLBACK_DEFAULT[harness], models };
+}
+async function launch(harness, argv) {
+    let args;
+    try {
+        args = parseLaunchArgs(argv);
+    }
+    catch (error) {
+        if (error instanceof ArgError)
+            throw new CliError(error.message, { hint: LAUNCH_HELP[harness] });
+        throw error;
+    }
+    if (args.help) {
+        print(LAUNCH_HELP[harness]);
+        print(helpText());
+        return 0;
+    }
+    const apiKey = requireApiKey();
+    const base = apiBase();
+    const { model, models } = await resolveModel(harness, args, apiKey);
+    let plan;
+    switch (harness) {
+        case 'claude':
+            plan = buildClaudePlan({ apiKey, apiBase: base, model, closedNetwork: args.closedNetwork, passthrough: args.passthrough });
+            if (args.reasoningEffort)
+                warn('Claude Code 는 추론 강도를 실행 옵션으로 받지 않습니다. 세션 안에서 /effort 를 사용하세요.');
+            break;
+        case 'codex':
+            plan = buildCodexPlan({
+                apiKey,
+                apiBase: base,
+                model: model ?? FALLBACK_DEFAULT.codex,
+                reasoningEffort: args.reasoningEffort,
+                resetServiceTier: existsSync(codexConfigPath()) && codexConfigPinsServiceTier(readFileSync(codexConfigPath(), 'utf8')),
+                passthrough: args.passthrough,
+            });
+            if (args.closedNetwork)
+                warn('--closed-network 는 Claude Code 전용 옵션입니다.');
+            break;
+        case 'opencode':
+            plan = buildOpencodePlan({ apiKey, apiBase: base, model: model ?? FALLBACK_DEFAULT.opencode, models, reasoningEffort: args.reasoningEffort, passthrough: args.passthrough });
+            if (args.closedNetwork)
+                warn('--closed-network 는 Claude Code 전용 옵션입니다.');
+            break;
+        case 'hermes':
+            plan = buildHermesPlan({ apiKey, apiBase: base, model: model ?? FALLBACK_DEFAULT.hermes, passthrough: args.passthrough });
+            if (args.reasoningEffort)
+                warn('Hermes 는 추론 강도 옵션을 받지 않습니다.');
+            break;
+    }
+    if (!args.dryRun)
+        for (const note of plan.notes ?? [])
+            info(note);
+    return runPlan(plan, { dryRun: args.dryRun, maskValue: maskKey });
+}
+async function main(argv) {
+    const [command, ...rest] = argv;
+    switch (command) {
+        case undefined:
+        case 'help':
+        case '--help':
+        case '-h':
+            print(helpText());
+            return 0;
+        case '--version':
+        case '-v':
+        case 'version':
+            print(VERSION);
+            return 0;
+        case 'login':
+            return loginCommand(rest);
+        case 'auth':
+            return authCommand();
+        case 'logout':
+            return logoutCommand();
+        case 'models':
+            return modelsCommand(rest);
+        case 'setup':
+            return setupCommand(rest);
+        case 'doctor':
+            return doctorCommand();
+        case 'env':
+            return envCommand();
+        case 'update':
+            return updateCommand();
+        case 'claude':
+        case 'codex':
+        case 'opencode':
+        case 'hermes':
+            return launch(command, rest);
+        default:
+            throw new CliError(`알 수 없는 명령입니다: ${command}`, { hint: '`bizrouter help` 로 전체 명령을 볼 수 있습니다.' });
+    }
+}
+main(process.argv.slice(2))
+    .then((code) => {
+    process.exitCode = code;
+})
+    .catch((error) => {
+    if (error instanceof CliError) {
+        fail(error.message);
+        if (error.hint)
+            info(error.hint);
+        process.exitCode = error.exitCode;
+        return;
+    }
+    fail(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/prompt.js

@@ -0,0 +1,36 @@
+import { createInterface } from 'node:readline';
+import { Writable } from 'node:stream';
+/** Read one line from stdin without echoing it (for API keys). */
+export function readSecret(promptText) {
+    if (!process.stdin.isTTY) {
+        return new Promise((resolve) => {
+            let data = '';
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', (chunk) => (data += chunk));
+            process.stdin.on('end', () => resolve(data.trim()));
+        });
+    }
+    return new Promise((resolve) => {
+        const muted = new Writable({
+            write(_chunk, _encoding, callback) {
+                callback();
+            },
+        });
+        process.stderr.write(promptText);
+        const rl = createInterface({ input: process.stdin, output: muted, terminal: true });
+        rl.question('', (answer) => {
+            rl.close();
+            process.stderr.write('\n');
+            resolve(answer.trim());
+        });
+    });
+}
+export function readLine(promptText) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        rl.question(promptText, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}