dr-claw 1.1.2 → 1.1.4

package/server/routes/cli-auth.js

@@ -6,10 +6,114 @@ import os from 'os';
 import fetch from 'node-fetch';
 import { resolveCursorCliCommand } from '../utils/cursorCommand.js';
 import { resolveAvailableCliCommand } from '../utils/cliResolution.js';
+import {
+  DEFAULT_OLLAMA_URL,
+  detectGPUs,
+  checkOllamaStatus,
+  pullOllamaModel,
+  normalizeLocalOllamaBaseUrl,
+} from '../local-gpu.js';
 
 const router = express.Router();
 
+const PROVIDER_INSTALLERS = {
+  claude: {
+    displayName: 'Claude Code CLI',
+    docsUrl: 'https://docs.anthropic.com/en/docs/claude-code/overview',
+    fallbackDownloadUrl: 'https://docs.anthropic.com/en/docs/claude-code/overview',
+    commands: {
+      darwin: [
+        { bin: 'brew', args: ['install', 'claude-code'], label: 'brew install claude-code' },
+      ],
+      linux: [
+        { bin: 'npm', args: ['install', '-g', '@anthropic-ai/claude-code'], label: 'npm install -g @anthropic-ai/claude-code' },
+      ],
+      win32: [
+        { bin: 'winget', args: ['install', '--id', 'Anthropic.ClaudeCode', '-e'], label: 'winget install Anthropic.ClaudeCode' },
+      ],
+    },
+  },
+  cursor: {
+    displayName: 'Cursor CLI',
+    docsUrl: 'https://cursor.com/downloads',
+    fallbackDownloadUrl: 'https://cursor.com/downloads',
+    commands: {
+      darwin: [
+        { bin: 'brew', args: ['install', '--cask', 'cursor'], label: 'brew install --cask cursor' },
+      ],
+      win32: [
+        { bin: 'winget', args: ['install', '--id', 'CursorAI,Inc.Cursor', '-e'], label: 'winget install CursorAI,Inc.Cursor' },
+      ],
+    },
+  },
+  codex: {
+    displayName: 'OpenAI Codex CLI',
+    docsUrl: 'https://github.com/openai/codex',
+    fallbackDownloadUrl: 'https://github.com/openai/codex',
+    commands: {
+      darwin: [
+        { bin: 'npm', args: ['install', '-g', '@openai/codex'], label: 'npm install -g @openai/codex' },
+      ],
+      linux: [
+        { bin: 'npm', args: ['install', '-g', '@openai/codex'], label: 'npm install -g @openai/codex' },
+      ],
+      win32: [
+        { bin: 'npm.cmd', args: ['install', '-g', '@openai/codex'], label: 'npm install -g @openai/codex' },
+      ],
+    },
+  },
+  gemini: {
+    displayName: 'Gemini CLI',
+    docsUrl: 'https://github.com/google-gemini/gemini-cli',
+    fallbackDownloadUrl: 'https://github.com/google-gemini/gemini-cli',
+    commands: {
+      darwin: [
+        { bin: 'npm', args: ['install', '-g', '@google/gemini-cli'], label: 'npm install -g @google/gemini-cli' },
+      ],
+      linux: [
+        { bin: 'npm', args: ['install', '-g', '@google/gemini-cli'], label: 'npm install -g @google/gemini-cli' },
+      ],
+      win32: [
+        { bin: 'npm.cmd', args: ['install', '-g', '@google/gemini-cli'], label: 'npm install -g @google/gemini-cli' },
+      ],
+    },
+  },
+  nano: {
+    displayName: 'Nano Claude Code',
+    docsUrl: 'https://github.com/OpenLAIR/nano-claude-code',
+    fallbackDownloadUrl: 'https://github.com/OpenLAIR/nano-claude-code',
+    commands: {
+      darwin: [
+        {
+          bin: 'pip3',
+          args: ['install', '-U', 'git+https://github.com/OpenLAIR/nano-claude-code.git'],
+          label: 'pip3 install from GitHub (recommended)',
+        },
+      ],
+      linux: [
+        {
+          bin: 'pip3',
+          args: ['install', '-U', 'git+https://github.com/OpenLAIR/nano-claude-code.git'],
+          label: 'pip3 install from GitHub (use a venv if your distro manages system Python)',
+        },
+      ],
+      win32: [
+        {
+          bin: 'pip',
+          args: ['install', '-U', 'git+https://github.com/OpenLAIR/nano-claude-code.git'],
+          label: 'pip install from GitHub',
+        },
+      ],
+    },
+  },
+};
+
 function buildCliInstallHint(agent) {
+  const installer = PROVIDER_INSTALLERS[agent];
+  if (installer?.docsUrl) {
+    return `${installer.displayName} is not installed. Install it in Dr. Claw or open the official guide: ${installer.docsUrl}`;
+  }
+
   switch (agent) {
     case 'claude':
       return 'Claude Code CLI is not installed. Install it first, then retry login.';
@@ -21,11 +125,91 @@ function buildCliInstallHint(agent) {
       return 'Gemini CLI is not installed. Install it first, then retry login.';
     case 'openrouter':
       return 'Set OPENROUTER_API_KEY in your .env file. Get a key at https://openrouter.ai/keys';
+    case 'nano':
+      return 'nano-claude-code is not on PATH. Install from https://github.com/OpenLAIR/nano-claude-code or set NANO_CLAUDE_CODE_COMMAND to the executable.';
     default:
       return 'Required CLI is not installed. Install it first, then retry login.';
   }
 }
 
+function getInstallerDefinition(agent) {
+  return PROVIDER_INSTALLERS[agent] || null;
+}
+
+function getPlatformInstallCommands(agent, platform = process.platform) {
+  const definition = getInstallerDefinition(agent);
+  if (!definition) {
+    return [];
+  }
+
+  return definition.commands?.[platform] || [];
+}
+
+function runInstallCommand(command, { cwd = process.cwd(), timeoutMs = 15 * 60 * 1000 } = {}) {
+  return new Promise((resolve) => {
+    let completed = false;
+    const child = spawn(command.bin, command.args, {
+      cwd,
+      env: process.env,
+      shell: process.platform === 'win32',
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    const finish = (result) => {
+      if (completed) {
+        return;
+      }
+      completed = true;
+      resolve(result);
+    };
+
+    const timeout = setTimeout(() => {
+      if (!completed) {
+        child.kill('SIGTERM');
+      }
+      finish({
+        ok: false,
+        code: null,
+        signal: 'SIGTERM',
+        stdout,
+        stderr: `${stderr}${stderr ? '\n' : ''}Installation timed out after ${timeoutMs}ms.`,
+      });
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on('error', (error) => {
+      clearTimeout(timeout);
+      finish({
+        ok: false,
+        code: null,
+        signal: null,
+        stdout,
+        stderr: `${stderr}${stderr ? '\n' : ''}${error.message}`,
+      });
+    });
+
+    child.on('close', (code, signal) => {
+      clearTimeout(timeout);
+      finish({
+        ok: code === 0,
+        code,
+        signal,
+        stdout,
+        stderr,
+      });
+    });
+  });
+}
+
 function isCliMockedMissing(agent) {
   const raw = process.env.MOCK_MISSING_CLIS || '';
   return raw
@@ -36,16 +220,134 @@ function isCliMockedMissing(agent) {
 }
 
 function buildStatusPayload(result, agent) {
+  const installCommands = getPlatformInstallCommands(agent).map((command) => ({
+    label: command.label,
+    bin: command.bin,
+    args: command.args,
+  }));
+  const definition = getInstallerDefinition(agent);
+
   return {
     authenticated: Boolean(result.authenticated),
     email: result.email || null,
     error: result.error || null,
     cliAvailable: result.cliAvailable !== false,
     cliCommand: result.cliCommand || null,
-    installHint: result.installHint || (result.cliAvailable === false ? buildCliInstallHint(agent) : null)
+    installHint: result.installHint || (result.cliAvailable === false ? buildCliInstallHint(agent) : null),
+    installable: installCommands.length > 0,
+    installCommands,
+    docsUrl: definition?.docsUrl || null,
+    downloadUrl: definition?.fallbackDownloadUrl || null,
   };
 }
 
+router.get('/providers', async (_req, res) => {
+  try {
+    const statuses = await Promise.all([
+      checkClaudeCredentials().then((result) => ['claude', buildStatusPayload(result, 'claude')]),
+      checkCursorStatus().then((result) => ['cursor', buildStatusPayload(result, 'cursor')]),
+      checkCodexCredentials().then((result) => ['codex', buildStatusPayload(result, 'codex')]),
+      checkGeminiCredentials().then((result) => ['gemini', buildStatusPayload(result, 'gemini')]),
+    ]);
+
+    res.json({ providers: Object.fromEntries(statuses) });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+async function checkNanoCliForInstall() {
+  const resolvedCliCommand = await resolveAvailableCliCommand({
+    envVarName: 'NANO_CLAUDE_CODE_COMMAND',
+    defaultCommands: ['nano-claude-code'],
+    args: ['--version'],
+    appendWindowsSuffixes: true,
+  });
+  if (!resolvedCliCommand) {
+    return {
+      authenticated: false,
+      email: null,
+      error: 'nano-claude-code CLI not found',
+      cliAvailable: false,
+      cliCommand: 'nano-claude-code',
+    };
+  }
+  return {
+    authenticated: true,
+    email: 'Nano Claude Code',
+    cliAvailable: true,
+    cliCommand: resolvedCliCommand,
+  };
+}
+
+router.post('/install/:provider', async (req, res) => {
+  const provider = String(req.params.provider || '').toLowerCase();
+  const definition = getInstallerDefinition(provider);
+
+  if (!definition) {
+    return res.status(404).json({ error: `Unknown provider: ${provider}` });
+  }
+
+  const commands = getPlatformInstallCommands(provider);
+  if (commands.length === 0) {
+    return res.status(400).json({
+      ok: false,
+      provider,
+      error: `No automatic installer is configured for ${definition.displayName} on ${process.platform}. See the official docs for manual Linux steps.`,
+      docsUrl: definition.docsUrl,
+      downloadUrl: definition.fallbackDownloadUrl,
+    });
+  }
+
+  const command = commands[0];
+  const result = await runInstallCommand(command);
+
+  const checker = provider === 'claude'
+    ? checkClaudeCredentials
+    : provider === 'cursor'
+      ? checkCursorStatus
+      : provider === 'codex'
+        ? checkCodexCredentials
+        : provider === 'nano'
+          ? checkNanoCliForInstall
+          : checkGeminiCredentials;
+
+  const latestStatus = await checker();
+
+  res.status(result.ok ? 200 : 500).json({
+    ok: result.ok,
+    provider,
+    command: {
+      label: command.label,
+      bin: command.bin,
+      args: command.args,
+    },
+    stdout: result.stdout,
+    stderr: result.stderr,
+    code: result.code,
+    signal: result.signal,
+    status: buildStatusPayload(latestStatus, provider),
+    docsUrl: definition.docsUrl,
+    downloadUrl: definition.fallbackDownloadUrl,
+  });
+});
+
+router.get('/download/:provider', async (req, res) => {
+  const provider = String(req.params.provider || '').toLowerCase();
+  const definition = getInstallerDefinition(provider);
+
+  if (!definition) {
+    return res.status(404).json({ error: `Unknown provider: ${provider}` });
+  }
+
+  res.json({
+    provider,
+    displayName: definition.displayName,
+    docsUrl: definition.docsUrl,
+    downloadUrl: definition.fallbackDownloadUrl,
+  });
+});
+
 router.get('/claude/status', async (req, res) => {
   try {
     const credentialsResult = await checkClaudeCredentials();
@@ -134,6 +436,42 @@ router.get('/gemini/status', async (req, res) => {
   }
 });
 
+router.get('/nano/status', async (req, res) => {
+  try {
+    const resolvedCliCommand = await resolveAvailableCliCommand({
+      envVarName: 'NANO_CLAUDE_CODE_COMMAND',
+      defaultCommands: ['nano-claude-code'],
+      args: ['--version'],
+      appendWindowsSuffixes: true,
+    });
+
+    if (!resolvedCliCommand) {
+      return res.json(buildStatusPayload({
+        authenticated: false,
+        email: null,
+        error: 'nano-claude-code CLI not found',
+        cliAvailable: false,
+        cliCommand: 'nano-claude-code',
+        installHint: buildCliInstallHint('nano'),
+      }, 'nano'));
+    }
+
+    return res.json(buildStatusPayload({
+      authenticated: true,
+      email: 'Nano Claude Code',
+      cliAvailable: true,
+      cliCommand: resolvedCliCommand,
+    }, 'nano'));
+  } catch (error) {
+    console.error('Error checking Nano Claude Code status:', error);
+    res.status(500).json({
+      authenticated: false,
+      email: null,
+      error: error.message,
+    });
+  }
+});
+
 async function checkGeminiCredentials() {
   console.log('[DEBUG] Checking Gemini credentials...');
   let cliCommand = process.env.GEMINI_CLI_PATH || 'gemini';
@@ -177,7 +515,6 @@ async function checkGeminiCredentials() {
       };
     }
 
-    // Check for GOOGLE_API_KEY environment variable first
     if (process.env.GOOGLE_API_KEY) {
       console.log('[DEBUG] Gemini: Found GOOGLE_API_KEY in environment');
       return {
@@ -188,18 +525,15 @@ async function checkGeminiCredentials() {
       };
     }
 
-    // Check for OAuth credentials file (new Gemini CLI)
     const oauthPath = path.join(os.homedir(), '.gemini', 'oauth_creds.json');
     console.log(`[DEBUG] Gemini: Checking for OAuth file at ${oauthPath}`);
     try {
       const content = await fs.readFile(oauthPath, 'utf8');
       const creds = JSON.parse(content);
 
-      // Check for presence of refresh_token or access_token
       if (creds.refresh_token || creds.access_token) {
         let email = creds.email || 'OAuth (Config)';
 
-        // Try to extract email from id_token if available
         if (!creds.email && creds.id_token) {
           try {
             const parts = creds.id_token.split('.');
@@ -230,7 +564,6 @@ async function checkGeminiCredentials() {
       }
     }
 
-    // Fallback to legacy config file check
     const configPath = path.join(os.homedir(), '.gemini', 'config.json');
     console.log(`[DEBUG] Gemini: Checking for legacy config at ${configPath}`);
     try {
@@ -301,7 +634,6 @@ async function checkClaudeCredentials() {
         if (childProcess) {
           childProcess.kill();
         }
-        // Fall back to credentials file check on timeout
         checkClaudeCredentialsFile({ cliAvailable: true, cliCommand: resolvedCliCommand }).then(resolve);
       }
     }, 5000);
@@ -319,16 +651,11 @@ async function checkClaudeCredentials() {
     }
 
     let stdout = '';
-    let stderr = '';
 
     childProcess.stdout.on('data', (data) => {
       stdout += data.toString();
     });
 
-    childProcess.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
     childProcess.on('close', (code) => {
       if (processCompleted) return;
       processCompleted = true;
@@ -347,11 +674,9 @@ async function checkClaudeCredentials() {
             return;
           }
         } catch {
-          // JSON parse failed, fall through
         }
       }
 
-      // CLI check failed, fall back to credentials file
       checkClaudeCredentialsFile({ cliAvailable: true, cliCommand: resolvedCliCommand }).then(resolve);
     });
 
@@ -359,8 +684,6 @@ async function checkClaudeCredentials() {
       if (processCompleted) return;
       processCompleted = true;
       clearTimeout(timeout);
-      // Command was already validated by resolveAvailableCliCommand, so treat
-      // any spawn error as a transient failure rather than "CLI missing".
       checkClaudeCredentialsFile({ cliAvailable: true, cliCommand: resolvedCliCommand }).then(resolve);
     });
   });
@@ -394,7 +717,7 @@ async function checkClaudeCredentialsFile({ cliAvailable = true, cliCommand = 'c
       error: cliAvailable ? null : 'Claude Code CLI not installed',
       installHint: cliAvailable ? null : buildCliInstallHint('claude')
     };
-  } catch (error) {
+  } catch (_error) {
     return {
       authenticated: false,
       email: null,
@@ -495,7 +818,7 @@ function checkCursorStatus() {
       }
     });
 
-    childProcess.on('error', (err) => {
+    childProcess.on('error', () => {
       if (processCompleted) return;
       processCompleted = true;
       clearTimeout(timeout);
@@ -512,9 +835,24 @@ function checkCursorStatus() {
   });
 }
 
+// Auth precedence:
+// 1. JWT tokens (id_token / access_token) from ~/.codex/auth.json
+// 2. OPENAI_API_KEY from server environment variable
+// 3. OPENAI_API_KEY from ~/.codex/auth.json
 async function checkCodexCredentials() {
   let cliCommand = process.env.CODEX_CLI_PATH || 'codex';
   try {
+    if (isCliMockedMissing('codex')) {
+      return {
+        authenticated: false,
+        email: null,
+        error: 'Codex CLI not installed (mocked)',
+        cliAvailable: false,
+        cliCommand,
+        installHint: buildCliInstallHint('codex')
+      };
+    }
+
     const resolvedCliCommand = await resolveAvailableCliCommand({
       envVarName: 'CODEX_CLI_PATH',
       defaultCommands: ['codex'],
@@ -544,28 +882,32 @@ async function checkCodexCredentials() {
       };
     }
 
+    const envApiKey = String(process.env.OPENAI_API_KEY || '').trim();
     const authPath = path.join(os.homedir(), '.codex', 'auth.json');
-    const content = await fs.readFile(authPath, 'utf8');
-    const auth = JSON.parse(content);
+    let auth = null;
+
+    try {
+      const content = await fs.readFile(authPath, 'utf8');
+      auth = JSON.parse(content);
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.warn('[DEBUG] Codex: Failed to read auth.json, falling back to env auth if available:', error.message);
+      }
+    }
 
     // Tokens are nested under 'tokens' key
-    const tokens = auth.tokens || {};
+    const tokens = auth?.tokens || {};
 
-    // Check for valid tokens (id_token or access_token)
     if (tokens.id_token || tokens.access_token) {
-      // Try to extract email from id_token JWT payload
       let email = 'Authenticated';
       if (tokens.id_token) {
         try {
-          // JWT is base64url encoded: header.payload.signature
           const parts = tokens.id_token.split('.');
           if (parts.length >= 2) {
-            // Decode the payload (second part)
             const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
             email = payload.email || payload.user || 'Authenticated';
           }
         } catch {
-          // If JWT decoding fails, use fallback
           email = 'Authenticated';
         }
       }
@@ -578,8 +920,8 @@ async function checkCodexCredentials() {
       };
     }
 
-    // Also check for OPENAI_API_KEY as fallback auth method (in auth.json or env)
-    if (auth.OPENAI_API_KEY || process.env.OPENAI_API_KEY) {
+    // Service deployments may authenticate Codex through server env only.
+    if (envApiKey) {
       return {
         authenticated: true,
         email: 'API Key Connected',
@@ -589,16 +931,8 @@ async function checkCodexCredentials() {
       };
     }
 
-    return {
-      authenticated: false,
-      email: null,
-      error: 'No valid tokens found',
-      cliAvailable: true,
-      cliCommand
-    };
-  } catch (error) {
-    // File not found — check env var before giving up
-    if (process.env.OPENAI_API_KEY) {
+    // Also check for OPENAI_API_KEY stored in auth.json as a fallback auth method
+    if (auth?.OPENAI_API_KEY) {
       return {
         authenticated: true,
         email: 'API Key Connected',
@@ -607,15 +941,15 @@ async function checkCodexCredentials() {
         cliCommand
       };
     }
-    if (error.code === 'ENOENT') {
-      return {
-        authenticated: false,
-        email: null,
-        error: 'Codex not configured',
-        cliAvailable: true,
-        cliCommand
-      };
-    }
+
+    return {
+      authenticated: false,
+      email: null,
+      error: auth ? 'No valid tokens found' : 'Codex not configured',
+      cliAvailable: true,
+      cliCommand
+    };
+  } catch (error) {
     return {
       authenticated: false,
       email: null,
@@ -785,14 +1119,20 @@ router.post('/claude/verify-custom-api', async (req, res) => {
       })
     });
 
-    // 200 = success, 401/403 = bad token, anything else with a valid JSON body means the endpoint is reachable
     if (response.ok || (response.status >= 400 && response.status < 500 && response.status !== 401 && response.status !== 403)) {
       const envPath = path.join(process.cwd(), '.env');
       let envContent = '';
       try {
         envContent = await fs.readFile(envPath, 'utf8');
-      } catch (e) { /* ignore if not exists */ }
+      } catch (e) {}
 
+      const lines = envContent ? envContent.split(/\r?\n/) : [];
+      const nextLines = lines.filter((line) => !line.startsWith('ANTHROPIC_BASE_URL=') && !line.startsWith('ANTHROPIC_AUTH_TOKEN='));
+      nextLines.push(`ANTHROPIC_BASE_URL=${baseUrl || 'https://api.anthropic.com'}`);
+      nextLines.push(`ANTHROPIC_AUTH_TOKEN=${token}`);
+      await fs.writeFile(envPath, `${nextLines.filter(Boolean).join('\n')}\n`, 'utf8');
+
+      return res.json({ success: true });
       const keysToUpdate = {
         'ANTHROPIC_BASE_URL': baseUrl || 'https://api.anthropic.com',
         'ANTHROPIC_API_KEY': token,
@@ -835,8 +1175,10 @@ router.post('/claude/verify-custom-api', async (req, res) => {
       const err = await response.text();
       return res.status(response.status).json({ error: `Verification failed: ${err}` });
     }
+
+    return res.status(400).json({ error: 'Failed to verify custom API token' });
   } catch (error) {
-    res.status(500).json({ error: error.message });
+    return res.status(500).json({ error: error.message });
   }
 });
 
@@ -844,8 +1186,6 @@ router.post('/claude/verify-custom-api', async (req, res) => {
 // Local GPU / Ollama routes
 // ---------------------------------------------------------------------------
 
-import { detectGPUs, checkOllamaStatus, pullOllamaModel } from '../local-gpu.js';
-
 router.get('/local/gpu-info', async (req, res) => {
   try {
     const result = await detectGPUs();
@@ -857,7 +1197,7 @@ router.get('/local/gpu-info', async (req, res) => {
 
 router.get('/local/status', async (req, res) => {
   try {
-    const serverUrl = process.env.LOCAL_GPU_SERVER_URL || 'http://localhost:11434';
+    const serverUrl = process.env.LOCAL_GPU_SERVER_URL || DEFAULT_OLLAMA_URL;
     const status = await checkOllamaStatus(serverUrl);
 
     if (status.running) {
@@ -887,7 +1227,14 @@ router.get('/local/status', async (req, res) => {
 
 router.get('/local/models', async (req, res) => {
   try {
-    const serverUrl = req.query.serverUrl || process.env.LOCAL_GPU_SERVER_URL || 'http://localhost:11434';
+    let serverUrl;
+    try {
+      serverUrl = normalizeLocalOllamaBaseUrl(
+        req.query.serverUrl || process.env.LOCAL_GPU_SERVER_URL || DEFAULT_OLLAMA_URL,
+      );
+    } catch (e) {
+      return res.status(400).json({ error: e.message, models: [] });
+    }
     const status = await checkOllamaStatus(serverUrl);
     if (!status.running) {
       return res.status(503).json({ error: 'Ollama is not running', models: [] });
@@ -918,7 +1265,14 @@ router.post('/local/pull-model', async (req, res) => {
     const { modelName, serverUrl } = req.body;
     if (!modelName) return res.status(400).json({ error: 'modelName is required' });
 
-    const url = serverUrl || process.env.LOCAL_GPU_SERVER_URL || 'http://localhost:11434';
+    let url;
+    try {
+      url = normalizeLocalOllamaBaseUrl(
+        serverUrl || process.env.LOCAL_GPU_SERVER_URL || DEFAULT_OLLAMA_URL,
+      );
+    } catch (e) {
+      return res.status(400).json({ error: e.message });
+    }
     await pullOllamaModel(url, modelName);
     return res.json({ success: true, message: `Model "${modelName}" pulled successfully.` });
   } catch (error) {
@@ -930,6 +1284,12 @@ router.post('/local/save-config', async (req, res) => {
   try {
     const { serverUrl } = req.body;
     if (serverUrl) {
+      let normalizedUrl;
+      try {
+        normalizedUrl = normalizeLocalOllamaBaseUrl(serverUrl);
+      } catch (e) {
+        return res.status(400).json({ error: e.message });
+      }
       const envPath = path.join(process.cwd(), '.env');
       let envContent = '';
       try { envContent = await fs.readFile(envPath, 'utf8'); } catch {}
@@ -939,14 +1299,14 @@ router.post('/local/save-config', async (req, res) => {
       const newLines = lines.map(line => {
         if (line.trim().startsWith('LOCAL_GPU_SERVER_URL=')) {
           found = true;
-          return `LOCAL_GPU_SERVER_URL=${serverUrl}`;
+          return `LOCAL_GPU_SERVER_URL=${normalizedUrl}`;
         }
         return line;
       }).filter(l => l.trim() !== '' || found);
 
-      if (!found) newLines.push(`LOCAL_GPU_SERVER_URL=${serverUrl}`);
+      if (!found) newLines.push(`LOCAL_GPU_SERVER_URL=${normalizedUrl}`);
       await fs.writeFile(envPath, newLines.join('\n') + '\n');
-      process.env.LOCAL_GPU_SERVER_URL = serverUrl;
+      process.env.LOCAL_GPU_SERVER_URL = normalizedUrl;
     }
 
     return res.json({ success: true, message: 'Local GPU configuration saved.' });
@@ -955,4 +1315,8 @@ router.post('/local/save-config', async (req, res) => {
   }
 });
 
+export {
+  checkCodexCredentials,
+};
+
 export default router;