@swarmclawai/swarmclaw 1.7.1 → 1.7.3

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.ts

@@ -12,6 +12,7 @@ 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
@@ -468,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/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 {

package/src/lib/providers/index.ts

@@ -8,7 +8,8 @@ import { streamDroidCliChat } from './droid-cli'
 import { streamCursorCliChat } from './cursor-cli'
 import { streamQwenCodeCliChat } from './qwen-code-cli'
 import { streamGooseChat } from './goose'
-import { streamGenericCliChat, GENERIC_CLI_BINARIES } from './generic-cli'
+import { streamGenericCliChat } from './generic-cli'
+import { GENERIC_CLI_PROVIDER_METADATA, isCliProviderId } from './cli-provider-metadata'
 import { streamOpenAiChat } from './openai'
 import { streamOllamaChat } from './ollama'
 import { streamAnthropicChat } from './anthropic'
@@ -52,53 +53,22 @@ interface BuiltinProviderConfig extends ProviderInfo {
   handler: ProviderHandler
 }
 
-const GENERIC_CLI_DISPLAY_NAMES: Record<string, string> = {
-  'aider-cli': 'Aider CLI',
-  'amp-cli': 'Amp CLI',
-  'augment-cli': 'Augment CLI',
-  'adal-cli': 'AdaL CLI',
-  'bob-cli': 'IBM Bob CLI',
-  'cline-cli': 'Cline CLI',
-  'codebuddy-cli': 'CodeBuddy CLI',
-  'command-code-cli': 'Command Code CLI',
-  'continue-cli': 'Continue CLI',
-  'cortex-cli': 'Cortex Code CLI',
-  'crush-cli': 'Crush CLI',
-  'deepagents-cli': 'Deep Agents CLI',
-  'firebender-cli': 'Firebender CLI',
-  'iflow-cli': 'iFlow CLI',
-  'junie-cli': 'Junie CLI',
-  'kilo-code-cli': 'Kilo Code CLI',
-  'kimi-cli': 'Kimi Code CLI',
-  'kode-cli': 'Kode CLI',
-  'mcpjam-cli': 'MCPJam CLI',
-  'mistral-vibe-cli': 'Mistral Vibe CLI',
-  'mux-cli': 'Mux CLI',
-  'neovate-cli': 'Neovate CLI',
-  'openhands-cli': 'OpenHands CLI',
-  'pochi-cli': 'Pochi CLI',
-  'qoder-cli': 'Qoder CLI',
-  'replit-cli': 'Replit Agent CLI',
-  'roo-code-cli': 'Roo Code CLI',
-  'trae-cn-cli': 'TRAE CN CLI',
-  'warp-cli': 'Warp Agent CLI',
-  'windsurf-cli': 'Windsurf CLI',
-  'zencoder-cli': 'Zencoder CLI',
-}
-
 function buildGenericCliEntries(): Record<string, BuiltinProviderConfig> {
   const entries: Record<string, BuiltinProviderConfig> = {}
-  for (const [providerId, binaryName] of Object.entries(GENERIC_CLI_BINARIES)) {
-    const displayName = GENERIC_CLI_DISPLAY_NAMES[providerId] ?? providerId
-    entries[providerId] = {
-      id: providerId,
-      name: displayName,
-      models: ['default'],
+  for (const provider of GENERIC_CLI_PROVIDER_METADATA) {
+    entries[provider.id] = {
+      id: provider.id,
+      name: provider.displayName,
+      models: [provider.defaultModel],
       requiresApiKey: false,
-      optionalApiKey: true,
+      optionalApiKey: provider.optionalApiKey,
       requiresEndpoint: false,
       handler: {
-        streamChat: (opts) => streamGenericCliChat({ ...opts, binaryName, displayName }),
+        streamChat: (opts) => streamGenericCliChat({
+          ...opts,
+          binaryName: provider.binaryName,
+          displayName: provider.displayName,
+        }),
       },
     }
   }
@@ -530,7 +500,7 @@ export function getProviderList(): ProviderInfo[] {
         ...info,
         models: overrides[info.id] || info.models,
         defaultModels: info.models,
-        supportsModelDiscovery: !['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'droid-cli', 'cursor-cli', 'qwen-code-cli', 'goose', 'fireworks', ...Object.keys(GENERIC_CLI_BINARIES)].includes(info.id),
+        supportsModelDiscovery: !isCliProviderId(info.id) && info.id !== 'fireworks',
       }
     })
   

package/src/lib/server/cli-provider-readiness.test.ts

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { checkCliProviderReady } from './cli-provider-readiness'
+
+describe('checkCliProviderReady', () => {
+  it('accepts a generic CLI provider when its binary is present', () => {
+    const result = checkCliProviderReady('aider-cli', {
+      resolveBinary: (name) => name === 'aider' ? '/usr/local/bin/aider' : null,
+    })
+
+    assert.equal(result.ok, true)
+    assert.equal(result.displayName, 'Aider CLI')
+    assert.equal(result.binaryName, 'aider')
+    assert.equal(result.generic, true)
+    assert.match(result.message, /binary is available/)
+  })
+
+  it('reports a missing generic CLI binary with install guidance', () => {
+    const result = checkCliProviderReady('windsurf-cli', {
+      resolveBinary: () => null,
+    })
+
+    assert.equal(result.ok, false)
+    assert.equal(result.displayName, 'Windsurf CLI')
+    assert.equal(result.binaryName, 'windsurf')
+    assert.match(result.message, /Install `windsurf`/)
+  })
+
+  it('keeps auth-aware checks for bespoke CLI providers', () => {
+    const result = checkCliProviderReady('claude-cli', {
+      resolveBinary: () => '/usr/local/bin/claude',
+      env: { ...process.env },
+      probeAuth: () => ({
+        authenticated: false,
+        errorMessage: 'Claude CLI is not authenticated.',
+      }),
+    })
+
+    assert.equal(result.ok, false)
+    assert.equal(result.displayName, 'Claude Code CLI')
+    assert.equal(result.generic, false)
+    assert.equal(result.message, 'Claude CLI is not authenticated.')
+  })
+})

package/src/lib/server/cli-provider-readiness.ts

@@ -0,0 +1,84 @@
+import {
+  CLI_PROVIDER_METADATA_BY_ID,
+  isCliProviderId,
+  type CliAuthBackend,
+  type CliProviderMetadata,
+} from '@/lib/providers/cli-provider-metadata'
+import { buildCliEnv, probeCliAuth, resolveCliBinary, type AuthProbeResult } from '@/lib/providers/cli-utils'
+
+export interface CliProviderReadyResult {
+  ok: boolean
+  message: string
+  providerId?: string
+  displayName?: string
+  binaryName?: string
+  binaryPath?: string
+  generic?: boolean
+}
+
+interface CheckCliProviderReadyOptions {
+  cwd?: string
+  env?: NodeJS.ProcessEnv
+  resolveBinary?: (name: string) => string | null
+  probeAuth?: (
+    binary: string,
+    backend: CliAuthBackend,
+    env: NodeJS.ProcessEnv,
+    cwd?: string,
+  ) => AuthProbeResult
+}
+
+function missingBinaryMessage(meta: CliProviderMetadata): string {
+  return `${meta.displayName} is not installed. Install \`${meta.binaryName}\` and ensure it is on your PATH.`
+}
+
+export function checkCliProviderReady(
+  providerId: string,
+  options: CheckCliProviderReadyOptions = {},
+): CliProviderReadyResult {
+  if (!isCliProviderId(providerId)) {
+    return { ok: false, message: 'Unknown CLI provider.', providerId }
+  }
+
+  const meta = CLI_PROVIDER_METADATA_BY_ID[providerId]
+  const resolveBinary = options.resolveBinary || resolveCliBinary
+  const binaryPath = resolveBinary(meta.binaryName)
+  if (!binaryPath) {
+    return {
+      ok: false,
+      message: missingBinaryMessage(meta),
+      providerId,
+      displayName: meta.displayName,
+      binaryName: meta.binaryName,
+      generic: meta.generic,
+    }
+  }
+
+  if (meta.authBackend) {
+    const env = options.env || buildCliEnv()
+    const auth = (options.probeAuth || probeCliAuth)(binaryPath, meta.authBackend, env, options.cwd || process.cwd())
+    if (!auth.authenticated) {
+      return {
+        ok: false,
+        message: auth.errorMessage || `${meta.displayName} is not configured.`,
+        providerId,
+        displayName: meta.displayName,
+        binaryName: meta.binaryName,
+        binaryPath,
+        generic: meta.generic,
+      }
+    }
+  }
+
+  return {
+    ok: true,
+    message: meta.authBackend
+      ? `${meta.displayName} is installed and ready.`
+      : `${meta.displayName} binary is available. If it requires account setup, complete that in \`${meta.binaryName}\` before running agent turns.`,
+    providerId,
+    displayName: meta.displayName,
+    binaryName: meta.binaryName,
+    binaryPath,
+    generic: meta.generic,
+  }
+}

package/src/lib/server/provider-health.test.ts

@@ -179,4 +179,10 @@ describe('provider-health', () => {
       globalThis.fetch = originalFetch
     }
   })
+
+  it('skips extended CLI providers instead of treating them as HTTP providers', async () => {
+    const result = await providerHealth.pingProvider('aider-cli', undefined, undefined)
+    assert.equal(result.ok, true)
+    assert.equal(result.message, 'CLI provider - skipped.')
+  })
 })

package/src/lib/server/provider-health.ts

@@ -2,6 +2,7 @@ import { spawnSync } from 'child_process'
 import { errorMessage, hmrSingleton, jitteredBackoff } from '@/lib/shared-utils'
 import { upsertStoredItem, loadCollection } from './storage'
 import { log } from './logger'
+import { isCliProviderId } from '@/lib/providers/cli-provider-metadata'
 
 const TAG = 'provider-health'
 
@@ -352,9 +353,8 @@ export async function pingProvider(
   apiKey: string | undefined,
   endpoint: string | undefined,
 ): Promise<{ ok: boolean; message: string }> {
-  const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'droid-cli', 'cursor-cli', 'qwen-code-cli', 'goose']
   const OPTIONAL_OPENAI_COMPATIBLE_KEY_PROVIDERS = new Set(['hermes'])
-  if (CLI_PROVIDERS.includes(provider)) return { ok: true, message: 'CLI provider — skipped.' }
+  if (isCliProviderId(provider)) return { ok: true, message: 'CLI provider - skipped.' }
 
   try {
     if (provider === 'anthropic') {

package/src/lib/setup-defaults.test.ts

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
+import { CLI_PROVIDER_METADATA } from './providers/cli-provider-metadata'
 import { DEFAULT_AGENTS, getDefaultModelForProvider } from './setup-defaults'
 
 // ---------------------------------------------------------------------------
@@ -48,6 +49,13 @@ test('getDefaultModelForProvider returns expected defaults for cursor, qwen, and
   assert.equal(getDefaultModelForProvider('goose'), 'default')
 })
 
+test('every CLI provider has setup default agent coverage', () => {
+  for (const provider of CLI_PROVIDER_METADATA) {
+    assert.equal(getDefaultModelForProvider(provider.id), provider.defaultModel)
+    assert.ok(DEFAULT_AGENTS[provider.id].description.includes(provider.displayName))
+  }
+})
+
 test('getDefaultModelForProvider returns non-empty for ollama', () => {
   const model = getDefaultModelForProvider('ollama')
   assert.ok(model, 'ollama model should be truthy')