gemini模型环境变量分离 provider指令支持切换gemini

src/commands/__tests__/provider.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
+import { readFileSync, writeFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function getSettingsPath(): string {
+  return path.join(homedir(), ".claude", "settings.json");
+}
+
+// Mock settings module
+mock.module("../utils/settings/settings.js", () => ({
+  getInitialSettings: () => ({}),
+  getSettings_DEPRECATED: () => ({}),
+  getSettingsForSource: () => ({}),
+  updateSettingsForSource: () => {},
+}));
+mock.module("../utils/managedEnv.js", () => ({
+  applyConfigEnvironmentVariables: () => {},
+}));
+
+const { default: providerCommand } = await import("../provider.ts");
+
+describe("provider command", () => {
+  const envKeys = [
+    "CLAUDE_CODE_USE_GEMINI",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+    "CLAUDE_CODE_USE_OPENAI",
+    "GEMINI_API_KEY",
+    "OPENAI_API_KEY",
+    "OPENAI_BASE_URL",
+  ] as const;
+
+  const savedEnv: Record<string, string | undefined> = {};
+
+  beforeEach(() => {
+    // Save and clear environment variables
+    for (const key of envKeys) {
+      savedEnv[key] = process.env[key];
+      delete process.env[key];
+    }
+  });
+
+  afterEach(() => {
+    // Restore environment variables
+    for (const key of envKeys) {
+      if (savedEnv[key] !== undefined) {
+        process.env[key] = savedEnv[key];
+      } else {
+        delete process.env[key];
+      }
+    }
+  });
+
+  test("validates gemini as a valid provider", async () => {
+    const result = await providerCommand.load().then(cmd => cmd.call("gemini", {} as any));
+    expect(result).toBeDefined();
+    // Should not return an error about invalid provider
+    if (result && typeof result === 'object' && 'value' in result) {
+      expect(result.value as string).toContain("gemini");
+    }
+  });
+
+  test("switches to gemini without API key warning", async () => {
+    const result = await providerCommand.load().then(cmd => cmd.call("gemini", {} as any));
+    expect(result).toBeDefined();
+    if (result && typeof result === 'object' && 'value' in result) {
+      const value = result.value as string;
+      // Should either succeed or show warning about missing API key
+      expect(value).toMatch(/API provider set to gemini|Switched to Gemini provider/);
+    }
+  });
+
+  test("switches to gemini with API key set", async () => {
+    process.env.GEMINI_API_KEY = "test-key";
+    const result = await providerCommand.load().then(cmd => cmd.call("gemini", {} as any));
+    expect(result).toBeDefined();
+    if (result && typeof result === 'object' && 'value' in result) {
+      const value = result.value as string;
+      expect(value).toContain("API provider set to gemini");
+      expect(value).not.toContain("Warning");
+    }
+  });
+
+  test("provider list includes gemini", async () => {
+    // Test that help or description shows gemini is supported
+    expect(providerCommand.description).toContain("gemini");
+    expect(providerCommand.argumentHint).toContain("gemini");
+  });
+
+  test("unset clears gemini env var", async () => {
+    process.env.CLAUDE_CODE_USE_GEMINI = "1";
+    const result = await providerCommand.load().then(cmd => cmd.call("unset", {} as any));
+    expect(result).toBeDefined();
+    expect(process.env.CLAUDE_CODE_USE_GEMINI).toBeUndefined();
+  });
+});

src/commands/provider.ts

@@ -13,6 +13,8 @@ function getEnvVarForProvider(provider: string): string {
       return 'CLAUDE_CODE_USE_VERTEX'
     case 'foundry':
       return 'CLAUDE_CODE_USE_FOUNDRY'
+    case 'gemini':
+      return 'CLAUDE_CODE_USE_GEMINI'
     default:
       throw new Error(`Unknown provider: ${provider}`)
   }
@@ -45,13 +47,27 @@ const call: LocalCommandCall = async (args, context) => {
     delete process.env.CLAUDE_CODE_USE_VERTEX
     delete process.env.CLAUDE_CODE_USE_FOUNDRY
     delete process.env.CLAUDE_CODE_USE_OPENAI
-    return { type: 'text', value: 'API provider cleared (will use environment variables).' }
+    delete process.env.CLAUDE_CODE_USE_GEMINI
+    return {
+      type: 'text',
+      value: 'API provider cleared (will use environment variables).',
+    }
   }
 
   // Validate provider
-  const validProviders = ['anthropic', 'openai', 'bedrock', 'vertex', 'foundry']
+  const validProviders = [
+    'anthropic',
+    'openai',
+    'gemini',
+    'bedrock',
+    'vertex',
+    'foundry',
+  ]
   if (!validProviders.includes(arg)) {
-    return { type: 'text', value: `Invalid provider: ${arg}\nValid: ${validProviders.join(', ')}` }
+    return {
+      type: 'text',
+      value: `Invalid provider: ${arg}\nValid: ${validProviders.join(', ')}`,
+    }
   }
 
   // Check env vars when switching to openai (including settings.env)
@@ -71,37 +87,58 @@ const call: LocalCommandCall = async (args, context) => {
     }
   }
 
+  // Check env vars when switching to gemini (including settings.env)
+  if (arg === 'gemini') {
+    const mergedEnv = getMergedEnv()
+    const hasKey = !!mergedEnv.GEMINI_API_KEY
+    // GEMINI_BASE_URL is optional (has default)
+    if (!hasKey) {
+      updateSettingsForSource('userSettings', { modelType: 'gemini' })
+      return {
+        type: 'text',
+        value: `Switched to Gemini provider.\nWarning: Missing env var: GEMINI_API_KEY\nConfigure it via /login or set manually.`,
+      }
+    }
+  }
+
   // Handle different provider types
-  // - 'anthropic' and 'openai' are stored in settings.json (persistent)
+  // - 'anthropic', 'openai', 'gemini' are stored in settings.json (persistent)
   // - 'bedrock', 'vertex', 'foundry' are env-only (do NOT touch settings.json)
-  if (arg === 'anthropic' || arg === 'openai') {
+  if (arg === 'anthropic' || arg === 'openai' || arg === 'gemini') {
     // Clear any cloud provider env vars to avoid conflicts
     delete process.env.CLAUDE_CODE_USE_BEDROCK
     delete process.env.CLAUDE_CODE_USE_VERTEX
     delete process.env.CLAUDE_CODE_USE_FOUNDRY
+    delete process.env.CLAUDE_CODE_USE_OPENAI
+    delete process.env.CLAUDE_CODE_USE_GEMINI
     // Update settings.json
     updateSettingsForSource('userSettings', { modelType: arg })
     // Ensure settings.env gets applied to process.env
     applyConfigEnvironmentVariables()
     return { type: 'text', value: `API provider set to ${arg}.` }
   } else {
-    // Cloud providers: set env vars only, do NOT touch settings.modelType
+    // Cloud providers: set env vars only, do NOT touch settings.json
     delete process.env.CLAUDE_CODE_USE_OPENAI
     delete process.env.OPENAI_API_KEY
     delete process.env.OPENAI_BASE_URL
+    delete process.env.CLAUDE_CODE_USE_GEMINI
     process.env[getEnvVarForProvider(arg)] = '1'
     // Do not modify settings.json - cloud providers controlled solely by env vars
     applyConfigEnvironmentVariables()
-    return { type: 'text', value: `API provider set to ${arg} (via environment variable).` }
+    return {
+      type: 'text',
+      value: `API provider set to ${arg} (via environment variable).`,
+    }
   }
 }
 
 const provider = {
   type: 'local',
   name: 'provider',
-  description: 'Switch API provider (anthropic/openai/bedrock/vertex/foundry)',
+  description:
+    'Switch API provider (anthropic/openai/gemini/bedrock/vertex/foundry)',
   aliases: ['api'],
-  argumentHint: '[anthropic|openai|bedrock|vertex|foundry|unset]',
+  argumentHint: '[anthropic|openai|gemini|bedrock|vertex|foundry|unset]',
   supportsNonInteractive: true,
   load: () => Promise.resolve({ call }),
 } satisfies Command