@swarmclawai/swarmclaw 1.7.0 → 1.7.2

package/src/lib/providers/cli-provider-metadata.ts

@@ -0,0 +1,208 @@
+import type { ProviderType } from '../../types/provider.ts'
+
+export type CliAuthBackend =
+  | 'claude'
+  | 'codex'
+  | 'opencode'
+  | 'gemini'
+  | 'copilot'
+  | 'droid'
+  | 'cursor'
+  | 'qwen'
+  | 'goose'
+
+export interface CliProviderMetadata {
+  id: ProviderType
+  displayName: string
+  binaryName: string
+  capability: string
+  description: string
+  defaultModel: string
+  icon: string
+  setupBadge: string
+  generic: boolean
+  optionalApiKey?: boolean
+  authBackend?: CliAuthBackend
+  keyUrl?: string
+  keyLabel?: string
+  keyPlaceholder?: string
+  modelLibraryUrl?: string
+}
+
+export const BESPOKE_CLI_PROVIDER_METADATA = [
+  {
+    id: 'claude-cli',
+    displayName: 'Claude Code CLI',
+    binaryName: 'claude',
+    capability: 'multi-file code editing, refactoring, debugging, code review',
+    description: "Anthropic's coding agent with native tools, strong edits, and first-class CLI workflows.",
+    defaultModel: 'claude-sonnet-4-6',
+    icon: 'C',
+    setupBadge: 'CLI',
+    generic: false,
+    authBackend: 'claude',
+    modelLibraryUrl: 'https://docs.anthropic.com/en/docs/about-claude/models',
+  },
+  {
+    id: 'codex-cli',
+    displayName: 'OpenAI Codex CLI',
+    binaryName: 'codex',
+    capability: 'code generation, file creation, automated coding tasks',
+    description: "OpenAI's terminal coding agent with resume support and structured headless output.",
+    defaultModel: 'gpt-5.4-codex',
+    icon: 'O',
+    setupBadge: 'CLI',
+    generic: false,
+    authBackend: 'codex',
+    modelLibraryUrl: 'https://platform.openai.com/docs/models',
+  },
+  {
+    id: 'opencode-cli',
+    displayName: 'OpenCode CLI',
+    binaryName: 'opencode',
+    capability: 'code analysis, generation across multiple LLM backends',
+    description: 'A flexible coding CLI that can route across multiple model backends.',
+    defaultModel: 'claude-sonnet-4-6',
+    icon: 'O',
+    setupBadge: 'CLI',
+    generic: false,
+    authBackend: 'opencode',
+  },
+  {
+    id: 'gemini-cli',
+    displayName: 'Gemini CLI',
+    binaryName: 'gemini',
+    capability: 'code generation, analysis with Gemini models',
+    description: "Google's terminal coding agent with project-aware headless mode and resume support.",
+    defaultModel: 'gemini-3.1-pro',
+    icon: 'G',
+    setupBadge: 'CLI',
+    generic: false,
+    authBackend: 'gemini',
+    modelLibraryUrl: 'https://ai.google.dev/gemini-api/docs/models',
+  },
+  {
+    id: 'copilot-cli',
+    displayName: 'GitHub Copilot CLI',
+    binaryName: 'copilot',
+    capability: 'code generation, analysis, multi-model support via GitHub Copilot',
+    description: "GitHub's multi-model terminal agent for coding and automation.",
+    defaultModel: 'claude-sonnet-4-6',
+    icon: 'P',
+    setupBadge: 'CLI',
+    generic: false,
+    authBackend: 'copilot',
+  },
+  {
+    id: 'droid-cli',
+    displayName: 'Factory Droid CLI',
+    binaryName: 'droid',
+    capability: 'code generation, refactoring, and automation via Factory Droid with configurable autonomy',
+    description: "Factory.ai's terminal coding agent with headless exec mode, session resume, and autonomy controls.",
+    defaultModel: 'default',
+    icon: 'F',
+    setupBadge: 'CLI',
+    generic: false,
+    optionalApiKey: true,
+    authBackend: 'droid',
+    keyUrl: 'https://app.factory.ai/settings/api-keys',
+    keyLabel: 'app.factory.ai',
+    keyPlaceholder: 'FACTORY_API_KEY (optional if signed in via `droid`)',
+  },
+  {
+    id: 'cursor-cli',
+    displayName: 'Cursor Agent CLI',
+    binaryName: 'cursor-agent',
+    capability: 'full-agent coding workflows, multi-file edits, project-aware code changes',
+    description: "Cursor's terminal agent with resume support, JSON output, and Cursor-native coding workflows.",
+    defaultModel: 'auto',
+    icon: 'U',
+    setupBadge: 'CLI',
+    generic: false,
+    authBackend: 'cursor',
+  },
+  {
+    id: 'qwen-code-cli',
+    displayName: 'Qwen Code CLI',
+    binaryName: 'qwen',
+    capability: 'terminal-native coding workflows, code generation, review, and automation',
+    description: "Qwen's terminal coding agent with structured headless mode and multi-provider model config.",
+    defaultModel: 'default',
+    icon: 'Q',
+    setupBadge: 'CLI',
+    generic: false,
+    authBackend: 'qwen',
+  },
+  {
+    id: 'goose',
+    displayName: 'Goose',
+    binaryName: 'goose',
+    capability: 'agentic coding workflows with extensions, tools, and runtime-managed execution',
+    description: 'A runtime-managed terminal agent with extensions, session history, and ACP support.',
+    defaultModel: 'default',
+    icon: 'G',
+    setupBadge: 'Runtime',
+    generic: false,
+    optionalApiKey: true,
+    authBackend: 'goose',
+  },
+] as const satisfies readonly CliProviderMetadata[]
+
+export const GENERIC_CLI_PROVIDER_METADATA = [
+  ['aider-cli', 'Aider CLI', 'aider', 'paired-programming-style multi-file edits and git-aware code changes'],
+  ['amp-cli', 'Amp CLI', 'amp', 'agentic coding via Sourcegraph Amp'],
+  ['augment-cli', 'Augment CLI', 'augment', 'codebase-aware agentic edits via Augment'],
+  ['adal-cli', 'AdaL CLI', 'adal', 'AdaL coding agent for terminal-driven workflows'],
+  ['bob-cli', 'IBM Bob CLI', 'bob', 'IBM watsonx Code Assistant terminal coding workflows'],
+  ['cline-cli', 'Cline CLI', 'cline', 'autonomous file-level edits and terminal automation via Cline'],
+  ['codebuddy-cli', 'CodeBuddy CLI', 'codebuddy', 'CodeBuddy agentic coding workflows'],
+  ['command-code-cli', 'Command Code CLI', 'commandcode', 'Command Code terminal-native coding agent'],
+  ['continue-cli', 'Continue CLI', 'continue', 'agentic coding via the Continue CLI'],
+  ['cortex-cli', 'Cortex Code CLI', 'cortex', 'Snowflake Cortex Code agentic workflows'],
+  ['crush-cli', 'Crush CLI', 'crush', 'Crush terminal coding agent'],
+  ['deepagents-cli', 'Deep Agents CLI', 'deepagents', 'long-horizon planning and multi-step coding via Deep Agents'],
+  ['firebender-cli', 'Firebender CLI', 'firebender', 'Firebender JetBrains-aligned coding agent'],
+  ['iflow-cli', 'iFlow CLI', 'iflow', 'iFlow CLI agentic coding workflows'],
+  ['junie-cli', 'Junie CLI', 'junie', 'JetBrains Junie coding agent for terminal use'],
+  ['kilo-code-cli', 'Kilo Code CLI', 'kilocode', 'Kilo Code agentic coding workflows'],
+  ['kimi-cli', 'Kimi CLI', 'kimi', 'Kimi Code CLI coding agent'],
+  ['kode-cli', 'Kode CLI', 'kode', 'Kode terminal coding agent'],
+  ['mcpjam-cli', 'MCPJam CLI', 'mcpjam', 'MCPJam-tooled agentic coding workflows'],
+  ['mistral-vibe-cli', 'Mistral Vibe CLI', 'vibe', 'Mistral Vibe coding agent'],
+  ['mux-cli', 'Mux CLI', 'mux', 'Mux multi-tool coding agent'],
+  ['neovate-cli', 'Neovate CLI', 'neovate', 'Neovate coding agent for terminal workflows'],
+  ['openhands-cli', 'OpenHands CLI', 'openhands', 'OpenHands agentic coding via terminal'],
+  ['pochi-cli', 'Pochi CLI', 'pochi', 'Pochi coding agent'],
+  ['qoder-cli', 'Qoder CLI', 'qoder', 'Qoder agentic coding workflows'],
+  ['replit-cli', 'Replit Agent CLI', 'replit', 'Replit Agent terminal coding workflows'],
+  ['roo-code-cli', 'Roo Code CLI', 'roo', 'Roo Code agentic coding workflows'],
+  ['trae-cn-cli', 'TRAE CN CLI', 'trae-cn', 'TRAE CN coding agent'],
+  ['warp-cli', 'Warp Agent CLI', 'warp', 'Warp Agent terminal-native coding workflows'],
+  ['windsurf-cli', 'Windsurf CLI', 'windsurf', 'Windsurf agentic coding workflows'],
+  ['zencoder-cli', 'Zencoder CLI', 'zencoder', 'Zencoder agentic coding workflows'],
+].map(([id, displayName, binaryName, capability]) => ({
+  id: id as ProviderType,
+  displayName,
+  binaryName,
+  capability,
+  description: `${displayName}: ${capability}.`,
+  defaultModel: 'default',
+  icon: displayName.charAt(0),
+  setupBadge: 'CLI',
+  generic: true,
+  optionalApiKey: true,
+})) satisfies readonly CliProviderMetadata[]
+
+export const CLI_PROVIDER_METADATA = [
+  ...BESPOKE_CLI_PROVIDER_METADATA,
+  ...GENERIC_CLI_PROVIDER_METADATA,
+] as const satisfies readonly CliProviderMetadata[]
+
+export type CliProviderId = (typeof CLI_PROVIDER_METADATA)[number]['id']
+
+export const CLI_PROVIDER_METADATA_BY_ID: Record<string, CliProviderMetadata> =
+  Object.fromEntries(CLI_PROVIDER_METADATA.map((provider) => [provider.id, provider]))
+
+export function isCliProviderId(providerId: string): providerId is CliProviderId {
+  return providerId in CLI_PROVIDER_METADATA_BY_ID
+}

package/src/lib/providers/cli-utils.test.ts

@@ -1,7 +1,17 @@
 import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 import { describe, it } from 'node:test'
 
-import { isStderrNoise, buildCliEnv, isCliProvider, CLI_PROVIDER_CAPABILITIES } from './cli-utils'
+import {
+  isStderrNoise,
+  buildCliEnv,
+  isCliProvider,
+  CLI_PROVIDER_CAPABILITIES,
+  resolveCodexProbeInvocation,
+  ensureCliWorkingDirectory,
+} from './cli-utils'
 
 // ---------------------------------------------------------------------------
 // isStderrNoise
@@ -142,3 +152,57 @@ describe('CLI_PROVIDER_CAPABILITIES', () => {
     }
   })
 })
+
+// ---------------------------------------------------------------------------
+// resolveCodexProbeInvocation
+// ---------------------------------------------------------------------------
+
+describe('resolveCodexProbeInvocation', () => {
+  it('uses node directly for codex JS wrappers discovered through a symlink', () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-codex-probe-'))
+    try {
+      const realScript = path.join(tmpRoot, 'codex.js')
+      fs.writeFileSync(realScript, '#!/usr/bin/env node\nconsole.log("ok")\n')
+      fs.chmodSync(realScript, 0o755)
+
+      const wrapperPath = path.join(tmpRoot, 'codex')
+      fs.symlinkSync(realScript, wrapperPath)
+
+      const invocation = resolveCodexProbeInvocation(wrapperPath)
+      assert.equal(invocation.command, process.execPath)
+      assert.deepEqual(invocation.args, [fs.realpathSync(realScript), 'login', 'status'])
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true })
+    }
+  })
+
+  it('uses the binary directly for non-JS executables', () => {
+    const invocation = resolveCodexProbeInvocation('/usr/local/bin/codex-bin')
+    assert.equal(invocation.command, '/usr/local/bin/codex-bin')
+    assert.deepEqual(invocation.args, ['login', 'status'])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ensureCliWorkingDirectory
+// ---------------------------------------------------------------------------
+
+describe('ensureCliWorkingDirectory', () => {
+  it('creates a missing working directory recursively', () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-cli-cwd-'))
+    const target = path.join(tmpRoot, 'nested', 'room')
+    try {
+      assert.equal(fs.existsSync(target), false)
+      const resolved = ensureCliWorkingDirectory(target)
+      assert.equal(resolved, target)
+      assert.equal(fs.existsSync(target), true)
+      assert.equal(fs.statSync(target).isDirectory(), true)
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true })
+    }
+  })
+
+  it('falls back to process.cwd when cwd is blank', () => {
+    assert.equal(ensureCliWorkingDirectory(''), process.cwd())
+  })
+})

package/src/lib/providers/cli-utils.ts

@@ -10,7 +10,9 @@ import os from 'os'
 import { findBinaryOnPath } from '../server/session-tools/context'
 import path from 'path'
 import { spawnSync, type ChildProcess } from 'child_process'
+import { realpathSync } from 'fs'
 import { log } from '../server/logger'
+import { CLI_PROVIDER_METADATA, CLI_PROVIDER_METADATA_BY_ID } from './cli-provider-metadata'
 
 // ---------------------------------------------------------------------------
 // Binary Discovery
@@ -168,6 +170,25 @@ export interface AuthProbeResult {
   errorMessage?: string
 }
 
+export function resolveCodexProbeInvocation(binary: string): { command: string; args: string[] } {
+  try {
+    const resolved = realpathSync(binary)
+    if (resolved.toLowerCase().endsWith('.js')) {
+      return { command: process.execPath, args: [resolved, 'login', 'status'] }
+    }
+  } catch {
+    // Fall through to direct execution when the binary cannot be resolved.
+  }
+
+  return { command: binary, args: ['login', 'status'] }
+}
+
+export function ensureCliWorkingDirectory(cwd?: string | null): string {
+  const resolved = typeof cwd === 'string' && cwd.trim() ? cwd.trim() : process.cwd()
+  fs.mkdirSync(resolved, { recursive: true })
+  return resolved
+}
+
 /**
  * Unified auth check for supported CLI-backed providers.
  */
@@ -198,7 +219,8 @@ export function probeCliAuth(
   }
 
   if (backend === 'codex') {
-    const probe = spawnSync(binary, ['login', 'status'], {
+    const invocation = resolveCodexProbeInvocation(binary)
+    const probe = spawnSync(invocation.command, invocation.args, {
       cwd, env, encoding: 'utf-8', timeout: 8000,
     })
     const probeText = `${probe.stdout || ''}\n${probe.stderr || ''}`.toLowerCase()
@@ -447,50 +469,10 @@ export function symlinkConfigFiles(
 // ---------------------------------------------------------------------------
 
 /** Human-readable descriptions of what each CLI provider excels at. */
-export const CLI_PROVIDER_CAPABILITIES: Record<string, string> = {
-  'claude-cli': 'multi-file code editing, refactoring, debugging, code review',
-  'codex-cli': 'code generation, file creation, automated coding tasks',
-  'opencode-cli': 'code analysis, generation across multiple LLM backends',
-  'gemini-cli': 'code generation, analysis with Gemini models',
-  'copilot-cli': 'code generation, analysis, multi-model support via GitHub Copilot',
-  'droid-cli': 'code generation, refactoring, and automation via Factory Droid with configurable autonomy',
-  'cursor-cli': 'full-agent coding workflows, multi-file edits, project-aware code changes',
-  'qwen-code-cli': 'terminal-native coding workflows, code generation, review, and automation',
-  goose: 'agentic coding workflows with extensions, tools, and runtime-managed execution',
-  'aider-cli': 'paired-programming-style multi-file edits and git-aware code changes',
-  'amp-cli': 'agentic coding via Sourcegraph Amp',
-  'augment-cli': 'codebase-aware agentic edits via Augment',
-  'adal-cli': 'AdaL coding agent for terminal-driven workflows',
-  'bob-cli': 'IBM watsonx Code Assistant (Bob) terminal coding workflows',
-  'cline-cli': 'autonomous file-level edits and terminal automation via Cline',
-  'codebuddy-cli': 'CodeBuddy agentic coding workflows',
-  'command-code-cli': 'Command Code terminal-native coding agent',
-  'continue-cli': 'agentic coding via the Continue CLI',
-  'cortex-cli': 'Snowflake Cortex Code agentic workflows',
-  'crush-cli': 'Crush terminal coding agent',
-  'deepagents-cli': 'long-horizon planning and multi-step coding via Deep Agents',
-  'firebender-cli': 'Firebender JetBrains-aligned coding agent',
-  'iflow-cli': 'iFlow CLI agentic coding workflows',
-  'junie-cli': 'JetBrains Junie coding agent for terminal use',
-  'kilo-code-cli': 'Kilo Code agentic coding workflows',
-  'kimi-cli': 'Kimi Code CLI coding agent',
-  'kode-cli': 'Kode terminal coding agent',
-  'mcpjam-cli': 'MCPJam-tooled agentic coding workflows',
-  'mistral-vibe-cli': 'Mistral Vibe coding agent',
-  'mux-cli': 'Mux multi-tool coding agent',
-  'neovate-cli': 'Neovate coding agent for terminal workflows',
-  'openhands-cli': 'OpenHands agentic coding via terminal',
-  'pochi-cli': 'Pochi coding agent',
-  'qoder-cli': 'Qoder agentic coding workflows',
-  'replit-cli': 'Replit Agent terminal coding workflows',
-  'roo-code-cli': 'Roo Code agentic coding workflows',
-  'trae-cn-cli': 'TRAE CN coding agent',
-  'warp-cli': 'Warp Agent terminal-native coding workflows',
-  'windsurf-cli': 'Windsurf agentic coding workflows',
-  'zencoder-cli': 'Zencoder agentic coding workflows',
-}
+export const CLI_PROVIDER_CAPABILITIES: Record<string, string> =
+  Object.fromEntries(CLI_PROVIDER_METADATA.map((provider) => [provider.id, provider.capability]))
 
 /** Check if a provider ID is a CLI-based provider. */
 export function isCliProvider(providerId: string): boolean {
-  return providerId in CLI_PROVIDER_CAPABILITIES
+  return providerId in CLI_PROVIDER_METADATA_BY_ID
 }

package/src/lib/providers/codex-cli.ts

@@ -5,7 +5,7 @@ import { spawn } from 'child_process'
 import type { StreamChatOptions } from './index'
 import { log } from '../server/logger'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
-import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, symlinkConfigFiles, isStderrNoise } from './cli-utils'
+import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, symlinkConfigFiles, isStderrNoise, ensureCliWorkingDirectory } from './cli-utils'
 import { getAgent } from '@/lib/server/agents/agent-repository'
 import { loadMcpServers } from '@/lib/server/storage'
 
@@ -27,6 +27,9 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
 
   const prompt = message
   const args: string[] = ['exec']
+  // Use ~/.codex-sessions/ not /tmp — codex refuses to create helper binaries under /tmp.
+  const sessionsDir = path.join(os.homedir(), '.codex-sessions')
+  const perSessionHome = path.join(sessionsDir, session.id)
 
   // Session resume
   if (session.codexThreadId) {
@@ -53,15 +56,16 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
 
   // Build clean env — preserves user's CODEX_HOME for auth
   const env = buildCliEnv()
+  const effectiveCwd = ensureCliWorkingDirectory(session.cwd)
 
   // Pass API key if available
   if (session.apiKey) {
     env.OPENAI_API_KEY = session.apiKey
   }
 
-  // Auth probe BEFORE creating temp CODEX_HOME — uses real config dir
+  // Auth probe BEFORE creating the session CODEX_HOME — uses real config dir
   if (!session.apiKey) {
-    const auth = probeCliAuth(binary, 'codex', env, session.cwd)
+    const auth = probeCliAuth(binary, 'codex', env, effectiveCwd)
     if (!auth.authenticated) {
       log.error('codex-cli', auth.errorMessage || 'Auth failed')
       write(`data: ${JSON.stringify({ t: 'err', text: auth.errorMessage || 'Codex CLI is not authenticated.' })}\n\n`)
@@ -69,86 +73,80 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
     }
   }
 
-  // System prompt + MCP injection: create a temp CODEX_HOME when needed
-  // Symlink auth files from the real config dir so auth still works
-  let tempCodexHome: string | null = null
+  // Always use a stable per-session CODEX_HOME for the actual Codex run. A first
+  // turn can emit a thread id even without system-prompt or MCP injection, and
+  // the next turn needs the same local metadata to resume that thread.
+  const sessionCodexHome = perSessionHome
   const agentForMcp = session.agentId ? getAgent(session.agentId as string) : null
   const agentMcpServerIds: string[] = agentForMcp?.mcpServerIds || []
-  const needsTempHome = (systemPrompt && !session.codexThreadId) || agentMcpServerIds.length > 0
-  if (needsTempHome) {
-    const realCodexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
-    // Use ~/.codex-sessions/ not /tmp — codex refuses to create helper binaries under /tmp
-    const sessionsDir = path.join(os.homedir(), '.codex-sessions')
-    tempCodexHome = path.join(sessionsDir, session.id)
-    fs.mkdirSync(tempCodexHome, { recursive: true })
-
-    // Symlink auth/config files from real CODEX_HOME into temp dir
-    symlinkConfigFiles(realCodexHome, tempCodexHome)
-
-    // Write system prompt as AGENTS.override.md (first turn only)
-    if (systemPrompt && !session.codexThreadId) {
-      fs.writeFileSync(path.join(tempCodexHome, 'AGENTS.override.md'), systemPrompt)
-    }
+  const realCodexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
+  fs.mkdirSync(sessionCodexHome, { recursive: true })
 
-    // Inject agent-assigned MCP servers into config.toml
-    if (agentMcpServerIds.length > 0) {
-      try {
-        const allMcpServers = loadMcpServers()
-        const tomlParts: string[] = []
-        for (const serverId of agentMcpServerIds) {
-          const config = allMcpServers[serverId]
-          if (!config) continue
-          const name = config.name.replace(/[^a-zA-Z0-9_]/g, '_')
-          if (config.transport === 'stdio' && config.command) {
-            tomlParts.push(`[mcp_servers.${name}]`)
-            tomlParts.push(`command = ${JSON.stringify(config.command)}`)
-            const argsStr = (config.args || []).map((a: string) => JSON.stringify(a)).join(', ')
-            tomlParts.push(`args = [${argsStr}]`)
-            if (config.cwd) tomlParts.push(`cwd = ${JSON.stringify(config.cwd)}`)
-            tomlParts.push('')
-            // Env vars go in a separate subsection: [mcp_servers.name.env]
-            if (config.env && Object.keys(config.env).length > 0) {
-              tomlParts.push(`[mcp_servers.${name}.env]`)
-              for (const [k, v] of Object.entries(config.env as Record<string, string>)) {
-                tomlParts.push(`${k} = ${JSON.stringify(v)}`)
-              }
-              tomlParts.push('')
+  // Symlink auth/config files from real CODEX_HOME into session dir
+  symlinkConfigFiles(realCodexHome, sessionCodexHome)
+
+  // Write system prompt as AGENTS.override.md (first turn only)
+  if (systemPrompt && !session.codexThreadId) {
+    fs.writeFileSync(path.join(sessionCodexHome, 'AGENTS.override.md'), systemPrompt)
+  }
+
+  // Inject agent-assigned MCP servers into config.toml
+  if (agentMcpServerIds.length > 0) {
+    try {
+      const allMcpServers = loadMcpServers()
+      const tomlParts: string[] = []
+      for (const serverId of agentMcpServerIds) {
+        const config = allMcpServers[serverId]
+        if (!config) continue
+        const name = config.name.replace(/[^a-zA-Z0-9_]/g, '_')
+        if (config.transport === 'stdio' && config.command) {
+          tomlParts.push(`[mcp_servers.${name}]`)
+          tomlParts.push(`command = ${JSON.stringify(config.command)}`)
+          const argsStr = (config.args || []).map((a: string) => JSON.stringify(a)).join(', ')
+          tomlParts.push(`args = [${argsStr}]`)
+          if (config.cwd) tomlParts.push(`cwd = ${JSON.stringify(config.cwd)}`)
+          tomlParts.push('')
+          // Env vars go in a separate subsection: [mcp_servers.name.env]
+          if (config.env && Object.keys(config.env).length > 0) {
+            tomlParts.push(`[mcp_servers.${name}.env]`)
+            for (const [k, v] of Object.entries(config.env as Record<string, string>)) {
+              tomlParts.push(`${k} = ${JSON.stringify(v)}`)
             }
-          } else if ((config.transport === 'sse' || config.transport === 'streamable-http') && config.url) {
-            tomlParts.push(`[mcp_servers.${name}]`)
-            tomlParts.push(`url = ${JSON.stringify(config.url)}`)
             tomlParts.push('')
           }
+        } else if ((config.transport === 'sse' || config.transport === 'streamable-http') && config.url) {
+          tomlParts.push(`[mcp_servers.${name}]`)
+          tomlParts.push(`url = ${JSON.stringify(config.url)}`)
+          tomlParts.push('')
         }
-        if (tomlParts.length > 0) {
-          const realConfigPath = path.join(realCodexHome, 'config.toml')
-          const existingConfig = fs.existsSync(realConfigPath)
-            ? fs.readFileSync(realConfigPath, 'utf-8')
-            : ''
-          const tempConfigPath = path.join(tempCodexHome, 'config.toml')
-          // Remove symlink created by symlinkConfigFiles before writing our own file
-          try { fs.unlinkSync(tempConfigPath) } catch { /* no symlink — ignore */ }
-          fs.writeFileSync(tempConfigPath, existingConfig + '\n' + tomlParts.join('\n'))
-          log.info('codex-cli', `Injecting ${agentMcpServerIds.length} MCP server(s) via config.toml`)
-        }
-      } catch (mcpErr) {
-        log.warn('codex-cli', `Failed to build MCP config: ${mcpErr}`)
       }
+      if (tomlParts.length > 0) {
+        const realConfigPath = path.join(realCodexHome, 'config.toml')
+        const existingConfig = fs.existsSync(realConfigPath)
+          ? fs.readFileSync(realConfigPath, 'utf-8')
+          : ''
+        const tempConfigPath = path.join(sessionCodexHome, 'config.toml')
+        // Remove symlink created by symlinkConfigFiles before writing our own file
+        try { fs.unlinkSync(tempConfigPath) } catch { /* no symlink — ignore */ }
+        fs.writeFileSync(tempConfigPath, existingConfig + '\n' + tomlParts.join('\n'))
+        log.info('codex-cli', `Injecting ${agentMcpServerIds.length} MCP server(s) via config.toml`)
+      }
+    } catch (mcpErr) {
+      log.warn('codex-cli', `Failed to build MCP config: ${mcpErr}`)
     }
-
-    env.CODEX_HOME = tempCodexHome
   }
+  env.CODEX_HOME = sessionCodexHome
 
   log.info('codex-cli', `Spawning: ${binary}`, {
     args: args.map(a => a.length > 100 ? a.slice(0, 100) + '...' : a),
-    cwd: session.cwd,
+    cwd: effectiveCwd,
     promptLen: prompt.length,
     hasSystemPrompt: !!systemPrompt,
-    tempCodexHome,
+    sessionCodexHome,
   })
 
   const proc = spawn(binary, args, {
-    cwd: session.cwd,
+    cwd: effectiveCwd,
     env,
     stdio: ['pipe', 'pipe', 'pipe'],
     timeout: processTimeoutMs,
@@ -185,9 +183,14 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
         eventCount++
 
         // Track thread ID for session resume
-        if (ev.type === 'thread.started' && ev.thread_id) {
-          session.codexThreadId = ev.thread_id
-          log.info('codex-cli', `Got thread_id: ${ev.thread_id}`)
+        const threadId = typeof ev.thread_id === 'string'
+          ? ev.thread_id
+          : (typeof ev.thread?.id === 'string' ? ev.thread.id : null)
+        if (threadId) {
+          session.codexThreadId = threadId
+          if (eventCount <= 3 || ev.type === 'thread.started') {
+            log.info('codex-cli', `Got thread_id: ${threadId} (${ev.type})`)
+          }
         }
 
         // Streaming text deltas (if codex adds streaming support)
@@ -269,10 +272,6 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
     proc.on('close', (code, sig) => {
       log.info('codex-cli', `Process closed: code=${code} signal=${sig} events=${eventCount} response=${fullResponse.length}chars`)
       active.delete(session.id)
-      // Clean up temp CODEX_HOME
-      if (tempCodexHome) {
-        try { fs.rmSync(tempCodexHome, { recursive: true }) } catch { /* ignore */ }
-      }
       if ((code ?? 0) !== 0 && !fullResponse.trim()) {
         const msg = stderrText.trim()
           ? `Codex CLI exited with code ${code ?? 'unknown'}${sig ? ` (${sig})` : ''}: ${stderrText.trim().slice(0, 1200)}`
@@ -285,9 +284,6 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
     proc.on('error', (e) => {
       log.error('codex-cli', `Process error: ${e.message}`)
       active.delete(session.id)
-      if (tempCodexHome) {
-        try { fs.rmSync(tempCodexHome, { recursive: true }) } catch { /* ignore */ }
-      }
       write(`data: ${JSON.stringify({ t: 'err', text: e.message })}\n\n`)
       resolve(fullResponse)
     })

package/src/lib/providers/generic-cli.ts

@@ -2,6 +2,7 @@ import { spawn } from 'child_process'
 import type { StreamChatOptions } from './index'
 import { log } from '../server/logger'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
+import { GENERIC_CLI_PROVIDER_METADATA } from './cli-provider-metadata'
 import { resolveCliBinary, buildCliEnv, attachAbortHandler, isStderrNoise } from './cli-utils'
 
 /**
@@ -9,37 +10,7 @@ import { resolveCliBinary, buildCliEnv, attachAbortHandler, isStderrNoise } from
  * Used by the generic CLI streamer for tools without a bespoke handler.
  */
 export const GENERIC_CLI_BINARIES: Record<string, string> = {
-  'aider-cli': 'aider',
-  'amp-cli': 'amp',
-  'augment-cli': 'augment',
-  'adal-cli': 'adal',
-  'bob-cli': 'bob',
-  'cline-cli': 'cline',
-  'codebuddy-cli': 'codebuddy',
-  'command-code-cli': 'commandcode',
-  'continue-cli': 'continue',
-  'cortex-cli': 'cortex',
-  'crush-cli': 'crush',
-  'deepagents-cli': 'deepagents',
-  'firebender-cli': 'firebender',
-  'iflow-cli': 'iflow',
-  'junie-cli': 'junie',
-  'kilo-code-cli': 'kilocode',
-  'kimi-cli': 'kimi',
-  'kode-cli': 'kode',
-  'mcpjam-cli': 'mcpjam',
-  'mistral-vibe-cli': 'vibe',
-  'mux-cli': 'mux',
-  'neovate-cli': 'neovate',
-  'openhands-cli': 'openhands',
-  'pochi-cli': 'pochi',
-  'qoder-cli': 'qoder',
-  'replit-cli': 'replit',
-  'roo-code-cli': 'roo',
-  'trae-cn-cli': 'trae-cn',
-  'warp-cli': 'warp',
-  'windsurf-cli': 'windsurf',
-  'zencoder-cli': 'zencoder',
+  ...Object.fromEntries(GENERIC_CLI_PROVIDER_METADATA.map((provider) => [provider.id, provider.binaryName])),
 }
 
 interface GenericCliOptions extends StreamChatOptions {