@swarmclawai/swarmclaw 1.7.0 → 1.7.2

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/chat-execution/chat-execution-session-sync.test.ts

@@ -109,6 +109,195 @@ test('executeSessionChatTurn syncs updated agent runtime fields onto its thread
   assert.equal(output.connectorContext, null)
 })
 
+test('executeSessionChatTurn persists codex thread id discovered on run-session object', () => {
+  const output = runWithTempDataDir<{
+    codexThreadId: string | null
+  }>(`
+    const storageMod = await import('@/lib/server/storage')
+    const providersMod = await import('@/lib/providers/index')
+    const execMod = await import('@/lib/server/chat-execution/chat-execution')
+    const storage = storageMod.default || storageMod['module.exports'] || storageMod
+    const executeSessionChatTurn = execMod.executeSessionChatTurn
+      || execMod.default?.executeSessionChatTurn
+      || execMod['module.exports']?.executeSessionChatTurn
+    const providers = providersMod.PROVIDERS
+      || providersMod.default?.PROVIDERS
+      || providersMod['module.exports']?.PROVIDERS
+
+    providers['test-codex-sync-provider'] = {
+      id: 'test-codex-sync-provider',
+      name: 'Codex Sync Test Provider',
+      models: ['unit'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: {
+        async streamChat(opts) {
+          opts.session.codexThreadId = 'thread_sync_123'
+          return 'ok'
+        },
+      },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      codexsync: {
+        id: 'codexsync',
+        name: 'Codex Sync Agent',
+        description: 'Codex thread id sync test',
+        provider: 'test-codex-sync-provider',
+        model: 'unit',
+        credentialId: null,
+        apiEndpoint: null,
+        fallbackCredentialIds: [],
+        disabled: false,
+        heartbeatEnabled: false,
+        heartbeatIntervalSec: null,
+        extensions: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+
+    storage.saveSessions({
+      codex_session: {
+        id: 'codex_session',
+        name: 'Codex Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'default',
+        provider: 'test-codex-sync-provider',
+        model: 'unit',
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        geminiSessionId: null,
+        copilotSessionId: null,
+        droidSessionId: null,
+        cursorSessionId: null,
+        qwenSessionId: null,
+        acpSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null, copilot: null, droid: null, cursor: null, qwen: null },
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        sessionType: 'human',
+        agentId: 'codexsync',
+        extensions: [],
+      },
+    })
+
+    await executeSessionChatTurn({
+      sessionId: 'codex_session',
+      message: 'hello',
+      runId: 'run-codex-sync',
+    })
+
+    const persisted = storage.loadSession('codex_session')
+    console.log(JSON.stringify({
+      codexThreadId: persisted?.codexThreadId || null,
+    }))
+  `)
+
+  assert.equal(output.codexThreadId, 'thread_sync_123')
+})
+
+test('executeSessionChatTurn persists intentional codex resume id clears from run-session object', () => {
+  const output = runWithTempDataDir<{
+    codexThreadId: string | null
+    delegateCodex: string | null
+  }>(`
+    const storageMod = await import('@/lib/server/storage')
+    const providersMod = await import('@/lib/providers/index')
+    const execMod = await import('@/lib/server/chat-execution/chat-execution')
+    const storage = storageMod.default || storageMod['module.exports'] || storageMod
+    const executeSessionChatTurn = execMod.executeSessionChatTurn
+      || execMod.default?.executeSessionChatTurn
+      || execMod['module.exports']?.executeSessionChatTurn
+    const providers = providersMod.PROVIDERS
+      || providersMod.default?.PROVIDERS
+      || providersMod['module.exports']?.PROVIDERS
+
+    providers['test-codex-clear-provider'] = {
+      id: 'test-codex-clear-provider',
+      name: 'Codex Clear Test Provider',
+      models: ['unit'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: {
+        async streamChat(opts) {
+          opts.session.codexThreadId = null
+          opts.session.delegateResumeIds = {
+            ...(opts.session.delegateResumeIds || {}),
+            codex: null,
+          }
+          return 'ok'
+        },
+      },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      codexclear: {
+        id: 'codexclear',
+        name: 'Codex Clear Agent',
+        description: 'Codex resume id clear test',
+        provider: 'test-codex-clear-provider',
+        model: 'unit',
+        credentialId: null,
+        apiEndpoint: null,
+        fallbackCredentialIds: [],
+        disabled: false,
+        heartbeatEnabled: false,
+        heartbeatIntervalSec: null,
+        extensions: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+
+    storage.saveSessions({
+      codex_clear_session: {
+        id: 'codex_clear_session',
+        name: 'Codex Clear Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'default',
+        provider: 'test-codex-clear-provider',
+        model: 'unit',
+        claudeSessionId: null,
+        codexThreadId: 'thread_old_123',
+        opencodeSessionId: null,
+        geminiSessionId: null,
+        copilotSessionId: null,
+        droidSessionId: null,
+        cursorSessionId: null,
+        qwenSessionId: null,
+        acpSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: 'thread_old_123', opencode: null, gemini: null, copilot: null, droid: null, cursor: null, qwen: null },
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        sessionType: 'human',
+        agentId: 'codexclear',
+        extensions: [],
+      },
+    })
+
+    await executeSessionChatTurn({
+      sessionId: 'codex_clear_session',
+      message: 'hello',
+      runId: 'run-codex-clear',
+    })
+
+    const persisted = storage.loadSession('codex_clear_session')
+    console.log(JSON.stringify({
+      codexThreadId: persisted?.codexThreadId ?? null,
+      delegateCodex: persisted?.delegateResumeIds?.codex ?? null,
+    }))
+  `)
+
+  assert.equal(output.codexThreadId, null)
+  assert.equal(output.delegateCodex, null)
+})
+
 test('executeSessionChatTurn keeps tool-only heartbeats off the visible main-thread history and clears stale connector state', () => {
   const output = runWithTempDataDir<{
     connectorContext: Record<string, unknown> | null

package/src/lib/server/chat-execution/chat-turn-finalization.ts

@@ -435,18 +435,25 @@ export async function finalizeChatTurn(params: {
         ;(current as unknown as Record<string, unknown>)[key] = normalized
       }
     }
+    const preferRunValue = (runValue: unknown, fallbackValue: unknown) => (
+      runValue !== undefined ? runValue : fallbackValue
+    )
 
-    persistField('claudeSessionId', session.claudeSessionId)
-    persistField('codexThreadId', session.codexThreadId)
-    persistField('opencodeSessionId', session.opencodeSessionId)
-    persistField('geminiSessionId', session.geminiSessionId)
-    persistField('copilotSessionId', session.copilotSessionId)
-    persistField('droidSessionId', session.droidSessionId)
-    persistField('cursorSessionId', session.cursorSessionId)
-    persistField('qwenSessionId', session.qwenSessionId)
-    persistField('acpSessionId', session.acpSessionId)
-
-    const sourceResume = session.delegateResumeIds
+    // Provider handlers receive `sessionForRun` and may mutate CLI resume IDs there.
+    // Persist from run-session first, allowing null to intentionally clear IDs.
+    persistField('claudeSessionId', preferRunValue(sessionForRun.claudeSessionId, session.claudeSessionId))
+    persistField('codexThreadId', preferRunValue(sessionForRun.codexThreadId, session.codexThreadId))
+    persistField('opencodeSessionId', preferRunValue(sessionForRun.opencodeSessionId, session.opencodeSessionId))
+    persistField('geminiSessionId', preferRunValue(sessionForRun.geminiSessionId, session.geminiSessionId))
+    persistField('copilotSessionId', preferRunValue(sessionForRun.copilotSessionId, session.copilotSessionId))
+    persistField('droidSessionId', preferRunValue(sessionForRun.droidSessionId, session.droidSessionId))
+    persistField('cursorSessionId', preferRunValue(sessionForRun.cursorSessionId, session.cursorSessionId))
+    persistField('qwenSessionId', preferRunValue(sessionForRun.qwenSessionId, session.qwenSessionId))
+    persistField('acpSessionId', preferRunValue(sessionForRun.acpSessionId, session.acpSessionId))
+
+    const sourceResume = (sessionForRun.delegateResumeIds && typeof sessionForRun.delegateResumeIds === 'object')
+      ? sessionForRun.delegateResumeIds
+      : session.delegateResumeIds
     if (sourceResume && typeof sourceResume === 'object') {
       const currentResume = (current.delegateResumeIds && typeof current.delegateResumeIds === 'object')
         ? current.delegateResumeIds
@@ -454,14 +461,14 @@ export async function finalizeChatTurn(params: {
       const sr = sourceResume as Record<string, unknown>
       const cr = currentResume as Record<string, unknown>
       const nextResume = {
-        claudeCode: normalizeResumeId(sr.claudeCode ?? cr.claudeCode),
-        codex: normalizeResumeId(sr.codex ?? cr.codex),
-        opencode: normalizeResumeId(sr.opencode ?? cr.opencode),
-        gemini: normalizeResumeId(sr.gemini ?? cr.gemini),
-        copilot: normalizeResumeId(sr.copilot ?? cr.copilot),
-        droid: normalizeResumeId(sr.droid ?? cr.droid),
-        cursor: normalizeResumeId(sr.cursor ?? cr.cursor),
-        qwen: normalizeResumeId(sr.qwen ?? cr.qwen),
+        claudeCode: normalizeResumeId(preferRunValue(sr.claudeCode, cr.claudeCode)),
+        codex: normalizeResumeId(preferRunValue(sr.codex, cr.codex)),
+        opencode: normalizeResumeId(preferRunValue(sr.opencode, cr.opencode)),
+        gemini: normalizeResumeId(preferRunValue(sr.gemini, cr.gemini)),
+        copilot: normalizeResumeId(preferRunValue(sr.copilot, cr.copilot)),
+        droid: normalizeResumeId(preferRunValue(sr.droid, cr.droid)),
+        cursor: normalizeResumeId(preferRunValue(sr.cursor, cr.cursor)),
+        qwen: normalizeResumeId(preferRunValue(sr.qwen, cr.qwen)),
       }
       if (JSON.stringify(currentResume) !== JSON.stringify(nextResume)) {
         current.delegateResumeIds = nextResume

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')