claude-code-provider-switch 1.1.4 → 1.1.6

package/lib/menu.js

@@ -9,6 +9,10 @@ const {
   getProviderDefaultModel,
   setDefaultProvider,
   setDefaultModel,
+  showApiKeyMenu,
+  getConfigurationSource,
+  getConfigurationPath,
+  hasGlobalConfiguration,
 } = require("./config");
 const {
   showModelSelection: showOpenRouterModelSelection,
@@ -27,12 +31,6 @@ async function showModelSelectionForProvider(provider) {
 
   switch (provider.id) {
     case "openrouter":
-      if (!envVars.OPENROUTER_AUTH_TOKEN) {
-        log("OpenRouter auth token required for model selection", "red");
-        log("Please set OPENROUTER_AUTH_TOKEN in .env file", "yellow");
-        log("Using default model...", "yellow");
-        return getProviderDefaultModel("openrouter");
-      }
       return await showOpenRouterModelSelection();
 
     case "ollama":
@@ -59,10 +57,12 @@ function showProviderMenu() {
     output: process.stdout,
   });
 
-  // Get current defaults
+  // Get current defaults and configuration source
   const defaultProvider = getDefaultProvider();
   const defaultModel = getDefaultModel();
+  const configSource = getConfigurationSource();
 
+  // Build providers array dynamically
   const providers = [
     {
       id: "openrouter",
@@ -77,9 +77,25 @@ function showProviderMenu() {
       aliases: ["original", "orig", "def", "d"],
     },
     { id: "set-default", name: "Set as Default", aliases: ["set-default"] },
-    { id: "help", name: "Help", aliases: ["help", "-h", "--help"] },
+    { id: "api-keys", name: "Manage API Keys", aliases: ["api-keys", "keys"] },
   ];
 
+  // Add "Save Configuration Locally" option only if global configuration exists
+  if (hasGlobalConfiguration()) {
+    providers.push({
+      id: "save-local",
+      name: "Save Configuration Locally",
+      aliases: ["save-local", "local", "save-locally"],
+    });
+  }
+
+  // Always add Help at the end
+  providers.push({
+    id: "help",
+    name: "Help",
+    aliases: ["help", "-h", "--help"],
+  });
+
   let selectedIndex = 0;
 
   function displayMenu() {
@@ -87,8 +103,18 @@ function showProviderMenu() {
     log("Claude Code Provider Switcher", "green");
     log("", "reset");
 
+    // Show configuration source with file path
+    const configSource = getConfigurationSource();
+    const configPath = getConfigurationPath();
+    log(`Configuration: ${configSource} (${configPath})`, "cyan");
+    log("", "reset");
+
     // Show current defaults
-    if (defaultProvider && defaultProvider !== "default") {
+    if (
+      defaultProvider &&
+      defaultProvider !== null &&
+      defaultProvider !== "default"
+    ) {
       const providerName =
         providers.find((p) => p.id === defaultProvider)?.name ||
         defaultProvider;
@@ -98,10 +124,8 @@ function showProviderMenu() {
         `Current default: ${providerName}${currentModel ? ` (${currentModel})` : ""}`,
         "yellow",
       );
-    } else {
-      log("No default provider set", "yellow");
+      log("", "reset");
     }
-    log("", "reset");
 
     log("Available providers:", "yellow");
     log("", "reset");
@@ -111,18 +135,21 @@ function showProviderMenu() {
       const isDefault = provider.id === defaultProvider;
       const defaultIndicator = isDefault ? " [DEFAULT]" : "";
       const isSetDefaultOption = provider.id === "set-default";
+      const isApiKeysOption = provider.id === "api-keys";
       const aliases =
         provider.aliases.length > 0
           ? `    Aliases: (${provider.aliases.join(", ")})`
           : "";
 
-      // Highlight "Set as Default" option in orange to make it stand out
+      // Highlight special options with different colors
       const color =
         index === selectedIndex
           ? "green"
           : isSetDefaultOption
             ? "orange"
-            : "reset";
+            : isApiKeysOption
+              ? "cyan"
+              : "reset";
 
       log(
         `${marker} ${index + 1}) ${provider.name}${defaultIndicator}${aliases}`,
@@ -130,51 +157,47 @@ function showProviderMenu() {
       );
     });
 
-    log("", "reset");
-    log("Controls:", "yellow");
-    log("↑/↓ - Navigate", "reset");
-    log("Enter - Select provider", "reset");
-    log("1-6 - Quick select", "reset");
-    log("ESC - Exit", "reset");
     log("", "reset");
 
     // Add helpful usage text
     log("💡 Quick Start:", "cyan");
     log("• Use ↑/↓ arrows to navigate providers", "reset");
     log("• Press Enter to launch selected provider", "reset");
+    log(`• Press 1-${providers.length} for quick select`, "reset");
     log("• Use 'Set as Default' to save your preferred provider", "reset");
     log("", "reset");
-    log("Commands:", "yellow");
-    log(
-      "  claude-switch                     - Show menu or use default",
-      "reset",
-    );
-    log(
-      "  claude-switch openrouter          - Use OpenRouter provider",
-      "reset",
-    );
-    log(
-      "  claude-switch anthropic           - Use Anthropic provider",
-      "reset",
-    );
-    log("  claude-switch ollama              - Use Ollama provider", "reset");
-    log(
-      "  claude-switch set-default         - Setup default provider",
-      "reset",
-    );
-    log("", "reset");
-    log("Model Selection:", "yellow");
-    log(
-      "  claude-switch openrouter --model  - Select OpenRouter model",
-      "reset",
-    );
-    log(
-      "  claude-switch anthropic --model   - Select Anthropic model",
-      "reset",
-    );
-    log("", "reset");
-    log("Type 'claude-switch --help' for complete documentation", "cyan");
-    log("", "reset");
+    // Commented out Commands section for cleaner menu
+    // log("Commands:", "yellow");
+    // log(
+    //   "  claude-switch                     - Show menu or use default",
+    //   "reset",
+    // );
+    // log(
+    //   "  claude-switch openrouter          - Use OpenRouter provider",
+    //   "reset",
+    // );
+    // log(
+    //   "  claude-switch anthropic           - Use Anthropic provider",
+    //   "reset",
+    // );
+    // log("  claude-switch ollama              - Use Ollama provider", "reset");
+    // log(
+    //   "  claude-switch set-default         - Setup default provider",
+    //   "reset",
+    // );
+    // log("", "reset");
+    // log("Model Selection:", "yellow");
+    // log(
+    //   "  claude-switch openrouter --model  - Select OpenRouter model",
+    //   "reset",
+    // );
+    // log(
+    //   "  claude-switch anthropic --model   - Select Anthropic model",
+    //   "reset",
+    // );
+    // log("", "reset");
+    // log("Type 'claude-switch --help' for complete documentation", "cyan");
+    // log("", "reset");
   }
 
   displayMenu();
@@ -197,7 +220,7 @@ function showProviderMenu() {
         process.stdin.removeAllListeners("keypress");
         rl.close();
         resolve(providers[selectedIndex]);
-      } else if (str && /^[1-6]$/.test(str)) {
+      } else if (str && /^[1-7]$/.test(str)) {
         const index = parseInt(str) - 1;
         if (index >= 0 && index < providers.length) {
           selectedIndex = index;
@@ -483,6 +506,11 @@ function showUsage() {
   );
   log("  show-defaults    - Display current default settings", "reset");
   log("  clear-defaults   - Reset all default settings", "reset");
+  log("  api-keys         - Manage API keys for providers", "reset");
+  log(
+    "  save-local       - Save global configuration to local .env file",
+    "reset",
+  );
   log("", "reset");
   log("Options:", "reset");
   log("  --model            - Show interactive model selection menu", "reset");

package/lib/ollama.js

@@ -10,7 +10,7 @@ const {
   loadEnvFile,
   findBestMatchingModel,
   promptForApiKey,
-  updateEnvFile,
+  updateConfigFile,
 } = require("./config");
 const { modelCache } = require("./cache");
 const { OLLAMA, CACHE, HTTP_STATUS, DEFAULT_MODELS } = require("./constants");
@@ -97,7 +97,7 @@ async function showModelSelection() {
       log("Ollama auth token is required for model selection", "red");
       process.exit(1);
     }
-    updateEnvFile("OLLAMA_AUTH_TOKEN", newToken);
+    updateConfigFile("OLLAMA_AUTH_TOKEN", newToken, null);
     authToken = newToken;
   }
 
@@ -378,8 +378,6 @@ async function launchOllama(
   extraArgs = [],
   directModel = null,
 ) {
-  log("Launching Claude Code with Ollama settings...", "green");
-
   const envVars = loadEnvFile();
   log(`Loading environment from: ${envVars.envFile}`, "yellow");
 
@@ -391,7 +389,7 @@ async function launchOllama(
     log("Press Enter to skip, or provide an auth token:", "reset");
     authToken = await promptForApiKey("Ollama (optional)", "OLLAMA_AUTH_TOKEN");
     if (authToken) {
-      updateEnvFile("OLLAMA_AUTH_TOKEN", authToken);
+      updateConfigFile("OLLAMA_AUTH_TOKEN", authToken, null);
       envVars.OLLAMA_AUTH_TOKEN = authToken;
     }
   }

package/lib/openrouter.js

@@ -9,7 +9,7 @@ const {
   loadEnvFile,
   findBestMatchingModel,
   promptForApiKey,
-  updateEnvFile,
+  updateConfigFile,
 } = require("./config");
 const { modelCache } = require("./cache");
 const {
@@ -435,8 +435,6 @@ async function launchOpenRouter(
   extraArgs = [],
   directModel = null,
 ) {
-  log("Launching Claude Code with OpenRouter settings...", "green");
-
   const envVars = loadEnvFile();
   log(`Loading environment from: ${envVars.envFile}`, "yellow");
 
@@ -450,7 +448,7 @@ async function launchOpenRouter(
       log("Error: OpenRouter auth token is required", "red");
       process.exit(1);
     }
-    updateEnvFile("OPENROUTER_AUTH_TOKEN", authToken);
+    updateConfigFile("OPENROUTER_AUTH_TOKEN", authToken, null);
     envVars.OPENROUTER_AUTH_TOKEN = authToken;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-provider-switch",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Cross-platform Claude Code provider switcher (OpenRouter, Ollama, Anthropic)",
   "main": "index.js",
   "bin": {
@@ -9,7 +9,6 @@
   "scripts": {
     "start": "node bin/claude-switch.js",
     "dev": "node bin/claude-switch.js",
-    "version": "npm version",
     "link": "npm link",
     "unlink": "npm unlink -g claude-code-provider-switch",
     "pub": "npm version patch && npm publish && git push origin main --tags",
@@ -22,15 +21,16 @@
     "test:all": "node test/run-tests.js"
   },
   "keywords": [
-    "claude",
     "claude-code",
-    "openrouter",
-    "llm switcher",
-    "llm provider switcher",
-    "ai provider switcher",
-    "ai model switcher",
-    "ai model provider switcher",
     "claude code provider switcher",
+    "claude code model switcher",
+    "claude code llm switcher",
+    "claude code llm provider switcher",
+    "ai provider switcher",
+    "claude code ai model switcher",
+    "claude code ai model provider switcher",
+    "claude code OpenRouter",
+    "claude code Ollama",
     "cli"
   ],
   "author": "Adrian R",
@@ -41,7 +41,9 @@
   "files": [
     "bin/",
     "lib/",
-    "README.md"
+    "test/",
+    "README.md",
+    "index.js"
   ],
   "preferGlobal": true
 }

package/test/run-tests.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process");
+const path = require("path");
+
+console.log("🧪 Running complete claude-switch test suite...\n");
+
+// Test files in order
+const testFiles = [
+  { name: "Validation & Error Tests", file: "test-validation-errors.js" },
+  { name: "Provider Integration Tests", file: "test-provider-integration.js" },
+  { name: "Comprehensive Integration Tests", file: "test-comprehensive.js" },
+];
+
+let currentTest = 0;
+
+function runNextTest() {
+  if (currentTest >= testFiles.length) {
+    console.log("\n🎉 All test suites passed!");
+    console.log("\n📊 Test Coverage Summary:");
+    console.log("  ✅ Constants and configuration");
+    console.log("  ✅ Error handling and validation");
+    console.log("  ✅ Provider-specific functionality");
+    console.log("  ✅ Integration and end-to-end tests");
+    console.log("  ✅ Cache and performance tests");
+    console.log("  ✅ Environment and configuration tests");
+    process.exit(0);
+    return;
+  }
+
+  const test = testFiles[currentTest];
+  console.log(`📋 Running ${test.name}...`);
+
+  const testProcess = spawn("node", [path.join(__dirname, test.file)], {
+    stdio: "inherit",
+  });
+
+  testProcess.on("close", (code) => {
+    if (code === 0) {
+      console.log(`✅ ${test.name} passed!\n`);
+      currentTest++;
+      runNextTest();
+    } else {
+      console.log(`\n❌ ${test.name} failed!`);
+      process.exit(1);
+    }
+  });
+
+  testProcess.on("error", (error) => {
+    console.log(`\n💥 Failed to run ${test.name}: ${error.message}`);
+    process.exit(1);
+  });
+}
+
+// Start running tests
+runNextTest();

package/test/test-comprehensive.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+
+// Test configuration
+const testConfig = {
+  timeout: 10000, // 10 seconds timeout for async operations
+  scriptPath: path.join(__dirname, "..", "bin", "claude-switch.js"),
+  envPath: path.join(__dirname, "..", ".env"),
+  testDir: __dirname,
+};
+
+// Utility functions
+function runCommand(args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("node", [testConfig.scriptPath, ...args], {
+      stdio: "pipe",
+      timeout: testConfig.timeout,
+      ...options,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", (code) => {
+      resolve({ code, stdout, stderr });
+    });
+
+    child.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+
+function runCommandWithInput(args, input, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("node", [testConfig.scriptPath, ...args], {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: testConfig.timeout,
+      ...options,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", (code) => {
+      resolve({ code, stdout, stderr });
+    });
+
+    child.on("error", (error) => {
+      reject(error);
+    });
+
+    // Send input
+    if (input) {
+      child.stdin.write(input);
+      child.stdin.end();
+    }
+  });
+}
+
+async function test(description, testFn) {
+  try {
+    console.log(`🧪 ${description}`);
+    await testFn();
+    console.log(`✅ ${description} - PASSED`);
+  } catch (error) {
+    console.log(`❌ ${description} - FAILED: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// Test suite
+async function runTests() {
+  console.log("🚀 Starting claude-switch test suite...\n");
+
+  // Test 1: Basic file existence
+  await test("Main script exists", () => {
+    if (!fs.existsSync(testConfig.scriptPath)) {
+      throw new Error("Main script not found");
+    }
+  });
+
+  await test("Environment file exists", () => {
+    if (!fs.existsSync(testConfig.envPath)) {
+      throw new Error("Environment file not found");
+    }
+  });
+
+  await test("Package.json exists", () => {
+    const packagePath = path.join(__dirname, "..", "package.json");
+    if (!fs.existsSync(packagePath)) {
+      throw new Error("Package.json not found");
+    }
+  });
+
+  // Test 2: Help command
+  await test("Help command works", async () => {
+    const result = await runCommand(["help"]);
+    if (result.code !== 0 || !result.stdout.includes("Usage:")) {
+      throw new Error(
+        `Help command failed. Code: ${result.code}, Output: ${result.stdout}`,
+      );
+    }
+  });
+
+  // Test 3: Version check
+  await test("Version information available", async () => {
+    const packagePath = path.join(__dirname, "..", "package.json");
+    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+    if (!packageJson.version || !packageJson.version.includes("1.0.0")) {
+      throw new Error(
+        `Version check failed. Expected: 1.0.0, Found: ${packageJson.version}`,
+      );
+    }
+  });
+
+  // Test 4: Provider listing
+  await test("Provider listing works", async () => {
+    const result = await runCommand(["help"]);
+    if (result.code !== 0 || !result.stdout.includes("Providers:")) {
+      throw new Error(
+        `Provider listing failed. Code: ${result.code}, Output: ${result.stdout}`,
+      );
+    }
+  });
+
+  // Test 5: Default provider functionality
+  await test("Default provider functionality works", async () => {
+    const result = await runCommand(["show-defaults"]);
+    if (
+      result.code !== 0 ||
+      (!result.stdout.includes("Default provider:") &&
+        !result.stdout.includes("No default provider set"))
+    ) {
+      throw new Error(
+        `Default provider functionality failed. Code: ${result.code}, Output: ${result.stdout}`,
+      );
+    }
+  });
+
+  // Test 6: Model selection with OpenRouter (test with exit)
+  await test("OpenRouter model selection interface works", async () => {
+    const result = await runCommandWithInput(
+      ["openrouter", "--model"],
+      "exit\n",
+    );
+    // Exit code 1 is acceptable when using default model after exit
+    if (result.code !== 0 && result.code !== 1) {
+      throw new Error(
+        `OpenRouter model selection failed. Code: ${result.code}`,
+      );
+    }
+    if (!result.stdout.includes("Found") || !result.stdout.includes("models")) {
+      throw new Error(
+        `OpenRouter model selection failed. Output: ${result.stdout}`,
+      );
+    }
+  });
+
+  // Test 7: Model selection with Ollama (test with exit)
+  await test("Ollama model selection interface works", async () => {
+    const result = await runCommandWithInput(["ollama", "--model"], "exit\n");
+    // Exit code 1 is acceptable when using default model after exit
+    if (result.code !== 0 && result.code !== 1) {
+      throw new Error(`Ollama model selection failed. Code: ${result.code}`);
+    }
+    if (!result.stdout.includes("Found") || !result.stdout.includes("models")) {
+      throw new Error(
+        `Ollama model selection failed. Output: ${result.stdout}`,
+      );
+    }
+  });
+
+  // Test 8: Model selection with Anthropic (test with enter)
+  await test("Anthropic model selection interface works", async () => {
+    const result = await runCommandWithInput(["anthropic", "--model"], "\n");
+    // Accept both successful model selection and API key error as valid
+    if (
+      !result.stdout.includes("Found") &&
+      !result.stdout.includes("models") &&
+      !result.stdout.includes("API key not found") &&
+      !result.stdout.includes("API key is required")
+    ) {
+      throw new Error(`Anthropic model selection failed. Code: ${result.code}`);
+    }
+  });
+
+  // Test 9: Error handling for invalid provider
+  await test("Invalid provider error handling", async () => {
+    const result = await runCommand(["invalid-provider"]);
+    if (result.code === 0 || !result.stdout.includes("Unknown command")) {
+      throw new Error("Invalid provider should fail with error message");
+    }
+  });
+
+  // Test 10: Virtual scrolling indicators present
+  await test("Virtual scrolling indicators present", async () => {
+    const result = await runCommandWithInput(
+      ["openrouter", "--model"],
+      "exit\n",
+    );
+    if (!result.stdout.includes("Use ↑/↓ to scroll through results")) {
+      throw new Error("Virtual scrolling instructions not present");
+    }
+  });
+
+  // Test 11: Default model highlighting
+  await test("Default model highlighting works", async () => {
+    const result = await runCommandWithInput(
+      ["openrouter", "--model"],
+      "exit\n",
+    );
+    if (!result.stdout.includes("[DEFAULT]")) {
+      throw new Error("Default model not highlighted");
+    }
+  });
+
+  // Test 12: Selection options instructions
+  await test("Selection options instructions present", async () => {
+    const result = await runCommandWithInput(
+      ["openrouter", "--model"],
+      "exit\n",
+    );
+    const requiredInstructions = [
+      "Type number to select",
+      "Type model name to search",
+      "Press Enter to select the first model",
+    ];
+
+    for (const instruction of requiredInstructions) {
+      if (!result.stdout.includes(instruction)) {
+        throw new Error(`Missing instruction: ${instruction}`);
+      }
+    }
+  });
+
+  // Test 13: Environment variable caching
+  await test("Environment caching works", async () => {
+    // This test checks that the app doesn't crash and loads environment properly
+    const result1 = await runCommand(["help"]);
+    const result2 = await runCommand(["help"]);
+
+    if (result1.code !== 0 || result2.code !== 0) {
+      throw new Error("Environment caching test failed");
+    }
+  });
+
+  // Test 14: Main menu functionality
+  await test("Main menu interface works", async () => {
+    const result = await runCommandWithInput([], "7\n"); // Select option 7 (should work)
+    if (result.code !== 0) {
+      throw new Error("Main menu interface failed");
+    }
+  });
+
+  console.log("\n🎉 All tests passed! The application is working correctly.");
+}
+
+// Run tests
+runTests().catch((error) => {
+  console.error("💥 Test suite failed:", error.message);
+  process.exit(1);
+});