feat: /login local model

src/components/LocalLoginFlow.tsx

@@ -1,14 +1,11 @@
 import * as React from 'react'
 import { useState } from 'react'
-import type { LocalJSXCommandOnDone } from '../../types/command.js'
 import { saveLocalModelConfig } from '../utils/auth.js'
 import { Box, Text } from '../ink.js'
 import TextInput from './TextInput.js'
-import { ConsoleOAuthFlow } from './ConsoleOAuthFlow.js'
-import Dialog from './design-system/Dialog.js'
 
 interface Props {
-  onDone: LocalJSXCommandOnDone
+  onDone: () => void
   startingMessage?: string
 }
 
@@ -47,15 +44,15 @@ export function LocalLoginFlow({ onDone, startingMessage }: Props) {
     try {
       // 保存本地模型配置
       await saveLocalModelConfig(finalUrl, finalModel)
-      onDone(true)
+      onDone()
     } catch (error) {
       console.error('Failed to save local model config:', error)
-      onDone(false)
+      onDone()
     }
   }
 
   const handleCancel = () => {
-    onDone(false)
+    onDone()
   }
 
   return (

src/hooks/useApiKeyVerification.ts

@@ -1,4 +1,4 @@
-import { useCallback, useState } from 'react'
+import { useCallback, useEffect, useState } from 'react'
 import { getIsNonInteractiveSession } from '../bootstrap/state.js'
 import { verifyApiKey } from '../services/api/claude.js'
 import { getGlobalConfig } from '../utils/config.js'
@@ -8,8 +8,12 @@ import {
   isAnthropicAuthEnabled,
   isClaudeAISubscriber,
   getConfiguredAuthProvider,
+  getConfiguredAuthProviderFromFile,
   getOpenAIAuthTokens,
+  getLocalBaseUrl,
+  getLocalModelName,
 } from '../utils/auth.js'
+import { useAppState } from '../state/AppState.js'
 
 export type VerificationStatus =
   | 'loading'
@@ -26,7 +30,17 @@ export type ApiKeyVerificationResult = {
 
 export function useApiKeyVerification(): ApiKeyVerificationResult {
   const [status, setStatus] = useState<VerificationStatus>(() => {
-    const authProvider = getConfiguredAuthProvider()
+    const authProvider = getConfiguredAuthProviderFromFile()
+    
+    // Check Local authentication
+    if (authProvider === 'local') {
+      const baseUrl = getLocalBaseUrl()
+      const modelName = getLocalModelName()
+      if (baseUrl && modelName) {
+        return 'valid'
+      }
+      return 'missing'
+    }
     
     // Check OpenAI authentication
     if (authProvider === 'openai') {
@@ -67,8 +81,109 @@ export function useApiKeyVerification(): ApiKeyVerificationResult {
   })
   const [error, setError] = useState<Error | null>(null)
 
+  // Watch authVersion changes to re-verify API key
+  const authVersion = useAppState(s => s.authVersion)
+
+  useEffect(() => {
+    // When authVersion changes, re-verify the API key
+    const reverify = async (): Promise<void> => {
+      const authProvider = getConfiguredAuthProviderFromFile()
+      console.log('[useApiKeyVerification] authVersion changed, authProvider:', authProvider)
+      
+      // Check Local authentication
+      if (authProvider === 'local') {
+        // Force re-read config by reading directly from file
+        const baseUrl = getLocalBaseUrl()
+        const modelName = getLocalModelName()
+        console.log('[useApiKeyVerification] Local - baseUrl:', baseUrl, 'modelName:', modelName)
+        if (baseUrl && modelName) {
+          setStatus('valid')
+        } else {
+          setStatus('missing')
+        }
+        return
+      }
+      
+      // Check OpenAI authentication
+      if (authProvider === 'openai') {
+        const { getGlobalConfig: getConfig } = await import('../utils/config.js')
+        const freshConfig = getConfig()
+        const hasApiKey = !!freshConfig.openAiApiKey
+        const hasAccessToken = !!freshConfig.openAiAccessToken
+        if (hasApiKey || hasAccessToken) {
+          setStatus('valid')
+        } else {
+          setStatus('missing')
+        }
+        return
+      }
+      
+      // Check OpenRouter authentication
+      if (authProvider === 'openrouter') {
+        const { getGlobalConfig: getConfig } = await import('../utils/config.js')
+        const freshConfig = getConfig()
+        const hasApiKey = !!freshConfig.openRouterApiKey
+        if (hasApiKey) {
+          setStatus('valid')
+        } else {
+          setStatus('missing')
+        }
+        return
+      }
+      
+      // Anthropic authentication
+      if (!isAnthropicAuthEnabled() || isClaudeAISubscriber()) {
+        setStatus('valid')
+        return
+      }
+      // Warm the apiKeyHelper cache (no-op if not configured), then read from
+      // all sources. getAnthropicApiKeyWithSource() reads the now-warm cache.
+      await getApiKeyFromApiKeyHelper(getIsNonInteractiveSession())
+      const { key: apiKey, source } = getAnthropicApiKeyWithSource()
+      if (!apiKey) {
+        if (source === 'apiKeyHelper') {
+          setStatus('error')
+          setError(new Error('API key helper did not return a valid key'))
+          return
+        }
+        const newStatus = 'missing'
+        setStatus(newStatus)
+        return
+      }
+
+      try {
+        const isValid = await verifyApiKey(apiKey, false)
+        const newStatus = isValid ? 'valid' : 'invalid'
+        setStatus(newStatus)
+        return
+      } catch (error) {
+        // This happens when there an error response from the API but it's not an invalid API key error
+        // In this case, we still mark the API key as invalid - but we also log the error so we can
+        // display it to the user to be more helpful
+        setError(error as Error)
+        const newStatus = 'error'
+        setStatus(newStatus)
+        return
+      }
+    }
+
+    void reverify()
+  }, [authVersion])
+
   const verify = useCallback(async (): Promise<void> => {
-    const authProvider = getConfiguredAuthProvider()
+    const authProvider = getConfiguredAuthProviderFromFile()
+    
+    // Check Local authentication
+    if (authProvider === 'local') {
+      const baseUrl = getLocalBaseUrl()
+      const modelName = getLocalModelName()
+      if (baseUrl && modelName) {
+        setStatus('valid')
+      } else {
+        setStatus('missing')
+      }
+      return
+    }
     
     // Check OpenAI authentication
     if (authProvider === 'openai') {

src/services/api/client.ts

@@ -11,6 +11,7 @@ import {
   refreshGcpCredentialsIfNeeded,
   getOpenRouterApiKey,
   getOpenAIApiKey,
+  getLocalBaseUrl,
 } from 'src/utils/auth.js'
 import { getUserAgent } from 'src/utils/http.js'
 import { getSmallFastModel } from 'src/utils/model/model.js'
@@ -335,6 +336,15 @@ export async function getAnthropicClient({
     }
   }
 
+  // Handle Local
+  if (provider === 'local') {
+    const localBaseUrl = await getLocalBaseUrl()
+    if (localBaseUrl) {
+      clientConfig.baseURL = localBaseUrl
+      clientConfig.apiKey = 'local-model' // Use a dummy API key for local models
+    }
+  }
+
   return new Anthropic(clientConfig)
 }
 
@@ -344,8 +354,8 @@ async function configureApiKeyHeaders(
 ): Promise<void> {
   const provider = getAPIProvider()
   
-  // Skip for OpenRouter and OpenAI - they use apiKey parameter instead
-  if (provider === 'openrouter' || provider === 'openai') {
+  // Skip for OpenRouter, OpenAI, and Local - they use apiKey parameter instead
+  if (provider === 'openrouter' || provider === 'openai' || provider === 'local') {
     return
   }
 

src/utils/auth.ts

@@ -49,6 +49,7 @@ import {
   saveGlobalConfig,
 } from './config.js'
 import { logAntError, logForDebugging } from './debug.js'
+import { getGlobalClaudeFile } from './env.js'
 import {
   getClaudeConfigHomeDir,
   isBareMode,
@@ -295,10 +296,8 @@ export function getOpenRouterApiKeyWithSource(): {
     : { key: null, source: 'none' }
 }
 
-export function getConfiguredAuthProvider():
-  | 'anthropic'
-  | 'openrouter'
-  | 'openai' {
+export function getConfiguredAuthProvider(): 'anthropic' | 'openrouter' | 'openai' | 'local' {
+  // First try to get from cache for performance
   const storedProvider = getGlobalConfig().authProvider
   if (storedProvider) {
     return storedProvider
@@ -315,6 +314,38 @@ export function getConfiguredAuthProvider():
   }
 }
 
+// Read authProvider directly from file to bypass cache
+export function getConfiguredAuthProviderFromFile(): 'anthropic' | 'openrouter' | 'openai' | 'local' {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { readFileSync } = require('fs') as typeof import('fs')
+    const raw = readFileSync(getGlobalClaudeFile(), 'utf8')
+    const config = JSON.parse(raw) as {
+      authProvider?: 'anthropic' | 'openrouter' | 'openai' | 'local'
+    }
+    console.log('[getConfiguredAuthProviderFromFile] Config from file:', config.authProvider)
+
+    if (config.authProvider) {
+      return config.authProvider
+    }
+  } catch (error) {
+    console.log('[getConfiguredAuthProviderFromFile] Error reading file:', error)
+    // Ignore errors, fall through to default
+  }
+
+  // Fallback to API provider
+  const provider = getAPIProvider()
+  console.log('[getConfiguredAuthProviderFromFile] Fallback to API provider:', provider)
+  switch (provider) {
+    case 'openrouter':
+      return 'openrouter'
+    case 'openai':
+      return 'openai'
+    default:
+      return 'anthropic'
+  }
+}
+
 export type OpenAIAuthTokens = {
   accessToken: string
   refreshToken?: string | null
@@ -394,6 +425,7 @@ export async function saveOpenRouterApiKey(apiKey: string): Promise<void> {
 }
 
 export async function saveLocalModelConfig(baseUrl: string, modelName: string): Promise<void> {
+  console.log('[saveLocalModelConfig] Saving local model config:', baseUrl, modelName)
   if (!baseUrl.trim()) {
     throw new Error('Base URL cannot be empty')
   }
@@ -405,16 +437,63 @@ export async function saveLocalModelConfig(baseUrl: string, modelName: string):
     throw new Error('Invalid URL format')
   }
   
-  saveGlobalConfig(current => ({
-    ...current,
-    authProvider: 'local',
-    localBaseUrl: baseUrl,
-    localModelName: modelName,
-  }))
+  saveGlobalConfig(current => {
+    const newConfig = {
+      ...current,
+      authProvider: 'local',
+      localBaseUrl: baseUrl,
+      localModelName: modelName,
+    }
+    console.log('[saveLocalModelConfig] New config to save:', newConfig)
+    return newConfig
+  })
   
   // Clear provider cache so it will be re-read on next access
   const { clearStoredProviderCache } = await import('./model/providers.js')
   clearStoredProviderCache()
+  console.log('[saveLocalModelConfig] Config saved successfully')
+}
+
+export function getLocalModelName(): string | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { readFileSync } = require('fs') as typeof import('fs')
+    const raw = readFileSync(getGlobalClaudeFile(), 'utf8')
+    const config = JSON.parse(raw) as {
+      authProvider?: string
+      localModelName?: string
+    }
+    console.log('[getLocalModelName] Config from file:', config.authProvider, config.localModelName)
+
+    if (config.authProvider === 'local' && config.localModelName) {
+      return config.localModelName
+    }
+    return null
+  } catch (error) {
+    console.log('[getLocalModelName] Error reading file:', error)
+    return null
+  }
+}
+
+export function getLocalBaseUrl(): string | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { readFileSync } = require('fs') as typeof import('fs')
+    const raw = readFileSync(getGlobalClaudeFile(), 'utf8')
+    const config = JSON.parse(raw) as {
+      authProvider?: string
+      localBaseUrl?: string
+    }
+    console.log('[getLocalBaseUrl] Config from file:', config.authProvider, config.localBaseUrl)
+
+    if (config.authProvider === 'local' && config.localBaseUrl) {
+      return config.localBaseUrl
+    }
+    return null
+  } catch (error) {
+    console.log('[getLocalBaseUrl] Error reading file:', error)
+    return null
+  }
 }
 
 function getCodexHomeDir(): string {

src/utils/config.ts

@@ -185,6 +185,21 @@ export type GlobalConfig = {
    * @deprecated Use settings.apiKeyHelper instead.
    */
   apiKeyHelper?: string
+  
+  // Authentication provider configuration
+  authProvider?: 'anthropic' | 'openai' | 'openrouter' | 'local'
+  
+  // OpenRouter API key
+  openRouterApiKey?: string
+  
+  // OpenAI API configuration
+  openAiApiKey?: string
+  openAiAccessToken?: string
+  
+  // Local model configuration
+  localBaseUrl?: string
+  localModelName?: string
+  
   projects?: Record<string, ProjectConfig>
   numStartups: number
   installMethod?: InstallMethod
@@ -626,6 +641,12 @@ export const DEFAULT_GLOBAL_CONFIG: GlobalConfig = createDefaultGlobalConfig()
 
 export const GLOBAL_CONFIG_KEYS = [
   'apiKeyHelper',
+  'authProvider',
+  'openRouterApiKey',
+  'openAiApiKey',
+  'openAiAccessToken',
+  'localBaseUrl',
+  'localModelName',
   'installMethod',
   'autoUpdates',
   'autoUpdatesProtectedForNative',

src/utils/model/model.ts

@@ -7,6 +7,7 @@
  */
 import { getMainLoopModelOverride } from '../../bootstrap/state.js'
 import {
+  getLocalModelName,
   getSubscriptionType,
   isClaudeAISubscriber,
   isMaxSubscriber,
@@ -170,12 +171,23 @@ export function getRuntimeMainLoopModel(params: {
  * Get the default main loop model setting.
  *
  * This handles the built-in default:
+ * - Local model name if configured as Local provider
  * - Opus for Max and Team Premium users
  * - Sonnet 4.6 for all other users (including Team Standard, Pro, Enterprise)
  *
  * @returns The default model setting to use
  */
 export function getDefaultMainLoopModelSetting(): ModelName | ModelAlias {
+  // Check if using Local provider
+  if (getAPIProvider() === 'local') {
+    const localModelName = getLocalModelName()
+    if (localModelName) {
+      return localModelName
+    }
+    // Fallback to 'default' if no local model name is configured
+    return 'default'
+  }
+
   // Ants default to defaultModel from flag config, or Opus 1M if not configured
   if (process.env.USER_TYPE === 'ant') {
     return (