@rabbi696/ezrouter 0.6.14 → 0.6.15

package/node_modules/confbox/dist/json5.d.mts

@@ -0,0 +1,59 @@
+import { t as FormatOptions } from "./_chunks/_format.mjs";
+
+//#region src/json5.d.ts
+/**
+ * Converts a [JSON5](https://json5.org/) string into an object.
+ *
+ * @template T The type of the return value.
+ * @param text The string to parse as JSON5.
+ * @param options Parsing options.
+ * @returns The JavaScript value converted from the JSON5 string.
+ */
+declare function parseJSON5<T = unknown>(text: string, options?: JSON5ParseOptions): T;
+/**
+ * Converts a JavaScript value to a [JSON5](https://json5.org/) string.
+ *
+ * @param value
+ * @param options
+ * @returns The JSON string converted from the JavaScript value.
+ */
+declare function stringifyJSON5(value: any, options?: JSON5StringifyOptions): string;
+interface JSON5ParseOptions extends FormatOptions {
+  /**
+   * A function that alters the behavior of the parsing process, or an array of
+   * String and Number objects that serve as a allowlist for selecting/filtering
+   * the properties of the value object to be included in the resulting
+   * JavaScript object. If this value is null or not provided, all properties of
+   * the object are included in the resulting JavaScript object.
+   */
+  reviver?: (this: any, key: string, value: any) => any;
+}
+interface JSON5StringifyOptions extends FormatOptions {
+  /**
+   * A function that alters the behavior of the stringification process, or an
+   * array of String and Number objects that serve as a allowlist for
+   * selecting/filtering the properties of the value object to be included in
+   * the JSON5 string. If this value is null or not provided, all properties
+   * of the object are included in the resulting JSON5 string.
+   */
+  replacer?: ((this: any, key: string, value: any) => any) | null;
+  /**
+   * A String or Number object that's used to insert white space into the
+   * output JSON5 string for readability purposes. If this is a Number, it
+   * indicates the number of space characters to use as white space; this
+   * number is capped at 10 (if it is greater, the value is just 10). Values
+   * less than 1 indicate that no space should be used. If this is a String,
+   * the string (or the first 10 characters of the string, if it's longer than
+   * that) is used as white space. If this parameter is not provided (or is
+   * null), no white space is used. If white space is used, trailing commas
+   * will be used in objects and arrays.
+   */
+  space?: string | number | null;
+  /**
+   * A String representing the quote character to use when serializing
+   * strings.
+   */
+  quote?: string | null;
+}
+//#endregion
+export { JSON5ParseOptions, JSON5StringifyOptions, parseJSON5, stringifyJSON5 };

package/node_modules/confbox/dist/json5.mjs

@@ -0,0 +1 @@
+import{n as e}from"./_chunks/rolldown-runtime.mjs";import{n as t,t as n}from"./_chunks/_format.mjs";import{n as r,t as i}from"./_chunks/libs/json5.mjs";var a=e(r(),1),o=e(i(),1);function s(e,n){let r=(0,a.default)(e,n?.reviver);return t(e,r,n),r}function c(e,t){let r=n(e,t),i=(0,o.default)(e,t?.replacer,r.indent);return r.whitespace.start+i+r.whitespace.end}export{s as parseJSON5,c as stringifyJSON5};

package/node_modules/confbox/dist/jsonc.d.mts

@@ -0,0 +1,41 @@
+import { t as FormatOptions } from "./_chunks/_format.mjs";
+
+//#region src/jsonc.d.ts
+/**
+ *
+ * Converts a [JSONC](https://github.com/microsoft/node-jsonc-parser) string into an object.
+ *
+ * @NOTE On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ *
+ * @NOTE Comments and trailing commas are not preserved after parsing.
+ *
+ * @template T The type of the return value.
+ * @param text The string to parse as JSONC.
+ * @param options Parsing options.
+ * @returns The JavaScript value converted from the JSONC string.
+ */
+declare function parseJSONC<T = unknown>(text: string, options?: JSONCParseOptions): T;
+/**
+ * Converts a JavaScript value to a [JSONC](https://github.com/microsoft/node-jsonc-parser) string.
+ *
+ * @NOTE Comments and trailing commas are not preserved in the output.
+ *
+ * @param value
+ * @param options
+ * @returns The JSON string converted from the JavaScript value.
+ */
+declare function stringifyJSONC(value: any, options?: JSONCStringifyOptions): string;
+interface JSONCParseOptions extends FormatOptions {
+  disallowComments?: boolean;
+  allowTrailingComma?: boolean;
+  allowEmptyContent?: boolean;
+  errors?: JSONCParseError[];
+}
+interface JSONCStringifyOptions extends FormatOptions {}
+interface JSONCParseError {
+  error: number;
+  offset: number;
+  length: number;
+}
+//#endregion
+export { JSONCParseError, JSONCParseOptions, JSONCStringifyOptions, parseJSONC, stringifyJSONC };

package/node_modules/confbox/dist/jsonc.mjs

@@ -0,0 +1 @@
+import{n as e}from"./_chunks/_format.mjs";import{t}from"./_chunks/libs/jsonc-parser.mjs";import{n}from"./_chunks/json.mjs";function r(n,r){let i=t(n,r?.errors,r);return e(n,i,r),i}function i(e,t){return n(e,t)}export{r as parseJSONC,i as stringifyJSONC};

package/node_modules/confbox/dist/toml.d.mts

@@ -0,0 +1,23 @@
+//#region src/toml.d.ts
+/**
+ * Converts a [TOML](https://toml.io/) string into an object.
+ *
+ * @NOTE Comments and indentation is not preserved after parsing.
+ *
+ * @template T The type of the return value.
+ * @param text The TOML string to parse.
+ * @returns The JavaScript value converted from the TOML string.
+ */
+declare function parseTOML<T = unknown>(text: string): T;
+/**
+ * Converts a JavaScript value to a [TOML](https://toml.io/) string.
+ *
+ * @NOTE Comments and indentation is not preserved in the output.
+ *
+ * @param value
+ * @param options
+ * @returns The YAML string converted from the JavaScript value.
+ */
+declare function stringifyTOML(value: any): string;
+//#endregion
+export { parseTOML, stringifyTOML };

package/node_modules/confbox/dist/toml.mjs

@@ -0,0 +1 @@
+import{n as e,t}from"./_chunks/_format.mjs";import{n,t as r}from"./_chunks/libs/smol-toml.mjs";function i(t){let r=n(t);return e(t,r,{preserveIndentation:!1}),r}function a(e){let n=t(e,{preserveIndentation:!1}),i=r(e);return n.whitespace.start+i+n.whitespace.end}export{i as parseTOML,a as stringifyTOML};

package/node_modules/confbox/dist/yaml.d.mts

@@ -0,0 +1,96 @@
+import { t as FormatOptions } from "./_chunks/_format.mjs";
+
+//#region src/yaml.d.ts
+/**
+ * Converts a [YAML](https://yaml.org/) string into an object.
+ *
+ * @NOTE This function does **not** understand multi-document sources, it throws exception on those.
+ *
+ * @NOTE Comments are not preserved after parsing.
+ *
+ * @NOTE This function does **not** support schema-specific tag resolution restrictions.
+ * So, the JSON schema is not as strictly defined in the YAML specification.
+ * It allows numbers in any notation, use `Null` and `NULL` as `null`, etc.
+ * The core schema also has no such restrictions. It allows binary notation for integers.
+ *
+ * @template T The type of the return value.
+ * @param text The YAML string to parse.
+ * @param options Parsing options.
+ * @returns The JavaScript value converted from the YAML string.
+ */
+declare function parseYAML<T = unknown>(text: string, options?: YAMLParseOptions): T;
+/**
+ * Converts a JavaScript value to a [YAML](https://yaml.org/) string.
+ *
+ * @NOTE Comments are not preserved in the output.
+ *
+ * @param value
+ * @param options
+ * @returns The YAML string converted from the JavaScript value.
+ */
+declare function stringifyYAML(value: any, options?: YAMLStringifyOptions): string;
+interface YAMLParseOptions extends FormatOptions {
+  /** string to be used as a file path in error/warning messages. */
+  filename?: string | undefined;
+  /** function to call on warning messages. */
+  onWarning?(this: null, e: YAMLException): void;
+  /** specifies a schema to use. */
+  schema?: any | undefined;
+  /** compatibility with JSON.parse behaviour. */
+  json?: boolean | undefined;
+  /** listener for parse events */
+  listener?(this: any, eventType: any, state: any): void;
+}
+interface YAMLStringifyOptions extends FormatOptions {
+  /** indentation width to use (in spaces). */
+  indent?: number | undefined;
+  /** when true, will not add an indentation level to array elements */
+  noArrayIndent?: boolean | undefined;
+  /** do not throw on invalid types (like function in the safe schema) and skip pairs and single values with such types. */
+  skipInvalid?: boolean | undefined;
+  /** specifies level of nesting, when to switch from block to flow style for collections. -1 means block style everwhere */
+  flowLevel?: number | undefined;
+  /** Each tag may have own set of styles.    - "tag" => "style" map. */
+  styles?: {
+    [x: string]: any;
+  } | undefined;
+  /** specifies a schema to use. */
+  schema?: any | undefined;
+  /** if true, sort keys when dumping YAML. If a function, use the function to sort the keys. (default: false) */
+  sortKeys?: boolean | ((a: any, b: any) => number) | undefined;
+  /** set max line width. (default: 80) */
+  lineWidth?: number | undefined;
+  /** if true, don't convert duplicate objects into references (default: false) */
+  noRefs?: boolean | undefined;
+  /** if true don't try to be compatible with older yaml versions. Currently: don't quote "yes", "no" and so on, as required for YAML 1.1 (default: false) */
+  noCompatMode?: boolean | undefined;
+  /**
+   * if true flow sequences will be condensed, omitting the space between `key: value` or `a, b`. Eg. `'[a,b]'` or `{a:{b:c}}`.
+   * Can be useful when using yaml for pretty URL query params as spaces are %-encoded. (default: false).
+   */
+  condenseFlow?: boolean | undefined;
+  /** strings will be quoted using this quoting style. If you specify single quotes, double quotes will still be used for non-printable characters. (default: `'`) */
+  quotingType?: "'" | '"' | undefined;
+  /** if true, all non-key strings will be quoted even if they normally don't need to. (default: false) */
+  forceQuotes?: boolean | undefined;
+  /** callback `function (key, value)` called recursively on each key/value in source object (see `replacer` docs for `JSON.stringify`). */
+  replacer?: ((key: string, value: any) => any) | undefined;
+}
+interface Mark {
+  buffer: string;
+  column: number;
+  line: number;
+  name: string;
+  position: number;
+  snippet: string;
+}
+declare class YAMLException extends Error {
+  constructor(reason?: string, mark?: Mark);
+  toString(compact?: boolean): string;
+  name: string;
+  reason: string;
+  message: string;
+  mark: Mark;
+}
+//#endregion
+export { YAMLParseOptions, YAMLStringifyOptions, parseYAML, stringifyYAML };

package/node_modules/confbox/dist/yaml.mjs

@@ -0,0 +1 @@
+import{n as e,t}from"./_chunks/_format.mjs";import{n,t as r}from"./_chunks/libs/js-yaml.mjs";function i(t,r){let i=n(t,r);return e(t,i,r),i}function a(e,n){let i=t(e,{preserveIndentation:!1}),a=r(e,{indent:typeof i.indent==`string`?i.indent.length:i.indent,...n});return i.whitespace.start+a.trim()+i.whitespace.end}export{i as parseYAML,a as stringifyYAML};

package/node_modules/confbox/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "confbox",
+  "version": "0.2.4",
+  "description": "Compact YAML, TOML, JSONC, JSON5 and INI parser and serializer",
+  "keywords": [
+    "config",
+    "ini",
+    "json5",
+    "jsonc",
+    "toml",
+    "unjs",
+    "yaml"
+  ],
+  "license": "MIT",
+  "repository": "unjs/confbox",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./ini": "./dist/ini.mjs",
+    "./json5": "./dist/json5.mjs",
+    "./jsonc": "./dist/jsonc.mjs",
+    "./toml": "./dist/toml.mjs",
+    "./yaml": "./dist/yaml.mjs"
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev --coverage",
+    "bench": "pnpm build && node test/bench.mjs",
+    "lint": "oxlint && oxfmt --check src test",
+    "lint:fix": "oxlint --fix && oxfmt src test",
+    "prepack": "pnpm build",
+    "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && pnpm test:types && vitest run --coverage",
+    "test:types": "tsgo --noEmit --skipLibCheck"
+  },
+  "devDependencies": {
+    "@types/ini": "^4.1.1",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.2.1",
+    "@typescript/native-preview": "7.0.0-dev.20260206.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "automd": "^0.4.3",
+    "changelogen": "^0.6.2",
+    "detect-indent": "^7.0.2",
+    "ini": "^6.0.0",
+    "jiti": "^2.6.1",
+    "js-toml": "^1.0.2",
+    "js-yaml": "^4.1.1",
+    "json5": "^2.2.3",
+    "jsonc-parser": "^3.3.1",
+    "mitata": "^1.0.34",
+    "obuild": "^0.4.26",
+    "oxfmt": "^0.28.0",
+    "oxlint": "^1.43.0",
+    "smol-toml": "^1.6.0",
+    "toml": "^3.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "yaml": "^2.8.2"
+  },
+  "packageManager": "pnpm@10.28.2"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabbi696/ezrouter",
-  "version": "0.6.14",
+  "version": "0.6.15",
   "description": "EzRouter CLI - Start and manage EzRouter server (default port 20126)",
   "bin": {
     "ezrouter": "./cli.js",
@@ -19,7 +19,8 @@
     "node-forge",
     "node-machine-id",
     "react",
-    "react-dom"
+    "react-dom",
+    "confbox"
   ],
   "scripts": {
     "dev": "nodemon -I --watch cli.js --watch src --watch hooks --ext js,json cli.js",
@@ -37,7 +38,8 @@
     "node-forge": "^1.3.3",
     "node-machine-id": "^1.1.12",
     "react": "19.2.1",
-    "react-dom": "19.2.1"
+    "react-dom": "19.2.1",
+    "confbox": "^0.2.4"
   },
   "comment_sqlite": "sql.js + better-sqlite3 are NOT bundled here. They are installed into ~/.ezrouter/runtime/node_modules by hooks/postinstall.js (and re-checked at runtime by cli.js). This avoids Windows EBUSY errors when updating the global CLI, since native .node files no longer live under the locked install dir.",
   "comment_systray": "systray2 is NOT bundled here. It is lazy-installed into ~/.ezrouter/runtime/node_modules by hooks/postinstall.js on macOS/Linux only. Windows uses PowerShell NotifyIcon (zero binary). This avoids shipping unsigned Go binaries that trigger antivirus false positives (Kaspersky). We use the systray2 fork because the legacy systray@1.0.5 ships a 2017 x86_64 binary that fails on modern macOS dyld.",

package/src/cli/commands/connect.js

@@ -0,0 +1,269 @@
+/**
+ * `ezrouter connect <server-url>` — point local CLI tools (Claude Code, Codex, …) at a
+ * REMOTE EzRouter server. Nothing runs locally: we log in with the dashboard
+ * password, reuse/create an API key for this machine, then write the tool's
+ * settings files (see connectTools.js). Works via `npx @rabbi696/ezrouter connect …` with no global install.
+ *
+ * The password and API key are never printed (key is masked).
+ */
+
+const os = require("os");
+const { TOOL_IDS, CLAUDE_MODELS, resolveTools } = require("./connectTools");
+
+const DEFAULT_MODEL = "cc/claude-sonnet-5";
+
+const HELP = `
+Usage: ezrouter connect <server-url> [options]
+
+Configure CLI tools on THIS machine to use a remote EzRouter server.
+No local server is started. Run without installing:
+
+  npx @rabbi696/ezrouter connect http://<server-host>:20126
+  npx @rabbi696/ezrouter connect http://<server-host>:20126 --tools claude,codex,opencode
+
+Options:
+  --tools <list>         Comma-separated tools to configure (prompted if omitted
+                         in a terminal; default: claude). Supported:
+                         ${TOOL_IDS.join(", ")}, all
+  --password <pw>        Dashboard password (or env EZROUTER_PASSWORD / NINE_ROUTER_PASSWORD;
+                         prompted if omitted — preferred, keeps it out of shell history)
+  --key-name <name>      API key name to reuse/create (default: cli-<hostname>)
+  --api-key <key>        Use this API key, skip login + key lookup
+  --model <model>        Model for non-Claude tools (default: ${DEFAULT_MODEL})
+  --fable|--opus|--sonnet|--haiku <model>
+                         Override Claude Code model mapping
+  --print-env            Also print OpenAI-compatible env vars for other CLIs
+  --reset                Remove EzRouter settings from the selected tools and exit
+  -h, --help             Show this help
+`;
+
+function parseArgs(argv) {
+  const opts = {
+    password: process.env.EZROUTER_PASSWORD || process.env.NINE_ROUTER_PASSWORD || null,
+    keyName: `cli-${os.hostname()}`.slice(0, 64),
+    apiKey: null,
+    models: {},
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => {
+      const v = argv[++i];
+      if (v === undefined) throw new Error(`Missing value for ${a}`);
+      return v;
+    };
+    if (a === "--password") opts.password = next();
+    else if (a === "--key-name") opts.keyName = next();
+    else if (a === "--api-key") opts.apiKey = next();
+    else if (a === "--tools") opts.tools = next().split(",");
+    else if (a === "--model") opts.model = next();
+    else if (a === "--print-env") opts.printEnv = true;
+    else if (a === "--reset") opts.reset = true;
+    else if (a === "-h" || a === "--help") opts.help = true;
+    else if (a.startsWith("--") && CLAUDE_MODELS.some((m) => `--${m.flag}` === a)) opts.models[a.slice(2)] = next();
+    else if (!a.startsWith("-") && !opts.url) opts.url = a;
+    else throw new Error(`Unknown option: ${a}`);
+  }
+  return opts;
+}
+
+function normalizeServerUrl(input) {
+  let raw = String(input || "").trim();
+  if (!/^https?:\/\//i.test(raw)) raw = `http://${raw}`;
+  const u = new URL(raw);
+  // Accept pasted dashboard/API URLs: keep only origin.
+  return u.origin;
+}
+
+function maskKey(key) {
+  if (!key || key.length < 12) return "****";
+  return `${key.slice(0, 6)}…${key.slice(-4)}`;
+}
+
+// Enquirer rejects with an empty value on Ctrl+C / Esc.
+class Cancelled extends Error {}
+const prompt = (p) => p.run().catch((err) => { throw err || new Cancelled("Cancelled"); });
+
+async function promptPassword() {
+  if (!process.stdin.isTTY) throw new Error("Password required: pass --password or set EZROUTER_PASSWORD");
+  const { Password } = require("enquirer");
+  return prompt(new Password({ message: "EzRouter dashboard password" }));
+}
+
+async function request(url, { method = "GET", body, cookie, apiKey } = {}) {
+  const headers = { Accept: "application/json" };
+  if (body) headers["Content-Type"] = "application/json";
+  if (cookie) headers.Cookie = cookie;
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  let res;
+  try {
+    res = await fetch(url, { method, headers, body: body ? JSON.stringify(body) : undefined, redirect: "manual" });
+  } catch (err) {
+    throw new Error(`Cannot reach ${new URL(url).origin}: ${err.cause?.code || err.message}`);
+  }
+  let data = null;
+  try { data = await res.json(); } catch { /* non-JSON */ }
+  // Server-controlled strings get printed later — strip control chars (terminal escape injection).
+  if (typeof data?.error === "string") data.error = data.error.replace(/[\x00-\x1f\x7f]/g, "");
+  return { status: res.status, headers: res.headers, data };
+}
+
+function extractAuthCookie(headers) {
+  const list = typeof headers.getSetCookie === "function" ? headers.getSetCookie() : [headers.get("set-cookie") || ""];
+  for (const c of list) {
+    const m = /(?:^|,\s*)auth_token=([^;]+)/.exec(c);
+    if (m) return `auth_token=${m[1]}`;
+  }
+  return null;
+}
+
+async function login(server, password) {
+  const res = await request(`${server}/api/auth/login`, { method: "POST", body: { password } });
+  if (res.status === 200 && res.data?.success) {
+    const cookie = extractAuthCookie(res.headers);
+    if (!cookie) throw new Error("Login succeeded but server returned no session cookie");
+    return cookie;
+  }
+  throw new Error(`Login failed (${res.status}): ${res.data?.error || "unknown error"}`);
+}
+
+async function getOrCreateApiKey(server, cookie, keyName) {
+  const list = await request(`${server}/api/keys`, { cookie });
+  if (list.status === 401) throw new Error("Unauthorized listing API keys — wrong password or session rejected");
+  if (list.status !== 200) throw new Error(`Failed to list API keys (${list.status}): ${list.data?.error || ""}`);
+  const keys = (list.data?.keys || []).filter((k) => k.isActive !== false);
+  const existing = keys.find((k) => k.name === keyName);
+  if (existing) return { key: existing.key, created: false };
+
+  const created = await request(`${server}/api/keys`, { method: "POST", cookie, body: { name: keyName } });
+  if (created.status !== 201 || !created.data?.key) {
+    throw new Error(`Failed to create API key (${created.status}): ${created.data?.error || ""}`);
+  }
+  return { key: created.data.key, created: true };
+}
+
+async function listModels(server, apiKey) {
+  const res = await request(`${server}/v1/models`, { apiKey });
+  if (res.status === 401) throw new Error("API key rejected by server (/v1/models returned 401)");
+  if (res.status !== 200) return null;
+  return new Set((res.data?.data || []).map((m) => m.id));
+}
+
+async function promptTools() {
+  const { MultiSelect } = require("enquirer");
+  const { TOOLS } = require("./connectTools");
+  return prompt(new MultiSelect({
+    message: "Select CLI tools to configure (space to toggle, enter to confirm)",
+    choices: TOOLS.map((t) => ({ name: t.id, message: t.name, hint: t.paths()[0], enabled: t.id === "claude" })),
+    validate: (v) => v.length > 0 || "Select at least one tool",
+  }));
+}
+
+async function selectTools(opts) {
+  if (opts.tools) return resolveTools(opts.tools);
+  if (process.stdin.isTTY) return resolveTools(await promptTools());
+  return resolveTools(["claude"]);
+}
+
+async function run(argv) {
+  try {
+    return await runConnect(argv);
+  } catch (err) {
+    if (err instanceof Cancelled) {
+      console.log("Cancelled.");
+      return 130;
+    }
+    throw err;
+  }
+}
+
+async function runConnect(argv) {
+  const opts = parseArgs(argv);
+  if (opts.help) {
+    console.log(HELP);
+    return 0;
+  }
+  if (!opts.reset && !opts.url) {
+    console.log(HELP);
+    return 1;
+  }
+
+  // Pick tools before any network call: bad names fail fast, and cancelling
+  // the picker never leaves a freshly created key on the server.
+  const tools = await selectTools(opts);
+
+  if (opts.reset) {
+    let failed = 0;
+    for (const t of tools) {
+      try {
+        const files = await t.reset();
+        console.log(files.length ? `✅ ${t.name}: removed EzRouter settings (${files.join(", ")})` : `• ${t.name}: nothing to reset`);
+      } catch (err) {
+        failed++;
+        console.log(`❌ ${t.name}: ${err.message}`);
+      }
+    }
+    return failed ? 1 : 0;
+  }
+
+  const server = normalizeServerUrl(opts.url);
+  const isRemoteHttp = server.startsWith("http://") && !/^http:\/\/(localhost|127\.0\.0\.1|\[::1\])(:|$)/.test(server);
+  if (isRemoteHttp) {
+    console.log("\x1b[33m⚠ Plain HTTP: password and API key travel unencrypted. Use only on a trusted LAN/VPN.\x1b[0m");
+  }
+
+  let apiKey = opts.apiKey;
+  if (apiKey) {
+    console.log("• Using provided API key");
+  } else {
+    const password = opts.password ?? (await promptPassword());
+    console.log(`• Logging in to ${server}`);
+    const cookie = await login(server, password);
+    const result = await getOrCreateApiKey(server, cookie, opts.keyName);
+    apiKey = result.key;
+    console.log(`• ${result.created ? "Created" : "Reusing"} API key "${opts.keyName}" (${maskKey(apiKey)})`);
+  }
+
+  const available = await listModels(server, apiKey);
+  const warnMissing = (label, model, flag) => {
+    if (available && !available.has(model)) {
+      console.log(`\x1b[33m⚠ ${label}: "${model}" not listed by server — override with ${flag} <model>\x1b[0m`);
+    }
+  };
+
+  const claudeModels = {};
+  if (tools.some((t) => t.id === "claude")) {
+    for (const m of CLAUDE_MODELS) {
+      claudeModels[m.envKey] = opts.models[m.flag] || m.defaultValue;
+      warnMissing(`claude ${m.flag}`, claudeModels[m.envKey], `--${m.flag}`);
+    }
+  }
+  const model = opts.model || DEFAULT_MODEL;
+  if (tools.some((t) => t.id !== "claude")) warnMissing("model", model, "--model");
+
+  const ctx = { baseUrl: server, apiKey, model, claudeModels };
+  let failed = 0;
+  for (const t of tools) {
+    try {
+      const files = await t.apply(ctx);
+      console.log(`✅ ${t.name} → ${files.join(", ")}`);
+    } catch (err) {
+      failed++;
+      console.log(`❌ ${t.name}: ${err.message}`);
+    }
+  }
+  console.log(`   Base URL: ${server}/v1`);
+  if (tools.some((t) => t.id === "claude")) {
+    for (const m of CLAUDE_MODELS) console.log(`   ${m.envKey}=${claudeModels[m.envKey]}`);
+  }
+  if (tools.some((t) => t.id !== "claude")) console.log(`   Model (other tools): ${model}`);
+  console.log(`   Restart the tools to apply. Undo: npx @rabbi696/ezrouter connect --reset --tools ${tools.map((t) => t.id).join(",")}`);
+
+  if (opts.printEnv) {
+    console.log("\nOpenAI-compatible CLIs (codex, opencode, aider, …):");
+    console.log(`   OPENAI_BASE_URL=${server}/v1`);
+    console.log(`   OPENAI_API_KEY=${apiKey}`);
+  }
+  return failed ? 1 : 0;
+}
+
+module.exports = { run, __test__: { parseArgs, normalizeServerUrl, extractAuthCookie, maskKey, Cancelled } };