@srouter/cli 0.1.3-rc.2 → 0.1.3-rc.4

package/dist/index.js

@@ -1,3 +1,5 @@
+import "./chunk-BJ7B4R26.js";
+
 // src/index.ts
 import { Command } from "commander";
 
@@ -32,7 +34,7 @@ var GOROUTER_BASE_URL = "https://gorouter.app/v1";
 var GOROUTER_PROVIDER = {
   id: "gorouter",
   name: "GoRouter",
-  category: "api_key",
+  category: "free_tier",
   protocol: "openai",
   base_url: GOROUTER_BASE_URL,
   web_url: "https://gorouter.app/sign-up?aff=cJJn",
@@ -46,7 +48,7 @@ var BLUESMINDS_BASE_URL = "https://api.bluesminds.com/v1";
 var BLUESMINDS_PROVIDER = {
   id: "bluesminds",
   name: "BluesMinds",
-  category: "api_key",
+  category: "free_tier",
   protocol: "openai",
   base_url: BLUESMINDS_BASE_URL,
   web_url: "https://api.bluesminds.com/sign-up?aff=nCAw",
@@ -60,7 +62,7 @@ var SEEKAI_BASE_URL = "https://seekai.cc/v1";
 var SEEKAI_PROVIDER = {
   id: "seekai",
   name: "SeekAI",
-  category: "api_key",
+  category: "free_tier",
   protocol: "openai",
   base_url: SEEKAI_BASE_URL,
   web_url: "https://seekai.cc/sign-up?aff=UU0C",
@@ -74,7 +76,7 @@ var TABITOKEN_BASE_URL = "https://tabitoken.com/v1";
 var TABITOKEN_PROVIDER = {
   id: "tabitoken",
   name: "TabiToken",
-  category: "api_key",
+  category: "free_tier",
   protocol: "openai",
   base_url: TABITOKEN_BASE_URL,
   web_url: "https://tabitoken.com/sign-up?aff=h5iN",
@@ -140,6 +142,9 @@ var ANTHROPIC_PROVIDER = {
 // ../../packages/constants/dist/providers/antigravity.js
 var ANTIGRAVITY_IDE_BASE_URL = "https://daily-cloudcode-pa.googleapis.com";
 var ANTIGRAVITY_MODELS = [
+  { id: "gemini-3.8-flash-high", name: "Gemini 3.8 Flash (High)" },
+  { id: "gemini-3.8-flash-medium", name: "Gemini 3.8 Flash (Medium)" },
+  { id: "gemini-3.8-flash-low", name: "Gemini 3.8 Flash (Low)" },
   { id: "gemini-3.7-flash-high", name: "Gemini 3.7 Flash (High)" },
   { id: "gemini-3.7-flash-medium", name: "Gemini 3.7 Flash (Medium)" },
   { id: "gemini-3.7-flash-low", name: "Gemini 3.7 Flash (Low)" },
@@ -290,7 +295,6 @@ var QODER_PROVIDER = {
 // ../../packages/constants/dist/providers/opencode.js
 var OPENCODE_ZEN_BASE_URL = "https://opencode.ai/zen/v1";
 var OPENCODE_ZEN_MODELS = [
-  { id: "x-preview-f-free", name: "Ox Alpha Free (Unlimited)" },
   { id: "big-pickle", name: "Big Pickle (Free)" },
   { id: "laguna-s-2.1-free", name: "Poolside Laguna S 2.1 (Free)" },
   { id: "nemotron-3.5-lightning-free", name: "Nemotron 3.5 Lightning (Free)" },
@@ -312,6 +316,21 @@ var OPENCODE_ZEN_PROVIDER = {
   status_message: "Free Tier Ready (Unlimited)"
 };
 
+// ../../packages/constants/dist/providers/bai.js
+var BAI_BASE_URL = "https://api.b.ai/v1";
+var BAI_PROVIDER = {
+  id: "bai",
+  name: "B.AI",
+  category: "free_tier",
+  protocol: "openai",
+  alias: "bai",
+  base_url: BAI_BASE_URL,
+  web_url: "https://b.ai",
+  requires_api_key: true,
+  supports_custom_url: true,
+  status_message: "B.AI API key missing"
+};
+
 // ../../packages/constants/dist/providers/catalog.js
 var KNOWN_PROVIDERS = [
   KIRO_PROVIDER,
@@ -328,13 +347,19 @@ var KNOWN_PROVIDERS = [
   QODER_PROVIDER,
   CODEBUDDY_PROVIDER,
   CODEBUDDY_CN_PROVIDER,
-  OPENCODE_ZEN_PROVIDER
+  OPENCODE_ZEN_PROVIDER,
+  BAI_PROVIDER
 ];
 var KNOWN_PROVIDER_MAP = Object.freeze(Object.fromEntries(KNOWN_PROVIDERS.map((Provider) => [Provider.id, Provider])));
 var KNOWN_PROVIDER_IDS_DESC = Object.freeze(Object.keys(KNOWN_PROVIDER_MAP).sort((A, B) => B.length - A.length));
 var LEGACY_ALIAS_MAP = Object.freeze({
   claude: "claude",
-  cbai: "codebuddy"
+  cbai: "codebuddy",
+  // OpenCode Zen's executor registers with base id "opencode_zen"; its
+  // listModels splits on "_" and produces "opencode/<model>" ids, while
+  // alias-prefixed connections produce "zen/<model>". Map both so log
+  // attribution and routing resolve to the registered base id.
+  opencode: "opencode_zen"
 });
 
 // ../../packages/constants/dist/seed.js
@@ -342,8 +367,8 @@ var DEFAULT_PROVIDERS = Object.freeze(KNOWN_PROVIDERS.map(({ alias: _alias, ...s
 var DEFAULT_PROVIDER_MAP = Object.freeze(Object.fromEntries(DEFAULT_PROVIDERS.map((seed) => [seed.id, seed])));
 
 // ../../packages/constants/dist/version.js
-var GLOBAL_VERSION = "0.1.3";
-var CLI_VERSION = GLOBAL_VERSION;
+var GLOBAL_VERSION = "0.1.4";
+var CLI_VERSION = "0.1.3-rc.4";
 var SROUTER_VERSION_TAG = `v${GLOBAL_VERSION}`;
 
 // src/commands/setup.ts
@@ -475,10 +500,10 @@ import { exec } from "node:child_process";
 import { promisify } from "node:util";
 var execAsync = promisify(exec);
 function getPlatform() {
-  const p2 = process.platform;
-  if (p2 === "win32") return "windows";
-  if (p2 === "darwin") return "macos";
-  if (p2 === "linux") return "linux";
+  const p3 = process.platform;
+  if (p3 === "win32") return "windows";
+  if (p3 === "darwin") return "macos";
+  if (p3 === "linux") return "linux";
   return "unknown";
 }
 function isWindows() {
@@ -488,10 +513,10 @@ function isMacOS() {
   return process.platform === "darwin";
 }
 function getOsDisplayName() {
-  const p2 = getPlatform();
+  const p3 = getPlatform();
   const arch = os2.arch();
   const rel = os2.release();
-  switch (p2) {
+  switch (p3) {
     case "macos":
       return `macOS (${arch === "arm64" ? "Apple Silicon" : arch}) [Darwin ${rel}]`;
     case "windows":
@@ -561,9 +586,9 @@ function getClaudeConfigPath() {
     candidatePaths.push(path2.join(home, ".claude", "config.json"));
     candidatePaths.push(path2.join(home, ".config", "claude", "config.json"));
   }
-  for (const p2 of candidatePaths) {
-    if (fs2.existsSync(p2)) {
-      return p2;
+  for (const p3 of candidatePaths) {
+    if (fs2.existsSync(p3)) {
+      return p3;
     }
   }
   if (fs2.existsSync(path2.join(home, ".claude"))) {
@@ -605,9 +630,9 @@ function getOpenCodeConfigPath() {
   }
   candidatePaths.push(path2.join(home, ".opencode.jsonc"));
   candidatePaths.push(path2.join(home, ".opencode.json"));
-  for (const p2 of candidatePaths) {
-    if (fs2.existsSync(p2)) {
-      return p2;
+  for (const p3 of candidatePaths) {
+    if (fs2.existsSync(p3)) {
+      return p3;
     }
   }
   if (isWindows()) {
@@ -721,6 +746,7 @@ var ClaudeAdapter = class extends AbstractToolAdapter {
     data.env.ANTHROPIC_DEFAULT_OPUS_MODEL = context.opusModel || defaultModel;
     data.env.ANTHROPIC_DEFAULT_SONNET_MODEL = context.sonnetModel || defaultModel;
     data.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = context.haikuModel || defaultModel;
+    data.env.CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT = "1";
     if (data.env.ANTHROPIC_DEFAULT_FABLE_MODEL) {
       delete data.env.ANTHROPIC_DEFAULT_FABLE_MODEL;
     }
@@ -783,6 +809,7 @@ var ClaudeAdapter = class extends AbstractToolAdapter {
         delete data.env.ANTHROPIC_DEFAULT_SONNET_MODEL;
         delete data.env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
         delete data.env.ANTHROPIC_DEFAULT_FABLE_MODEL;
+        delete data.env.CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT;
       }
       await fs3.writeFile(configPath, JSON.stringify(data, null, 2), "utf-8");
       return true;
@@ -802,15 +829,16 @@ var ClaudeAdapter = class extends AbstractToolAdapter {
       ANTHROPIC_MODEL: defaultModel,
       ANTHROPIC_DEFAULT_OPUS_MODEL: context.opusModel || defaultModel,
       ANTHROPIC_DEFAULT_SONNET_MODEL: context.sonnetModel || defaultModel,
-      ANTHROPIC_DEFAULT_HAIKU_MODEL: context.haikuModel || defaultModel
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: context.haikuModel || defaultModel,
+      CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT: "1"
     };
     return env;
   }
 };
 
 // src/adapters/opencode.ts
-import fs4 from "node:fs/promises";
-import path4 from "node:path";
+import fs5 from "node:fs/promises";
+import path5 from "node:path";
 
 // src/lib/srouterClient.ts
 function normalizeBaseUrl(baseUrl) {
@@ -881,7 +909,361 @@ async function fetchAvailableModels(baseUrl, apiKey) {
   }
 }
 
+// ../../packages/pricing/dist/parser.js
+import fs4 from "node:fs";
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+function stripJsonComments(jsonc) {
+  let insideString = false;
+  let isEscaped = false;
+  let output = "";
+  let i = 0;
+  while (i < jsonc.length) {
+    const char = jsonc[i];
+    const nextChar = jsonc[i + 1];
+    if (insideString) {
+      output += char;
+      if (isEscaped) {
+        isEscaped = false;
+      } else if (char === "\\") {
+        isEscaped = true;
+      } else if (char === '"') {
+        insideString = false;
+      }
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      insideString = true;
+      output += char;
+      i++;
+      continue;
+    }
+    if (char === "/" && nextChar === "/") {
+      i += 2;
+      while (i < jsonc.length && jsonc[i] !== "\n" && jsonc[i] !== "\r") {
+        i++;
+      }
+      continue;
+    }
+    if (char === "/" && nextChar === "*") {
+      i += 2;
+      while (i < jsonc.length && !(jsonc[i] === "*" && jsonc[i + 1] === "/")) {
+        i++;
+      }
+      i += 2;
+      continue;
+    }
+    output += char;
+    i++;
+  }
+  return output.replace(/,(\s*[}\]])/g, "$1");
+}
+function parseJsonc(jsonc) {
+  const cleanJson = stripJsonComments(jsonc);
+  return JSON.parse(cleanJson);
+}
+function flattenModelPrices(models) {
+  const flat = {};
+  for (const [key, val] of Object.entries(models || {})) {
+    if (Array.isArray(val)) {
+      for (const item of val) {
+        if (item && item.id) {
+          flat[item.id] = item;
+        }
+      }
+    } else if (val && typeof val === "object") {
+      if ("input" in val && "output" in val) {
+        flat[key] = val;
+      } else {
+        for (const [subKey, subVal] of Object.entries(val)) {
+          flat[subKey] = subVal;
+        }
+      }
+    }
+  }
+  return flat;
+}
+function resolvePricingDataPath(customPath) {
+  if (customPath)
+    return customPath;
+  const currentDir = path4.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path4.resolve(currentDir, "../data/pricing.jsonc"),
+    path4.resolve(currentDir, "../data/pricing.json"),
+    path4.resolve(currentDir, "../../data/pricing.jsonc"),
+    path4.resolve(currentDir, "../../data/pricing.json"),
+    path4.resolve(process.cwd(), "packages/pricing/data/pricing.jsonc"),
+    path4.resolve(process.cwd(), "packages/pricing/data/pricing.json"),
+    path4.resolve(process.cwd(), "data/pricing.jsonc"),
+    path4.resolve(process.cwd(), "data/pricing.json")
+  ];
+  for (const candidate of candidates) {
+    if (fs4.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[0];
+}
+function modelsDevToModelPrice(model) {
+  if (!model.cost)
+    return void 0;
+  const input = model.cost.input ?? 0;
+  const output = model.cost.output ?? 0;
+  return {
+    id: model.id,
+    name: model.name,
+    input,
+    output,
+    cached: model.cost.cache_read,
+    reasoning: model.cost.reasoning ?? output,
+    cache_creation: model.cost.cache_write ?? input
+  };
+}
+function loadPricingFromModelsDev(customPath) {
+  const modelsData = loadModelsDevData(customPath);
+  const models = {};
+  const providerModels = {};
+  const aliases = {};
+  for (const [key, item] of Object.entries(modelsData)) {
+    const price = modelsDevToModelPrice(item);
+    if (!price)
+      continue;
+    models[key] = price;
+    if (item.id && item.id !== key) {
+      models[item.id] = price;
+    }
+    if (key.includes("/")) {
+      const modelName = key.split("/").slice(1).join("/");
+      if (!aliases[modelName]) {
+        aliases[modelName] = key;
+      }
+      if (!models[modelName]) {
+        models[modelName] = price;
+      }
+    }
+    const provider = key.includes("/") ? key.split("/")[0] : "other";
+    if (!providerModels[provider]) {
+      providerModels[provider] = [];
+    }
+    providerModels[provider].push(price);
+  }
+  return {
+    version: "1.0.0",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    defaults: {
+      input: 2,
+      output: 8,
+      cached: 1,
+      reasoning: 12,
+      cache_creation: 2
+    },
+    models,
+    providerModels,
+    aliases
+  };
+}
+function loadPricingData(customPath) {
+  if (customPath && (customPath.endsWith("models.jsonc") || customPath.endsWith("models.json"))) {
+    return loadPricingFromModelsDev(customPath);
+  }
+  const filePath = resolvePricingDataPath(customPath);
+  if (!fs4.existsSync(filePath)) {
+    const modelsDevPath2 = resolveModelsDevDataPath();
+    if (fs4.existsSync(modelsDevPath2)) {
+      return loadPricingFromModelsDev(modelsDevPath2);
+    }
+    throw new Error(`Pricing dataset file not found at: ${filePath}`);
+  }
+  const content = fs4.readFileSync(filePath, "utf-8");
+  const raw = parseJsonc(content);
+  const flatModels = flattenModelPrices(raw.models);
+  const isGroupedArray = raw.models && Object.values(raw.models).length > 0 && Array.isArray(Object.values(raw.models)[0]);
+  const dataset = {
+    version: raw.version,
+    updatedAt: raw.updatedAt,
+    defaults: raw.defaults,
+    models: { ...flatModels },
+    providerModels: isGroupedArray ? { ...raw.models } : void 0,
+    aliases: { ...raw.aliases || {} }
+  };
+  const modelsDevPath = resolveModelsDevDataPath();
+  if (fs4.existsSync(modelsDevPath)) {
+    try {
+      const modelsDevDataset = loadPricingFromModelsDev(modelsDevPath);
+      for (const [k, v] of Object.entries(modelsDevDataset.models)) {
+        if (!dataset.models[k]) {
+          dataset.models[k] = v;
+        }
+      }
+      for (const [k, v] of Object.entries(modelsDevDataset.aliases)) {
+        if (!dataset.aliases[k] && !dataset.models[k]) {
+          dataset.aliases[k] = v;
+        }
+      }
+    } catch {
+    }
+  }
+  return dataset;
+}
+function resolveModelsDevDataPath(customPath) {
+  if (customPath) {
+    if (path4.isAbsolute(customPath)) {
+      return customPath;
+    }
+    return path4.resolve(process.cwd(), customPath);
+  }
+  const currentDir = path4.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path4.resolve(currentDir, "../models.jsonc"),
+    path4.resolve(currentDir, "../models.json"),
+    path4.resolve(currentDir, "../../models.jsonc"),
+    path4.resolve(currentDir, "../../models.json"),
+    path4.resolve(process.cwd(), "packages/pricing/models.jsonc"),
+    path4.resolve(process.cwd(), "packages/pricing/models.json"),
+    path4.resolve(process.cwd(), "models.jsonc"),
+    path4.resolve(process.cwd(), "models.json")
+  ];
+  for (const candidate of candidates) {
+    if (fs4.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[0];
+}
+function loadModelsDevData(customPath) {
+  const filePath = resolveModelsDevDataPath(customPath);
+  if (!fs4.existsSync(filePath)) {
+    return {};
+  }
+  const content = fs4.readFileSync(filePath, "utf-8");
+  return parseJsonc(content);
+}
+
+// ../../packages/pricing/dist/matcher.js
+function normalizeModelName(rawModel, aliases) {
+  if (!rawModel)
+    return "";
+  let clean = rawModel.trim();
+  if (clean.includes(":") && !clean.includes("://")) {
+    const colonIndex = clean.lastIndexOf(":");
+    clean = clean.substring(0, colonIndex).trim();
+  }
+  if (clean.includes("/")) {
+    clean = clean.split("/").pop()?.trim() ?? clean;
+  }
+  if (aliases) {
+    const lower = clean.toLowerCase();
+    for (const [alias, target] of Object.entries(aliases)) {
+      if (alias.toLowerCase() === lower) {
+        return target;
+      }
+    }
+  }
+  return clean;
+}
+function findCanonicalModelKey(rawModel, models, aliases) {
+  if (!rawModel)
+    return void 0;
+  const normalized = normalizeModelName(rawModel, aliases);
+  if (models[normalized]) {
+    return normalized;
+  }
+  if (models[rawModel]) {
+    return rawModel;
+  }
+  const normalizedLower = normalized.toLowerCase();
+  for (const key of Object.keys(models)) {
+    if (key.toLowerCase() === normalizedLower) {
+      return key;
+    }
+  }
+  const baseClean = (rawModel.includes("/") ? rawModel.split("/").pop() ?? rawModel : rawModel).split(":")[0].trim().toLowerCase();
+  for (const key of Object.keys(models)) {
+    if (key.toLowerCase() === baseClean) {
+      return key;
+    }
+  }
+  return void 0;
+}
+
+// ../../packages/pricing/dist/pricing.js
+var EMBEDDED_DEFAULT_PRICING = {
+  input: 2,
+  output: 8,
+  cached: 1,
+  reasoning: 12,
+  cache_creation: 2
+};
+var loadedDataset;
+try {
+  loadedDataset = loadPricingData();
+} catch {
+  loadedDataset = {
+    defaults: EMBEDDED_DEFAULT_PRICING,
+    models: {},
+    aliases: {}
+  };
+}
+var DEFAULT_PRICING = loadedDataset.defaults || EMBEDDED_DEFAULT_PRICING;
+var MODEL_PRICING = loadedDataset.models;
+var PROVIDER_MODELS = loadedDataset.providerModels;
+var MODEL_ALIASES = loadedDataset.aliases;
+var cachedModelsDevData;
+function getModelMetadata(modelId) {
+  if (!modelId)
+    return void 0;
+  if (!cachedModelsDevData) {
+    try {
+      cachedModelsDevData = loadModelsDevData();
+    } catch {
+      cachedModelsDevData = {};
+    }
+  }
+  const data = cachedModelsDevData;
+  if (data[modelId]) {
+    return data[modelId];
+  }
+  const canonical = findCanonicalModelKey(modelId, MODEL_PRICING, MODEL_ALIASES) || normalizeModelName(modelId, MODEL_ALIASES);
+  if (canonical && data[canonical]) {
+    return data[canonical];
+  }
+  const targetSuffix = `/${canonical}`;
+  for (const [key, item] of Object.entries(data)) {
+    if (key === canonical || key.endsWith(targetSuffix) || item.id === canonical || item.id.endsWith(targetSuffix)) {
+      return item;
+    }
+  }
+  return void 0;
+}
+
 // src/adapters/opencode.ts
+function createOpenCodeModelConfig(id, name) {
+  const displayName = name || formatModelDisplayName(id);
+  const config = {
+    id,
+    name: displayName
+  };
+  const meta = getModelMetadata(id);
+  if (meta?.modalities?.input?.includes("image") || meta?.attachment) {
+    config.attachment = true;
+    config.modalities = {
+      input: meta.modalities?.input || ["text", "image"],
+      output: meta.modalities?.output || ["text"]
+    };
+  } else {
+    const lower = id.toLowerCase();
+    const isKnownVision = lower.includes("gemini") || lower.includes("vision") || lower.includes("gpt-4o") || lower.includes("claude-3") || lower.includes("claude-sonnet") || lower.includes("claude-opus") || lower.includes("pixtral");
+    if (isKnownVision) {
+      config.attachment = true;
+      config.modalities = {
+        input: ["text", "image"],
+        output: ["text"]
+      };
+    }
+  }
+  return config;
+}
 var DEFAULT_SROUTER_MODELS = [
   { id: "anthropic/claude-3-7-sonnet", name: "Claude 3.7 Sonnet (Anthropic)" },
   { id: "claude-3-7-sonnet", name: "Claude 3.7 Sonnet" },
@@ -963,7 +1345,7 @@ function formatProviderLabel(provider) {
 function humanizeName(str2) {
   return str2.replace(/[-_]/g, " ").replace(/\b[a-z]/g, (c) => c.toUpperCase());
 }
-function parseJsonc(content) {
+function parseJsonc2(content) {
   try {
     const clean = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/,\s*([\]}])/g, "$1");
     return JSON.parse(clean);
@@ -999,8 +1381,8 @@ var OpenCodeAdapter = class extends AbstractToolAdapter {
     const configPath = this.getConfigPath();
     const installed = await this.isInstalled();
     try {
-      const raw = await fs4.readFile(configPath, "utf-8");
-      const parsed = parseJsonc(raw);
+      const raw = await fs5.readFile(configPath, "utf-8");
+      const parsed = parseJsonc2(raw);
       const baseUrl = parsed.provider?.srouter?.options?.baseURL || parsed.openai_base_url || parsed.api_base || parsed.baseUrl || parsed.providers?.srouter?.baseUrl || void 0;
       const model = parsed.model || parsed.default_model || void 0;
       const linked = Boolean(
@@ -1030,8 +1412,8 @@ var OpenCodeAdapter = class extends AbstractToolAdapter {
     const backupPath = context.dryRun ? void 0 : await this.store.createBackup(this.id, configPath);
     let data = {};
     try {
-      const raw = await fs4.readFile(configPath, "utf-8");
-      data = parseJsonc(raw);
+      const raw = await fs5.readFile(configPath, "utf-8");
+      data = parseJsonc2(raw);
     } catch {
       data = {};
     }
@@ -1046,14 +1428,18 @@ var OpenCodeAdapter = class extends AbstractToolAdapter {
     const existingModels = existingSrouter.models || {};
     const modelsMap = {};
     for (const m of DEFAULT_SROUTER_MODELS) {
-      modelsMap[m.id] = {
-        id: m.id,
-        name: m.name
-      };
+      modelsMap[m.id] = createOpenCodeModelConfig(m.id, m.name);
     }
     for (const [key, val] of Object.entries(existingModels)) {
       if (val && typeof val === "object") {
-        modelsMap[key] = val;
+        const existingVal = val;
+        const fresh = createOpenCodeModelConfig(key, existingVal.name);
+        modelsMap[key] = {
+          ...fresh,
+          ...existingVal,
+          ...fresh.attachment !== void 0 && { attachment: fresh.attachment },
+          ...fresh.modalities !== void 0 && { modalities: fresh.modalities }
+        };
       }
     }
     try {
@@ -1061,19 +1447,16 @@ var OpenCodeAdapter = class extends AbstractToolAdapter {
       for (const rawId of liveModels) {
         if (!rawId) continue;
         const cleanId = rawId.startsWith("srouter/") ? rawId.replace(/^srouter\//, "") : rawId;
-        modelsMap[cleanId] = {
-          id: cleanId,
-          name: formatModelDisplayName(cleanId)
-        };
+        modelsMap[cleanId] = createOpenCodeModelConfig(cleanId);
       }
     } catch {
     }
     const rawModel = context.model || "claude-3-7-sonnet";
     const cleanModelId = rawModel.startsWith("srouter/") ? rawModel.replace(/^srouter\//, "") : rawModel;
-    modelsMap[cleanModelId] = {
-      id: cleanModelId,
-      name: modelsMap[cleanModelId]?.name || formatModelDisplayName(cleanModelId)
-    };
+    modelsMap[cleanModelId] = createOpenCodeModelConfig(
+      cleanModelId,
+      modelsMap[cleanModelId]?.name
+    );
     data.provider.srouter = {
       name: "SRouter",
       npm: "@ai-sdk/openai-compatible",
@@ -1085,8 +1468,8 @@ var OpenCodeAdapter = class extends AbstractToolAdapter {
     };
     data.model = `srouter/${cleanModelId}`;
     if (!context.dryRun) {
-      await fs4.mkdir(path4.dirname(configPath), { recursive: true });
-      await fs4.writeFile(configPath, JSON.stringify(data, null, 4), "utf-8");
+      await fs5.mkdir(path5.dirname(configPath), { recursive: true });
+      await fs5.writeFile(configPath, JSON.stringify(data, null, 4), "utf-8");
     }
     return {
       backupPath,
@@ -1100,8 +1483,8 @@ var OpenCodeAdapter = class extends AbstractToolAdapter {
     }
     const configPath = this.getConfigPath();
     try {
-      const raw = await fs4.readFile(configPath, "utf-8");
-      const data = parseJsonc(raw);
+      const raw = await fs5.readFile(configPath, "utf-8");
+      const data = parseJsonc2(raw);
       if (data.provider?.srouter) {
         delete data.provider.srouter;
       }
@@ -1113,7 +1496,7 @@ var OpenCodeAdapter = class extends AbstractToolAdapter {
       delete data.openai_api_key;
       delete data.api_key;
       delete data.providers;
-      await fs4.writeFile(configPath, JSON.stringify(data, null, 4), "utf-8");
+      await fs5.writeFile(configPath, JSON.stringify(data, null, 4), "utf-8");
       return true;
     } catch {
       return false;
@@ -1566,124 +1949,988 @@ ${pc.yellow("No tools selected for configuration.")}`,
   );
 }
 
-// src/commands/link.ts
-async function linkCommand(toolId, options) {
-  const adapter = getAdapter(toolId);
-  if (!adapter) {
-    console.error(
-      formatError(
-        `Tool '${pc.bold(toolId)}' not supported. Available tools: ${getAllAdapters().map((a) => a.id).join(", ")}`
-      )
-    );
-    process.exitCode = 1;
-    return;
+// src/commands/init.ts
+import fs7 from "node:fs";
+import os6 from "node:os";
+import path8 from "node:path";
+import { spawn } from "node:child_process";
+import * as p from "@clack/prompts";
+
+// ../../packages/db/dist/db.js
+import path7 from "node:path";
+import os5 from "node:os";
+
+// ../../packages/db/dist/sqlite.js
+import path6 from "node:path";
+import fs6 from "node:fs";
+import os4 from "node:os";
+import { DatabaseSync } from "node:sqlite";
+var SROUTER_DIR = path6.join(os4.homedir(), ".srouter");
+var DEFAULT_DB_PATH = path6.join(SROUTER_DIR, "srouter.db");
+var LEGACY_DB_LOCATIONS = [
+  path6.resolve(process.cwd(), "apps/api/srouter.db"),
+  path6.resolve(process.cwd(), "srouter.db")
+];
+function getDatabasePath() {
+  if (process.env.DATABASE_PATH)
+    return process.env.DATABASE_PATH;
+  for (const legacyPath of LEGACY_DB_LOCATIONS) {
+    if (fs6.existsSync(legacyPath))
+      return legacyPath;
   }
-  const savedConfig = await defaultStore.loadConfig();
-  const baseUrl = options.url || savedConfig.defaultBaseUrl || "http://localhost:3000/v1";
-  const apiKey = options.key || savedConfig.defaultApiKey;
-  const model = options.model || savedConfig.defaultModel;
-  const opusModel = options.opusModel || savedConfig.defaultOpusModel;
-  const sonnetModel = options.sonnetModel || savedConfig.defaultSonnetModel;
-  const haikuModel = options.haikuModel || savedConfig.defaultHaikuModel;
-  try {
-    const result = await adapter.link({
-      baseUrl,
-      apiKey,
-      model,
-      opusModel,
-      sonnetModel,
-      haikuModel,
-      dryRun: options.dryRun
-    });
-    console.log(
-      formatSuccess(
-        `Successfully configured ${pc.bold(pc.cyan(adapter.name))} with SRouter proxy!`
-      )
-    );
-    console.log(`  ${pc.gray("Target Config:")} ${pc.white(result.modifiedPath)}`);
-    console.log(`  ${pc.gray("Proxy URL:")}     ${pc.white(baseUrl)}`);
-    if (model) {
-      console.log(`  ${pc.gray("Model:")}         ${pc.white(model)}`);
-    }
-    if (opusModel) {
-      console.log(`  ${pc.gray("Opus Model:")}    ${pc.white(opusModel)}`);
-    }
-    if (sonnetModel) {
-      console.log(`  ${pc.gray("Sonnet Model:")}  ${pc.white(sonnetModel)}`);
-    }
-    if (haikuModel) {
-      console.log(`  ${pc.gray("Haiku Model:")}   ${pc.white(haikuModel)}`);
-    }
-    if (result.backupPath) {
-      console.log(`  ${pc.gray("Backup Saved:")}  ${pc.white(result.backupPath)}`);
+  return DEFAULT_DB_PATH;
+}
+var dbPath = getDatabasePath();
+var dbDir = path6.dirname(dbPath);
+if (!fs6.existsSync(dbDir)) {
+  fs6.mkdirSync(dbDir, { recursive: true });
+}
+var sqliteDb = new DatabaseSync(dbPath);
+sqliteDb.exec("PRAGMA busy_timeout = 5000;");
+function execWithRetry(sql, attempts = 5) {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      sqliteDb.exec(sql);
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (code === "SQLITE_BUSY" && i < attempts - 1) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200 * (i + 1));
+        continue;
+      }
+      throw error;
     }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(formatError(`Failed to link ${adapter.name}: ${msg}`));
-    process.exitCode = 1;
   }
 }
+execWithRetry("PRAGMA journal_mode = WAL;");
+execWithRetry("PRAGMA foreign_keys = ON;");
+execWithRetry("PRAGMA synchronous = NORMAL;");
+execWithRetry("PRAGMA temp_store = MEMORY;");
+execWithRetry("PRAGMA cache_size = -20000;");
 
-// src/commands/unlink.ts
-async function unlinkCommand(toolId) {
-  const adapter = getAdapter(toolId);
-  if (!adapter) {
-    console.error(
-      formatError(
-        `Tool '${pc.bold(toolId)}' not supported. Available tools: ${getAllAdapters().map((a) => a.id).join(", ")}`
-      )
-    );
-    process.exitCode = 1;
-    return;
+// ../../packages/db/dist/client.js
+import {} from "node:sqlite";
+var SqliteClient = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
   }
-  try {
-    const restored = await adapter.unlink();
-    if (restored) {
-      console.log(
-        formatSuccess(
-          `Restored original configuration for ${pc.bold(pc.cyan(adapter.name))}!`
-        )
-      );
-    } else {
-      console.log(
-        formatInfo(
-          `No active SRouter configuration or backup found for ${pc.bold(adapter.name)}.`
-        )
-      );
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(formatError(`Failed to unlink ${adapter.name}: ${msg}`));
-    process.exitCode = 1;
+  /** Normalize undefined → null (node:sqlite previously tolerated undefined; pg needs null). */
+  normalizeParams(params) {
+    return params.map((p3) => p3 === void 0 ? null : p3);
   }
-}
-
-// src/commands/sync.ts
-async function syncCommand(toolId, options = {}) {
-  const savedConfig = await defaultStore.loadConfig();
-  const baseUrl = options.url || savedConfig.defaultBaseUrl || "http://localhost:3000/v1";
-  const apiKey = options.key || savedConfig.defaultApiKey;
-  const health = await checkServerHealth(baseUrl, apiKey);
-  if (!health.healthy) {
-    console.error(
-      formatError(
-        `Cannot sync: SRouter Gateway is unreachable at ${pc.bold(baseUrl)} (${health.error || "offline"}).`
-      )
-    );
-    process.exitCode = 1;
-    return;
+  all(sql, ...params) {
+    return Promise.resolve(this.db.prepare(sql).all(...this.normalizeParams(params)));
   }
-  const availableModels = await fetchAvailableModels(baseUrl, apiKey);
-  if (availableModels.length === 0) {
-    console.warn(
-      formatWarning(`SRouter Gateway responded at ${baseUrl}, but returned 0 models.`)
-    );
+  get(sql, ...params) {
+    return Promise.resolve(this.db.prepare(sql).get(...this.normalizeParams(params)));
   }
-  const adaptersToSync = toolId ? [getAdapter(toolId)].filter((a) => Boolean(a)) : getAllAdapters();
-  if (toolId && adaptersToSync.length === 0) {
-    console.error(formatError(`Tool '${pc.bold(toolId)}' not supported.`));
-    process.exitCode = 1;
-    return;
+  run(sql, ...params) {
+    const result = this.db.prepare(sql).run(...this.normalizeParams(params));
+    return Promise.resolve(result);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+    return Promise.resolve();
+  }
+  async tableColumns(table) {
+    const rows = await this.all(`PRAGMA table_info("${table}")`);
+    return rows.map((r) => r.name);
+  }
+};
+var pgPool = null;
+async function getPool() {
+  if (pgPool)
+    return pgPool;
+  const { Pool } = await import("./esm-5KJBUOHT.js");
+  pgPool = new Pool({
+    connectionString: process.env.DATABASE_URL,
+    max: 10,
+    idleTimeoutMillis: 3e4,
+    connectionTimeoutMillis: 1e4,
+    // Heroku Postgres requires TLS; self-signed cert → rejectUnauthorized: false
+    ssl: { rejectUnauthorized: false }
+  });
+  return pgPool;
+}
+function toPg(sql) {
+  let i = 0;
+  return sql.replace(/\?/g, () => `$${++i}`);
+}
+function splitStatements(sql) {
+  const statements = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let inDollar = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (!inDollar && !inSingle && !inDouble && ch === "'") {
+      inSingle = true;
+    } else if (inSingle && ch === "'" && next !== "'") {
+      inSingle = false;
+    } else if (!inDollar && !inSingle && !inDouble && ch === '"') {
+      inDouble = true;
+    } else if (inDouble && ch === '"' && next !== '"') {
+      inDouble = false;
+    } else if (!inSingle && !inDouble && ch === "$" && /^[a-zA-Z_0-9]*\$/.test(sql.slice(i, i + 40))) {
+      inDollar = true;
+    } else if (inDollar && ch === "$" && next !== "$") {
+      inDollar = false;
+    } else if (!inSingle && !inDouble && !inDollar && ch === ";") {
+      if (current.trim())
+        statements.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim())
+    statements.push(current.trim());
+  return statements;
+}
+var PgClient = class {
+  /** Normalize undefined → null (pg rejects undefined params). */
+  normalizeParams(params) {
+    return params.map((p3) => p3 === void 0 ? null : p3);
+  }
+  async all(sql, ...params) {
+    const pool = await getPool();
+    const result = await pool.query(toPg(sql), this.normalizeParams(params));
+    return result.rows;
+  }
+  async get(sql, ...params) {
+    const pool = await getPool();
+    const result = await pool.query(toPg(sql), this.normalizeParams(params));
+    return result.rows[0] ?? null;
+  }
+  async run(sql, ...params) {
+    const pool = await getPool();
+    const result = await pool.query(toPg(sql), this.normalizeParams(params));
+    return { changes: result.rowCount ?? 0 };
+  }
+  async exec(sql) {
+    const trimmed = sql.trim().toUpperCase();
+    if (trimmed.startsWith("PRAGMA"))
+      return;
+    const pool = await getPool();
+    const statements = splitStatements(sql);
+    for (const stmt of statements) {
+      await pool.query(stmt);
+    }
+  }
+  async tableColumns(table) {
+    const rows = await this.all("SELECT column_name AS name FROM information_schema.columns WHERE table_name = $1", table);
+    return rows.map((r) => r.name);
+  }
+};
+var _client = null;
+function getDbClient() {
+  if (_client)
+    return _client;
+  if (process.env.DATABASE_URL) {
+    _client = new PgClient();
+  } else {
+    _client = new SqliteClient(sqliteDb);
+  }
+  return _client;
+}
+
+// ../../packages/db/dist/db.js
+var SROUTER_DIR2 = path7.join(os5.homedir(), ".srouter");
+var DEFAULT_DB_PATH2 = path7.join(SROUTER_DIR2, "srouter.db");
+var LEGACY_DB_LOCATIONS2 = [
+  path7.resolve(process.cwd(), "apps/api/srouter.db"),
+  path7.resolve(process.cwd(), "srouter.db")
+];
+var CompatStatement = class {
+  client;
+  sql;
+  constructor(client, sql) {
+    this.client = client;
+    this.sql = sql;
+  }
+  all(...params) {
+    return this.client.all(this.sql, ...params);
+  }
+  get(...params) {
+    return this.client.get(this.sql, ...params);
+  }
+  run(...params) {
+    return this.client.run(this.sql, ...params);
+  }
+};
+var CompatDb = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  prepare(sql) {
+    return new CompatStatement(this.client, sql);
+  }
+  exec(sql) {
+    return this.client.exec(sql);
+  }
+};
+function makeCompatDb() {
+  return new CompatDb(getDbClient());
+}
+var db = makeCompatDb();
+sqliteDb.exec("PRAGMA busy_timeout = 5000;");
+function execWithRetry2(sql, attempts = 5) {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      sqliteDb.exec(sql);
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (code === "SQLITE_BUSY" && i < attempts - 1) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200 * (i + 1));
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+execWithRetry2("PRAGMA journal_mode = WAL;");
+execWithRetry2("PRAGMA foreign_keys = ON;");
+execWithRetry2("PRAGMA synchronous = NORMAL;");
+execWithRetry2("PRAGMA temp_store = MEMORY;");
+execWithRetry2("PRAGMA cache_size = -20000;");
+function isPostgres() {
+  return Boolean(process.env.DATABASE_URL);
+}
+function tableSql(table, pg) {
+  const cols = table.columns.map((c) => `${c.name} ${pg && c.definition.includes("INTEGER") ? "BIGINT" : c.definition}`).join(",\n    ");
+  return `CREATE TABLE IF NOT EXISTS ${table.name} (
+    ${cols}
+);`;
+}
+var TABLES = [
+  {
+    name: "providers",
+    columns: [
+      { name: "id", definition: "TEXT PRIMARY KEY" },
+      { name: "provider_id", definition: "TEXT NOT NULL" },
+      { name: "name", definition: "TEXT NOT NULL" },
+      { name: "alias", definition: "TEXT" },
+      { name: "category", definition: "TEXT NOT NULL" },
+      { name: "protocol", definition: "TEXT NOT NULL" },
+      { name: "base_url", definition: "TEXT" },
+      { name: "api_key", definition: "TEXT" },
+      { name: "access_token", definition: "TEXT" },
+      { name: "refresh_token", definition: "TEXT" },
+      { name: "account_id", definition: "TEXT" },
+      { name: "organization_id", definition: "TEXT" },
+      { name: "provider_specific_data", definition: "TEXT" },
+      { name: "custom_headers", definition: "TEXT" },
+      { name: "token_expires_at", definition: "INTEGER" },
+      { name: "last_refreshed_at", definition: "INTEGER" },
+      { name: "enabled", definition: "INTEGER NOT NULL DEFAULT 1" },
+      { name: "created_at", definition: "INTEGER NOT NULL" }
+    ]
+  },
+  {
+    name: "api_keys",
+    columns: [
+      { name: "id", definition: "TEXT PRIMARY KEY" },
+      { name: "key", definition: "TEXT UNIQUE NOT NULL" },
+      { name: "name", definition: "TEXT NOT NULL" },
+      { name: "enabled", definition: "INTEGER NOT NULL DEFAULT 1" },
+      { name: "rate_limit", definition: "INTEGER DEFAULT 0" },
+      { name: "quota_limit", definition: "INTEGER DEFAULT 0" },
+      { name: "usage_tokens", definition: "INTEGER DEFAULT 0" },
+      { name: "credit_limit", definition: "REAL DEFAULT 0" },
+      { name: "usage_cost", definition: "REAL DEFAULT 0" },
+      { name: "allowed_models", definition: "TEXT" },
+      { name: "created_at", definition: "INTEGER NOT NULL" }
+    ]
+  },
+  {
+    name: "request_logs",
+    columns: [
+      { name: "id", definition: "TEXT PRIMARY KEY" },
+      { name: "api_key_id", definition: "TEXT" },
+      { name: "provider_id", definition: "TEXT NOT NULL" },
+      { name: "model", definition: "TEXT NOT NULL" },
+      { name: "prompt_tokens", definition: "INTEGER NOT NULL DEFAULT 0" },
+      { name: "completion_tokens", definition: "INTEGER NOT NULL DEFAULT 0" },
+      { name: "total_tokens", definition: "INTEGER NOT NULL DEFAULT 0" },
+      { name: "status_code", definition: "INTEGER NOT NULL" },
+      { name: "latency_ms", definition: "INTEGER NOT NULL" },
+      { name: "cached_tokens", definition: "INTEGER NOT NULL DEFAULT 0" },
+      { name: "cache_creation_tokens", definition: "INTEGER NOT NULL DEFAULT 0" },
+      { name: "reasoning_tokens", definition: "INTEGER NOT NULL DEFAULT 0" },
+      { name: "estimated_cost", definition: "REAL NOT NULL DEFAULT 0" },
+      { name: "fallback_occurred", definition: "INTEGER NOT NULL DEFAULT 0" },
+      { name: "fallback_path", definition: "TEXT" },
+      { name: "fallback_reason", definition: "TEXT" },
+      { name: "resolved_model", definition: "TEXT" },
+      { name: "created_at", definition: "INTEGER NOT NULL" }
+    ]
+  },
+  {
+    name: "oauth_sessions",
+    columns: [
+      { name: "state", definition: "TEXT PRIMARY KEY" },
+      { name: "code_verifier", definition: "TEXT NOT NULL" },
+      { name: "client_id", definition: "TEXT NOT NULL" },
+      { name: "redirect_uri", definition: "TEXT NOT NULL" },
+      { name: "created_at", definition: "INTEGER NOT NULL" }
+    ]
+  },
+  {
+    name: "fallback_rules",
+    columns: [
+      { name: "id", definition: "TEXT PRIMARY KEY" },
+      { name: "source_model", definition: "TEXT NOT NULL" },
+      { name: "target_model", definition: "TEXT NOT NULL" },
+      { name: "priority", definition: "INTEGER NOT NULL DEFAULT 1" },
+      { name: "enabled", definition: "INTEGER NOT NULL DEFAULT 1" },
+      { name: "trigger_on_status", definition: "TEXT" },
+      { name: "max_retries", definition: "INTEGER DEFAULT 1" },
+      { name: "created_at", definition: "INTEGER NOT NULL" }
+    ]
+  },
+  {
+    name: "system_settings",
+    columns: [
+      { name: "key", definition: "TEXT PRIMARY KEY" },
+      { name: "value", definition: "TEXT NOT NULL" }
+    ]
+  },
+  {
+    name: "custom_models",
+    columns: [
+      { name: "provider_id", definition: "TEXT NOT NULL" },
+      { name: "model_id", definition: "TEXT NOT NULL" },
+      { name: "created_at", definition: "INTEGER NOT NULL" },
+      { name: "PRIMARY KEY (provider_id, model_id)", definition: "" }
+    ]
+  }
+];
+var INDEXES = [
+  { sql: "CREATE INDEX IF NOT EXISTS idx_request_logs_created_at ON request_logs(created_at DESC);" },
+  { sql: "CREATE INDEX IF NOT EXISTS idx_request_logs_provider_created ON request_logs(provider_id, created_at DESC);" },
+  { sql: "CREATE INDEX IF NOT EXISTS idx_request_logs_provider_model ON request_logs(provider_id, model);" },
+  { sql: "CREATE INDEX IF NOT EXISTS idx_request_logs_model ON request_logs(model);" },
+  { sql: "CREATE INDEX IF NOT EXISTS idx_fallback_rules_priority ON fallback_rules(priority ASC, created_at ASC);" },
+  { sql: "CREATE INDEX IF NOT EXISTS idx_providers_provider_id ON providers(provider_id);" },
+  { sql: "CREATE INDEX IF NOT EXISTS idx_custom_models_provider ON custom_models(provider_id, created_at ASC);" }
+];
+var ADMIN_TABLES = (pg) => {
+  const integer = pg ? "BIGINT" : "INTEGER";
+  return `
+    CREATE TABLE IF NOT EXISTS admin_account (
+        id ${integer} PRIMARY KEY CHECK (id = 1),
+        password_hash TEXT NOT NULL,
+        created_at ${integer} NOT NULL,
+        updated_at ${integer} NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS admin_sessions (
+        token_hash TEXT PRIMARY KEY,
+        created_at ${integer} NOT NULL,
+        expires_at ${integer} NOT NULL
+    );
+`;
+};
+async function ensureColumns(table, columns) {
+  const client = getDbClient();
+  const existing = new Set(await client.tableColumns(table));
+  for (const col of columns) {
+    if (existing.has(col.name))
+      continue;
+    try {
+      await client.exec(`ALTER TABLE ${table} ADD COLUMN ${col.definition};`);
+      existing.add(col.name);
+    } catch (error) {
+      const message = error.message || "";
+      if (!message.includes("duplicate column")) {
+        throw error;
+      }
+    }
+  }
+}
+function initDatabase() {
+  if (isPostgres()) {
+    return initPostgresSchema();
+  }
+  initSqliteSchemaSync();
+}
+function initSqliteSchemaSync() {
+  const raw = sqliteDb;
+  for (const table of TABLES) {
+    raw.exec(tableSql(table, false));
+  }
+  for (const index of INDEXES) {
+    raw.exec(index.sql);
+  }
+  raw.exec(ADMIN_TABLES(false));
+  const ensureSync = (table, columns) => {
+    const existing = new Set(raw.prepare(`PRAGMA table_info("${table}")`).all().map((col) => col.name));
+    for (const col of columns) {
+      if (existing.has(col.name))
+        continue;
+      try {
+        raw.exec(`ALTER TABLE ${table} ADD COLUMN ${col.definition};`);
+        existing.add(col.name);
+      } catch (error) {
+        const message = error.message || "";
+        if (!message.includes("duplicate column")) {
+          throw error;
+        }
+      }
+    }
+  };
+  ensureSync("providers", [
+    { name: "alias", definition: "alias TEXT" },
+    { name: "refresh_token", definition: "refresh_token TEXT" },
+    { name: "account_id", definition: "account_id TEXT" },
+    { name: "provider_specific_data", definition: "provider_specific_data TEXT" },
+    { name: "token_expires_at", definition: "token_expires_at INTEGER" },
+    { name: "last_refreshed_at", definition: "last_refreshed_at INTEGER" },
+    { name: "organization_id", definition: "organization_id TEXT" }
+  ]);
+  ensureSync("api_keys", [
+    { name: "allowed_models", definition: "allowed_models TEXT" },
+    { name: "credit_limit", definition: "credit_limit REAL DEFAULT 0" },
+    { name: "usage_cost", definition: "usage_cost REAL DEFAULT 0" }
+  ]);
+  ensureSync("request_logs", [
+    { name: "cached_tokens", definition: "cached_tokens INTEGER NOT NULL DEFAULT 0" },
+    { name: "cache_creation_tokens", definition: "cache_creation_tokens INTEGER NOT NULL DEFAULT 0" },
+    { name: "reasoning_tokens", definition: "reasoning_tokens INTEGER NOT NULL DEFAULT 0" },
+    { name: "estimated_cost", definition: "estimated_cost REAL NOT NULL DEFAULT 0" },
+    { name: "fallback_occurred", definition: "fallback_occurred INTEGER NOT NULL DEFAULT 0" },
+    { name: "fallback_path", definition: "fallback_path TEXT" },
+    { name: "fallback_reason", definition: "fallback_reason TEXT" },
+    { name: "resolved_model", definition: "resolved_model TEXT" }
+  ]);
+}
+async function initPostgresSchema() {
+  const client = getDbClient();
+  for (const table of TABLES) {
+    await client.exec(tableSql(table, true));
+  }
+  for (const index of INDEXES) {
+    await client.exec(index.sql);
+  }
+  await client.exec(ADMIN_TABLES(true));
+  await ensureColumns("providers", [
+    { name: "alias", definition: "alias TEXT" },
+    { name: "refresh_token", definition: "refresh_token TEXT" },
+    { name: "account_id", definition: "account_id TEXT" },
+    { name: "provider_specific_data", definition: "provider_specific_data TEXT" },
+    { name: "token_expires_at", definition: "token_expires_at INTEGER" },
+    { name: "last_refreshed_at", definition: "last_refreshed_at INTEGER" },
+    { name: "organization_id", definition: "organization_id TEXT" }
+  ]);
+  await ensureColumns("api_keys", [
+    { name: "allowed_models", definition: "allowed_models TEXT" },
+    { name: "credit_limit", definition: "credit_limit REAL DEFAULT 0" },
+    { name: "usage_cost", definition: "usage_cost REAL DEFAULT 0" }
+  ]);
+  await ensureColumns("request_logs", [
+    { name: "cached_tokens", definition: "cached_tokens INTEGER NOT NULL DEFAULT 0" },
+    { name: "cache_creation_tokens", definition: "cache_creation_tokens INTEGER NOT NULL DEFAULT 0" },
+    { name: "reasoning_tokens", definition: "reasoning_tokens INTEGER NOT NULL DEFAULT 0" },
+    { name: "estimated_cost", definition: "estimated_cost REAL NOT NULL DEFAULT 0" },
+    { name: "fallback_occurred", definition: "fallback_occurred INTEGER NOT NULL DEFAULT 0" },
+    { name: "fallback_path", definition: "fallback_path TEXT" },
+    { name: "fallback_reason", definition: "fallback_reason TEXT" },
+    { name: "resolved_model", definition: "resolved_model TEXT" }
+  ]);
+}
+if (!isPostgres()) {
+  initDatabase();
+}
+
+// ../../packages/db/dist/row-utils.js
+function str(value, fallback = "") {
+  return value === null || value === void 0 ? fallback : String(value);
+}
+function num(value, fallback = 0) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+// ../../packages/db/dist/adminAuth.js
+var AdminAuthStore = class {
+  initialized = false;
+  client;
+  /** Accept a DbClient for isolation (tests use :memory: SqliteClient); defaults to global. */
+  constructor(client) {
+    this.client = client ?? getDbClient();
+  }
+  async ensureTables() {
+    if (this.initialized)
+      return;
+    const pg = Boolean(process.env.DATABASE_URL);
+    const integer = pg ? "BIGINT" : "INTEGER";
+    await this.client.exec(`
+            CREATE TABLE IF NOT EXISTS admin_account (
+                id ${integer} PRIMARY KEY CHECK (id = 1),
+                password_hash TEXT NOT NULL,
+                created_at ${integer} NOT NULL,
+                updated_at ${integer} NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS admin_sessions (
+                token_hash TEXT PRIMARY KEY,
+                created_at ${integer} NOT NULL,
+                expires_at ${integer} NOT NULL
+            );
+        `);
+    this.initialized = true;
+  }
+  async hasAdminAccount() {
+    await this.ensureTables();
+    const Row = await this.client.get("SELECT 1 AS present FROM admin_account WHERE id = 1");
+    return Boolean(Row);
+  }
+  async createAdminAccount(passwordHash, now = Date.now()) {
+    await this.ensureTables();
+    const Result = await this.client.run(`INSERT INTO admin_account (id, password_hash, created_at, updated_at)
+             VALUES (1, ?, ?, ?)
+             ON CONFLICT(id) DO NOTHING`, passwordHash, now, now);
+    return num(Result.changes) > 0;
+  }
+  async getPasswordHash() {
+    await this.ensureTables();
+    const Row = await this.client.get("SELECT password_hash FROM admin_account WHERE id = 1");
+    return Row?.password_hash ? str(Row.password_hash) : null;
+  }
+  async updatePasswordHash(passwordHash, now = Date.now()) {
+    await this.ensureTables();
+    const Result = await this.client.run(`UPDATE admin_account
+             SET password_hash = ?, updated_at = ?
+             WHERE id = 1`, passwordHash, now);
+    return num(Result.changes) > 0;
+  }
+  async createSession(tokenHash, createdAt, expiresAt) {
+    await this.ensureTables();
+    await this.client.run(`INSERT INTO admin_sessions (token_hash, created_at, expires_at)
+             VALUES (?, ?, ?)`, tokenHash, createdAt, expiresAt);
+  }
+  async getSession(tokenHash, now = Date.now()) {
+    await this.ensureTables();
+    await this.client.run("DELETE FROM admin_sessions WHERE expires_at <= ?", now);
+    const Row = await this.client.get(`SELECT token_hash, created_at, expires_at
+             FROM admin_sessions
+             WHERE token_hash = ? AND expires_at > ?`, tokenHash, now);
+    if (!Row)
+      return null;
+    return {
+      tokenHash: str(Row.token_hash),
+      createdAt: num(Row.created_at),
+      expiresAt: num(Row.expires_at)
+    };
+  }
+  async deleteSession(tokenHash) {
+    await this.ensureTables();
+    const Result = await this.client.run("DELETE FROM admin_sessions WHERE token_hash = ?", tokenHash);
+    return num(Result.changes) > 0;
+  }
+};
+var adminAuthStore = new AdminAuthStore();
+
+// src/commands/init.ts
+var DEFAULT_PORT = "3000";
+var REPO_URL = "https://github.com/seaavey/SRouter.git";
+var DOCKER_IMAGE = "ghcr.io/seaavey/srouter:latest";
+function runProcess(command, args, options) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      cwd: options?.cwd,
+      stdio: options?.stdio ?? "inherit"
+    });
+    let stdout = "";
+    let stderr = "";
+    if (options?.stdio === "pipe") {
+      child.stdout?.on("data", (d) => stdout += d.toString());
+      child.stderr?.on("data", (d) => stderr += d.toString());
+    }
+    child.on("close", (code) => {
+      resolve({ code: code ?? 0, stdout, stderr });
+    });
+    child.on("error", (err) => {
+      resolve({ code: 1, stdout, stderr: err.message });
+    });
+  });
+}
+async function initDocker(port, detached) {
+  const s = p.spinner();
+  s.start("Checking Docker environment");
+  const hasDocker = await isExecutableInPath("docker");
+  if (!hasDocker) {
+    s.stop(formatError("Docker is not installed or not available in PATH."));
+    const fallbackChoice = await p.select({
+      message: "Docker was not found. What would you like to do?",
+      options: [
+        {
+          value: "source",
+          label: "Run from Source Code instead (Node.js & pnpm)",
+          hint: "Clones repo and builds locally without Docker"
+        },
+        {
+          value: "guide",
+          label: "View Docker installation instructions",
+          hint: "Get download link for your OS"
+        },
+        {
+          value: "exit",
+          label: "Exit",
+          hint: "Cancel initialization"
+        }
+      ]
+    });
+    if (p.isCancel(fallbackChoice) || fallbackChoice === "exit") {
+      p.outro("Initialization cancelled. Install Docker from https://docs.docker.com/get-docker/ and try again.");
+      return;
+    }
+    if (fallbackChoice === "guide") {
+      p.log.message(
+        [
+          "\u{1F4E6} " + pc.bold("How to install Docker:"),
+          `\u2022 Windows / macOS: ${pc.cyan("https://www.docker.com/products/docker-desktop/")}`,
+          `\u2022 Linux (Ubuntu/Debian): ${pc.yellow("curl -fsSL https://get.docker.com | sh")}`,
+          `\u2022 Linux (Arch): ${pc.yellow("sudo pacman -S docker && sudo systemctl enable --now docker")}`
+        ].join("\n")
+      );
+      p.outro("Run 'srouter init' again after installing Docker.");
+      return;
+    }
+    if (fallbackChoice === "source") {
+      const defaultDir = path8.join(os6.homedir(), "srouter");
+      await initSource(defaultDir, port);
+      return;
+    }
+  }
+  s.message("Verifying Docker daemon status");
+  const checkDaemon = await runProcess("docker", ["info"], { stdio: "pipe" });
+  if (checkDaemon.code !== 0) {
+    s.stop(formatError("Docker daemon is not running."));
+    p.log.info("Please start the Docker service/daemon and try again.");
+    process.exitCode = 1;
+    return;
+  }
+  const dataDir = path8.join(SROUTER_DIR2, "data");
+  fs7.mkdirSync(dataDir, { recursive: true, mode: 448 });
+  s.message(`Pulling latest SRouter Docker image (${DOCKER_IMAGE})`);
+  const pullRes = await runProcess("docker", ["pull", DOCKER_IMAGE], { stdio: "inherit" });
+  if (pullRes.code !== 0) {
+    s.stop(formatWarning("Failed to pull image from registry, checking local image cache"));
+  }
+  await runProcess("docker", ["rm", "-f", "srouter"], { stdio: "pipe" });
+  s.message(`Starting SRouter Gateway container on port ${port}`);
+  const dockerArgs = [
+    "run",
+    detached ? "-d" : "-it",
+    "--name",
+    "srouter",
+    "--restart",
+    "unless-stopped",
+    "-p",
+    `${port}:3000`,
+    "-p",
+    "1455:1455",
+    "-v",
+    `${dataDir}:/app/data`,
+    "-e",
+    `PORT=${port}`,
+    "-e",
+    "OAUTH_PORT=1455",
+    "-e",
+    "DATABASE_PATH=/app/data/srouter.db",
+    DOCKER_IMAGE
+  ];
+  if (detached) {
+    const runRes = await runProcess("docker", dockerArgs, { stdio: "pipe" });
+    if (runRes.code !== 0) {
+      s.stop(formatError("Failed to start SRouter Docker container."));
+      p.log.error(runRes.stderr);
+      process.exitCode = 1;
+      return;
+    }
+    s.stop(formatSuccess("SRouter Docker container started successfully!"));
+    p.log.message(
+      [
+        `\u{1F680} Gateway URL:  ${pc.bold(pc.cyan(`http://localhost:${port}`))}`,
+        `\u{1F4CA} Web Dashboard: ${pc.bold(pc.cyan(`http://localhost:${port}`))}`,
+        `\u{1F4BE} Persistent Data: ${pc.dim(dataDir)}`,
+        "",
+        `To inspect logs: ${pc.yellow("docker logs -f srouter")}`,
+        `To stop:         ${pc.yellow("docker stop srouter")}`
+      ].join("\n")
+    );
+    p.outro("SRouter is ready to use!");
+  } else {
+    s.stop("Launching container in foreground mode...");
+    await runProcess("docker", dockerArgs, { stdio: "inherit" });
+  }
+}
+async function initSource(targetDir, port) {
+  const s = p.spinner();
+  s.start("Checking prerequisites (git, node, pnpm)");
+  const hasGit = await isExecutableInPath("git");
+  const hasPnpm = await isExecutableInPath("pnpm");
+  if (!hasGit) {
+    s.stop(formatError("Git is required to clone SRouter repository."));
+    process.exitCode = 1;
+    return;
+  }
+  const resolvedDir = path8.resolve(targetDir);
+  if (!fs7.existsSync(path8.join(resolvedDir, "package.json"))) {
+    s.message(`Cloning SRouter into ${pc.bold(resolvedDir)}`);
+    fs7.mkdirSync(resolvedDir, { recursive: true });
+    const cloneRes = await runProcess("git", ["clone", REPO_URL, resolvedDir], {
+      stdio: "inherit"
+    });
+    if (cloneRes.code !== 0) {
+      s.stop(formatError("Failed to clone SRouter repository."));
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    p.log.info(`Using existing SRouter repository at ${pc.bold(resolvedDir)}`);
+  }
+  s.message("Installing dependencies with pnpm");
+  const pnpmCmd = hasPnpm ? "pnpm" : "npx";
+  const installArgs = hasPnpm ? ["install"] : ["pnpm", "install"];
+  const installRes = await runProcess(pnpmCmd, installArgs, {
+    cwd: resolvedDir,
+    stdio: "inherit"
+  });
+  if (installRes.code !== 0) {
+    s.stop(formatError("Dependency installation failed."));
+    process.exitCode = 1;
+    return;
+  }
+  s.message("Building SRouter packages, API, and Dashboard");
+  const buildArgs = hasPnpm ? ["run", "build"] : ["pnpm", "run", "build"];
+  const buildRes = await runProcess(pnpmCmd, buildArgs, {
+    cwd: resolvedDir,
+    stdio: "inherit"
+  });
+  if (buildRes.code !== 0) {
+    s.stop(formatError("Build step failed."));
+    process.exitCode = 1;
+    return;
+  }
+  s.stop(formatSuccess("SRouter built successfully!"));
+  p.log.message(
+    [
+      `\u{1F4C1} Project Directory: ${pc.bold(resolvedDir)}`,
+      `\u{1F680} Start Dev Server:  ${pc.yellow(`cd ${resolvedDir} && pnpm dev`)}`,
+      `\u26A1 Start Production:  ${pc.yellow(`PORT=${port} cd ${resolvedDir}/apps/api && pnpm start`)}`
+    ].join("\n")
+  );
+  const startNow = await p.confirm({
+    message: "Start SRouter API & Web server now?",
+    initialValue: true
+  });
+  if (startNow === true) {
+    p.outro(`Starting SRouter Gateway on port ${port}...`);
+    process.env.PORT = port;
+    const startArgs = hasPnpm ? ["--filter", "api", "start"] : ["pnpm", "--filter", "api", "start"];
+    await runProcess(pnpmCmd, startArgs, {
+      cwd: resolvedDir,
+      stdio: "inherit"
+    });
+  } else {
+    p.outro("Setup complete! You can start SRouter anytime.");
+  }
+}
+async function initCommand(options) {
+  p.intro(pc.bold(pc.cyan("\u26A1 SRouter Gateway Initialization")));
+  let mode = options.mode;
+  if (!mode) {
+    const choice = await p.select({
+      message: "How would you like to run SRouter?",
+      options: [
+        {
+          value: "docker",
+          label: "Docker (Recommended)",
+          hint: "Zero-config container with isolated environment & persistent database"
+        },
+        {
+          value: "source",
+          label: "Source Code (Node.js & pnpm)",
+          hint: "Clone repository, build from source, and run natively"
+        }
+      ]
+    });
+    if (p.isCancel(choice)) {
+      p.outro("Initialization cancelled.");
+      return;
+    }
+    mode = choice;
+  }
+  let port = options.port;
+  if (!port && !options.yes) {
+    const inputPort = await p.text({
+      message: "Gateway Port:",
+      defaultValue: DEFAULT_PORT,
+      placeholder: DEFAULT_PORT,
+      validate: (val) => {
+        const n = Number(val);
+        if (Number.isNaN(n) || n <= 0 || n > 65535) {
+          return "Please enter a valid port number (1-65535).";
+        }
+      }
+    });
+    if (p.isCancel(inputPort)) {
+      p.outro("Initialization cancelled.");
+      return;
+    }
+    port = inputPort || DEFAULT_PORT;
+  } else {
+    port = port || DEFAULT_PORT;
+  }
+  if (mode === "docker") {
+    const detached = options.detached ?? true;
+    await initDocker(port, detached);
+  } else {
+    const defaultDir = path8.join(os6.homedir(), "srouter");
+    let targetDir = options.dir;
+    if (!targetDir && !options.yes) {
+      const inputDir = await p.text({
+        message: "Target directory for SRouter source code:",
+        defaultValue: defaultDir,
+        placeholder: defaultDir
+      });
+      if (p.isCancel(inputDir)) {
+        p.outro("Initialization cancelled.");
+        return;
+      }
+      targetDir = inputDir || defaultDir;
+    } else {
+      targetDir = targetDir || defaultDir;
+    }
+    await initSource(targetDir, port);
+  }
+}
+
+// src/commands/link.ts
+async function linkCommand(toolId, options) {
+  const adapter = getAdapter(toolId);
+  if (!adapter) {
+    console.error(
+      formatError(
+        `Tool '${pc.bold(toolId)}' not supported. Available tools: ${getAllAdapters().map((a) => a.id).join(", ")}`
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const savedConfig = await defaultStore.loadConfig();
+  const baseUrl = options.url || savedConfig.defaultBaseUrl || "http://localhost:3000/v1";
+  const apiKey = options.key || savedConfig.defaultApiKey;
+  const model = options.model || savedConfig.defaultModel;
+  const opusModel = options.opusModel || savedConfig.defaultOpusModel;
+  const sonnetModel = options.sonnetModel || savedConfig.defaultSonnetModel;
+  const haikuModel = options.haikuModel || savedConfig.defaultHaikuModel;
+  try {
+    const result = await adapter.link({
+      baseUrl,
+      apiKey,
+      model,
+      opusModel,
+      sonnetModel,
+      haikuModel,
+      dryRun: options.dryRun
+    });
+    console.log(
+      formatSuccess(
+        `Successfully configured ${pc.bold(pc.cyan(adapter.name))} with SRouter proxy!`
+      )
+    );
+    console.log(`  ${pc.gray("Target Config:")} ${pc.white(result.modifiedPath)}`);
+    console.log(`  ${pc.gray("Proxy URL:")}     ${pc.white(baseUrl)}`);
+    if (model) {
+      console.log(`  ${pc.gray("Model:")}         ${pc.white(model)}`);
+    }
+    if (opusModel) {
+      console.log(`  ${pc.gray("Opus Model:")}    ${pc.white(opusModel)}`);
+    }
+    if (sonnetModel) {
+      console.log(`  ${pc.gray("Sonnet Model:")}  ${pc.white(sonnetModel)}`);
+    }
+    if (haikuModel) {
+      console.log(`  ${pc.gray("Haiku Model:")}   ${pc.white(haikuModel)}`);
+    }
+    if (result.backupPath) {
+      console.log(`  ${pc.gray("Backup Saved:")}  ${pc.white(result.backupPath)}`);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(formatError(`Failed to link ${adapter.name}: ${msg}`));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/unlink.ts
+async function unlinkCommand(toolId) {
+  const adapter = getAdapter(toolId);
+  if (!adapter) {
+    console.error(
+      formatError(
+        `Tool '${pc.bold(toolId)}' not supported. Available tools: ${getAllAdapters().map((a) => a.id).join(", ")}`
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const restored = await adapter.unlink();
+    if (restored) {
+      console.log(
+        formatSuccess(
+          `Restored original configuration for ${pc.bold(pc.cyan(adapter.name))}!`
+        )
+      );
+    } else {
+      console.log(
+        formatInfo(
+          `No active SRouter configuration or backup found for ${pc.bold(adapter.name)}.`
+        )
+      );
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(formatError(`Failed to unlink ${adapter.name}: ${msg}`));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/sync.ts
+async function syncCommand(toolId, options = {}) {
+  const savedConfig = await defaultStore.loadConfig();
+  const baseUrl = options.url || savedConfig.defaultBaseUrl || "http://localhost:3000/v1";
+  const apiKey = options.key || savedConfig.defaultApiKey;
+  const health = await checkServerHealth(baseUrl, apiKey);
+  if (!health.healthy) {
+    console.error(
+      formatError(
+        `Cannot sync: SRouter Gateway is unreachable at ${pc.bold(baseUrl)} (${health.error || "offline"}).`
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const availableModels = await fetchAvailableModels(baseUrl, apiKey);
+  if (availableModels.length === 0) {
+    console.warn(
+      formatWarning(`SRouter Gateway responded at ${baseUrl}, but returned 0 models.`)
+    );
+  }
+  const adaptersToSync = toolId ? [getAdapter(toolId)].filter((a) => Boolean(a)) : getAllAdapters();
+  if (toolId && adaptersToSync.length === 0) {
+    console.error(formatError(`Tool '${pc.bold(toolId)}' not supported.`));
+    process.exitCode = 1;
+    return;
   }
   for (const adapter of adaptersToSync) {
     if (!adapter) continue;
@@ -1848,7 +3095,7 @@ async function envCommand(toolId, options = {}) {
 }
 
 // src/commands/run.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 async function runCommand(toolId, toolArgs, options = {}) {
   const adapter = getAdapter(toolId);
   if (!adapter) {
@@ -1876,7 +3123,7 @@ async function runCommand(toolId, toolArgs, options = {}) {
     haikuModel
   });
   const binaryName = toolId === "claude" ? "claude" : "opencode";
-  const child = spawn(binaryName, toolArgs, {
+  const child = spawn2(binaryName, toolArgs, {
     stdio: "inherit",
     env: {
       ...process.env,
@@ -1903,254 +3150,11 @@ async function runCommand(toolId, toolArgs, options = {}) {
 }
 
 // src/commands/migrate.ts
-import fs6 from "node:fs";
-import os5 from "node:os";
-import path6 from "node:path";
-import * as p from "@clack/prompts";
+import fs8 from "node:fs";
+import os7 from "node:os";
+import path9 from "node:path";
+import * as p2 from "@clack/prompts";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-
-// ../../packages/db/dist/db.js
-import { DatabaseSync } from "node:sqlite";
-import path5 from "node:path";
-import fs5 from "node:fs";
-import os4 from "node:os";
-var SROUTER_DIR = path5.join(os4.homedir(), ".srouter");
-var DEFAULT_DB_PATH = path5.join(SROUTER_DIR, "srouter.db");
-var LEGACY_DB_LOCATIONS = [
-  path5.resolve(process.cwd(), "apps/api/srouter.db"),
-  path5.resolve(process.cwd(), "srouter.db")
-];
-function getDatabasePath() {
-  if (process.env.DATABASE_PATH)
-    return process.env.DATABASE_PATH;
-  for (const legacyPath of LEGACY_DB_LOCATIONS) {
-    if (fs5.existsSync(legacyPath))
-      return legacyPath;
-  }
-  return DEFAULT_DB_PATH;
-}
-var dbPath = getDatabasePath();
-var dbDir = path5.dirname(dbPath);
-if (!fs5.existsSync(dbDir)) {
-  fs5.mkdirSync(dbDir, { recursive: true });
-}
-var db = new DatabaseSync(dbPath);
-db.exec("PRAGMA busy_timeout = 5000;");
-function execWithRetry(sql, attempts = 5) {
-  for (let i = 0; i < attempts; i++) {
-    try {
-      db.exec(sql);
-      return;
-    } catch (error) {
-      const code = error.code;
-      if (code === "SQLITE_BUSY" && i < attempts - 1) {
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200 * (i + 1));
-        continue;
-      }
-      throw error;
-    }
-  }
-}
-execWithRetry("PRAGMA journal_mode = WAL;");
-execWithRetry("PRAGMA foreign_keys = ON;");
-function ensureColumns(table, columns) {
-  const existing = new Set(db.prepare(`PRAGMA table_info("${table}")`).all().map((col) => col.name));
-  for (const col of columns) {
-    if (existing.has(col.name))
-      continue;
-    try {
-      db.exec(`ALTER TABLE ${table} ADD COLUMN ${col.definition};`);
-      existing.add(col.name);
-    } catch (error) {
-      const message = error.message || "";
-      if (!message.includes("duplicate column name")) {
-        throw error;
-      }
-    }
-  }
-}
-function initDatabase() {
-  db.exec(`
-        CREATE TABLE IF NOT EXISTS providers (
-            id TEXT PRIMARY KEY,
-            provider_id TEXT NOT NULL,
-            name TEXT NOT NULL,
-            category TEXT NOT NULL,
-            protocol TEXT NOT NULL,
-            base_url TEXT,
-            api_key TEXT,
-            access_token TEXT,
-            refresh_token TEXT,
-            custom_headers TEXT,
-            enabled INTEGER NOT NULL DEFAULT 1,
-            created_at INTEGER NOT NULL
-        );
-    `);
-  ensureColumns("providers", [
-    { name: "refresh_token", definition: "refresh_token TEXT" },
-    // Multi-account OAuth binding (e.g. Codex ChatGPT-Account-ID)
-    { name: "account_id", definition: "account_id TEXT" },
-    // Provider-specific metadata (for example Kiro auth method/region/profile ARN)
-    { name: "provider_specific_data", definition: "provider_specific_data TEXT" },
-    // Token expiry tracking
-    { name: "token_expires_at", definition: "token_expires_at INTEGER" },
-    { name: "last_refreshed_at", definition: "last_refreshed_at INTEGER" },
-    // Claude OAuth organization binding
-    { name: "organization_id", definition: "organization_id TEXT" }
-  ]);
-  db.exec(`
-        CREATE TABLE IF NOT EXISTS api_keys (
-            id TEXT PRIMARY KEY,
-            key TEXT UNIQUE NOT NULL,
-            name TEXT NOT NULL,
-            enabled INTEGER NOT NULL DEFAULT 1,
-            rate_limit INTEGER DEFAULT 0,
-            quota_limit INTEGER DEFAULT 0,
-            usage_tokens INTEGER DEFAULT 0,
-            created_at INTEGER NOT NULL
-        );
-    `);
-  db.exec(`
-        CREATE TABLE IF NOT EXISTS request_logs (
-            id TEXT PRIMARY KEY,
-            api_key_id TEXT,
-            provider_id TEXT NOT NULL,
-            model TEXT NOT NULL,
-            prompt_tokens INTEGER NOT NULL DEFAULT 0,
-            completion_tokens INTEGER NOT NULL DEFAULT 0,
-            total_tokens INTEGER NOT NULL DEFAULT 0,
-            status_code INTEGER NOT NULL,
-            latency_ms INTEGER NOT NULL,
-            created_at INTEGER NOT NULL
-        );
-    `);
-  db.exec(`
-        CREATE TABLE IF NOT EXISTS oauth_sessions (
-            state TEXT PRIMARY KEY,
-            code_verifier TEXT NOT NULL,
-            client_id TEXT NOT NULL,
-            redirect_uri TEXT NOT NULL,
-            created_at INTEGER NOT NULL
-        );
-    `);
-  ensureColumns("request_logs", [
-    { name: "cached_tokens", definition: "cached_tokens INTEGER NOT NULL DEFAULT 0" },
-    {
-      name: "cache_creation_tokens",
-      definition: "cache_creation_tokens INTEGER NOT NULL DEFAULT 0"
-    },
-    { name: "reasoning_tokens", definition: "reasoning_tokens INTEGER NOT NULL DEFAULT 0" },
-    { name: "estimated_cost", definition: "estimated_cost REAL NOT NULL DEFAULT 0" },
-    { name: "fallback_occurred", definition: "fallback_occurred INTEGER NOT NULL DEFAULT 0" },
-    { name: "fallback_path", definition: "fallback_path TEXT" },
-    { name: "fallback_reason", definition: "fallback_reason TEXT" },
-    { name: "resolved_model", definition: "resolved_model TEXT" }
-  ]);
-  db.exec(`
-        CREATE TABLE IF NOT EXISTS fallback_rules (
-            id TEXT PRIMARY KEY,
-            source_model TEXT NOT NULL,
-            target_model TEXT NOT NULL,
-            priority INTEGER NOT NULL DEFAULT 1,
-            enabled INTEGER NOT NULL DEFAULT 1,
-            trigger_on_status TEXT,
-            max_retries INTEGER DEFAULT 1,
-            created_at INTEGER NOT NULL
-        );
-    `);
-  db.exec(`
-        CREATE TABLE IF NOT EXISTS system_settings (
-            key TEXT PRIMARY KEY,
-            value TEXT NOT NULL
-        );
-    `);
-  db.exec(`
-        CREATE TABLE IF NOT EXISTS custom_models (
-            provider_id TEXT NOT NULL,
-            model_id TEXT NOT NULL,
-            created_at INTEGER NOT NULL,
-            PRIMARY KEY (provider_id, model_id)
-        );
-    `);
-}
-initDatabase();
-
-// ../../packages/db/dist/row-utils.js
-function str(value, fallback = "") {
-  return value === null || value === void 0 ? fallback : String(value);
-}
-function num(value, fallback = 0) {
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-// ../../packages/db/dist/adminAuth.js
-var AdminAuthStore = class {
-  database;
-  constructor(database = db) {
-    this.database = database;
-    this.database.exec(`
-            CREATE TABLE IF NOT EXISTS admin_account (
-                id INTEGER PRIMARY KEY CHECK (id = 1),
-                password_hash TEXT NOT NULL,
-                created_at INTEGER NOT NULL,
-                updated_at INTEGER NOT NULL
-            );
-
-            CREATE TABLE IF NOT EXISTS admin_sessions (
-                token_hash TEXT PRIMARY KEY,
-                created_at INTEGER NOT NULL,
-                expires_at INTEGER NOT NULL
-            );
-        `);
-  }
-  hasAdminAccount() {
-    const Row = this.database.prepare("SELECT 1 AS present FROM admin_account WHERE id = 1").get();
-    return Boolean(Row);
-  }
-  createAdminAccount(passwordHash, now = Date.now()) {
-    const Result = this.database.prepare(`INSERT OR IGNORE INTO admin_account (id, password_hash, created_at, updated_at)
-                 VALUES (1, ?, ?, ?)`).run(passwordHash, now, now);
-    return num(Result.changes) > 0;
-  }
-  getPasswordHash() {
-    const Row = this.database.prepare("SELECT password_hash FROM admin_account WHERE id = 1").get();
-    return Row?.password_hash ? str(Row.password_hash) : null;
-  }
-  updatePasswordHash(passwordHash, now = Date.now()) {
-    const Result = this.database.prepare(`UPDATE admin_account
-                 SET password_hash = ?, updated_at = ?
-                 WHERE id = 1`).run(passwordHash, now);
-    return num(Result.changes) > 0;
-  }
-  createSession(tokenHash, createdAt, expiresAt) {
-    this.database.prepare(`INSERT INTO admin_sessions (token_hash, created_at, expires_at)
-                 VALUES (?, ?, ?)`).run(tokenHash, createdAt, expiresAt);
-  }
-  getSession(tokenHash, now = Date.now()) {
-    this.database.prepare("DELETE FROM admin_sessions WHERE expires_at <= ?").run(now);
-    const Row = this.database.prepare(`SELECT token_hash, created_at, expires_at
-                 FROM admin_sessions
-                 WHERE token_hash = ? AND expires_at > ?`).get(tokenHash, now);
-    if (!Row)
-      return null;
-    return {
-      tokenHash: str(Row.token_hash),
-      createdAt: num(Row.created_at),
-      expiresAt: num(Row.expires_at)
-    };
-  }
-  deleteSession(tokenHash) {
-    const Result = this.database.prepare("DELETE FROM admin_sessions WHERE token_hash = ?").run(tokenHash);
-    return num(Result.changes) > 0;
-  }
-};
-var adminAuthStore = new AdminAuthStore();
-
-// ../../packages/db/dist/quota.js
-var CN_REFILL_GAP_MS = 2 * 24 * 60 * 60 * 1e3;
-
-// src/commands/migrate.ts
 function parseDateToTimestamp(val) {
   if (typeof val === "number" && Number.isFinite(val)) return val;
   if (typeof val === "string") {
@@ -2279,58 +3283,58 @@ function importNineRouterJson(data, targetDb, action) {
   }
   return { inserted, skipped, tablesCount };
 }
-var TargetDbPath = DEFAULT_DB_PATH;
-var BackupDir = path6.join(SROUTER_DIR, "backups");
+var TargetDbPath = DEFAULT_DB_PATH2;
+var BackupDir = path9.join(SROUTER_DIR2, "backups");
 var NineRouterDbLocations = [
-  path6.join(os5.homedir(), ".9router", "srouter.db"),
-  path6.join(os5.homedir(), ".9router", "9router.db"),
-  path6.join(os5.homedir(), "9router", "srouter.db"),
-  path6.join(os5.homedir(), "9router", "data.db"),
-  path6.join(os5.homedir(), "9router", "db", "srouter.db"),
-  path6.join(os5.homedir(), ".config", "9router", "srouter.db"),
-  path6.join(os5.homedir(), ".config", "9router", "9router.db"),
+  path9.join(os7.homedir(), ".9router", "srouter.db"),
+  path9.join(os7.homedir(), ".9router", "9router.db"),
+  path9.join(os7.homedir(), "9router", "srouter.db"),
+  path9.join(os7.homedir(), "9router", "data.db"),
+  path9.join(os7.homedir(), "9router", "db", "srouter.db"),
+  path9.join(os7.homedir(), ".config", "9router", "srouter.db"),
+  path9.join(os7.homedir(), ".config", "9router", "9router.db"),
   "/root/9router/srouter.db",
   "/root/project/9router/db/srouter.db",
-  ...LEGACY_DB_LOCATIONS
+  ...LEGACY_DB_LOCATIONS2
 ];
 function fileKb(filePath) {
-  return `${(fs6.statSync(filePath).size / 1024).toFixed(2)} KB`;
+  return `${(fs8.statSync(filePath).size / 1024).toFixed(2)} KB`;
 }
 function ensureDirs() {
-  fs6.mkdirSync(SROUTER_DIR, { recursive: true, mode: 448 });
-  fs6.mkdirSync(BackupDir, { recursive: true, mode: 493 });
+  fs8.mkdirSync(SROUTER_DIR2, { recursive: true, mode: 448 });
+  fs8.mkdirSync(BackupDir, { recursive: true, mode: 493 });
 }
 function backupDb(source, label) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupPath = path6.join(BackupDir, `${label}-backup-${timestamp}.db`);
-  fs6.copyFileSync(source, backupPath);
-  p.log.step(`Backed up to ${pc.dim(backupPath)}`);
+  const backupPath = path9.join(BackupDir, `${label}-backup-${timestamp}.db`);
+  fs8.copyFileSync(source, backupPath);
+  p2.log.step(`Backed up to ${pc.dim(backupPath)}`);
   return backupPath;
 }
 function getDownloadDirs() {
-  const home = os5.homedir();
+  const home = os7.homedir();
   const dirs = [
-    path6.join(home, "Downloads"),
-    path6.join(home, "download"),
-    path6.join(home, "downloads"),
-    path6.join(home, "Desktop")
+    path9.join(home, "Downloads"),
+    path9.join(home, "download"),
+    path9.join(home, "downloads"),
+    path9.join(home, "Desktop")
   ];
   if (process.platform === "win32") {
     if (process.env.USERPROFILE) {
-      dirs.push(path6.join(process.env.USERPROFILE, "Downloads"));
-      dirs.push(path6.join(process.env.USERPROFILE, "Desktop"));
+      dirs.push(path9.join(process.env.USERPROFILE, "Downloads"));
+      dirs.push(path9.join(process.env.USERPROFILE, "Desktop"));
     }
   }
-  return Array.from(new Set(dirs.filter((d) => fs6.existsSync(d))));
+  return Array.from(new Set(dirs.filter((d) => fs8.existsSync(d))));
 }
 function scanFor9RouterFiles() {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
   const addFile = (filePath, label) => {
-    const resolved = path6.resolve(filePath);
-    if (!seen.has(resolved) && fs6.existsSync(resolved)) {
+    const resolved = path9.resolve(filePath);
+    if (!seen.has(resolved) && fs8.existsSync(resolved)) {
       try {
-        const stat = fs6.statSync(resolved);
+        const stat = fs8.statSync(resolved);
         if (stat.isFile()) {
           seen.add(resolved);
           results.push({ path: resolved, label, mtime: stat.mtimeMs });
@@ -2344,12 +3348,12 @@ function scanFor9RouterFiles() {
   }
   for (const downloadDir of getDownloadDirs()) {
     try {
-      const files = fs6.readdirSync(downloadDir);
+      const files = fs8.readdirSync(downloadDir);
       for (const file of files) {
         const lower = file.toLowerCase();
-        const fullPath = path6.join(downloadDir, file);
+        const fullPath = path9.join(downloadDir, file);
         if (lower.includes("9router") || lower.includes("srouter-backup") || lower.endsWith(".db") || lower.endsWith(".json") && lower.includes("backup")) {
-          addFile(fullPath, path6.basename(downloadDir));
+          addFile(fullPath, path9.basename(downloadDir));
         }
       }
     } catch {
@@ -2359,88 +3363,88 @@ function scanFor9RouterFiles() {
 }
 function findDatabase(candidates, label) {
   for (const candidate of candidates) {
-    const fullPath = path6.resolve(candidate);
-    if (fs6.existsSync(fullPath)) {
-      p.log.info(`Found ${label} database: ${pc.bold(fullPath)} (${fileKb(fullPath)})`);
+    const fullPath = path9.resolve(candidate);
+    if (fs8.existsSync(fullPath)) {
+      p2.log.info(`Found ${label} database: ${pc.bold(fullPath)} (${fileKb(fullPath)})`);
       return fullPath;
     }
   }
   return null;
 }
 async function migrateDb(options) {
-  p.intro("SRouter Database Migration");
-  if (fs6.existsSync(TargetDbPath)) {
-    p.log.warn(`Database already exists at ${TargetDbPath} (${fileKb(TargetDbPath)})`);
-    p.outro("No migration needed \u2014 already using the new location.");
+  p2.intro("SRouter Database Migration");
+  if (fs8.existsSync(TargetDbPath)) {
+    p2.log.warn(`Database already exists at ${TargetDbPath} (${fileKb(TargetDbPath)})`);
+    p2.outro("No migration needed \u2014 already using the new location.");
     return;
   }
-  const source = options.source && fs6.existsSync(options.source) ? path6.resolve(options.source) : findDatabase(LEGACY_DB_LOCATIONS, "legacy");
+  const source = options.source && fs8.existsSync(options.source) ? path9.resolve(options.source) : findDatabase(LEGACY_DB_LOCATIONS2, "legacy");
   if (!source) {
-    p.log.error("No existing database found.");
-    p.outro(
+    p2.log.error("No existing database found.");
+    p2.outro(
       `Start SRouter and a fresh database will be created at ${TargetDbPath}, or pass --source /path/to/srouter.db.`
     );
     return;
   }
   ensureDirs();
-  const proceed = options.yes || await p.confirm({ message: `Migrate database from ${source}?` }) === true;
+  const proceed = options.yes || await p2.confirm({ message: `Migrate database from ${source}?` }) === true;
   if (!proceed) {
-    p.outro("Migration cancelled.");
+    p2.outro("Migration cancelled.");
     return;
   }
   try {
     backupDb(source, "srouter");
-    fs6.copyFileSync(source, TargetDbPath);
-    fs6.chmodSync(TargetDbPath, 384);
-    p.log.success(`Database moved to ${TargetDbPath}`);
-    p.outro("Restart SRouter to use the migrated database.");
+    fs8.copyFileSync(source, TargetDbPath);
+    fs8.chmodSync(TargetDbPath, 384);
+    p2.log.success(`Database moved to ${TargetDbPath}`);
+    p2.outro("Restart SRouter to use the migrated database.");
   } catch (error) {
-    p.log.error(formatError(`Migration failed: ${error.message}`));
+    p2.log.error(formatError(`Migration failed: ${error.message}`));
     process.exitCode = 1;
   }
 }
 async function migrateNineRouter(options) {
-  p.intro("9Router \u2192 SRouter Database Migration");
-  let source = options.source && fs6.existsSync(options.source) ? path6.resolve(options.source) : null;
+  p2.intro("9Router \u2192 SRouter Database Migration");
+  let source = options.source && fs8.existsSync(options.source) ? path9.resolve(options.source) : null;
   if (!source) {
     const foundFiles = scanFor9RouterFiles();
     if (foundFiles.length === 1) {
       source = foundFiles[0].path;
-      p.log.info(`Found 9Router file: ${pc.bold(source)} (${fileKb(source)}) [${foundFiles[0].label}]`);
+      p2.log.info(`Found 9Router file: ${pc.bold(source)} (${fileKb(source)}) [${foundFiles[0].label}]`);
     } else if (foundFiles.length > 1) {
       if (options.yes) {
         source = foundFiles[0].path;
-        p.log.info(`Auto-selected latest 9Router file: ${pc.bold(source)} (${fileKb(source)})`);
+        p2.log.info(`Auto-selected latest 9Router file: ${pc.bold(source)} (${fileKb(source)})`);
       } else {
-        const choice = await p.select({
+        const choice = await p2.select({
           message: "Multiple 9Router database/backup files found. Select one to migrate:",
           options: [
             ...foundFiles.map((f) => ({
               value: f.path,
-              label: `${path6.basename(f.path)} (${fileKb(f.path)})`,
+              label: `${path9.basename(f.path)} (${fileKb(f.path)})`,
               hint: `${f.label} \u2022 ${f.path}`
             })),
             { value: "custom", label: "Enter custom path manually..." }
           ]
         });
-        if (p.isCancel(choice)) {
-          p.outro("Migration cancelled.");
+        if (p2.isCancel(choice)) {
+          p2.outro("Migration cancelled.");
           return;
         }
         if (choice === "custom") {
-          const customPath = await p.text({
+          const customPath = await p2.text({
             message: "Enter path to 9Router .db or .json backup file:",
             validate: (val) => {
-              if (!val || !fs6.existsSync(path6.resolve(val))) {
+              if (!val || !fs8.existsSync(path9.resolve(val))) {
                 return "File does not exist. Please check the path.";
               }
             }
           });
-          if (p.isCancel(customPath) || !customPath) {
-            p.outro("Migration cancelled.");
+          if (p2.isCancel(customPath) || !customPath) {
+            p2.outro("Migration cancelled.");
             return;
           }
-          source = path6.resolve(customPath);
+          source = path9.resolve(customPath);
         } else {
           source = choice;
         }
@@ -2448,21 +3452,21 @@ async function migrateNineRouter(options) {
     }
   }
   if (!source) {
-    p.log.error("No 9Router database or backup file found.");
-    p.outro(
+    p2.log.error("No 9Router database or backup file found.");
+    p2.outro(
       "Pass the location explicitly: srouter migrate 9router --source /path/to/9router-backup.json"
     );
     process.exitCode = 1;
     return;
   }
-  const existingTarget = fs6.existsSync(TargetDbPath);
+  const existingTarget = fs8.existsSync(TargetDbPath);
   let action = options.action ?? "copy";
   if (existingTarget && !options.action) {
     if (options.yes) {
       action = "merge";
     } else {
-      p.log.warn(`Existing SRouter database found at ${TargetDbPath} (${fileKb(TargetDbPath)})`);
-      const choice = await p.select({
+      p2.log.warn(`Existing SRouter database found at ${TargetDbPath} (${fileKb(TargetDbPath)})`);
+      const choice = await p2.select({
         message: "How should the existing SRouter database be handled?",
         options: [
           { value: "backup_and_replace", label: "Backup current, replace with 9Router data" },
@@ -2470,8 +3474,8 @@ async function migrateNineRouter(options) {
           { value: "abort", label: "Cancel migration" }
         ]
       });
-      if (choice === "abort" || p.isCancel(choice)) {
-        p.outro("Migration cancelled. Your 9Router installation remains intact.");
+      if (choice === "abort" || p2.isCancel(choice)) {
+        p2.outro("Migration cancelled. Your 9Router installation remains intact.");
         return;
       }
       if (choice === "merge" || choice === "backup_and_replace") {
@@ -2479,9 +3483,9 @@ async function migrateNineRouter(options) {
       }
     }
   }
-  const proceed = options.yes || await p.confirm({ message: "Proceed with migration?" }) === true;
+  const proceed = options.yes || await p2.confirm({ message: "Proceed with migration?" }) === true;
   if (!proceed) {
-    p.outro("Migration cancelled. No changes made.");
+    p2.outro("Migration cancelled. No changes made.");
     return;
   }
   ensureDirs();
@@ -2490,10 +3494,10 @@ async function migrateNineRouter(options) {
   if (action === "backup_and_replace") {
     targetBackup = backupDb(TargetDbPath, "srouter");
   }
-  const s = p.spinner();
+  const s = p2.spinner();
   try {
     s.start("Preparing target database");
-    initDatabase();
+    await initDatabase();
     const targetDb = new DatabaseSync2(TargetDbPath);
     targetDb.exec("PRAGMA foreign_keys = OFF;");
     let inserted = 0;
@@ -2502,7 +3506,7 @@ async function migrateNineRouter(options) {
     const isJson = source.endsWith(".json");
     if (isJson) {
       s.message("Reading 9Router JSON backup");
-      const raw = fs6.readFileSync(source, "utf-8");
+      const raw = fs8.readFileSync(source, "utf-8");
       const parsed = JSON.parse(raw);
       const res = importNineRouterJson(parsed, targetDb, action);
       inserted = res.inserted;
@@ -2517,7 +3521,7 @@ async function migrateNineRouter(options) {
       );
       for (const table of sourceTables) {
         if (!targetTables.has(table)) {
-          p.log.warn(`Skipping table ${table} (not recognized by SRouter)`);
+          p2.log.warn(`Skipping table ${table} (not recognized by SRouter)`);
           continue;
         }
         const rows = sourceDb.prepare(`SELECT * FROM "${table}"`).all();
@@ -2526,7 +3530,7 @@ async function migrateNineRouter(options) {
           try {
             targetDb.prepare(`DELETE FROM "${table}"`).run();
           } catch {
-            p.log.warn(`Could not clear table ${table}, rows will be appended`);
+            p2.log.warn(`Could not clear table ${table}, rows will be appended`);
           }
         }
         const sourceColumns = new Set(
@@ -2553,7 +3557,7 @@ async function migrateNineRouter(options) {
     targetDb.exec("PRAGMA foreign_keys = ON;");
     targetDb.close();
     s.stop("Migration complete");
-    p.log.message(
+    p2.log.message(
       [
         `Tables/Categories migrated: ${tablesCount}`,
         `Rows/Items inserted: ${inserted}`,
@@ -2563,14 +3567,14 @@ async function migrateNineRouter(options) {
       ].join("\n")
     );
     if (targetBackup) {
-      p.log.info(`Old SRouter database backed up to ${targetBackup}`);
+      p2.log.info(`Old SRouter database backed up to ${targetBackup}`);
     }
-    p.log.success(formatSuccess(`9Router backup saved to ${sourceBackup}`));
-    p.outro("Your 9Router providers are now available in SRouter.");
+    p2.log.success(formatSuccess(`9Router backup saved to ${sourceBackup}`));
+    p2.outro("Your 9Router providers are now available in SRouter.");
   } catch (error) {
     s.stop(formatError("Migration failed"));
-    p.log.error(error.message);
-    p.log.info(formatInfo(`Restore from backup if needed: cp ${sourceBackup} ${source}`));
+    p2.log.error(error.message);
+    p2.log.info(formatInfo(`Restore from backup if needed: cp ${sourceBackup} ${source}`));
     process.exitCode = 1;
   }
 }
@@ -2581,8 +3585,8 @@ async function migrateCommand(target, options) {
     case "9router":
       return migrateNineRouter(options);
     default:
-      p.log.error(formatError(`Unknown migration target: ${target}`));
-      p.log.info(
+      p2.log.error(formatError(`Unknown migration target: ${target}`));
+      p2.log.info(
         formatWarning("Available targets: db (legacy location), 9router (9Router import)")
       );
       process.exitCode = 1;
@@ -2609,6 +3613,9 @@ function createCli() {
   ).action(async (opts) => {
     await setupCommand(opts);
   });
+  program.command("init").description("Initialize and run SRouter Gateway (Docker container or Source Code)").option("-m, --mode <mode>", "Run mode (docker or source)").option("-p, --port <port>", "Gateway port (default: 3000)").option("-d, --dir <dir>", "Source code clone directory (default: ~/srouter)").option("-y, --yes", "Accept default values without interactive prompt").option("--detached", "Run docker container in background (default: true)").action(async (opts) => {
+    await initCommand(opts);
+  });
   program.command("link <tool>").description("Configure a specific tool to use SRouter proxy (claude, opencode)").option("-u, --url <url>", "SRouter Gateway Base URL (e.g. http://localhost:3000/v1)").option("-k, --key <key>", "SRouter API Key").option("-m, --model <model>", "Model ID").option(
     "--opus-model <model>",
     "Opus tier model ID for Claude Code (ANTHROPIC_DEFAULT_OPUS_MODEL)"
@@ -2661,10 +3668,14 @@ function createCli() {
   });
   return program;
 }
-if (process.argv[1]?.endsWith("srouter.js") || process.argv[1]?.endsWith("index.ts") || process.argv[1]?.endsWith("index.js")) {
-  const program = createCli();
-  program.parse(process.argv);
+function runCli() {
+  const isEntrypoint = process.argv[1]?.endsWith("srouter.js") || process.argv[1]?.endsWith("index.js") || process.argv[1]?.endsWith("index.ts") || process.argv[1]?.includes("/.bin/srouter") || process.argv[1]?.includes("/bin/srouter");
+  if (isEntrypoint) {
+    const program = createCli();
+    program.parse(process.argv);
+  }
 }
+runCli();
 export {
   createCli
 };