@timo972/cc-router 0.7.0

package/dist/ui/accountsApi.js

@@ -0,0 +1,48 @@
+/**
+ * Tiny authenticated HTTP client for /cc-router/accounts.
+ *
+ * Used by the Ink dashboard to mutate account settings (enable/disable,
+ * set per-account caps, delete) without exiting the TUI. The `addAccount`
+ * flow is NOT in here — that runs inquirer and must exit Ink first; see
+ * src/cli/cmd-status.ts `runAddAccountFlow`.
+ */
+const REQUEST_TIMEOUT_MS = 3_000;
+export function createAccountsApi(baseUrl, authToken) {
+    const base = baseUrl.replace(/\/+$/, "") + "/cc-router/accounts";
+    const authHeaders = authToken
+        ? { authorization: `Bearer ${authToken}` }
+        : {};
+    async function send(method, path, body) {
+        const res = await fetch(base + path, {
+            method,
+            headers: {
+                ...authHeaders,
+                ...(body !== undefined ? { "content-type": "application/json" } : {}),
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!res.ok) {
+            // Try to surface the server's error message if we can read one
+            let detail = "";
+            try {
+                const data = await res.json();
+                if (data?.error)
+                    detail = `: ${data.error}`;
+            }
+            catch { /* best effort */ }
+            throw new Error(`HTTP ${res.status}${detail}`);
+        }
+    }
+    return {
+        patch(id, patch) {
+            return send("PATCH", `/${encodeURIComponent(id)}`, patch);
+        },
+        setProviderEnabled(provider, enabled) {
+            return send("PATCH", `/providers/${encodeURIComponent(provider)}`, { enabled });
+        },
+        remove(id) {
+            return send("DELETE", `/${encodeURIComponent(id)}`);
+        },
+    };
+}

package/dist/ui/modelsApi.js

@@ -0,0 +1,47 @@
+/**
+ * Authenticated HTTP client for /cc-router/models.
+ *
+ * Used by the dashboard so local and remote client mode can inspect discovered
+ * provider models and change router defaults through the same management API.
+ */
+const REQUEST_TIMEOUT_MS = 5_000;
+export function createModelsApi(baseUrl, authToken) {
+    const endpoint = baseUrl.replace(/\/+$/, "") + "/cc-router/models";
+    const authHeaders = authToken
+        ? { authorization: `Bearer ${authToken}` }
+        : {};
+    async function send(method, body) {
+        const res = await fetch(endpoint, {
+            method,
+            headers: {
+                ...authHeaders,
+                ...(body !== undefined ? { "content-type": "application/json" } : {}),
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!res.ok) {
+            let detail = "";
+            try {
+                const data = await res.json();
+                if (data?.error)
+                    detail = `: ${data.error}`;
+            }
+            catch { /* best effort */ }
+            throw new Error(`HTTP ${res.status}${detail}`);
+        }
+        const data = await res.json();
+        return {
+            routing: data.routing ?? {},
+            models: data.models ?? [],
+        };
+    }
+    return {
+        list() {
+            return send("GET");
+        },
+        setDefaults(patch) {
+            return send("PATCH", patch);
+        },
+    };
+}

package/dist/utils/claude-config.js

@@ -0,0 +1,185 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+import { CLAUDE_SETTINGS_PATH } from "../config/paths.js";
+import { readConfigStrict, writeConfig } from "../config/manager.js";
+const MANAGED_STREAM_IDLE_TIMEOUT_MS = "1800000";
+const MANAGED_STREAM_ENV_KEYS = [
+    "CLAUDE_STREAM_IDLE_TIMEOUT_MS",
+    "CLAUDE_BYTE_STREAM_IDLE_TIMEOUT_MS",
+];
+function captureClaudeEnvBackup(env) {
+    const capture = (key) => {
+        const value = env[key];
+        return typeof value === "string" ? { existed: true, value } : { existed: false };
+    };
+    return {
+        CLAUDE_STREAM_IDLE_TIMEOUT_MS: capture("CLAUDE_STREAM_IDLE_TIMEOUT_MS"),
+        CLAUDE_BYTE_STREAM_IDLE_TIMEOUT_MS: capture("CLAUDE_BYTE_STREAM_IDLE_TIMEOUT_MS"),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateClaudeEnvBackup(config) {
+    const raw = config["claudeEnvBackup"];
+    if (raw === undefined)
+        return undefined;
+    if (!isRecord(raw)) {
+        throw new TypeError("claudeEnvBackup must contain an object");
+    }
+    for (const key of MANAGED_STREAM_ENV_KEYS) {
+        const entry = raw[key];
+        if (!isRecord(entry) || typeof entry["existed"] !== "boolean") {
+            throw new TypeError(`claudeEnvBackup.${key} must contain a boolean existed field`);
+        }
+        if (entry["existed"] === true && typeof entry["value"] !== "string") {
+            throw new TypeError(`claudeEnvBackup.${key}.value must be a string when it existed`);
+        }
+        if (entry["existed"] === false && Object.hasOwn(entry, "value")) {
+            throw new TypeError(`claudeEnvBackup.${key}.value must be absent when it did not exist`);
+        }
+    }
+    return raw;
+}
+function clearClaudeEnvBackup() {
+    const config = readConfigStrict();
+    if (!validateClaudeEnvBackup(config))
+        return;
+    const { claudeEnvBackup: _removed, ...rest } = config;
+    writeConfig(rest);
+}
+function parseClaudeSettings(raw) {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new TypeError(`${CLAUDE_SETTINGS_PATH} must contain a JSON object`);
+    }
+    const settings = parsed;
+    const env = settings["env"];
+    if (env !== undefined && !isRecord(env)) {
+        throw new TypeError(`${CLAUDE_SETTINGS_PATH} env must contain a JSON object`);
+    }
+    return settings;
+}
+function readClaudeSettingsIfPresent() {
+    try {
+        return parseClaudeSettings(readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+}
+/**
+ * Write ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN into ~/.claude/settings.json.
+ *
+ * Rules from official Claude Code docs:
+ *   - ANTHROPIC_AUTH_TOKEN is sent as "Authorization: Bearer <value>"
+ *   - Do NOT append /v1 to ANTHROPIC_BASE_URL — Claude Code adds it automatically
+ *   - Merges with existing settings, preserving all other keys
+ */
+/**
+ * @param port - proxy port (used only when baseUrl is not provided)
+ * @param baseUrl - full proxy URL e.g. "http://192.168.1.50:3456" or "https://cc-router.example.com"
+ *                  If omitted, defaults to http://localhost:<port>
+ * @param authToken - explicit auth token; when omitted, reads proxySecret from config or uses "proxy-managed"
+ * @param defaultModel - optional Claude Code model, e.g. "openai/default"
+ */
+export function writeClaudeSettings(port, baseUrl, authToken, defaultModel) {
+    const existing = readClaudeSettingsIfPresent() ?? {};
+    const existingEnv = existing["env"] ?? {};
+    const config = readConfigStrict();
+    const backup = validateClaudeEnvBackup(config);
+    // Do not create directories or write either user file until all existing
+    // settings and backup state have been read and validated successfully.
+    mkdirSync(dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
+    if (!backup) {
+        config.claudeEnvBackup = captureClaudeEnvBackup(existingEnv);
+        writeConfig(config);
+    }
+    // ANTHROPIC_BASE_URL: no trailing /v1 — Claude Code appends it automatically
+    const resolvedUrl = baseUrl ?? `http://localhost:${port}`;
+    const updated = {
+        ...existing,
+        ...(defaultModel ? { model: defaultModel } : {}),
+        env: {
+            ...existingEnv,
+            ANTHROPIC_BASE_URL: resolvedUrl,
+            // ANTHROPIC_AUTH_TOKEN has higher precedence than ANTHROPIC_API_KEY in Claude Code.
+            // Explicit authToken wins (client mode points at a remote secret); otherwise
+            // uses the local proxy secret, or the open placeholder if neither is set.
+            ANTHROPIC_AUTH_TOKEN: authToken ?? config.proxySecret ?? "proxy-managed",
+            CLAUDE_STREAM_IDLE_TIMEOUT_MS: MANAGED_STREAM_IDLE_TIMEOUT_MS,
+            CLAUDE_BYTE_STREAM_IDLE_TIMEOUT_MS: MANAGED_STREAM_IDLE_TIMEOUT_MS,
+        },
+    };
+    writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(updated, null, 2), "utf-8");
+}
+/**
+ * Remove cc-router settings from ~/.claude/settings.json.
+ * Called when uninstalling cc-router so Claude Code goes back to its default auth.
+ */
+export function removeClaudeSettings() {
+    const config = readConfigStrict();
+    const backup = validateClaudeEnvBackup(config);
+    let rawSettings;
+    try {
+        rawSettings = readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+        clearClaudeEnvBackup();
+        return;
+    }
+    let existing;
+    try {
+        existing = parseClaudeSettings(rawSettings);
+    }
+    catch {
+        // Malformed settings are user-owned. Leave both the file and backup intact.
+        return;
+    }
+    const env = existing["env"];
+    if (env) {
+        delete env["ANTHROPIC_BASE_URL"];
+        delete env["ANTHROPIC_AUTH_TOKEN"];
+        if (backup) {
+            for (const key of MANAGED_STREAM_ENV_KEYS) {
+                if (env[key] !== MANAGED_STREAM_IDLE_TIMEOUT_MS)
+                    continue;
+                const previous = backup[key];
+                if (previous.existed && previous.value !== undefined) {
+                    env[key] = previous.value;
+                }
+                else {
+                    delete env[key];
+                }
+            }
+        }
+        if (Object.keys(env).length === 0)
+            delete existing["env"];
+    }
+    // Persist settings first. If this fails, keep the backup for a retry.
+    writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(existing, null, 2), "utf-8");
+    clearClaudeEnvBackup();
+}
+/** Read current Claude Code proxy settings (for display) */
+export function readClaudeProxySettings() {
+    if (!existsSync(CLAUDE_SETTINGS_PATH))
+        return {};
+    try {
+        const raw = JSON.parse(readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+        const env = raw["env"];
+        if (!env)
+            return {};
+        return {
+            baseUrl: env?.["ANTHROPIC_BASE_URL"],
+            authToken: env?.["ANTHROPIC_AUTH_TOKEN"],
+            model: raw["model"],
+        };
+    }
+    catch {
+        return {};
+    }
+}

package/dist/utils/codex-config.js

@@ -0,0 +1,62 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import os from "os";
+const START = "# cc-router:start";
+const END = "# cc-router:end";
+export function codexBaseUrlFromRouterUrl(remoteUrl) {
+    const base = remoteUrl.trim().replace(/\/+$/, "");
+    return base.endsWith("/v1") ? base : `${base}/v1`;
+}
+function managedBlock(baseUrl, tokenEnvKey, defaultModel) {
+    return [
+        START,
+        ...(defaultModel ? [`model = "${defaultModel}"`] : []),
+        "model_provider = \"cc-router\"",
+        "",
+        "[model_providers.cc-router]",
+        "name = \"CC-Router\"",
+        `base_url = "${baseUrl}"`,
+        "wire_api = \"responses\"",
+        `env_key = "${tokenEnvKey}"`,
+        END,
+    ].join("\n");
+}
+function replaceManagedBlock(existing, block) {
+    const start = existing.indexOf(START);
+    const end = existing.indexOf(END);
+    if (start >= 0 && end >= start) {
+        const before = existing.slice(0, start).trimEnd();
+        const after = existing.slice(end + END.length).trimStart();
+        return [before, block, after].filter(Boolean).join("\n\n") + "\n";
+    }
+    return [existing.trimEnd(), block].filter(Boolean).join("\n\n") + "\n";
+}
+export function writeCodexRouterConfig(opts) {
+    const fs = opts.fs ?? { existsSync, readFileSync, writeFileSync, mkdirSync };
+    const homeDir = opts.homeDir ?? os.homedir();
+    const codexDir = join(homeDir, ".codex");
+    const configPath = join(codexDir, "config.toml");
+    const tokenEnvKey = opts.tokenEnvKey ?? "CC_ROUTER_TOKEN";
+    if (!fs.existsSync(codexDir))
+        fs.mkdirSync(codexDir, { recursive: true });
+    const existing = fs.existsSync(configPath)
+        ? fs.readFileSync(configPath, "utf-8")
+        : "";
+    const next = replaceManagedBlock(existing, managedBlock(opts.baseUrl, tokenEnvKey, opts.defaultModel));
+    fs.writeFileSync(configPath, next, "utf-8");
+    return { path: configPath };
+}
+export function writeCodexRouterConfigFromClient(cfg, opts = {}) {
+    if (!cfg.client?.remoteUrl) {
+        throw new Error("Client mode is not configured. Run: cc-router client connect <url>");
+    }
+    const result = writeCodexRouterConfig({
+        ...opts,
+        baseUrl: codexBaseUrlFromRouterUrl(cfg.client.remoteUrl),
+        tokenEnvKey: "CC_ROUTER_TOKEN",
+    });
+    return {
+        ...result,
+        hasSecret: Boolean(cfg.client.remoteSecret),
+    };
+}

package/dist/utils/network.js

@@ -0,0 +1,16 @@
+import os from "os";
+/** Return non-internal IPv4 addresses (useful for printing server mode instructions). */
+export function getLocalIPs() {
+    const interfaces = os.networkInterfaces();
+    const ips = [];
+    for (const addrs of Object.values(interfaces)) {
+        if (!addrs)
+            continue;
+        for (const addr of addrs) {
+            if (addr.family === "IPv4" && !addr.internal) {
+                ips.push(addr.address);
+            }
+        }
+    }
+    return ips;
+}

package/dist/utils/platform.js

@@ -0,0 +1,13 @@
+export function detectPlatform() {
+    switch (process.platform) {
+        case "darwin": return "macos";
+        case "win32": return "windows";
+        default: return "linux";
+    }
+}
+export function isWindows() {
+    return process.platform === "win32";
+}
+export function isMacos() {
+    return process.platform === "darwin";
+}

package/dist/utils/self-update.js

@@ -0,0 +1,239 @@
+import { spawn, execFileSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, realpathSync } from "fs";
+import { join, resolve } from "path";
+import { createRequire } from "module";
+import chalk from "chalk";
+import { CONFIG_DIR } from "../config/paths.js";
+import { removePid } from "../daemon/pid.js";
+// Single source of truth for the published package name: CLI hints that tell a
+// user what to install must never drift from what self-update actually pulls.
+export const PKG_NAME = "@timo972/cc-router";
+const REGISTRY_URL = `https://registry.npmjs.org/${PKG_NAME}/latest`;
+const CHECK_CACHE_PATH = join(CONFIG_DIR, "update-check.json");
+const LAST_GOOD_PATH = join(CONFIG_DIR, "last-good-version.json");
+const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+// ─── Version helpers ─────────────────────────────────────────────────────────
+// Strict semver. The registry response is untrusted input: it is interpolated
+// into the `npm install @timo972/cc-router@<version>` argument, so any value that is
+// not a clean semver string must be rejected before it reaches a child process.
+const SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+export function isValidVersion(value) {
+    return typeof value === "string" && SEMVER_RE.test(value);
+}
+export function getCurrentVersion() {
+    const require = createRequire(import.meta.url);
+    const pkg = require("../../package.json");
+    return pkg.version;
+}
+/** Simple semver diff: returns "major" | "minor" | "patch" | null */
+function semverDiff(current, latest) {
+    const c = current.split(".").map(Number);
+    const l = latest.split(".").map(Number);
+    if (l[0] > c[0])
+        return "major";
+    if (l[1] > c[1])
+        return "minor";
+    if (l[2] > c[2])
+        return "patch";
+    return null;
+}
+function readCache() {
+    try {
+        if (!existsSync(CHECK_CACHE_PATH))
+            return null;
+        return JSON.parse(readFileSync(CHECK_CACHE_PATH, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(latest) {
+    try {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+        writeFileSync(CHECK_CACHE_PATH, JSON.stringify({ latest, checkedAt: Date.now() }), "utf-8");
+    }
+    catch { /* non-critical */ }
+}
+/** Check npm registry for a newer version. Uses a 6h disk cache. */
+export async function checkForUpdate(force = false) {
+    const current = getCurrentVersion();
+    // Use cache if fresh enough
+    if (!force) {
+        const cached = readCache();
+        if (cached && Date.now() - cached.checkedAt < CHECK_INTERVAL_MS) {
+            const diff = semverDiff(current, cached.latest);
+            return { current, latest: cached.latest, diff, updateAvailable: diff !== null };
+        }
+    }
+    // Fetch from registry
+    try {
+        const res = await fetch(REGISTRY_URL, {
+            signal: AbortSignal.timeout(5_000),
+            headers: { accept: "application/json" },
+        });
+        if (!res.ok)
+            return { current, latest: current, diff: null, updateAvailable: false };
+        const data = (await res.json());
+        // Reject anything that is not a clean semver string — a malicious or
+        // compromised registry response must never flow into the install command.
+        if (!isValidVersion(data.version)) {
+            return { current, latest: current, diff: null, updateAvailable: false };
+        }
+        writeCache(data.version);
+        const diff = semverDiff(current, data.version);
+        return { current, latest: data.version, diff, updateAvailable: diff !== null };
+    }
+    catch {
+        return { current, latest: current, diff: null, updateAvailable: false };
+    }
+}
+// ─── Install prefix detection ────────────────────────────────────────────────
+// Detect from process.argv[1] (the actual script), NOT from `npm config get prefix`
+// which can return a wrong path under nvm/volta/fnm.
+function detectInstallPrefix() {
+    try {
+        const scriptPath = realpathSync(process.argv[1]);
+        // scriptPath is like: /prefix/lib/node_modules/@timo972/cc-router/dist/cli/index.js
+        // We need to walk up to the prefix root. join() normalizes the scope
+        // separator, so the marker matches on Windows backslash paths too.
+        const marker = join("node_modules", PKG_NAME);
+        const idx = scriptPath.indexOf(marker);
+        if (idx !== -1) {
+            // Walk up from .../lib/node_modules/@timo972/cc-router → .../
+            const libDir = scriptPath.slice(0, idx); // .../lib/
+            return resolve(libDir, "..");
+        }
+    }
+    catch { /* fallback */ }
+    // Fallback: ask npm (less reliable but better than nothing)
+    try {
+        return execFileSync("npm", ["config", "get", "prefix"], { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "/usr/local";
+    }
+}
+// ─── Perform update ──────────────────────────────────────────────────────────
+export async function performUpdate(targetVersion) {
+    // Defense in depth: never build an install command from an unvalidated
+    // version, even if a caller bypassed checkForUpdate.
+    if (!isValidVersion(targetVersion)) {
+        console.error(chalk.red(`✗ Refusing to update: "${targetVersion}" is not a valid version`));
+        return false;
+    }
+    const prefix = detectInstallPrefix();
+    console.log(chalk.cyan(`\nUpdating ${PKG_NAME} to v${targetVersion}...`));
+    console.log(chalk.gray(`  prefix: ${prefix}`));
+    return new Promise((resolve) => {
+        // No shell: pass argv directly. On Windows npm is a .cmd shim, so invoke it
+        // by name without shell:true (which would re-parse the joined string through
+        // cmd.exe and turn the version arg into a command-injection sink).
+        const npmBin = process.platform === "win32" ? "npm.cmd" : "npm";
+        const child = spawn(npmBin, ["install", "-g", `${PKG_NAME}@${targetVersion}`, `--prefix=${prefix}`], { stdio: "inherit" });
+        child.on("error", (err) => {
+            console.error(chalk.red(`✗ Update failed: ${err.message}`));
+            resolve(false);
+        });
+        child.on("exit", (code) => {
+            if (code === 0) {
+                console.log(chalk.green(`✓ Updated to v${targetVersion}`));
+                writeLastGood(targetVersion);
+                resolve(true);
+            }
+            else {
+                console.error(chalk.red(`✗ npm install exited with code ${code}`));
+                resolve(false);
+            }
+        });
+    });
+}
+// ─── Restart ─────────────────────────────────────────────────────────────────
+/** Detect if running under an OS-level service manager or PM2. */
+function isRunningAsService() {
+    // Custom env var set by our own service definitions (launchd/systemd)
+    if (process.env["CC_ROUTER_SERVICE"] === "1")
+        return true;
+    // PM2 (legacy — users who haven't migrated yet)
+    if (process.env["PM2_HOME"] || process.env["pm_id"])
+        return true;
+    return false;
+}
+/**
+ * Restart the process.
+ * - Under a service manager (launchd/systemd/PM2) → exit and let the manager restart us.
+ * - Standalone daemon → spawn a replacement, then exit.
+ * - Foreground → spawn a replacement, then exit.
+ */
+export function restartSelf() {
+    if (isRunningAsService()) {
+        console.log(chalk.gray("Restarting via service manager..."));
+        // Clean up PID file before exit
+        removePid();
+        // Exit with non-zero so KeepAlive/Restart=on-failure triggers a restart.
+        // Note: exit(1) is intentional — launchd's SuccessfulExit=false and
+        // systemd's Restart=on-failure both require a non-zero exit to restart.
+        // A cleaner approach (custom exit code or env-based signal) would avoid
+        // polluting logs with "FAILURE" entries, but requires service file changes.
+        process.exit(1);
+        return;
+    }
+    console.log(chalk.gray("Restarting..."));
+    const child = spawn(process.execPath, process.argv.slice(1), {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, CC_ROUTER_UPDATED: "1" },
+    });
+    child.unref();
+    process.exit(0);
+}
+// ─── Last good version (rollback safety) ─────────────────────────────────────
+function writeLastGood(version) {
+    try {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+        writeFileSync(LAST_GOOD_PATH, JSON.stringify({ version, ts: Date.now() }), "utf-8");
+    }
+    catch { /* non-critical */ }
+}
+export function getLastGoodVersion() {
+    try {
+        if (!existsSync(LAST_GOOD_PATH))
+            return null;
+        const data = JSON.parse(readFileSync(LAST_GOOD_PATH, "utf-8"));
+        return data.version;
+    }
+    catch {
+        return null;
+    }
+}
+// ─── High-level: check + update + restart ────────────────────────────────────
+/** Background auto-update check. Only patches/minor. Returns true if update was started. */
+export async function autoUpdateIfAvailable() {
+    const check = await checkForUpdate();
+    if (!check.updateAvailable || check.diff === "major")
+        return false;
+    console.log(chalk.cyan(`\nNew version available: v${check.current} → v${check.latest}`));
+    const ok = await performUpdate(check.latest);
+    if (ok) {
+        restartSelf();
+        return true;
+    }
+    return false;
+}
+// ─── Notification banner (for interactive CLI) ──────────────────────────────
+export function printUpdateBanner(check) {
+    if (!check.updateAvailable)
+        return;
+    const border = "─".repeat(50);
+    console.log();
+    console.log(chalk.yellow(border));
+    console.log(chalk.yellow("  Update available: ") +
+        chalk.gray(`v${check.current}`) +
+        chalk.yellow(" → ") +
+        chalk.green.bold(`v${check.latest}`));
+    console.log(chalk.yellow("  Run: ") +
+        chalk.cyan("cc-router update") +
+        chalk.yellow("  or  ") +
+        chalk.cyan(`npm i -g ${PKG_NAME}@${check.latest}`));
+    console.log(chalk.yellow(border));
+    console.log();
+}