@srouter/cli 0.1.4 → 0.1.5-rc.1

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,11 +295,8 @@ 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)" },
-  { id: "nemotron-3-ultra-free", name: "Nemotron 3 Ultra (Free)" },
   { id: "mimo-v2.5-free", name: "Xiaomi MiMo V2.5 (Free)" }
 ];
 var OPENCODE_ZEN_MODEL_IDS = OPENCODE_ZEN_MODELS.map((m) => m.id);
@@ -312,6 +314,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 +345,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 +365,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.6";
+var CLI_VERSION = "0.1.5-rc.1";
 var SROUTER_VERSION_TAG = `v${GLOBAL_VERSION}`;
 
 // src/commands/setup.ts
@@ -475,10 +498,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 +511,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":
@@ -550,9 +573,9 @@ function getClaudeConfigPath() {
     candidatePaths.push(path2.join(process.env.CLAUDE_CONFIG_DIR, "settings.json"));
     candidatePaths.push(path2.join(process.env.CLAUDE_CONFIG_DIR, "config.json"));
   }
+  candidatePaths.push(path2.join(home, ".claude.json"));
   candidatePaths.push(path2.join(home, ".claude", "settings.json"));
   candidatePaths.push(path2.join(home, ".config", "claude", "settings.json"));
-  candidatePaths.push(path2.join(home, ".claude.json"));
   if (isWindows()) {
     const appData = process.env.APPDATA || path2.join(home, "AppData", "Roaming");
     candidatePaths.push(path2.join(appData, "Claude", "settings.json"));
@@ -561,9 +584,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 +628,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()) {
@@ -666,38 +689,55 @@ var ClaudeAdapter = class extends AbstractToolAdapter {
   async getStatus() {
     const configPath = this.getConfigPath();
     const installed = await this.isInstalled();
-    try {
-      const raw = await fs3.readFile(configPath, "utf-8");
-      const parsed = parseJsonSafe(raw);
-      const baseUrl = parsed.env?.ANTHROPIC_BASE_URL || parsed.ANTHROPIC_BASE_URL || parsed.baseUrl || void 0;
-      const model = parsed.env?.ANTHROPIC_DEFAULT_MODEL || parsed.env?.ANTHROPIC_MODEL || parsed.model || parsed.ANTHROPIC_MODEL || void 0;
-      const opusModel = parsed.env?.ANTHROPIC_DEFAULT_OPUS_MODEL || parsed.ANTHROPIC_DEFAULT_OPUS_MODEL || parsed.env?.ANTHROPIC_OPUS_MODEL || parsed.ANTHROPIC_OPUS_MODEL || void 0;
-      const sonnetModel = parsed.env?.ANTHROPIC_DEFAULT_SONNET_MODEL || parsed.ANTHROPIC_DEFAULT_SONNET_MODEL || parsed.env?.ANTHROPIC_SONNET_MODEL || parsed.ANTHROPIC_SONNET_MODEL || void 0;
-      const haikuModel = parsed.env?.ANTHROPIC_DEFAULT_HAIKU_MODEL || parsed.ANTHROPIC_DEFAULT_HAIKU_MODEL || parsed.env?.ANTHROPIC_HAIKU_MODEL || parsed.ANTHROPIC_HAIKU_MODEL || void 0;
-      const linked = Boolean(
-        baseUrl && (baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1") || baseUrl.includes("srouter"))
-      );
-      return {
-        id: this.id,
-        name: this.name,
-        installed,
-        linked,
-        configPath,
-        currentBaseUrl: baseUrl,
-        currentModel: model,
-        currentOpusModel: opusModel,
-        currentSonnetModel: sonnetModel,
-        currentHaikuModel: haikuModel
-      };
-    } catch {
-      return {
-        id: this.id,
-        name: this.name,
-        installed,
-        linked: false,
-        configPath
-      };
+    const candidatePaths = [configPath];
+    if (!this.customConfigPath) {
+      const homeClaudeJson = path3.join(os3.homedir(), ".claude.json");
+      const homeClaudeSettings = path3.join(os3.homedir(), ".claude", "settings.json");
+      if (!candidatePaths.includes(homeClaudeJson)) candidatePaths.push(homeClaudeJson);
+      if (!candidatePaths.includes(homeClaudeSettings)) candidatePaths.push(homeClaudeSettings);
+    }
+    let unlinkedModel;
+    let unlinkedBaseUrl;
+    for (const targetPath of candidatePaths) {
+      try {
+        const raw = await fs3.readFile(targetPath, "utf-8");
+        const parsed = parseJsonSafe(raw);
+        const baseUrl = parsed.env?.ANTHROPIC_BASE_URL || parsed.ANTHROPIC_BASE_URL || parsed.baseUrl || void 0;
+        const model = parsed.env?.ANTHROPIC_DEFAULT_MODEL || parsed.env?.ANTHROPIC_MODEL || parsed.model || parsed.ANTHROPIC_MODEL || void 0;
+        const opusModel = parsed.env?.ANTHROPIC_DEFAULT_OPUS_MODEL || parsed.ANTHROPIC_DEFAULT_OPUS_MODEL || parsed.env?.ANTHROPIC_OPUS_MODEL || parsed.ANTHROPIC_OPUS_MODEL || void 0;
+        const sonnetModel = parsed.env?.ANTHROPIC_DEFAULT_SONNET_MODEL || parsed.ANTHROPIC_DEFAULT_SONNET_MODEL || parsed.env?.ANTHROPIC_SONNET_MODEL || parsed.ANTHROPIC_SONNET_MODEL || void 0;
+        const haikuModel = parsed.env?.ANTHROPIC_DEFAULT_HAIKU_MODEL || parsed.ANTHROPIC_DEFAULT_HAIKU_MODEL || parsed.env?.ANTHROPIC_HAIKU_MODEL || parsed.ANTHROPIC_HAIKU_MODEL || void 0;
+        const linked = Boolean(
+          baseUrl && (baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1") || baseUrl.includes("srouter"))
+        );
+        if (linked) {
+          return {
+            id: this.id,
+            name: this.name,
+            installed,
+            linked: true,
+            configPath: targetPath,
+            currentBaseUrl: baseUrl,
+            currentModel: model,
+            currentOpusModel: opusModel,
+            currentSonnetModel: sonnetModel,
+            currentHaikuModel: haikuModel
+          };
+        }
+        if (!unlinkedModel && model) unlinkedModel = model;
+        if (!unlinkedBaseUrl && baseUrl) unlinkedBaseUrl = baseUrl;
+      } catch {
+      }
     }
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      linked: false,
+      configPath,
+      currentBaseUrl: unlinkedBaseUrl,
+      currentModel: unlinkedModel
+    };
   }
   async link(context) {
     const configPath = this.getConfigPath();
@@ -721,6 +761,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 +824,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 +844,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 +924,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 +1360,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 +1396,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 +1427,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 +1443,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 +1462,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 +1483,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 +1498,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 +1511,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;
@@ -1136,9 +1534,183 @@ var OpenCodeAdapter = class extends AbstractToolAdapter {
   }
 };
 
+// src/adapters/hindsight.ts
+import fs6 from "node:fs/promises";
+import fsSync from "node:fs";
+import path6 from "node:path";
+import os4 from "node:os";
+function getHindsightConfigPath() {
+  const cwdEnv = path6.join(process.cwd(), ".env");
+  const homeHindsightEnv = path6.join(os4.homedir(), ".hindsight", ".env");
+  if (process.env.HINDSIGHT_CONFIG_PATH) {
+    return process.env.HINDSIGHT_CONFIG_PATH;
+  }
+  try {
+    if (fsSync.existsSync(cwdEnv)) {
+      const content = fsSync.readFileSync(cwdEnv, "utf-8");
+      if (content.includes("HINDSIGHT_")) {
+        return cwdEnv;
+      }
+    }
+    if (fsSync.existsSync(homeHindsightEnv)) {
+      return homeHindsightEnv;
+    }
+  } catch {
+  }
+  return homeHindsightEnv;
+}
+function parseEnvLines(content) {
+  const map = /* @__PURE__ */ new Map();
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx > 0) {
+      const key = trimmed.slice(0, eqIdx).trim();
+      let val = trimmed.slice(eqIdx + 1).trim();
+      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+        val = val.slice(1, -1);
+      }
+      map.set(key, val);
+    }
+  }
+  return map;
+}
+function updateEnvContent(content, updates) {
+  const lines = content.split("\n");
+  const updatedKeys = /* @__PURE__ */ new Set();
+  const newLines = lines.map((line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return line;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx > 0) {
+      const key = trimmed.slice(0, eqIdx).trim();
+      if (key in updates) {
+        updatedKeys.add(key);
+        return `${key}="${updates[key]}"`;
+      }
+    }
+    return line;
+  });
+  for (const [k, v] of Object.entries(updates)) {
+    if (!updatedKeys.has(k)) {
+      newLines.push(`${k}="${v}"`);
+    }
+  }
+  return newLines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+var HindsightAdapter = class extends AbstractToolAdapter {
+  id = "hindsight";
+  name = "Hindsight";
+  description = "Vectorize agent memory system (retain, recall, reflect)";
+  customConfigPath;
+  constructor(store = defaultStore, customConfigPath) {
+    super(store);
+    this.customConfigPath = customConfigPath;
+  }
+  getConfigPath() {
+    if (this.customConfigPath) {
+      return this.customConfigPath;
+    }
+    return getHindsightConfigPath();
+  }
+  async isInstalled() {
+    return await isExecutableInPath("hindsight") || Boolean(process.env.HINDSIGHT_API_URL) || Boolean(process.env.HINDSIGHT_API_LLM_PROVIDER);
+  }
+  async getStatus() {
+    const configPath = this.getConfigPath();
+    const installed = await this.isInstalled();
+    try {
+      const raw = await fs6.readFile(configPath, "utf-8");
+      const envMap = parseEnvLines(raw);
+      const baseUrl = envMap.get("HINDSIGHT_API_LLM_BASE_URL");
+      const model = envMap.get("HINDSIGHT_API_LLM_MODEL");
+      const linked = Boolean(
+        baseUrl && (baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1") || baseUrl.includes("srouter"))
+      );
+      return {
+        id: this.id,
+        name: this.name,
+        installed,
+        linked,
+        configPath,
+        currentBaseUrl: baseUrl,
+        currentModel: model
+      };
+    } catch {
+      return {
+        id: this.id,
+        name: this.name,
+        installed,
+        linked: false,
+        configPath
+      };
+    }
+  }
+  async link(context) {
+    const configPath = this.getConfigPath();
+    const backupPath = context.dryRun ? void 0 : await this.store.createBackup(this.id, configPath);
+    let existingContent = "";
+    try {
+      existingContent = await fs6.readFile(configPath, "utf-8");
+    } catch {
+      existingContent = "# Hindsight Environment Configuration\n";
+    }
+    const model = context.model || "antigravity/claude-sonnet-4-6";
+    const apiKey = context.apiKey || "\xABredacted:sk-\u2026\xBB";
+    const normalizedBaseUrl = context.baseUrl.replace(/\/+$/, "");
+    const updates = {
+      HINDSIGHT_API_LLM_PROVIDER: "openai",
+      HINDSIGHT_API_LLM_BASE_URL: normalizedBaseUrl,
+      HINDSIGHT_API_LLM_API_KEY: apiKey,
+      HINDSIGHT_API_LLM_MODEL: model
+    };
+    const updatedContent = updateEnvContent(existingContent, updates);
+    if (!context.dryRun) {
+      await fs6.mkdir(path6.dirname(configPath), { recursive: true });
+      await fs6.writeFile(configPath, updatedContent, "utf-8");
+    }
+    return {
+      backupPath,
+      modifiedPath: configPath
+    };
+  }
+  async unlink() {
+    const restored = await this.store.restoreLatestBackup(this.id);
+    if (restored) {
+      return true;
+    }
+    const configPath = this.getConfigPath();
+    try {
+      const raw = await fs6.readFile(configPath, "utf-8");
+      const lines = raw.split("\n");
+      const filtered = lines.filter((l) => {
+        const trimmed = l.trim();
+        return !trimmed.startsWith("HINDSIGHT_API_LLM_PROVIDER=") && !trimmed.startsWith("HINDSIGHT_API_LLM_BASE_URL=") && !trimmed.startsWith("HINDSIGHT_API_LLM_API_KEY=") && !trimmed.startsWith("HINDSIGHT_API_LLM_MODEL=");
+      });
+      await fs6.writeFile(configPath, filtered.join("\n"), "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getEnv(context) {
+    const model = context.model || "antigravity/claude-sonnet-4-6";
+    const apiKey = context.apiKey || "\xABredacted:sk-\u2026\xBB";
+    const normalizedBaseUrl = context.baseUrl.replace(/\/+$/, "");
+    return {
+      HINDSIGHT_API_LLM_PROVIDER: "openai",
+      HINDSIGHT_API_LLM_BASE_URL: normalizedBaseUrl,
+      HINDSIGHT_API_LLM_API_KEY: apiKey,
+      HINDSIGHT_API_LLM_MODEL: model
+    };
+  }
+};
+
 // src/adapters/index.ts
 function createAdapters(store = defaultStore) {
-  return [new ClaudeAdapter(store), new OpenCodeAdapter(store)];
+  return [new ClaudeAdapter(store), new OpenCodeAdapter(store), new HindsightAdapter(store)];
 }
 var cachedAdapters = null;
 function getAllAdapters() {
@@ -1566,17 +2138,903 @@ ${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 fs8 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/sqlite.js
+import path7 from "node:path";
+import fs7 from "node:fs";
+import os5 from "node:os";
+import { DatabaseSync } from "node:sqlite";
+var SROUTER_DIR = path7.join(os5.homedir(), ".srouter");
+var DEFAULT_DB_PATH = path7.join(SROUTER_DIR, "srouter.db");
+var LEGACY_DB_LOCATIONS = [
+  path7.resolve(process.cwd(), "apps/api/srouter.db"),
+  path7.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 (fs7.existsSync(legacyPath))
+      return legacyPath;
+  }
+  return DEFAULT_DB_PATH;
+}
+function assertNotProductionDatabaseInTests(dbPath) {
+  if (process.env.NODE_ENV !== "test")
+    return;
+  if (path7.resolve(dbPath) === path7.resolve(DEFAULT_DB_PATH)) {
+    throw new Error(`Refusing to open the production database (DATABASE_PATH points at ${DEFAULT_DB_PATH}) while NODE_ENV=test. Run tests through \`pnpm test\` so tests/setup.ts redirects to an isolated temp database.`);
+  }
+}
+function openDatabase(dbPath) {
+  assertNotProductionDatabaseInTests(dbPath);
+  const dbDir = path7.dirname(dbPath);
+  if (!fs7.existsSync(dbDir)) {
+    fs7.mkdirSync(dbDir, { recursive: true });
+  }
+  const db2 = new DatabaseSync(dbPath);
+  db2.exec("PRAGMA busy_timeout = 5000;");
+  for (let i = 0; i < 5; i++) {
+    try {
+      db2.exec("PRAGMA journal_mode = WAL;");
+      break;
+    } catch (error) {
+      const code = error.code;
+      if (code !== "SQLITE_BUSY" || i === 4)
+        throw error;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200 * (i + 1));
+    }
+  }
+  db2.exec("PRAGMA foreign_keys = ON;");
+  db2.exec("PRAGMA synchronous = NORMAL;");
+  db2.exec("PRAGMA temp_store = MEMORY;");
+  db2.exec("PRAGMA cache_size = -20000;");
+  return db2;
+}
+var _sqliteDb = null;
+var _sqliteDbPath = null;
+function getSqliteDbInstance() {
+  const dbPath = getDatabasePath();
+  if (!_sqliteDb || _sqliteDbPath !== path7.resolve(dbPath)) {
+    try {
+      _sqliteDb?.close();
+    } catch {
+    }
+    _sqliteDb = openDatabase(dbPath);
+    _sqliteDbPath = path7.resolve(dbPath);
+  }
+  return _sqliteDb;
+}
+var sqliteDb = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getSqliteDbInstance();
+    const value = instance[prop];
+    return typeof value === "function" ? value.bind(instance) : value;
+  }
+});
+
+// ../../packages/db/dist/client.js
+import {} from "node:sqlite";
+var SqliteClient = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  /** Normalize undefined → null (node:sqlite previously tolerated undefined; pg needs null). */
+  normalizeParams(params) {
+    return params.map((p3) => p3 === void 0 ? null : p3);
+  }
+  all(sql, ...params) {
+    return Promise.resolve(this.db.prepare(sql).all(...this.normalizeParams(params)));
+  }
+  get(sql, ...params) {
+    return Promise.resolve(this.db.prepare(sql).get(...this.normalizeParams(params)));
+  }
+  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 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 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;
+    }
+  }
+}
+execWithRetry("PRAGMA journal_mode = WAL;");
+execWithRetry("PRAGMA foreign_keys = ON;");
+execWithRetry("PRAGMA synchronous = NORMAL;");
+execWithRetry("PRAGMA temp_store = MEMORY;");
+execWithRetry("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: "ip_address", definition: "TEXT" },
+      { name: "user_agent", 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: "ip_address", definition: "ip_address TEXT" },
+    { name: "user_agent", definition: "user_agent TEXT" },
+    { 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: "ip_address", definition: "ip_address TEXT" },
+    { name: "user_agent", definition: "user_agent TEXT" },
+    { 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_DIR, "data");
+  fs8.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 (!fs8.existsSync(path8.join(resolvedDir, "package.json"))) {
+    s.message(`Cloning SRouter into ${pc.bold(resolvedDir)}`);
+    fs8.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";
@@ -1848,7 +3306,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 +3334,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,412 +3361,437 @@ async function runCommand(toolId, toolArgs, options = {}) {
 }
 
 // src/commands/migrate.ts
-import fs6 from "node:fs";
-import path6 from "node:path";
-import * as p from "@clack/prompts";
+import fs9 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;
+function parseDateToTimestamp(val) {
+  if (typeof val === "number" && Number.isFinite(val)) return val;
+  if (typeof val === "string") {
+    const parsed = Date.parse(val);
+    if (!Number.isNaN(parsed)) return parsed;
   }
-  return DEFAULT_DB_PATH;
+  return Date.now();
 }
-var dbPath = getDatabasePath();
-var dbDir = path5.dirname(dbPath);
-if (!fs5.existsSync(dbDir)) {
-  fs5.mkdirSync(dbDir, { recursive: true });
+function map9RouterProtocol(apiType, type) {
+  if (apiType === "anthropic" || type === "anthropic" || type?.includes("anthropic")) {
+    return "anthropic";
+  }
+  return "openai";
 }
-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;
+function importNineRouterJson(data, targetDb, action) {
+  const nodesMap = /* @__PURE__ */ new Map();
+  if (Array.isArray(data.providerNodes)) {
+    for (const node of data.providerNodes) {
+      nodesMap.set(node.id, node);
     }
   }
-}
-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;
+  if (action !== "copy") {
     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;
-      }
+      targetDb.prepare('DELETE FROM "providers"').run();
+      targetDb.prepare('DELETE FROM "api_keys"').run();
+      targetDb.prepare('DELETE FROM "custom_models"').run();
+    } catch {
     }
   }
-}
-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
+  let inserted = 0;
+  let skipped = 0;
+  let tablesCount = 0;
+  if (Array.isArray(data.providerConnections) && data.providerConnections.length > 0) {
+    tablesCount++;
+    const insertProvider = targetDb.prepare(`
+            INSERT OR REPLACE INTO providers (
+                id, provider_id, name, category, protocol, base_url, api_key, access_token,
+                refresh_token, account_id, organization_id, token_expires_at, last_refreshed_at,
+                custom_headers, provider_specific_data, enabled, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+    for (const conn of data.providerConnections) {
+      try {
+        const node = nodesMap.get(conn.provider);
+        const providerId = node ? node.name.toLowerCase() : conn.provider;
+        const protocol = node ? map9RouterProtocol(node.apiType, node.type) : "openai";
+        const baseUrl = node?.baseUrl ?? conn.providerSpecificData?.baseUrl ?? null;
+        const apiKey = conn.apiKey ?? null;
+        const accessToken = conn.accessToken ?? conn.access_token ?? null;
+        const refreshToken = conn.refreshToken ?? conn.refresh_token ?? null;
+        const tokenExpiresAt = conn.tokenExpiresAt ?? (conn.expiresAt ? parseDateToTimestamp(conn.expiresAt) : null);
+        const lastRefreshedAt = conn.lastRefreshedAt ?? (conn.lastRefreshAt ? parseDateToTimestamp(conn.lastRefreshAt) : null);
+        const accountId = conn.providerSpecificData?.chatgptAccountId ?? conn.providerSpecificData?.accountId ?? null;
+        const orgId = conn.providerSpecificData?.organizationId ?? null;
+        const enabled = conn.isActive === false ? 0 : 1;
+        const createdAt = parseDateToTimestamp(conn.createdAt);
+        insertProvider.run(
+          conn.id,
+          providerId,
+          conn.name || providerId,
+          "general",
+          protocol,
+          baseUrl,
+          apiKey,
+          accessToken,
+          refreshToken,
+          accountId,
+          orgId,
+          tokenExpiresAt,
+          lastRefreshedAt,
+          null,
+          conn.providerSpecificData ? JSON.stringify(conn.providerSpecificData) : null,
+          enabled,
+          createdAt
         );
-    `);
-  db.exec(`
-        CREATE TABLE IF NOT EXISTS system_settings (
-            key TEXT PRIMARY KEY,
-            value TEXT NOT NULL
+        inserted++;
+      } catch {
+        skipped++;
+      }
+    }
+  }
+  if (Array.isArray(data.apiKeys) && data.apiKeys.length > 0) {
+    tablesCount++;
+    const insertKey = targetDb.prepare(`
+            INSERT OR REPLACE INTO api_keys (
+                id, key, name, enabled, rate_limit, quota_limit, usage_tokens, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+    for (const keyItem of data.apiKeys) {
+      try {
+        insertKey.run(
+          keyItem.id || `key_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+          keyItem.key,
+          keyItem.name || "Default Key",
+          keyItem.isActive === false ? 0 : 1,
+          0,
+          0,
+          0,
+          parseDateToTimestamp(keyItem.createdAt)
         );
-    `);
-  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)
+        inserted++;
+      } catch {
+        skipped++;
+      }
+    }
+  }
+  if (Array.isArray(data.customModels) && data.customModels.length > 0) {
+    tablesCount++;
+    const insertCustomModel = targetDb.prepare(`
+            INSERT OR IGNORE INTO custom_models (
+                provider_id, model_id, created_at
+            ) VALUES (?, ?, ?)
+        `);
+    for (const model of data.customModels) {
+      try {
+        insertCustomModel.run(
+          model.providerAlias || "default",
+          model.id || model.name || "unknown",
+          Date.now()
         );
-    `);
+        inserted++;
+      } catch {
+        skipped++;
+      }
+    }
+  }
+  return { inserted, skipped, tablesCount };
 }
-initDatabase();
-
-// ../../packages/db/dist/row-utils.js
-function str(value, fallback = "") {
-  return value === null || value === void 0 ? fallback : String(value);
+function getTargetDbPath() {
+  return getDatabasePath();
 }
-function num(value, fallback = 0) {
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
+function getBackupDir(targetDbPath) {
+  return path9.join(path9.dirname(targetDbPath), "backups");
 }
-
-// ../../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
-var TargetDbPath = DEFAULT_DB_PATH;
-var BackupDir = path6.join(SROUTER_DIR, "backups");
 var NineRouterDbLocations = [
+  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
 ];
 function fileKb(filePath) {
-  return `${(fs6.statSync(filePath).size / 1024).toFixed(2)} KB`;
+  return `${(fs9.statSync(filePath).size / 1024).toFixed(2)} KB`;
 }
-function ensureDirs() {
-  fs6.mkdirSync(SROUTER_DIR, { recursive: true, mode: 448 });
-  fs6.mkdirSync(BackupDir, { recursive: true, mode: 493 });
+function ensureDirs(targetDbPath) {
+  fs9.mkdirSync(path9.dirname(targetDbPath), { recursive: true, mode: 448 });
+  fs9.mkdirSync(getBackupDir(targetDbPath), { recursive: true, mode: 493 });
 }
-function backupDb(source, label) {
+function backupDb(source, label, targetDbPath) {
   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(getBackupDir(targetDbPath), `${label}-backup-${timestamp}.db`);
+  fs9.copyFileSync(source, backupPath);
+  p2.log.step(`Backed up to ${pc.dim(backupPath)}`);
   return backupPath;
 }
+function getDownloadDirs() {
+  const home = os7.homedir();
+  const dirs = [
+    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(path9.join(process.env.USERPROFILE, "Downloads"));
+      dirs.push(path9.join(process.env.USERPROFILE, "Desktop"));
+    }
+  }
+  return Array.from(new Set(dirs.filter((d) => fs9.existsSync(d))));
+}
+function scanFor9RouterFiles() {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addFile = (filePath, label) => {
+    const resolved = path9.resolve(filePath);
+    if (!seen.has(resolved) && fs9.existsSync(resolved)) {
+      try {
+        const stat = fs9.statSync(resolved);
+        if (stat.isFile()) {
+          seen.add(resolved);
+          results.push({ path: resolved, label, mtime: stat.mtimeMs });
+        }
+      } catch {
+      }
+    }
+  };
+  for (const loc of NineRouterDbLocations) {
+    addFile(loc, "Installed Database");
+  }
+  for (const downloadDir of getDownloadDirs()) {
+    try {
+      const files = fs9.readdirSync(downloadDir);
+      for (const file of files) {
+        const lower = file.toLowerCase();
+        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, path9.basename(downloadDir));
+        }
+      }
+    } catch {
+    }
+  }
+  return results.sort((a, b) => b.mtime - a.mtime);
+}
 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 (fs9.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");
+  const targetDbPath = getTargetDbPath();
+  if (fs9.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 && fs9.existsSync(options.source) ? path9.resolve(options.source) : findDatabase(LEGACY_DB_LOCATIONS, "legacy");
   if (!source) {
-    p.log.error("No existing database found.");
-    p.outro(
-      `Start SRouter and a fresh database will be created at ${TargetDbPath}, or pass --source /path/to/srouter.db.`
+    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;
+  ensureDirs(targetDbPath);
+  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.");
+    backupDb(source, "srouter", targetDbPath);
+    fs9.copyFileSync(source, targetDbPath);
+    fs9.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");
-  const source = options.source && fs6.existsSync(options.source) ? path6.resolve(options.source) : findDatabase(NineRouterDbLocations, "9Router");
+  p2.intro("9Router \u2192 SRouter Database Migration");
+  let source = options.source && fs9.existsSync(options.source) ? path9.resolve(options.source) : null;
   if (!source) {
-    p.log.error("No 9Router database found.");
-    p.outro(
-      "Pass the location explicitly: srouter migrate 9router --source /path/to/9router.db"
+    const foundFiles = scanFor9RouterFiles();
+    if (foundFiles.length === 1) {
+      source = foundFiles[0].path;
+      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;
+        p2.log.info(`Auto-selected latest 9Router file: ${pc.bold(source)} (${fileKb(source)})`);
+      } else {
+        const choice = await p2.select({
+          message: "Multiple 9Router database/backup files found. Select one to migrate:",
+          options: [
+            ...foundFiles.map((f) => ({
+              value: f.path,
+              label: `${path9.basename(f.path)} (${fileKb(f.path)})`,
+              hint: `${f.label} \u2022 ${f.path}`
+            })),
+            { value: "custom", label: "Enter custom path manually..." }
+          ]
+        });
+        if (p2.isCancel(choice)) {
+          p2.outro("Migration cancelled.");
+          return;
+        }
+        if (choice === "custom") {
+          const customPath = await p2.text({
+            message: "Enter path to 9Router .db or .json backup file:",
+            validate: (val) => {
+              if (!val || !fs9.existsSync(path9.resolve(val))) {
+                return "File does not exist. Please check the path.";
+              }
+            }
+          });
+          if (p2.isCancel(customPath) || !customPath) {
+            p2.outro("Migration cancelled.");
+            return;
+          }
+          source = path9.resolve(customPath);
+        } else {
+          source = choice;
+        }
+      }
+    }
+  }
+  if (!source) {
+    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);
-  let action = "copy";
-  if (existingTarget) {
-    p.log.warn(`Existing SRouter database found at ${TargetDbPath} (${fileKb(TargetDbPath)})`);
-    const choice = await p.select({
-      message: "How should the existing SRouter database be handled?",
-      options: [
-        { value: "backup_and_replace", label: "Backup current, replace with 9Router data" },
-        { value: "merge", label: "Overwrite tables with 9Router data" },
-        { value: "abort", label: "Cancel migration" }
-      ]
-    });
-    if (choice === "abort" || p.isCancel(choice)) {
-      p.outro("Migration cancelled. Your 9Router installation remains intact.");
-      return;
-    }
-    if (choice === "merge" || choice === "backup_and_replace") {
-      action = choice;
+  const targetDbPath = getTargetDbPath();
+  const existingTarget = fs9.existsSync(targetDbPath);
+  let action = options.action ?? "copy";
+  if (existingTarget && !options.action) {
+    if (options.yes) {
+      action = "merge";
+    } else {
+      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" },
+          { value: "merge", label: "Overwrite tables with 9Router data" },
+          { value: "abort", label: "Cancel migration" }
+        ]
+      });
+      if (choice === "abort" || p2.isCancel(choice)) {
+        p2.outro("Migration cancelled. Your 9Router installation remains intact.");
+        return;
+      }
+      if (choice === "merge" || choice === "backup_and_replace") {
+        action = choice;
+      }
     }
   }
-  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();
-  const sourceBackup = backupDb(source, "9router");
+  ensureDirs(targetDbPath);
+  const sourceBackup = backupDb(source, "9router", targetDbPath);
   let targetBackup = null;
   if (action === "backup_and_replace") {
-    targetBackup = backupDb(TargetDbPath, "srouter");
+    targetBackup = backupDb(targetDbPath, "srouter", targetDbPath);
   }
-  const s = p.spinner();
+  const s = p2.spinner();
   try {
-    s.start("Opening databases");
-    const sourceDb = new DatabaseSync2(source);
-    const targetDb = new DatabaseSync2(TargetDbPath);
-    s.message("Reading source tables");
-    const tables = sourceDb.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all().map((t) => t.name);
+    s.start("Preparing target database");
+    await initDatabase();
+    const targetDb = new DatabaseSync2(targetDbPath);
+    targetDb.exec("PRAGMA foreign_keys = OFF;");
     let inserted = 0;
     let skipped = 0;
-    for (const table of tables) {
-      const rows = sourceDb.prepare(`SELECT * FROM "${table}"`).all();
-      if (rows.length === 0) continue;
-      if (action !== "copy") {
-        try {
-          targetDb.prepare(`DELETE FROM "${table}"`).run();
-        } catch {
-          p.log.warn(`Could not clear table ${table}, rows will be appended`);
-        }
-      }
-      const columns = sourceDb.prepare(`PRAGMA table_info("${table}")`).all().map((col) => col.name);
-      const placeholders = columns.map(() => "?").join(", ");
-      const insert = targetDb.prepare(
-        `INSERT INTO "${table}" (${columns.join(", ")}) VALUES (${placeholders})`
+    let tablesCount = 0;
+    const isJson = source.endsWith(".json");
+    if (isJson) {
+      s.message("Reading 9Router JSON backup");
+      const raw = fs9.readFileSync(source, "utf-8");
+      const parsed = JSON.parse(raw);
+      const res = importNineRouterJson(parsed, targetDb, action);
+      inserted = res.inserted;
+      skipped = res.skipped;
+      tablesCount = res.tablesCount;
+    } else {
+      const sourceDb = new DatabaseSync2(source);
+      s.message("Reading source SQLite tables");
+      const sourceTables = sourceDb.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all().map((t) => t.name).filter((name) => !name.startsWith("sqlite_"));
+      const targetTables = new Set(
+        targetDb.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((t) => t.name)
       );
-      for (const row of rows) {
-        try {
-          insert.run(...columns.map((col) => row[col]));
-          inserted++;
-        } catch {
-          skipped++;
+      for (const table of sourceTables) {
+        if (!targetTables.has(table)) {
+          p2.log.warn(`Skipping table ${table} (not recognized by SRouter)`);
+          continue;
+        }
+        const rows = sourceDb.prepare(`SELECT * FROM "${table}"`).all();
+        if (rows.length === 0) continue;
+        if (action !== "copy") {
+          try {
+            targetDb.prepare(`DELETE FROM "${table}"`).run();
+          } catch {
+            p2.log.warn(`Could not clear table ${table}, rows will be appended`);
+          }
+        }
+        const sourceColumns = new Set(
+          sourceDb.prepare(`PRAGMA table_info("${table}")`).all().map((col) => col.name)
+        );
+        const targetColumns = targetDb.prepare(`PRAGMA table_info("${table}")`).all().map((col) => col.name).filter((col) => sourceColumns.has(col));
+        if (targetColumns.length === 0) continue;
+        const placeholders = targetColumns.map(() => "?").join(", ");
+        const insert = targetDb.prepare(
+          `INSERT OR REPLACE INTO "${table}" (${targetColumns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`
+        );
+        for (const row of rows) {
+          try {
+            insert.run(...targetColumns.map((col) => row[col] ?? null));
+            inserted++;
+          } catch {
+            skipped++;
+          }
         }
+        tablesCount++;
       }
+      sourceDb.close();
     }
-    sourceDb.close();
+    targetDb.exec("PRAGMA foreign_keys = ON;");
     targetDb.close();
     s.stop("Migration complete");
-    p.log.message(
+    p2.log.message(
       [
-        `Tables migrated: ${tables.length}`,
-        `Rows inserted: ${inserted}`,
-        `Rows skipped: ${skipped}`,
+        `Tables/Categories migrated: ${tablesCount}`,
+        `Rows/Items inserted: ${inserted}`,
+        `Rows/Items skipped: ${skipped}`,
         `Source: ${source}`,
-        `Target: ${TargetDbPath}`
+        `Target: ${targetDbPath}`
       ].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;
   }
 }
@@ -2319,8 +3802,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;
@@ -2347,7 +3830,10 @@ function createCli() {
   ).action(async (opts) => {
     await setupCommand(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(
+  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, hindsight)").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)"
   ).option(
@@ -2394,15 +3880,19 @@ function createCli() {
   ).allowUnknownOption().action(async (tool, args, opts) => {
     await runCommand(tool, args, opts);
   });
-  program.command("migrate <target>").description("Migrate databases (targets: db = legacy location, 9router = 9Router import)").option("--source <path>", "Explicit path to the source SQLite database").option("-y, --yes", "Skip confirmation prompts").action(async (target, opts) => {
+  program.command("migrate <target>").description("Migrate databases (targets: db = legacy location, 9router = 9Router import)").option("--source <path>", "Explicit path to the source SQLite database").option("-y, --yes", "Skip confirmation prompts").option("-a, --action <action>", "Migration conflict resolution (copy, merge, backup_and_replace)").action(async (target, opts) => {
     await migrateCommand(target, opts);
   });
   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
 };