claude-ai-switcher 1.1.4

package/src/clients/opencode.ts

@@ -0,0 +1,618 @@
+/**
+ * OpenCode Client Handler
+ *
+ * Manages ~/.config/opencode/opencode.json for OpenCode
+ */
+
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+
+export interface OpenCodeSettings {
+  $schema?: string;
+  provider?: Record<string, any>;
+  mcpServers?: Record<string, any>;
+  agents?: Record<string, any>;
+  [key: string]: any;
+}
+
+/**
+ * Get the OpenCode config path
+ * Priority: ~/.config/opencode/opencode.json
+ */
+export function getOpenCodeConfigPath(): string {
+  return path.join(os.homedir(), ".config", "opencode", "opencode.json");
+}
+
+/**
+ * Check if OpenCode settings file exists
+ */
+export function opencodeSettingsExists(): boolean {
+  const configPath = getOpenCodeConfigPath();
+  return fs.existsSync(configPath);
+}
+
+/**
+ * Read current OpenCode settings
+ */
+export async function readOpenCodeSettings(): Promise<OpenCodeSettings> {
+  const configPath = getOpenCodeConfigPath();
+  
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  const content = await fs.readFile(configPath, "utf-8");
+  return JSON.parse(content);
+}
+
+/**
+ * Write OpenCode settings with backup
+ */
+export async function writeOpenCodeSettings(settings: OpenCodeSettings): Promise<void> {
+  const configPath = getOpenCodeConfigPath();
+  const configDir = path.dirname(configPath);
+
+  // Ensure directory exists
+  await fs.ensureDir(configDir);
+
+  // Backup existing settings if they exist
+  if (opencodeSettingsExists()) {
+    const backupPath = `${configPath}.backup.${Date.now()}`;
+    await fs.copyFile(configPath, backupPath);
+  }
+
+  // Write new settings
+  await fs.writeFile(configPath, JSON.stringify(settings, null, 2), "utf-8");
+}
+
+/**
+ * Configure OpenCode for Alibaba Coding Plan
+ * Writes the full provider configuration with all models
+ */
+export async function configureAlibaba(apiKey: string): Promise<void> {
+  const settings = await readOpenCodeSettings();
+
+  // Set schema
+  settings.$schema = "https://opencode.ai/config.json";
+
+  // Configure bailian-coding-plan provider with all models
+  settings.provider = settings.provider || {};
+  settings.provider["bailian-coding-plan"] = {
+    npm: "@ai-sdk/anthropic",
+    name: "Model Studio Coding Plan",
+    options: {
+      baseURL: "https://coding-intl.dashscope.aliyuncs.com/apps/anthropic/v1",
+      apiKey: apiKey
+    },
+    models: {
+      "qwen3.7-plus": {
+        name: "Qwen3.7 Plus",
+        modalities: {
+          input: ["text", "image"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 1000000,
+          output: 65536
+        }
+      },
+      "qwen3.6-plus": {
+        name: "Qwen3.6 Plus",
+        modalities: {
+          input: ["text", "image"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 1000000,
+          output: 65536
+        }
+      },
+      "qwen3-max-2026-01-23": {
+        name: "Qwen3 Max 2026-01-23",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 262144,
+          output: 32768
+        }
+      },
+      "qwen3-coder-next": {
+        name: "Qwen3 Coder Next",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 262144,
+          output: 65536
+        }
+      },
+      "qwen3-coder-plus": {
+        name: "Qwen3 Coder Plus",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 1000000,
+          output: 65536
+        }
+      },
+      "MiniMax-M2.5": {
+        name: "MiniMax M2.5",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 200000,
+          output: 24576
+        }
+      },
+      "glm-5": {
+        name: "GLM-5",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 200000,
+          output: 16384
+        }
+      },
+      "glm-4.7": {
+        name: "GLM-4.7",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 256000,
+          output: 16384
+        }
+      },
+      "kimi-k2.5": {
+        name: "Kimi K2.5",
+        modalities: {
+          input: ["text", "image"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 200000,
+          output: 32768
+        }
+      }
+    }
+  };
+
+  await writeOpenCodeSettings(settings);
+}
+
+/**
+ * Configure OpenCode for Anthropic (default)
+ * Removes bailian-coding-plan provider to use native Anthropic
+ */
+export async function configureAnthropic(): Promise<void> {
+  const settings = await readOpenCodeSettings();
+
+  // Remove bailian-coding-plan provider
+  if (settings.provider?.["bailian-coding-plan"]) {
+    delete settings.provider["bailian-coding-plan"];
+  }
+
+  // Remove openrouter provider
+  if (settings.provider?.["openrouter"]) {
+    delete settings.provider["openrouter"];
+  }
+
+  // Remove ollama provider
+  if (settings.provider?.["ollama"]) {
+    delete settings.provider["ollama"];
+  }
+
+  // Remove gemini provider
+  if (settings.provider?.["gemini"]) {
+    delete settings.provider["gemini"];
+  }
+
+  // Remove glm provider
+  if (settings.provider?.["glm"]) {
+    delete settings.provider["glm"];
+  }
+
+  // Clean up empty provider object
+  if (settings.provider && Object.keys(settings.provider).length === 0) {
+    delete settings.provider;
+  }
+
+  await writeOpenCodeSettings(settings);
+}
+
+/**
+ * Configure OpenCode for GLM/Z.AI
+ * Auth is managed by coding-helper — reads baseURL and apiKey from Claude settings
+ */
+export async function configureGLM(baseURL: string, apiKey: string): Promise<void> {
+  const settings = await readOpenCodeSettings();
+
+  settings.$schema = "https://opencode.ai/config.json";
+
+  settings.provider = settings.provider || {};
+  settings.provider["glm"] = {
+    npm: "@ai-sdk/anthropic",
+    name: "GLM/Z.AI",
+    options: {
+      baseURL,
+      apiKey
+    },
+    models: {
+      "glm-5.1": {
+        name: "GLM-5.1",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 200000,
+          output: 16384
+        }
+      },
+      "glm-5v-turbo": {
+        name: "GLM-5V-Turbo",
+        modalities: {
+          input: ["text", "image"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 200000,
+          output: 16384
+        }
+      },
+      "glm-5-turbo": {
+        name: "GLM-5-Turbo",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 200000,
+          output: 16384
+        }
+      },
+      "glm-4.7": {
+        name: "GLM-4.7",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        options: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 8192
+          }
+        },
+        limit: {
+          context: 256000,
+          output: 16384
+        }
+      },
+      "glm-4.7-flash": {
+        name: "GLM-4.7-Flash",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 256000,
+          output: 16384
+        }
+      }
+    }
+  };
+
+  await writeOpenCodeSettings(settings);
+}
+
+/**
+ * Configure OpenCode for OpenRouter
+ * Writes the openrouter provider with available models
+ */
+export async function configureOpenRouter(apiKey: string): Promise<void> {
+  const settings = await readOpenCodeSettings();
+
+  // Set schema
+  settings.$schema = "https://opencode.ai/config.json";
+
+  // Configure openrouter provider with models
+  settings.provider = settings.provider || {};
+  settings.provider["openrouter"] = {
+    npm: "@ai-sdk/openai",
+    name: "OpenRouter",
+    options: {
+      baseURL: "https://openrouter.ai/api/v1",
+      apiKey: apiKey
+    },
+    models: {
+      "qwen/qwen3.6-plus:free": {
+        name: "Qwen3.6 Plus (Free)",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 131072,
+          output: 32768
+        }
+      },
+      "openrouter/free": {
+        name: "OpenRouter Free",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 131072,
+          output: 32768
+        }
+      }
+    }
+  };
+
+  await writeOpenCodeSettings(settings);
+}
+
+/**
+ * Configure OpenCode for Ollama (via LiteLLM proxy on port 4000)
+ */
+export async function configureOllama(): Promise<void> {
+  const settings = await readOpenCodeSettings();
+
+  settings.$schema = "https://opencode.ai/config.json";
+
+  settings.provider = settings.provider || {};
+  settings.provider["ollama"] = {
+    npm: "@ai-sdk/openai",
+    name: "Ollama (Local)",
+    options: {
+      baseURL: "http://localhost:4000/v1",
+      apiKey: "ollama"
+    },
+    models: {
+      "deepseek-r1:latest": {
+        name: "DeepSeek R1",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 128000,
+          output: 32768
+        }
+      },
+      "qwen2.5-coder:latest": {
+        name: "Qwen 2.5 Coder",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 128000,
+          output: 32768
+        }
+      },
+      "llama3.1:latest": {
+        name: "Llama 3.1",
+        modalities: {
+          input: ["text", "image"],
+          output: ["text"]
+        },
+        limit: {
+          context: 128000,
+          output: 32768
+        }
+      },
+      "codellama:latest": {
+        name: "Code Llama",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 100000,
+          output: 32768
+        }
+      }
+    }
+  };
+
+  await writeOpenCodeSettings(settings);
+}
+
+/**
+ * Configure OpenCode for Gemini (via LiteLLM proxy on port 4001)
+ */
+export async function configureGemini(apiKey: string): Promise<void> {
+  const settings = await readOpenCodeSettings();
+
+  settings.$schema = "https://opencode.ai/config.json";
+
+  settings.provider = settings.provider || {};
+  settings.provider["gemini"] = {
+    npm: "@ai-sdk/openai",
+    name: "Gemini (Google)",
+    options: {
+      baseURL: "http://localhost:4001/v1",
+      apiKey: apiKey
+    },
+    models: {
+      "gemini-2.5-pro": {
+        name: "Gemini 2.5 Pro",
+        modalities: {
+          input: ["text", "image"],
+          output: ["text"]
+        },
+        limit: {
+          context: 1000000,
+          output: 65536
+        }
+      },
+      "gemini-2.5-flash": {
+        name: "Gemini 2.5 Flash",
+        modalities: {
+          input: ["text", "image"],
+          output: ["text"]
+        },
+        limit: {
+          context: 1000000,
+          output: 65536
+        }
+      },
+      "gemini-2.5-flash-lite": {
+        name: "Gemini 2.5 Flash Lite",
+        modalities: {
+          input: ["text"],
+          output: ["text"]
+        },
+        limit: {
+          context: 1000000,
+          output: 65536
+        }
+      }
+    }
+  };
+
+  await writeOpenCodeSettings(settings);
+}
+
+/**
+ * Remove a specific provider from OpenCode settings
+ * Only removes the named provider, preserving others
+ */
+export async function removeProvider(providerKey: string): Promise<void> {
+  const settings = await readOpenCodeSettings();
+
+  if (settings.provider?.[providerKey]) {
+    delete settings.provider[providerKey];
+  }
+
+  // Clean up empty provider object
+  if (settings.provider && Object.keys(settings.provider).length === 0) {
+    delete settings.provider;
+  }
+
+  await writeOpenCodeSettings(settings);
+}
+
+/**
+ * Get current provider from OpenCode settings
+ */
+export async function getCurrentProvider(): Promise<{
+  provider: string;
+  model?: string;
+  endpoint?: string;
+} | null> {
+  if (!opencodeSettingsExists()) {
+    return { provider: "anthropic" };
+  }
+
+  const settings = await readOpenCodeSettings();
+
+  // Check for bailian-coding-plan (Alibaba) configuration
+  if (settings.provider?.["bailian-coding-plan"]) {
+    return {
+      provider: "alibaba",
+      endpoint: settings.provider["bailian-coding-plan"].options?.baseURL
+    };
+  }
+
+  // Check for openrouter configuration
+  if (settings.provider?.["openrouter"]) {
+    return {
+      provider: "openrouter",
+      endpoint: "https://openrouter.ai/api/v1"
+    };
+  }
+
+  // Check for ollama configuration
+  if (settings.provider?.["ollama"]) {
+    return {
+      provider: "ollama",
+      endpoint: "http://localhost:4000/v1"
+    };
+  }
+
+  // Check for gemini configuration
+  if (settings.provider?.["gemini"]) {
+    return {
+      provider: "gemini",
+      endpoint: "http://localhost:4001/v1"
+    };
+  }
+
+  // Check for glm configuration
+  if (settings.provider?.["glm"]) {
+    return {
+      provider: "glm",
+      endpoint: settings.provider["glm"].options?.baseURL
+    };
+  }
+
+  return { provider: "anthropic" };
+}

package/src/config.ts

@@ -0,0 +1,101 @@
+/**
+ * Configuration Manager
+ * 
+ * Manages API keys and settings in ~/.claude-ai-switcher/config.json
+ */
+
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+
+const CONFIG_DIR = path.join(os.homedir(), ".claude-ai-switcher");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+export interface UserConfig {
+  alibabaApiKey?: string;
+  openrouterApiKey?: string;
+  geminiApiKey?: string;
+  defaultProvider?: string;
+  defaultModel?: string;
+}
+
+/**
+ * Ensure config directory exists
+ */
+async function ensureConfigDir(): Promise<void> {
+  await fs.ensureDir(CONFIG_DIR);
+}
+
+/**
+ * Read user configuration
+ */
+export async function readConfig(): Promise<UserConfig> {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  
+  const content = await fs.readFile(CONFIG_FILE, "utf-8");
+  return JSON.parse(content);
+}
+
+/**
+ * Write user configuration
+ */
+export async function writeConfig(config: UserConfig): Promise<void> {
+  await ensureConfigDir();
+  await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+
+/**
+ * Get API key for a provider
+ */
+export async function getApiKey(provider: string): Promise<string | undefined> {
+  const config = await readConfig();
+  
+  switch (provider) {
+    case "alibaba":
+      return config.alibabaApiKey;
+    case "openrouter":
+      return config.openrouterApiKey;
+    case "gemini":
+      return config.geminiApiKey;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Set API key for a provider
+ */
+export async function setApiKey(provider: string, apiKey: string): Promise<void> {
+  const config = await readConfig();
+  
+  switch (provider) {
+    case "alibaba":
+      config.alibabaApiKey = apiKey;
+      break;
+    case "openrouter":
+      config.openrouterApiKey = apiKey;
+      break;
+    case "gemini":
+      config.geminiApiKey = apiKey;
+      break;
+  }
+  
+  await writeConfig(config);
+}
+
+/**
+ * Check if API key is set for a provider
+ */
+export async function hasApiKey(provider: string): Promise<boolean> {
+  const apiKey = await getApiKey(provider);
+  return !!apiKey;
+}
+
+/**
+ * Get config file path
+ */
+export function getConfigPath(): string {
+  return CONFIG_FILE;
+}