@cbuk100011/claude-mode 1.2.0

package/dist/index.js

@@ -0,0 +1,1024 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import { select, input } from "@inquirer/prompts";
+import { spawn, execSync } from "child_process";
+import { config } from "dotenv";
+import { fileURLToPath } from "url";
+import path2 from "path";
+
+// src/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+function getConfigDir() {
+  return path.join(homedir(), ".claude-mode");
+}
+function getConfigPaths() {
+  return [
+    path.join(getConfigDir(), "claude-mode.json")
+    // ~/.claude-mode/claude-mode.json (primary)
+  ];
+}
+function getCacheDir() {
+  const configDir = getConfigDir();
+  const cacheDir = path.join(configDir, "cache");
+  if (!existsSync(cacheDir)) {
+    mkdirSync(cacheDir, { recursive: true });
+  }
+  return cacheDir;
+}
+var DEFAULT_CONFIG = {
+  defaultProvider: "",
+  defaultModel: "",
+  modelDiscoveryTimeout: 5e3,
+  healthCheckTimeout: 2e3,
+  cacheTTL: 3e4,
+  customProviders: [],
+  skipHealthCheck: false,
+  offlineMode: false,
+  headlessAllowedTools: "Read,Edit,Write,Bash,Glob,Grep"
+};
+var _cachedConfig = null;
+function loadConfig() {
+  if (_cachedConfig) {
+    return _cachedConfig;
+  }
+  const paths = getConfigPaths();
+  for (const configPath of paths) {
+    if (existsSync(configPath)) {
+      try {
+        const content = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(content);
+        _cachedConfig = { ...DEFAULT_CONFIG, ...parsed };
+        return _cachedConfig;
+      } catch (error) {
+        console.error(`Warning: Failed to parse config at ${configPath}:`, error);
+      }
+    }
+  }
+  _cachedConfig = DEFAULT_CONFIG;
+  return _cachedConfig;
+}
+function getConfig(key) {
+  const config2 = loadConfig();
+  return config2[key] ?? DEFAULT_CONFIG[key];
+}
+function initConfig() {
+  const configDir = getConfigDir();
+  const configPath = path.join(configDir, "claude-mode.json");
+  if (existsSync(configPath)) {
+    return configPath;
+  }
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  const defaultConfig = {
+    defaultProvider: "",
+    defaultModel: "",
+    modelDiscoveryTimeout: 5e3,
+    healthCheckTimeout: 2e3,
+    cacheTTL: 3e4,
+    customProviders: [
+      // Example custom provider (commented out in JSON)
+    ],
+    skipHealthCheck: false,
+    offlineMode: false,
+    headlessAllowedTools: "Read,Edit,Write,Bash,Glob,Grep"
+  };
+  writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2), "utf-8");
+  return configPath;
+}
+function loadModelCache() {
+  const cachePath = path.join(getCacheDir(), "models.json");
+  if (!existsSync(cachePath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function saveModelCache(providerKey, models3) {
+  const cache = loadModelCache();
+  cache[providerKey] = {
+    models: models3,
+    timestamp: Date.now()
+  };
+  const cachePath = path.join(getCacheDir(), "models.json");
+  writeFileSync(cachePath, JSON.stringify(cache, null, 2), "utf-8");
+}
+function getCachedModels(providerKey) {
+  const cache = loadModelCache();
+  const entry = cache[providerKey];
+  if (!entry) {
+    return null;
+  }
+  return entry.models;
+}
+
+// src/errors.ts
+import chalk from "chalk";
+function classifyError(error) {
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    if (msg.includes("econnrefused") || msg.includes("connection refused")) {
+      return {
+        code: "CONNECTION_REFUSED" /* CONNECTION_REFUSED */,
+        message: "Connection refused",
+        hint: "Check that the server is running and the URL is correct.",
+        cause: error
+      };
+    }
+    if (msg.includes("etimedout") || msg.includes("timeout") || msg.includes("timed out")) {
+      return {
+        code: "CONNECTION_TIMEOUT" /* CONNECTION_TIMEOUT */,
+        message: "Connection timed out",
+        hint: "The server took too long to respond. Check network connectivity or increase timeout in config.",
+        cause: error
+      };
+    }
+    if (msg.includes("enotfound") || msg.includes("getaddrinfo")) {
+      return {
+        code: "DNS_RESOLUTION_FAILED" /* DNS_RESOLUTION_FAILED */,
+        message: "DNS resolution failed",
+        hint: "Could not resolve hostname. Check the URL and your internet connection.",
+        cause: error
+      };
+    }
+    if (msg.includes("401") || msg.includes("unauthorized")) {
+      return {
+        code: "AUTH_INVALID" /* AUTH_INVALID */,
+        message: "Authentication failed",
+        hint: "Check that your API key is valid and correctly set in .env file.",
+        cause: error
+      };
+    }
+    if (msg.includes("403") || msg.includes("forbidden")) {
+      return {
+        code: "AUTH_INVALID" /* AUTH_INVALID */,
+        message: "Access forbidden",
+        hint: "Your API key may not have access to this resource.",
+        cause: error
+      };
+    }
+    if (msg.includes("model") && (msg.includes("not found") || msg.includes("404"))) {
+      return {
+        code: "MODEL_NOT_FOUND" /* MODEL_NOT_FOUND */,
+        message: "Model not found",
+        hint: "The specified model does not exist on this provider. Use --list to see available models.",
+        cause: error
+      };
+    }
+    if (msg.includes("enoent") && msg.includes("claude")) {
+      return {
+        code: "CLAUDE_NOT_FOUND" /* CLAUDE_NOT_FOUND */,
+        message: "Claude CLI not found",
+        hint: "Install Claude Code CLI: npm install -g @anthropic-ai/claude-code",
+        cause: error
+      };
+    }
+  }
+  return {
+    code: "UNKNOWN" /* UNKNOWN */,
+    message: error instanceof Error ? error.message : String(error),
+    cause: error instanceof Error ? error : void 0
+  };
+}
+function formatError(error) {
+  const lines = [];
+  lines.push(chalk.red(`Error: ${error.message}`));
+  if (error.hint) {
+    lines.push(chalk.yellow(`Hint: ${error.hint}`));
+  }
+  if (process.env.DEBUG && error.cause) {
+    lines.push(chalk.gray(`Debug: ${error.cause.stack || error.cause.message}`));
+  }
+  return lines.join("\n");
+}
+function printError(error) {
+  console.error(formatError(error));
+}
+function claudeNotFoundError() {
+  return {
+    code: "CLAUDE_NOT_FOUND" /* CLAUDE_NOT_FOUND */,
+    message: "Claude CLI not found in PATH",
+    hint: "Install Claude Code CLI: npm install -g @anthropic-ai/claude-code\nOr check that it is in your PATH."
+  };
+}
+
+// src/providers.ts
+var builtInProviders = {
+  openrouter: {
+    name: "OpenRouter",
+    key: "openrouter",
+    getBaseUrl: () => process.env.ANTHROPIC_BASE_URL || "https://openrouter.ai/api",
+    getAuthToken: () => process.env.ANTHROPIC_AUTH_TOKEN || process.env.OPEN_ROUTER_API_KEY || "",
+    getDescription: () => {
+      const url = process.env.ANTHROPIC_BASE_URL || "https://openrouter.ai/api";
+      return `OpenRouter API (${url})`;
+    },
+    isBuiltIn: true
+  },
+  "ollama-cloud": {
+    name: "Ollama Cloud",
+    key: "ollama-cloud",
+    getBaseUrl: () => process.env.OLLAMA_HOST || "https://ollama.com",
+    getAuthToken: () => process.env.OLLAMA_API_KEY || "",
+    getDescription: () => {
+      const url = process.env.OLLAMA_HOST || "https://ollama.com";
+      return `Ollama Cloud (${url})`;
+    },
+    isBuiltIn: true
+  },
+  "ollama-local": {
+    name: "Ollama Local",
+    key: "ollama-local",
+    getBaseUrl: () => process.env.OLLAMA_BASE_URL_LOCAL || "http://localhost:11434",
+    getAuthToken: () => "ollama",
+    getDescription: () => {
+      const url = process.env.OLLAMA_BASE_URL_LOCAL || "http://localhost:11434";
+      return `Ollama Local (${url})`;
+    },
+    isBuiltIn: true
+  },
+  "ollama-custom": {
+    name: "Ollama Custom",
+    key: "ollama-custom",
+    getBaseUrl: () => process.env.OLLAMA_BASE_URL_CUSTOM || "http://192.168.86.101:11434",
+    getAuthToken: () => "ollama",
+    getDescription: () => {
+      const url = process.env.OLLAMA_BASE_URL_CUSTOM || "http://192.168.86.101:11434";
+      return `Ollama Custom (${url})`;
+    },
+    isBuiltIn: true
+  }
+};
+var _providersCache = null;
+function createCustomProvider(custom) {
+  return {
+    name: custom.name,
+    key: custom.key,
+    getBaseUrl: () => custom.baseUrl,
+    getAuthToken: () => {
+      if (custom.authToken) return custom.authToken;
+      if (custom.authEnvVar) return process.env[custom.authEnvVar] || "";
+      return "";
+    },
+    getDescription: () => custom.description || `${custom.name} (${custom.baseUrl})`,
+    isBuiltIn: false
+  };
+}
+function getProviders() {
+  if (_providersCache) {
+    return _providersCache;
+  }
+  const config2 = loadConfig();
+  const providers3 = { ...builtInProviders };
+  if (config2.customProviders) {
+    for (const custom of config2.customProviders) {
+      if (custom.key && custom.name && custom.baseUrl) {
+        providers3[custom.key] = createCustomProvider(custom);
+      }
+    }
+  }
+  _providersCache = providers3;
+  return providers3;
+}
+var providers = new Proxy({}, {
+  get: (_, key) => getProviders()[key],
+  ownKeys: () => Object.keys(getProviders()),
+  getOwnPropertyDescriptor: (_, key) => ({
+    enumerable: true,
+    configurable: true,
+    value: getProviders()[key]
+  })
+});
+var models = {
+  openrouter: [
+    // Premium / Frontier Models
+    { id: "openai/gpt-5.2", name: "GPT-5.2", shortcut: "gpt52" },
+    { id: "openai/gpt-5.2-pro", name: "GPT-5.2 Pro", shortcut: "gpt52-pro" },
+    { id: "openai/gpt-5.2-codex", name: "GPT-5.2 Codex", shortcut: "gpt52-codex" },
+    { id: "anthropic/claude-opus-4.5", name: "Claude Opus 4.5", shortcut: "opus" },
+    { id: "x-ai/grok-4.1-fast", name: "Grok 4.1 Fast", shortcut: "grok" },
+    // Cost-Effective Performance
+    { id: "deepseek/deepseek-v3.2", name: "DeepSeek V3.2", shortcut: "deepseek" },
+    { id: "z-ai/glm-4.7-flash", name: "Z.AI GLM 4.7 Flash", shortcut: "zai-glm47-flash" },
+    // Existing Models
+    { id: "anthropic/claude-sonnet-4.5", name: "Claude Sonnet 4.5", shortcut: "sonnet" },
+    { id: "anthropic/claude-haiku-4.5", name: "Claude Haiku 4.5", shortcut: "haiku" },
+    { id: "@preset/gpt-oss-120b-cerebras", name: "GPT-OSS 120B (Cerebras)", shortcut: "gpt120" },
+    { id: "@preset/cerebras-glm-4-7-cerebras", name: "GLM 4.7 (Cerebras)", shortcut: "glm47" },
+    { id: "z-ai/glm-4.7", name: "Z.AI GLM 4.7", shortcut: "zai-glm47" },
+    { id: "google/gemini-3-pro-preview", name: "Gemini 3 Pro Preview", shortcut: "gemini-pro" },
+    { id: "google/gemini-3-flash-preview", name: "Gemini 3 Flash Preview", shortcut: "gemini-flash" },
+    { id: "openrouter/auto", name: "OpenRouter Auto", shortcut: "auto" }
+  ]
+  // Ollama models are dynamically fetched via API
+};
+var providerAliases = {
+  or: "openrouter",
+  open: "openrouter",
+  oc: "ollama-cloud",
+  cloud: "ollama-cloud",
+  ol: "ollama-local",
+  local: "ollama-local",
+  custom: "ollama-custom",
+  remote: "ollama-custom"
+};
+function resolveProvider(shortcut) {
+  return providerAliases[shortcut] || shortcut;
+}
+function getProviderKeys() {
+  return Object.keys(getProviders());
+}
+function getProvider(key) {
+  return getProviders()[resolveProvider(key)];
+}
+async function resolveModel(providerKey, shortcut) {
+  const resolvedKey = resolveProvider(providerKey);
+  if (isOllamaProvider(resolvedKey)) {
+    const ollamaModels = await getOllamaModels(resolvedKey);
+    const model2 = ollamaModels.find(
+      (m) => m.shortcut === shortcut || m.id === shortcut || m.name.toLowerCase() === shortcut.toLowerCase()
+    );
+    return model2?.id || shortcut;
+  }
+  const providerModels = models[resolvedKey];
+  if (!providerModels) return shortcut;
+  const model = providerModels.find(
+    (m) => m.shortcut === shortcut || m.id === shortcut || m.name.toLowerCase() === shortcut.toLowerCase()
+  );
+  return model?.id || shortcut;
+}
+async function getModels(providerKey) {
+  const resolvedKey = resolveProvider(providerKey);
+  if (isOllamaProvider(resolvedKey)) {
+    return getOllamaModels(resolvedKey);
+  }
+  return models[resolvedKey] || [];
+}
+function isOllamaProvider(providerKey) {
+  return providerKey === "ollama-local" || providerKey === "ollama-custom" || providerKey === "ollama-cloud" || providerKey.startsWith("ollama-");
+}
+var _ollamaModelCache = /* @__PURE__ */ new Map();
+async function fetchOllamaModelsFromAPI(baseUrl, timeout) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(`${baseUrl}/v1/models`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const models3 = [];
+    if (data.data && Array.isArray(data.data)) {
+      for (const model of data.data) {
+        models3.push({
+          id: model.id,
+          name: model.id,
+          shortcut: model.id
+        });
+      }
+    }
+    return models3;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error("Connection timed out");
+    }
+    throw error;
+  }
+}
+async function getOllamaModels(providerKey) {
+  const now = Date.now();
+  const cacheTTL = getConfig("cacheTTL") || 3e4;
+  const cached = _ollamaModelCache.get(providerKey);
+  if (cached && now - cached.timestamp < cacheTTL) {
+    return cached.models;
+  }
+  const allProviders = getProviders();
+  const provider = allProviders[providerKey];
+  if (!provider) return [];
+  const timeout = getConfig("modelDiscoveryTimeout") || 5e3;
+  try {
+    const models3 = await fetchOllamaModelsFromAPI(provider.getBaseUrl(), timeout);
+    _ollamaModelCache.set(providerKey, { models: models3, timestamp: now });
+    saveModelCache(providerKey, models3);
+    return models3;
+  } catch (error) {
+    const diskCached = getCachedModels(providerKey);
+    if (diskCached && diskCached.length > 0) {
+      console.warn(`Warning: Using cached models for ${providerKey} (API unreachable)`);
+      return diskCached;
+    }
+    const classified = classifyError(error);
+    if (classified.code !== "UNKNOWN" /* UNKNOWN */) {
+      console.error(`Failed to fetch models from ${providerKey}: ${classified.message}`);
+      if (classified.hint) {
+        console.error(`Hint: ${classified.hint}`);
+      }
+    }
+    return [];
+  }
+}
+async function checkProviderHealth(providerKey) {
+  const allProviders = getProviders();
+  const provider = allProviders[providerKey];
+  if (!provider) {
+    return {
+      provider: providerKey,
+      healthy: false,
+      error: {
+        code: "PROVIDER_NOT_FOUND" /* PROVIDER_NOT_FOUND */,
+        message: `Provider not found: ${providerKey}`
+      }
+    };
+  }
+  const timeout = getConfig("healthCheckTimeout") || 2e3;
+  const baseUrl = provider.getBaseUrl();
+  const startTime = Date.now();
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    let healthUrl = `${baseUrl}/v1/models`;
+    if (providerKey === "openrouter") {
+      healthUrl = `${baseUrl}/v1/models`;
+    }
+    const response = await fetch(healthUrl, {
+      signal: controller.signal,
+      headers: provider.getAuthToken() ? {
+        "Authorization": `Bearer ${provider.getAuthToken()}`
+      } : {}
+    });
+    clearTimeout(timeoutId);
+    const latencyMs = Date.now() - startTime;
+    if (response.ok) {
+      return {
+        provider: providerKey,
+        healthy: true,
+        latencyMs
+      };
+    }
+    if (response.status === 401 || response.status === 403) {
+      return {
+        provider: providerKey,
+        healthy: false,
+        latencyMs,
+        error: {
+          code: "AUTH_INVALID" /* AUTH_INVALID */,
+          message: `Authentication failed (${response.status})`,
+          hint: "Check your API key configuration."
+        }
+      };
+    }
+    return {
+      provider: providerKey,
+      healthy: false,
+      latencyMs,
+      error: {
+        code: "PROVIDER_UNAVAILABLE" /* PROVIDER_UNAVAILABLE */,
+        message: `HTTP ${response.status}: ${response.statusText}`
+      }
+    };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    const latencyMs = Date.now() - startTime;
+    return {
+      provider: providerKey,
+      healthy: false,
+      latencyMs,
+      error: classifyError(error)
+    };
+  }
+}
+async function checkAllProvidersHealth() {
+  const providerKeys = getProviderKeys();
+  const results = await Promise.all(
+    providerKeys.map((key) => checkProviderHealth(key))
+  );
+  return results;
+}
+
+// src/index.ts
+config();
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+config({ path: path2.join(__dirname, "..", ".env") });
+var program = new Command();
+function printHeader(text) {
+  console.log("");
+  console.log(chalk2.bold.blue("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  console.log(chalk2.bold.blue("\u2551") + "  " + chalk2.cyan(text));
+  console.log(chalk2.bold.blue("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  console.log("");
+}
+function printConfig(provider, modelId, mode) {
+  console.log(chalk2.cyan("Provider:") + " " + provider.name);
+  console.log(chalk2.cyan("Model:") + " " + modelId);
+  console.log(chalk2.cyan("Base URL:") + " " + provider.getBaseUrl());
+  console.log(chalk2.cyan("Mode:") + " " + mode);
+  console.log("");
+}
+function isClaudeInstalled() {
+  try {
+    execSync("which claude", { stdio: "ignore" });
+    return true;
+  } catch {
+    try {
+      execSync("where claude", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function validateClaudeCLI() {
+  if (!isClaudeInstalled()) {
+    printError(claudeNotFoundError());
+    process.exit(1);
+  }
+}
+async function runClaude(provider, modelId, headless, skipPermissions, prompt) {
+  validateClaudeCLI();
+  const baseUrl = provider.getBaseUrl();
+  process.env.ANTHROPIC_BASE_URL = baseUrl;
+  process.env.ANTHROPIC_AUTH_TOKEN = provider.getAuthToken();
+  process.env.ANTHROPIC_API_KEY = "";
+  process.env.ANTHROPIC_DEFAULT_OPUS_MODEL = modelId;
+  process.env.ANTHROPIC_DEFAULT_SONNET_MODEL = modelId;
+  process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = modelId;
+  process.env.CLAUDE_CODE_SUBAGENT_MODEL = modelId;
+  const args = ["--model", modelId];
+  if (skipPermissions) {
+    args.push("--dangerously-skip-permissions");
+  }
+  if (headless && prompt) {
+    args.push("-p", prompt);
+    const allowedTools = getConfig("headlessAllowedTools");
+    if (allowedTools) {
+      args.push("--allowedTools", allowedTools);
+    }
+  }
+  const claude = spawn("claude", args, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ANTHROPIC_BASE_URL: baseUrl,
+      ANTHROPIC_AUTH_TOKEN: provider.getAuthToken(),
+      ANTHROPIC_API_KEY: "",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: modelId,
+      ANTHROPIC_DEFAULT_SONNET_MODEL: modelId,
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: modelId,
+      CLAUDE_CODE_SUBAGENT_MODEL: modelId
+    }
+  });
+  return new Promise((resolve, reject) => {
+    claude.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Claude exited with code ${code}`));
+      }
+    });
+    claude.on("error", (err) => {
+      const classified = classifyError(err);
+      printError(classified);
+      reject(err);
+    });
+  });
+}
+function formatHealthStatus(result) {
+  const allProviders = getProviders();
+  const provider = allProviders[result.provider];
+  const name = provider?.name || result.provider;
+  if (result.healthy) {
+    const latency = result.latencyMs ? ` (${result.latencyMs}ms)` : "";
+    return `${chalk2.green("\u2713")} ${name}${chalk2.gray(latency)}`;
+  } else {
+    const error = result.error?.message || "unavailable";
+    return `${chalk2.red("\u2717")} ${name} ${chalk2.gray(`- ${error}`)}`;
+  }
+}
+async function displayHealthCheck() {
+  const skipHealthCheck = getConfig("skipHealthCheck");
+  if (skipHealthCheck) return;
+  console.log(chalk2.gray("Checking provider availability..."));
+  const results = await checkAllProvidersHealth();
+  console.log("");
+  for (const result of results) {
+    console.log("  " + formatHealthStatus(result));
+  }
+  console.log("");
+}
+async function interactiveMode(skipPermissions) {
+  console.clear();
+  printHeader("Claude Mode");
+  await displayHealthCheck();
+  const allProviders = getProviders();
+  const providerKey = await select({
+    message: "Select Provider:",
+    choices: getProviderKeys().map((key) => ({
+      name: allProviders[key].name,
+      value: key,
+      description: allProviders[key].getDescription()
+    }))
+  });
+  const provider = getProvider(providerKey);
+  console.log(chalk2.yellow("\u2192 Selected:") + " " + provider.name);
+  const providerModels = await getModels(providerKey);
+  if (providerModels.length === 0) {
+    console.log(chalk2.yellow("No models available for this provider."));
+    console.log(chalk2.gray("You can enter a model ID manually."));
+    const modelId2 = await input({
+      message: "Enter model ID:",
+      validate: (value) => value.length > 0 ? true : "Model ID cannot be empty"
+    });
+    console.log(chalk2.yellow("\u2192 Model:") + " " + modelId2);
+    await continueInteractiveMode(provider, modelId2, skipPermissions);
+    return;
+  }
+  const modelId = await select({
+    message: "Select Model:",
+    choices: providerModels.map((model) => ({
+      name: model.name,
+      value: model.id,
+      description: model.shortcut
+    }))
+  });
+  const selectedModel = providerModels.find((m) => m.id === modelId);
+  console.log(chalk2.yellow("\u2192 Selected:") + " " + selectedModel?.name + ` (${modelId})`);
+  await continueInteractiveMode(provider, modelId, skipPermissions);
+}
+async function continueInteractiveMode(provider, modelId, skipPermissions) {
+  const mode = await select({
+    message: "Select Mode:",
+    choices: [
+      { name: "Terminal (interactive)", value: "terminal" },
+      { name: "Headless (single prompt)", value: "headless" }
+    ]
+  });
+  let prompt;
+  if (mode === "headless") {
+    prompt = await input({
+      message: "Enter your prompt:",
+      validate: (value) => value.length > 0 ? true : "Prompt cannot be empty"
+    });
+  }
+  if (!skipPermissions) {
+    skipPermissions = await select({
+      message: "Skip permission prompts when executing commands?",
+      choices: [
+        { name: "No (ask for permission)", value: false },
+        { name: "Yes (skip all prompts)", value: true }
+      ]
+    });
+  }
+  console.log(
+    chalk2.yellow("\u2192 Skip permissions:") + " " + (skipPermissions ? chalk2.red("Yes (\u26A0\uFE0F auto-approve)") : chalk2.green("No (ask)"))
+  );
+  const isHeadless = mode === "headless";
+  if (isHeadless) {
+    printHeader("Executing Claude Code (Headless)");
+  } else {
+    printHeader("Launching Claude Code (Interactive)");
+  }
+  printConfig(provider, modelId, isHeadless ? "Headless" : "Interactive");
+  try {
+    await runClaude(provider, modelId, isHeadless, skipPermissions, prompt);
+  } catch (error) {
+    console.error(chalk2.red("Error:"), error);
+    process.exit(1);
+  }
+}
+async function quickMode(providerArg, modelArg, skipPermissions, modeArg, promptArg) {
+  const providerKey = resolveProvider(providerArg);
+  const provider = getProvider(providerKey);
+  if (!provider) {
+    console.error(chalk2.red(`Unknown provider: ${providerArg}`));
+    console.log(chalk2.gray("Available providers: " + getProviderKeys().join(", ")));
+    process.exit(1);
+  }
+  const modelId = await resolveModel(providerKey, modelArg);
+  let isHeadless = false;
+  let prompt = promptArg;
+  if (modeArg) {
+    const modeAliases = {
+      terminal: false,
+      t: false,
+      interactive: false,
+      i: false,
+      headless: true,
+      h: true,
+      prompt: true,
+      p: true
+    };
+    if (modeArg in modeAliases) {
+      isHeadless = modeAliases[modeArg];
+    } else {
+      isHeadless = true;
+      prompt = modeArg;
+    }
+  }
+  if (isHeadless && !prompt) {
+    prompt = await input({
+      message: "Enter your prompt:",
+      validate: (value) => value.length > 0 ? true : "Prompt cannot be empty"
+    });
+  }
+  printConfig(provider, modelId, isHeadless ? "Headless" : "Interactive");
+  try {
+    await runClaude(provider, modelId, isHeadless, skipPermissions, prompt);
+  } catch (error) {
+    console.error(chalk2.red("Error:"), error);
+    process.exit(1);
+  }
+}
+async function listModels() {
+  console.log(chalk2.bold("\nAvailable Models by Provider:\n"));
+  const allProviders = getProviders();
+  for (const providerKey of getProviderKeys()) {
+    const provider = allProviders[providerKey];
+    const providerModels = await getModels(providerKey);
+    console.log(chalk2.cyan(`${provider.name}:`));
+    console.log(chalk2.gray(`  ${provider.getDescription()}`));
+    if (providerModels.length === 0) {
+      console.log(`  ${chalk2.gray("(no models found)")}`);
+    } else {
+      for (const model of providerModels) {
+        console.log(`  ${chalk2.green(model.shortcut.padEnd(14))} \u2192 ${model.id}`);
+      }
+    }
+    console.log("");
+  }
+}
+function showConfig() {
+  const config2 = loadConfig();
+  console.log(chalk2.bold("\nCurrent Configuration:\n"));
+  console.log(JSON.stringify(config2, null, 2));
+  console.log("");
+}
+function initConfigCommand() {
+  const configPath = initConfig();
+  console.log(chalk2.green(`Config file created at: ${configPath}`));
+  console.log(chalk2.gray("Edit this file to customize your settings."));
+}
+function generateBashCompletion() {
+  const providerKeys = getProviderKeys();
+  const providerAliases2 = ["or", "open", "oc", "cloud", "ol", "local", "custom", "remote"];
+  const allProviders = [...providerKeys, ...providerAliases2].join(" ");
+  const modeOptions = "terminal t interactive i headless h prompt p";
+  return `# claude-mode bash completion
+# Add to ~/.bashrc or ~/.bash_profile:
+#   eval "$(claude-mode completion bash)"
+
+_claude_mode_completions() {
+    local cur prev
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+    # First argument: provider or option
+    if [[ \${COMP_CWORD} -eq 1 ]]; then
+        COMPREPLY=( $(compgen -W "${allProviders} --list --help --prompt -l -p" -- "\${cur}") )
+        return 0
+    fi
+
+    # Second argument: model (depends on provider, show generic)
+    if [[ \${COMP_CWORD} -eq 2 ]]; then
+        # For now, just show common shortcuts
+        COMPREPLY=( $(compgen -W "sonnet haiku opus gpt120 glm47 deepseek" -- "\${cur}") )
+        return 0
+    fi
+
+    # Third argument: mode
+    if [[ \${COMP_CWORD} -eq 3 ]]; then
+        COMPREPLY=( $(compgen -W "${modeOptions}" -- "\${cur}") )
+        return 0
+    fi
+}
+
+complete -F _claude_mode_completions claude-mode
+`;
+}
+function generateZshCompletion() {
+  const providerKeys = getProviderKeys();
+  return `#compdef claude-mode
+# claude-mode zsh completion
+# Add to ~/.zshrc:
+#   eval "$(claude-mode completion zsh)"
+
+_claude_mode() {
+    local -a providers modes
+
+    providers=(
+        'openrouter:OpenRouter API'
+        'ollama-cloud:Ollama Cloud'
+        'ollama-local:Ollama Local'
+        'ollama-custom:Ollama Custom'
+        'or:OpenRouter (alias)'
+        'oc:Ollama Cloud (alias)'
+        'ol:Ollama Local (alias)'
+        'custom:Ollama Custom (alias)'
+    )
+
+    modes=(
+        'terminal:Interactive terminal mode'
+        't:Interactive terminal mode (alias)'
+        'interactive:Interactive terminal mode (alias)'
+        'i:Interactive terminal mode (alias)'
+        'headless:Single prompt execution'
+        'h:Single prompt execution (alias)'
+        'prompt:Single prompt execution (alias)'
+        'p:Single prompt execution (alias)'
+    )
+
+    case $CURRENT in
+        2)
+            _describe 'provider' providers
+            _arguments '--list[List all models]' '--help[Show help]' '--prompt[Headless mode with prompt]' '-l[List all models]' '-p[Headless mode with prompt]'
+            ;;
+        3)
+            _message 'model shortcut or ID'
+            ;;
+        4)
+            _describe 'mode' modes
+            ;;
+        5)
+            _message 'prompt (for headless mode)'
+            ;;
+    esac
+}
+
+_claude_mode "$@"
+`;
+}
+function generateFishCompletion() {
+  return `# claude-mode fish completion
+# Add to ~/.config/fish/completions/claude-mode.fish
+
+# Providers
+complete -c claude-mode -n "__fish_is_first_arg" -a "openrouter" -d "OpenRouter API"
+complete -c claude-mode -n "__fish_is_first_arg" -a "ollama-cloud" -d "Ollama Cloud"
+complete -c claude-mode -n "__fish_is_first_arg" -a "ollama-local" -d "Ollama Local"
+complete -c claude-mode -n "__fish_is_first_arg" -a "ollama-custom" -d "Ollama Custom"
+complete -c claude-mode -n "__fish_is_first_arg" -a "or" -d "OpenRouter (alias)"
+complete -c claude-mode -n "__fish_is_first_arg" -a "oc" -d "Ollama Cloud (alias)"
+complete -c claude-mode -n "__fish_is_first_arg" -a "ol" -d "Ollama Local (alias)"
+complete -c claude-mode -n "__fish_is_first_arg" -a "custom" -d "Ollama Custom (alias)"
+
+# Options
+complete -c claude-mode -s l -l list -d "List all models"
+complete -c claude-mode -s p -l prompt -d "Headless mode with prompt"
+complete -c claude-mode -s d -l dangerously-skip-permissions -d "Skip permission prompts"
+
+# Modes (third argument)
+complete -c claude-mode -n "__fish_seen_argument" -a "terminal t interactive i" -d "Interactive mode"
+complete -c claude-mode -n "__fish_seen_argument" -a "headless h prompt p" -d "Headless mode"
+`;
+}
+function printCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      console.log(generateBashCompletion());
+      break;
+    case "zsh":
+      console.log(generateZshCompletion());
+      break;
+    case "fish":
+      console.log(generateFishCompletion());
+      break;
+    default:
+      console.error(chalk2.red(`Unknown shell: ${shell}`));
+      console.log(chalk2.gray("Supported shells: bash, zsh, fish"));
+      process.exit(1);
+  }
+}
+async function healthCommand() {
+  console.log(chalk2.bold("\nProvider Health Check:\n"));
+  const results = await checkAllProvidersHealth();
+  for (const result of results) {
+    console.log("  " + formatHealthStatus(result));
+  }
+  console.log("");
+  const healthy = results.filter((r) => r.healthy).length;
+  const total = results.length;
+  if (healthy === total) {
+    console.log(chalk2.green(`All ${total} providers are healthy.`));
+  } else {
+    console.log(chalk2.yellow(`${healthy}/${total} providers are healthy.`));
+  }
+}
+program.name("claude-mode").description(
+  `
+${chalk2.bold("Claude Mode")} - Launch Claude Code with different providers
+
+${chalk2.bold("Providers:")}
+  openrouter        OpenRouter API
+  ollama-cloud      Ollama Cloud (OLLAMA_HOST)
+  ollama-local      Ollama Local (OLLAMA_BASE_URL_LOCAL)
+  ollama-custom     Ollama Custom (OLLAMA_BASE_URL_CUSTOM)
+
+${chalk2.bold("Model shortcuts:")}
+  OpenRouter (Premium): gpt52, gpt52-pro, gpt52-codex, opus, grok
+  OpenRouter (Value): deepseek, zai-glm47-flash, seed16, sonnet, haiku
+  OpenRouter (Existing): gpt120, glm47, gemini-pro, gemini-flash
+  Ollama: Models discovered dynamically via API
+
+${chalk2.bold("Mode shortcuts:")}
+  terminal, t, interactive, i  - Interactive terminal mode
+  headless, h, prompt, p       - Headless mode with prompt
+
+${chalk2.bold("Options:")}
+  -p, --prompt <prompt>               Headless mode (uses defaults if provider/model not set)
+  -d, --dangerously-skip-permissions  Skip permission prompts (\u26A0\uFE0F use with caution)
+
+${chalk2.bold("Default Provider/Model:")}
+  Set in ~/.claude-mode/claude-mode.json:
+    { "defaultProvider": "openrouter", "defaultModel": "sonnet" }
+
+${chalk2.bold("Examples:")}
+  claude-mode                                    Interactive menu
+  claude-mode -p "perform a code review"         Headless with default provider/model
+  claude-mode openrouter sonnet                  Interactive with Claude Sonnet
+  claude-mode or sonnet -p "list files"          Headless with specified provider/model
+  claude-mode ollama-local qwen3 h "list files"  Headless with local Qwen3 (legacy syntax)
+  claude-mode --dangerously-skip-permissions     Skip all permission prompts
+  claude-mode --list                             List all available models
+  claude-mode health                             Check provider availability
+  claude-mode config init                        Create config file
+  claude-mode completion bash                    Generate shell completions
+`
+).version("1.2.0");
+program.command("list").description("List all available providers and models").action(async () => {
+  await listModels();
+});
+program.command("health").description("Check health/availability of all providers").action(async () => {
+  await healthCommand();
+});
+program.command("config").description("Manage configuration").argument("[action]", "Action: show, init").action((action) => {
+  switch (action) {
+    case "init":
+      initConfigCommand();
+      break;
+    case "show":
+    default:
+      showConfig();
+      break;
+  }
+});
+program.command("completion").description("Generate shell completion scripts").argument("<shell>", "Shell type: bash, zsh, fish").action((shell) => {
+  printCompletion(shell);
+});
+program.option("-d, --dangerously-skip-permissions", "Skip permission prompts when executing commands").option("-l, --list", "List all available providers and models").option("-p, --prompt <prompt>", "Run in headless mode with the given prompt (uses defaults if provider/model not specified)").argument("[provider]", "Provider (openrouter, ollama-cloud, ollama-local, ollama-custom)").argument("[model]", "Model ID or shortcut").argument("[mode]", "Mode (terminal/t, headless/h) or prompt for headless").argument("[promptArg]", "Prompt for headless mode").action(async (provider, model, mode, promptArg, options) => {
+  if (options.list) {
+    await listModels();
+    return;
+  }
+  const skipPermissions = options.dangerouslySkipPermissions || false;
+  if (options.prompt) {
+    const defaultProvider = getConfig("defaultProvider");
+    const defaultModel = getConfig("defaultModel");
+    const effectiveProvider = provider || defaultProvider;
+    const effectiveModel = model || defaultModel;
+    if (!effectiveProvider || !effectiveModel) {
+      console.error(chalk2.red("Error: Provider and model are required"));
+      if (!effectiveProvider && !effectiveModel) {
+        console.log(chalk2.gray("Set defaults in config: claude-mode config init"));
+        console.log(chalk2.gray("Then edit ~/.claude-mode/claude-mode.json to set defaultProvider and defaultModel"));
+      } else if (!effectiveProvider) {
+        console.log(chalk2.gray("Missing: provider (set defaultProvider in config or pass as argument)"));
+      } else {
+        console.log(chalk2.gray("Missing: model (set defaultModel in config or pass as argument)"));
+      }
+      process.exit(1);
+    }
+    await quickMode(effectiveProvider, effectiveModel, skipPermissions, "headless", options.prompt);
+    return;
+  }
+  if (!provider) {
+    await interactiveMode(skipPermissions);
+  } else if (!model) {
+    const defaultModel = getConfig("defaultModel");
+    if (defaultModel) {
+      await quickMode(provider, defaultModel, skipPermissions, mode, promptArg);
+    } else {
+      console.error(chalk2.red("Error: Model is required when provider is specified"));
+      console.log(chalk2.gray("Usage: claude-mode <provider> <model> [mode] [prompt]"));
+      console.log(chalk2.gray("Or set defaultModel in ~/.claude-mode/claude-mode.json"));
+      console.log(chalk2.gray("Run claude-mode --list to see available models"));
+      process.exit(1);
+    }
+  } else {
+    await quickMode(provider, model, skipPermissions, mode, promptArg);
+  }
+});
+program.parse();