byok-llm 1.0.0

package/dist/index.js

@@ -0,0 +1,848 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync, chmodSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { createInterface } from 'readline';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/providers/anthropic.ts
+var anthropic;
+var init_anthropic = __esm({
+  "src/providers/anthropic.ts"() {
+    anthropic = {
+      id: "anthropic",
+      name: "Anthropic",
+      envKeys: ["ANTHROPIC_API_KEY"],
+      keyPrefix: "sk-ant-",
+      baseUrl: "https://api.anthropic.com",
+      docsUrl: "https://console.anthropic.com/settings/keys",
+      authStyle: "x-api-key",
+      authHeader: "x-api-key",
+      defaultHeaders: {
+        "anthropic-version": "2023-06-01"
+      },
+      validateEndpoint: "/v1/models",
+      openaiCompatible: false
+    };
+  }
+});
+
+// src/providers/openai.ts
+var openai;
+var init_openai = __esm({
+  "src/providers/openai.ts"() {
+    openai = {
+      id: "openai",
+      name: "OpenAI",
+      envKeys: ["OPENAI_API_KEY"],
+      keyPrefix: "sk-",
+      baseUrl: "https://api.openai.com",
+      docsUrl: "https://platform.openai.com/api-keys",
+      authStyle: "bearer",
+      validateEndpoint: "/v1/models",
+      openaiCompatible: true
+    };
+  }
+});
+
+// src/providers/openrouter.ts
+var openrouter;
+var init_openrouter = __esm({
+  "src/providers/openrouter.ts"() {
+    openrouter = {
+      id: "openrouter",
+      name: "OpenRouter",
+      envKeys: ["OPENROUTER_API_KEY"],
+      keyPrefix: "sk-or-",
+      baseUrl: "https://openrouter.ai/api",
+      docsUrl: "https://openrouter.ai/keys",
+      authStyle: "bearer",
+      validateEndpoint: "/v1/auth/key",
+      openaiCompatible: true
+    };
+  }
+});
+
+// src/providers/google.ts
+var google;
+var init_google = __esm({
+  "src/providers/google.ts"() {
+    google = {
+      id: "google",
+      name: "Google Gemini",
+      envKeys: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+      baseUrl: "https://generativelanguage.googleapis.com",
+      docsUrl: "https://aistudio.google.com/app/apikey",
+      authStyle: "query-param",
+      validateEndpoint: "/v1beta/models",
+      openaiCompatible: false
+    };
+  }
+});
+
+// src/providers/groq.ts
+var groq;
+var init_groq = __esm({
+  "src/providers/groq.ts"() {
+    groq = {
+      id: "groq",
+      name: "Groq",
+      envKeys: ["GROQ_API_KEY"],
+      keyPrefix: "gsk_",
+      baseUrl: "https://api.groq.com/openai",
+      docsUrl: "https://console.groq.com/keys",
+      authStyle: "bearer",
+      validateEndpoint: "/v1/models",
+      openaiCompatible: true
+    };
+  }
+});
+
+// src/providers/xai.ts
+var xai;
+var init_xai = __esm({
+  "src/providers/xai.ts"() {
+    xai = {
+      id: "xai",
+      name: "xAI (Grok)",
+      envKeys: ["XAI_API_KEY"],
+      keyPrefix: "xai-",
+      baseUrl: "https://api.x.ai",
+      docsUrl: "https://console.x.ai/",
+      authStyle: "bearer",
+      validateEndpoint: "/v1/models",
+      openaiCompatible: true
+    };
+  }
+});
+
+// src/providers/mistral.ts
+var mistral;
+var init_mistral = __esm({
+  "src/providers/mistral.ts"() {
+    mistral = {
+      id: "mistral",
+      name: "Mistral AI",
+      envKeys: ["MISTRAL_API_KEY"],
+      baseUrl: "https://api.mistral.ai",
+      docsUrl: "https://console.mistral.ai/api-keys",
+      authStyle: "bearer",
+      validateEndpoint: "/v1/models",
+      openaiCompatible: true
+    };
+  }
+});
+
+// src/providers/deepseek.ts
+var deepseek;
+var init_deepseek = __esm({
+  "src/providers/deepseek.ts"() {
+    deepseek = {
+      id: "deepseek",
+      name: "DeepSeek",
+      envKeys: ["DEEPSEEK_API_KEY"],
+      keyPrefix: "sk-",
+      baseUrl: "https://api.deepseek.com",
+      docsUrl: "https://platform.deepseek.com/api_keys",
+      authStyle: "bearer",
+      validateEndpoint: "/models",
+      openaiCompatible: true
+    };
+  }
+});
+
+// src/providers/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  DEFAULT_FALLBACK_ORDER: () => DEFAULT_FALLBACK_ORDER,
+  getProvider: () => getProvider,
+  hasProvider: () => hasProvider,
+  listProviders: () => listProviders,
+  registerProvider: () => registerProvider
+});
+function registerBuiltins() {
+  for (const provider of [anthropic, openai, openrouter, google, groq, xai, mistral, deepseek]) {
+    registry.set(provider.id, provider);
+  }
+}
+function registerProvider(definition) {
+  registry.set(definition.id, definition);
+}
+function getProvider(id) {
+  return registry.get(id);
+}
+function listProviders() {
+  return Array.from(registry.values());
+}
+function hasProvider(id) {
+  return registry.has(id);
+}
+var registry, DEFAULT_FALLBACK_ORDER;
+var init_registry = __esm({
+  "src/providers/registry.ts"() {
+    init_anthropic();
+    init_openai();
+    init_openrouter();
+    init_google();
+    init_groq();
+    init_xai();
+    init_mistral();
+    init_deepseek();
+    registry = /* @__PURE__ */ new Map();
+    registerBuiltins();
+    DEFAULT_FALLBACK_ORDER = [
+      "anthropic",
+      "openai",
+      "openrouter",
+      "google",
+      "groq",
+      "xai",
+      "mistral",
+      "deepseek"
+    ];
+  }
+});
+
+// src/index.ts
+init_registry();
+
+// src/config/resolver.ts
+init_registry();
+function getConfigHome() {
+  return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+}
+function getUserConfigPath() {
+  return join(getConfigHome(), "byok-ai", "config.json");
+}
+function getKeysStorePath() {
+  return join(getConfigHome(), "byok-ai", "keys.json");
+}
+function resolveValue(value) {
+  const envMatch = value.match(/^\{env:([^}]+)\}$/);
+  if (envMatch) {
+    return process.env[envMatch[1]] || "";
+  }
+  const fileMatch = value.match(/^\{file:([^}]+)\}$/);
+  if (fileMatch) {
+    const filePath = fileMatch[1].replace(/^~/, homedir());
+    try {
+      return readFileSync(filePath, "utf-8").trim();
+    } catch {
+      return "";
+    }
+  }
+  return value;
+}
+function readJsonConfig(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.providers) {
+      for (const [, config] of Object.entries(parsed.providers)) {
+        const providerConf = config;
+        if (typeof providerConf.apiKey === "string") {
+          providerConf.apiKey = resolveValue(providerConf.apiKey);
+        }
+      }
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function readPackageJsonConfig() {
+  try {
+    const pkgPath = join(process.cwd(), "package.json");
+    if (!existsSync(pkgPath)) return null;
+    const raw = readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    if (pkg.byok && typeof pkg.byok === "object") {
+      return pkg.byok;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var PROJECT_CONFIG_NAMES = [".byokrc.json", ".byokrc", "byok.config.json"];
+function findProjectConfig() {
+  for (const name of PROJECT_CONFIG_NAMES) {
+    const filePath = join(process.cwd(), name);
+    const config = readJsonConfig(filePath);
+    if (config) return config;
+  }
+  return readPackageJsonConfig();
+}
+function mergeConfigs(base, override) {
+  const merged = { ...base, ...override };
+  if (base.providers || override.providers) {
+    merged.providers = { ...base.providers };
+    if (override.providers) {
+      for (const [id, config] of Object.entries(override.providers)) {
+        merged.providers[id] = { ...merged.providers[id], ...config };
+      }
+    }
+  }
+  return merged;
+}
+function loadConfig(customPath) {
+  let config = {};
+  const sources = [];
+  const userConfig = readJsonConfig(getUserConfigPath());
+  if (userConfig) {
+    config = mergeConfigs(config, userConfig);
+    sources.push("user-config");
+  }
+  const projectConfig = findProjectConfig();
+  if (projectConfig) {
+    config = mergeConfigs(config, projectConfig);
+    sources.push("project-config");
+  }
+  if (customPath) {
+    const customConfig = readJsonConfig(customPath);
+    if (customConfig) {
+      config = mergeConfigs(config, customConfig);
+      sources.push("custom-config");
+    }
+  }
+  return { config, sources };
+}
+function readStore() {
+  const storePath = getKeysStorePath();
+  try {
+    if (!existsSync(storePath)) return {};
+    const raw = readFileSync(storePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeStore(store) {
+  const storePath = getKeysStorePath();
+  const dir = dirname(storePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  writeFileSync(storePath, JSON.stringify(store, null, 2), { mode: 384 });
+  try {
+    chmodSync(storePath, 384);
+  } catch {
+  }
+}
+async function storeKey(providerId, key) {
+  const store = readStore();
+  store[providerId] = key;
+  writeStore(store);
+}
+async function getKey(providerId) {
+  const store = readStore();
+  return store[providerId] || null;
+}
+async function removeKey(providerId) {
+  const store = readStore();
+  delete store[providerId];
+  writeStore(store);
+}
+async function listStoredKeys() {
+  const store = readStore();
+  return Object.keys(store);
+}
+async function clearAllKeys() {
+  writeStore({});
+}
+
+// src/config/helpers.ts
+init_registry();
+function buildAuthHeaders(provider, key, providerConfig) {
+  const headers = {};
+  switch (provider.authStyle) {
+    case "x-api-key":
+      headers[provider.authHeader || "x-api-key"] = key;
+      break;
+    case "bearer":
+      headers["Authorization"] = `Bearer ${key}`;
+      break;
+  }
+  if (provider.defaultHeaders) {
+    Object.assign(headers, provider.defaultHeaders);
+  }
+  if (providerConfig?.headers) {
+    Object.assign(headers, providerConfig.headers);
+  }
+  return headers;
+}
+function getEffectiveBaseUrl(providerId, providerConfig) {
+  if (providerConfig?.baseUrl) return providerConfig.baseUrl;
+  const provider = getProvider(providerId);
+  return provider?.baseUrl || "";
+}
+async function getProviderHeaders(providerId) {
+  const provider = getProvider(providerId);
+  if (!provider) throw new Error(`Unknown provider: ${providerId}`);
+  const resolved = await resolveKey(providerId);
+  if (!resolved) {
+    throw new Error(
+      `No API key configured for ${provider.name}. Set ${provider.envKeys[0]} or run the setup wizard.`
+    );
+  }
+  const config = getConfig();
+  const providerConfig = config.providers?.[providerId];
+  return buildAuthHeaders(provider, resolved.key, providerConfig);
+}
+function getProviderBaseUrl(providerId) {
+  const config = getConfig();
+  const providerConfig = config.providers?.[providerId];
+  return getEffectiveBaseUrl(providerId, providerConfig);
+}
+async function getOpenAICompatibleConfig(providerId) {
+  const provider = getProvider(providerId);
+  if (!provider) throw new Error(`Unknown provider: ${providerId}`);
+  const resolved = await resolveKey(providerId);
+  if (!resolved) {
+    throw new Error(
+      `No API key configured for ${provider.name}. Set ${provider.envKeys[0]} or run the setup wizard.`
+    );
+  }
+  const config = getConfig();
+  const providerConfig = config.providers?.[providerId];
+  const result = {
+    apiKey: resolved.key,
+    baseURL: getEffectiveBaseUrl(providerId, providerConfig)
+  };
+  const extraHeaders = {
+    ...provider.defaultHeaders,
+    ...providerConfig?.headers
+  };
+  if (Object.keys(extraHeaders).length > 0) {
+    result.defaultHeaders = extraHeaders;
+  }
+  return result;
+}
+function buildUrl(provider, endpoint, key, providerConfig) {
+  const base = provider.baseUrl;
+  const url = new URL(endpoint, base);
+  if (provider.authStyle === "query-param" && key) {
+    url.searchParams.set("key", key);
+  }
+  return url.toString();
+}
+
+// src/config/resolver.ts
+var cachedConfig = null;
+var cachedOptions = null;
+function initConfig(options) {
+  const { config } = loadConfig(options?.configPath);
+  if (options?.providers) {
+    if (!config.providers) config.providers = {};
+    for (const [id, providerOpts] of Object.entries(options.providers)) {
+      config.providers[id] = { ...config.providers[id], ...providerOpts };
+    }
+  }
+  cachedConfig = config;
+  cachedOptions = options || null;
+  return config;
+}
+function getConfig() {
+  if (!cachedConfig) {
+    return initConfig(cachedOptions || void 0);
+  }
+  return cachedConfig;
+}
+async function resolveKey(providerId, runtimeKey) {
+  const provider = getProvider(providerId);
+  if (!provider) return null;
+  const config = getConfig();
+  const providerConfig = config.providers?.[providerId];
+  if (providerConfig?.disabled) return null;
+  if (runtimeKey) {
+    return { key: runtimeKey, source: "runtime", providerId };
+  }
+  if (providerConfig?.apiKey) {
+    return {
+      key: providerConfig.apiKey,
+      source: "runtime",
+      providerId
+    };
+  }
+  for (const envKey of provider.envKeys) {
+    const value = process.env[envKey];
+    if (value) {
+      return { key: value, source: "env", providerId, envVar: envKey };
+    }
+  }
+  const storedKey = await getKey(providerId);
+  if (storedKey) {
+    return { key: storedKey, source: "user-config", providerId };
+  }
+  return null;
+}
+async function resolveWithFallback(providerIds) {
+  const order = providerIds || getConfig().fallbackOrder || DEFAULT_FALLBACK_ORDER;
+  for (const id of order) {
+    const provider = getProvider(id);
+    if (!provider) continue;
+    const resolved = await resolveKey(id);
+    if (!resolved) continue;
+    const config = getConfig();
+    const providerConfig = config.providers?.[id];
+    return {
+      providerId: id,
+      key: resolved.key,
+      source: resolved.source,
+      baseUrl: getEffectiveBaseUrl(id, providerConfig),
+      headers: buildAuthHeaders(provider, resolved.key, providerConfig)
+    };
+  }
+  return null;
+}
+async function getConfiguredProviders() {
+  const results = [];
+  for (const provider of listProviders()) {
+    const resolved = await resolveKey(provider.id);
+    if (resolved) {
+      results.push(resolved);
+    }
+  }
+  return results;
+}
+
+// src/validation/validator.ts
+init_registry();
+function validateKeyFormat(providerId, key) {
+  const provider = getProvider(providerId);
+  if (!provider) {
+    return { valid: false, error: `Unknown provider: ${providerId}` };
+  }
+  if (!key || key.trim().length === 0) {
+    return { valid: false, error: "Key is empty" };
+  }
+  if (provider.keyPrefix) {
+    const prefixes = Array.isArray(provider.keyPrefix) ? provider.keyPrefix : [provider.keyPrefix];
+    const hasValidPrefix = prefixes.some((p) => key.startsWith(p));
+    if (!hasValidPrefix) {
+      return {
+        valid: false,
+        error: `Key should start with ${prefixes.join(" or ")} for ${provider.name}`
+      };
+    }
+  }
+  if (key.length < 10) {
+    return { valid: false, error: "Key seems too short" };
+  }
+  return { valid: true };
+}
+async function validateKey(providerId, key) {
+  const formatResult = validateKeyFormat(providerId, key);
+  if (!formatResult.valid) return formatResult;
+  const provider = getProvider(providerId);
+  if (!provider) {
+    return { valid: false, error: `Unknown provider: ${providerId}` };
+  }
+  if (!provider.validateEndpoint) {
+    return { valid: true };
+  }
+  try {
+    const url = buildUrl(provider, provider.validateEndpoint, key);
+    const headers = buildAuthHeaders(provider, key);
+    headers["Content-Type"] = "application/json";
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(1e4)
+      // 10 second timeout
+    });
+    if (response.ok) {
+      const meta = {};
+      try {
+        const data = await response.json();
+        if (providerId === "openrouter" && data?.data) {
+          const d = data.data;
+          meta.usage = d.usage;
+          meta.limit = d.limit;
+          meta.label = d.label;
+        }
+      } catch {
+      }
+      return { valid: true, meta: Object.keys(meta).length > 0 ? meta : void 0 };
+    }
+    if (response.status === 401 || response.status === 403) {
+      return { valid: false, error: "Invalid API key (authentication failed)" };
+    }
+    if (response.status === 429) {
+      return {
+        valid: true,
+        meta: { warning: "Rate limited \u2014 key is valid but currently throttled" }
+      };
+    }
+    return {
+      valid: false,
+      error: `Validation failed with status ${response.status}`
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    if (message.includes("timeout") || message.includes("ENOTFOUND")) {
+      return {
+        valid: true,
+        meta: { warning: "Could not reach provider API to validate (network issue)" }
+      };
+    }
+    return { valid: false, error: `Validation error: ${message}` };
+  }
+}
+async function validateAllKeys() {
+  const { listProviders: listProviders2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  const results = {};
+  const providers = listProviders2();
+  const promises = providers.map(async (provider) => {
+    const resolved = await resolveKey(provider.id);
+    if (!resolved) {
+      results[provider.id] = { valid: false, error: "No key configured" };
+      return;
+    }
+    results[provider.id] = await validateKey(provider.id, resolved.key);
+  });
+  await Promise.all(promises);
+  return results;
+}
+
+// src/storage/env.ts
+init_registry();
+function hasEnvKey(providerId) {
+  const provider = getProvider(providerId);
+  if (!provider) return false;
+  return provider.envKeys.some((key) => !!process.env[key]);
+}
+function getEnvKey(providerId) {
+  const provider = getProvider(providerId);
+  if (!provider) return null;
+  for (const key of provider.envKeys) {
+    const value = process.env[key];
+    if (value) return value;
+  }
+  return null;
+}
+function getEnvVarName(providerId) {
+  const provider = getProvider(providerId);
+  if (!provider) return null;
+  return provider.envKeys[0] || null;
+}
+function generateEnvTemplate(providerIds) {
+  const providers = providerIds ? providerIds.map((id) => getProvider(id)).filter(Boolean) : listProviders();
+  const lines = [
+    "# byok-ai \u2014 API Keys",
+    "# Add your API keys below. You only need keys for providers you want to use.",
+    ""
+  ];
+  for (const provider of providers) {
+    if (!provider) continue;
+    lines.push(`# ${provider.name} \u2014 Get a key at: ${provider.docsUrl}`);
+    for (const envKey of provider.envKeys) {
+      lines.push(`# ${envKey}=`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/ui/setup-wizard.ts
+init_registry();
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m"
+};
+function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+function maskKey(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 6) + "..." + key.slice(-4);
+}
+async function setupWizard(options = {}) {
+  const { appName = "this app", skipConfigured = true, required = [] } = options;
+  const providerIds = options.providers || listProviders().map((p) => p.id);
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log();
+    console.log(`${c.bold}${c.cyan}  byok-ai${c.reset} \u2014 API Key Setup`);
+    console.log(`${c.dim}  ${appName} needs an AI provider to work.${c.reset}`);
+    console.log(`${c.dim}  You only need to configure one provider.${c.reset}`);
+    console.log();
+    const configured = [];
+    const skipped = [];
+    for (const id of providerIds) {
+      const provider = getProvider(id);
+      if (!provider) continue;
+      const existing = await resolveKey(id);
+      if (existing && skipConfigured) {
+        console.log(
+          `  ${c.green}\u2713${c.reset} ${c.bold}${provider.name}${c.reset}  ${c.dim}(configured via ${existing.source})${c.reset}`
+        );
+        configured.push(id);
+        continue;
+      }
+      if (existing) {
+        console.log(
+          `  ${c.green}\u2713${c.reset} ${c.bold}${provider.name}${c.reset}  ${c.dim}(${maskKey(existing.key)} via ${existing.source})${c.reset}`
+        );
+      }
+      console.log();
+      console.log(
+        `  ${c.bold}${provider.name}${c.reset}  ${c.dim}\u2014 Get a key at: ${provider.docsUrl}${c.reset}`
+      );
+      const input = await ask(rl, `  ${c.cyan}API Key${c.reset} (or Enter to skip): `);
+      if (!input) {
+        skipped.push(id);
+        console.log(`  ${c.dim}Skipped${c.reset}`);
+        continue;
+      }
+      const formatCheck = validateKeyFormat(id, input);
+      if (!formatCheck.valid) {
+        console.log(`  ${c.yellow}\u26A0 Warning:${c.reset} ${formatCheck.error}`);
+        const proceed = await ask(rl, `  ${c.dim}Save anyway? (y/N):${c.reset} `);
+        if (proceed.toLowerCase() !== "y") {
+          skipped.push(id);
+          continue;
+        }
+      }
+      console.log(`  ${c.dim}Validating...${c.reset}`);
+      const result = await validateKey(id, input);
+      if (result.valid) {
+        await storeKey(id, input);
+        configured.push(id);
+        console.log(`  ${c.green}\u2713 Valid!${c.reset} Key saved.`);
+        if (result.meta?.warning) {
+          console.log(`  ${c.yellow}\u26A0 ${result.meta.warning}${c.reset}`);
+        }
+      } else {
+        console.log(`  ${c.red}\u2717 ${result.error}${c.reset}`);
+        const saveAnyway = await ask(rl, `  ${c.dim}Save anyway? (y/N):${c.reset} `);
+        if (saveAnyway.toLowerCase() === "y") {
+          await storeKey(id, input);
+          configured.push(id);
+          console.log(`  ${c.dim}Key saved.${c.reset}`);
+        } else {
+          skipped.push(id);
+        }
+      }
+    }
+    console.log();
+    console.log(`${c.bold}  Summary${c.reset}`);
+    console.log(`${c.dim}  ${"\u2500".repeat(40)}${c.reset}`);
+    if (configured.length > 0) {
+      console.log(
+        `  ${c.green}\u2713${c.reset} ${configured.length} provider(s) configured: ${c.bold}${configured.join(", ")}${c.reset}`
+      );
+    }
+    if (skipped.length > 0) {
+      console.log(`  ${c.dim}\u25CB ${skipped.length} skipped: ${skipped.join(", ")}${c.reset}`);
+    }
+    const missingRequired = required.filter((r) => !configured.includes(r));
+    if (missingRequired.length > 0) {
+      console.log();
+      console.log(
+        `  ${c.yellow}\u26A0 Required providers not configured: ${c.bold}${missingRequired.join(", ")}${c.reset}`
+      );
+      console.log(`  ${c.dim}${appName} may not work without these.${c.reset}`);
+    }
+    console.log();
+  } finally {
+    rl.close();
+  }
+}
+
+// src/ui/status.ts
+init_registry();
+function maskKey2(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 6) + "..." + key.slice(-4);
+}
+async function getStatus(providerIds) {
+  const providers = providerIds ? providerIds.map((id) => getProvider(id)).filter((p) => !!p) : listProviders();
+  const statuses = [];
+  for (const provider of providers) {
+    const resolved = await resolveKey(provider.id);
+    statuses.push({
+      id: provider.id,
+      name: provider.name,
+      configured: !!resolved,
+      source: resolved?.source,
+      keyPreview: resolved ? maskKey2(resolved.key) : void 0
+    });
+  }
+  const config = getConfig();
+  return {
+    providers: statuses,
+    defaultProvider: config.defaultProvider
+  };
+}
+var col = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m"
+};
+async function printStatus(providerIds) {
+  const status = await getStatus(providerIds);
+  console.log();
+  console.log(`${col.bold}${col.cyan}  byok-ai${col.reset} \u2014 Provider Status`);
+  console.log(`${col.dim}  ${"\u2500".repeat(50)}${col.reset}`);
+  for (const p of status.providers) {
+    const icon = p.configured ? `${col.green}\u2713` : `${col.red}\u2717`;
+    const source = p.source ? `${col.dim}(${p.source})${col.reset}` : "";
+    const preview = p.keyPreview ? `${col.dim}${p.keyPreview}${col.reset}` : "";
+    console.log(
+      `  ${icon}${col.reset} ${col.bold}${p.name.padEnd(16)}${col.reset} ${preview} ${source}`
+    );
+  }
+  const total = status.providers.length;
+  const active = status.providers.filter((p) => p.configured).length;
+  console.log();
+  console.log(`  ${col.dim}${active}/${total} providers configured${col.reset}`);
+  if (status.defaultProvider) {
+    console.log(`  ${col.dim}Default: ${status.defaultProvider}${col.reset}`);
+  }
+  console.log();
+}
+
+// src/index.ts
+async function init(options = {}) {
+  const { providers, appName, interactive = true, ...byokOptions } = options;
+  initConfig(byokOptions);
+  let resolved = await resolveWithFallback(providers);
+  if (!resolved && interactive && process.stdin.isTTY) {
+    await setupWizard({
+      providers,
+      appName
+    });
+    resolved = await resolveWithFallback(providers);
+  }
+  return resolved;
+}
+
+export { DEFAULT_FALLBACK_ORDER, clearAllKeys, generateEnvTemplate, getConfig, getConfiguredProviders, getEnvKey, getEnvVarName, getKey, getKeysStorePath, getOpenAICompatibleConfig, getProvider, getProviderBaseUrl, getProviderHeaders, getStatus, getUserConfigPath, hasEnvKey, hasProvider, init, initConfig, listProviders, listStoredKeys, printStatus, registerProvider, removeKey, resolveKey, resolveWithFallback, setupWizard, storeKey, validateAllKeys, validateKey, validateKeyFormat };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map