@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/lib/server/connectors/slack.ts

@@ -145,11 +145,12 @@ const slack: PlatformConnector = {
       }
       botUserId = auth.user_id as string
       log.info(TAG, `Authenticated as @${auth.user} in workspace "${auth.team}"`)
-    } catch (err: any) {
-      const hint = err.code === 'slack_webapi_platform_error'
+    } catch (err: unknown) {
+      const hint = (err instanceof Error && 'code' in err) ? (err as { code: string }).code : undefined
+      const suffix = hint === 'slack_webapi_platform_error'
         ? '. Check that your Bot Token (xoxb-...) is correct and the app is installed to the workspace.'
         : ''
-      throw new Error(`Slack auth failed: ${err.message}${hint}`)
+      throw new Error(`Slack auth failed: ${errorMessage(err)}${suffix}`)
     }
 
     const app = new App({
@@ -215,8 +216,8 @@ const slack: PlatformConnector = {
                 media.push(stored)
                 continue
               }
-            } catch (err: any) {
-              log.warn(TAG, `Media download failed (${f?.name || 'file'}):`, err?.message || String(err))
+            } catch (err: unknown) {
+              log.warn(TAG, `Media download failed (${f?.name || 'file'}):`, errorMessage(err))
             }
           }
           media.push({
@@ -264,8 +265,8 @@ const slack: PlatformConnector = {
             return sent.ts || undefined
           },
         })
-      } catch (err: any) {
-        log.error(TAG, 'Error handling message:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling message:', errorMessage(err))
         try {
           await say('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }
@@ -322,8 +323,8 @@ const slack: PlatformConnector = {
             return sent.ts || undefined
           },
         })
-      } catch (err: any) {
-        log.error(TAG, 'Error handling mention:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling mention:', errorMessage(err))
       }
     })
 

package/src/lib/server/connectors/swarmdock-bidding.ts

@@ -0,0 +1,74 @@
+import { log } from '@/lib/server/logger'
+import type { BidCreateInput } from '@swarmdock/shared'
+
+const TAG = 'swarmdock-bid'
+
+interface SwarmDockTask {
+  id: string
+  title: string
+  skillRequirements: string[]
+  budgetMax: string
+}
+
+interface SwarmDockConfig {
+  skills: string
+  maxBudget: string
+  autoDiscover: boolean
+}
+
+/**
+ * Determine if the agent should auto-bid on a discovered task.
+ * Checks skill overlap and budget limits.
+ */
+export function shouldAutoBid(task: SwarmDockTask, config: SwarmDockConfig): boolean {
+  if (!config.autoDiscover) return false
+
+  // Check budget
+  const maxBudget = BigInt(config.maxBudget || '0')
+  if (maxBudget > BigInt(0)) {
+    const taskBudget = BigInt(task.budgetMax || '0')
+    if (taskBudget > maxBudget) {
+      log.debug(TAG, `Skipping "${task.title}" — budget ${task.budgetMax} exceeds max ${config.maxBudget}`)
+      return false
+    }
+  }
+
+  // Check skill overlap
+  const agentSkills = new Set(
+    config.skills.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean),
+  )
+  if (agentSkills.size === 0) return false
+
+  const hasMatchingSkill = task.skillRequirements.some(
+    (req) => agentSkills.has(req.toLowerCase()),
+  )
+  if (!hasMatchingSkill) {
+    log.debug(TAG, `Skipping "${task.title}" — no matching skills`)
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Submit an auto-bid on a SwarmDock task.
+ * Uses the task's max budget as the proposed price (simple strategy).
+ */
+export async function submitAutoBid(
+  client: { tasks: { bid: (taskId: string, input: BidCreateInput) => Promise<unknown> } },
+  taskId: string,
+  config: SwarmDockConfig,
+): Promise<void> {
+  const agentSkills = config.skills.split(',').map((s) => s.trim()).filter(Boolean)
+
+  const bid: BidCreateInput = {
+    proposedPrice: config.maxBudget || '1000000',
+    confidenceScore: 0.8,
+    proposal: `SwarmClaw agent with skills: ${agentSkills.join(', ')}. Ready to start immediately.`,
+    portfolioRefs: [],
+  }
+
+  await client.tasks.bid(taskId, bid)
+
+  log.info(TAG, `Auto-bid submitted for task ${taskId}`)
+}

package/src/lib/server/connectors/swarmdock-payloads.test.ts

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { submitAutoBid } from '@/lib/server/connectors/swarmdock-bidding'
+import { submitSwarmdockTaskResult } from '@/lib/server/connectors/swarmdock'
+
+test('submitAutoBid includes empty portfolio refs for SDK compatibility', async () => {
+  const seen: {
+    taskId?: string
+    bid?: { proposedPrice: string; portfolioRefs: string[] }
+  } = {}
+
+  await submitAutoBid(
+    {
+      tasks: {
+        bid: async (taskId, input) => {
+          seen.taskId = taskId
+          seen.bid = {
+            proposedPrice: input.proposedPrice,
+            portfolioRefs: [...input.portfolioRefs],
+          }
+        },
+      },
+    },
+    'task-123',
+    {
+      skills: 'typescript,automation',
+      maxBudget: '2500000',
+      autoDiscover: true,
+    },
+  )
+
+  assert.equal(seen.taskId, 'task-123')
+  assert.deepEqual(seen.bid, {
+    proposedPrice: '2500000',
+    portfolioRefs: [],
+  })
+})
+
+test('submitSwarmdockTaskResult includes empty files and propagates submit errors', async () => {
+  const seen: {
+    taskId?: string
+    payload?: { files: unknown[]; artifacts: Array<{ type: string; content: string }> }
+  } = {}
+
+  await submitSwarmdockTaskResult(
+    {
+      tasks: {
+        submit: async (taskId, input) => {
+          seen.taskId = taskId
+          seen.payload = {
+            files: [...input.files],
+            artifacts: input.artifacts.map((artifact) => ({
+              type: artifact.type,
+              content: String(artifact.content),
+            })),
+          }
+        },
+      },
+    },
+    'task-456',
+    'Result body',
+  )
+
+  assert.equal(seen.taskId, 'task-456')
+  assert.deepEqual(seen.payload, {
+    files: [],
+    artifacts: [{ type: 'text/markdown', content: 'Result body' }],
+  })
+
+  await assert.rejects(
+    submitSwarmdockTaskResult(
+      {
+        tasks: {
+          submit: async () => {
+            throw new Error('submit failed')
+          },
+        },
+      },
+      'task-456',
+      'Result body',
+    ),
+    /submit failed/,
+  )
+})

package/src/lib/server/connectors/swarmdock-secret.test.ts

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import test from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-swarmdock-secret-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        CREDENTIAL_SECRET: 'test-credential-secret',
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+test('createConnector stores SwarmDock private keys as credentials and redacts config output', () => {
+  const output = runWithTempDataDir(`
+    const storageMod = await import('./src/lib/server/storage')
+    const serviceMod = await import('./src/lib/server/connectors/connector-service')
+    const secretMod = await import('./src/lib/server/connectors/swarmdock-secret')
+    const storage = storageMod.default || storageMod
+    const service = serviceMod.default || serviceMod
+    const secret = secretMod.default || secretMod
+
+    const created = service.createConnector({
+      name: 'SwarmDock Worker',
+      platform: 'swarmdock',
+      config: {
+        apiUrl: 'https://api.swarmdock.example',
+        walletAddress: '0x000000000000000000000000000000000000dEaD',
+        privateKey: 'legacy-private-key',
+      },
+    })
+
+    const stored = storage.loadConnectors()[created.id]
+    const credentials = storage.loadCredentials()
+    const credential = stored?.credentialId ? credentials[stored.credentialId] : null
+    const redacted = secret.redactConnectorSecrets({
+      ...stored,
+      config: {
+        ...(stored?.config || {}),
+        privateKey: 'should-not-leak',
+      },
+    })
+
+    console.log(JSON.stringify({
+      credentialId: stored?.credentialId || null,
+      storedHasPrivateKey: Boolean(stored?.config && Object.prototype.hasOwnProperty.call(stored.config, 'privateKey')),
+      credentialProvider: credential?.provider || null,
+      credentialName: credential?.name || null,
+      redactedHasPrivateKey: Boolean(redacted?.config && Object.prototype.hasOwnProperty.call(redacted.config, 'privateKey')),
+    }))
+  `)
+
+  assert.match(String(output.credentialId || ''), /^cred_/)
+  assert.equal(output.storedHasPrivateKey, false)
+  assert.equal(output.credentialProvider, 'swarmdock')
+  assert.match(String(output.credentialName || ''), /SwarmDock Identity Key/)
+  assert.equal(output.redactedHasPrivateKey, false)
+})
+
+test('ensureSwarmdockConnectorCredential migrates stored legacy config keys into credentials', () => {
+  const output = runWithTempDataDir(`
+    const storageMod = await import('./src/lib/server/storage')
+    const repoMod = await import('./src/lib/server/connectors/connector-repository')
+    const secretMod = await import('./src/lib/server/connectors/swarmdock-secret')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+    const secret = secretMod.default || secretMod
+
+    storage.saveConnectors({
+      conn_legacy: {
+        id: 'conn_legacy',
+        name: 'Legacy SwarmDock',
+        platform: 'swarmdock',
+        agentId: null,
+        chatroomId: null,
+        credentialId: null,
+        config: {
+          walletAddress: '0x000000000000000000000000000000000000dEaD',
+          privateKey: 'legacy-private-key',
+        },
+        isEnabled: false,
+        status: 'stopped',
+        lastError: null,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const prepared = secret.ensureSwarmdockConnectorCredential(repo.loadConnector('conn_legacy'))
+    const migrated = repo.loadConnector('conn_legacy')
+    const credentials = storage.loadCredentials()
+    const credential = migrated?.credentialId ? credentials[migrated.credentialId] : null
+
+    console.log(JSON.stringify({
+      fallbackPrivateKey: prepared.fallbackPrivateKey,
+      migratedCredentialId: migrated?.credentialId || null,
+      migratedHasPrivateKey: Boolean(migrated?.config && Object.prototype.hasOwnProperty.call(migrated.config, 'privateKey')),
+      credentialProvider: credential?.provider || null,
+    }))
+  `)
+
+  assert.equal(output.fallbackPrivateKey, null)
+  assert.match(String(output.migratedCredentialId || ''), /^cred_/)
+  assert.equal(output.migratedHasPrivateKey, false)
+  assert.equal(output.credentialProvider, 'swarmdock')
+})

package/src/lib/server/connectors/swarmdock-secret.ts

@@ -0,0 +1,152 @@
+import type { Connector } from '@/types'
+import { createCredentialRecord, resolveCredentialSecret } from '@/lib/server/credentials/credential-service'
+import { upsertConnector } from './connector-repository'
+import { notify } from '@/lib/server/ws-hub'
+
+export const SWARMMDOCK_CREDENTIAL_PROVIDER = 'swarmdock'
+
+function clean(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function cloneConfig(config: Record<string, string> | null | undefined): Record<string, string> {
+  return config ? { ...config } : {}
+}
+
+function getLegacyPrivateKey(config: Record<string, string> | null | undefined): string {
+  return clean(config?.privateKey)
+}
+
+function stripLegacyPrivateKey(config: Record<string, string> | null | undefined): Record<string, string> {
+  const next = cloneConfig(config)
+  delete next.privateKey
+  return next
+}
+
+function buildCredentialName(connectorName: string): string {
+  const normalizedName = clean(connectorName)
+  return normalizedName ? `${normalizedName} SwarmDock Identity Key` : 'SwarmDock Identity Key'
+}
+
+function persistConnectorSecretMigration(
+  connector: Connector,
+  credentialId: string,
+): Connector {
+  const nextConfig = stripLegacyPrivateKey(connector.config)
+  const next: Connector = {
+    ...connector,
+    credentialId,
+    config: nextConfig,
+    updatedAt: Date.now(),
+  }
+  upsertConnector(next.id, next)
+  notify('connectors')
+  return next
+}
+
+export function redactConnectorSecrets<T extends Connector>(connector: T): T {
+  if (connector.platform !== 'swarmdock') {
+    return {
+      ...connector,
+      config: cloneConfig(connector.config),
+    }
+  }
+  return {
+    ...connector,
+    config: stripLegacyPrivateKey(connector.config),
+  }
+}
+
+export function prepareSwarmdockConnectorInput(params: {
+  platform: Connector['platform']
+  name: string
+  credentialId: string | null
+  config: Record<string, string> | null | undefined
+}): {
+  credentialId: string | null
+  config: Record<string, string>
+} {
+  const config = cloneConfig(params.config)
+  if (params.platform !== 'swarmdock') {
+    return {
+      credentialId: clean(params.credentialId) || null,
+      config,
+    }
+  }
+
+  const credentialId = clean(params.credentialId)
+  const legacyPrivateKey = getLegacyPrivateKey(config)
+  if (!legacyPrivateKey) {
+    return {
+      credentialId: credentialId || null,
+      config: stripLegacyPrivateKey(config),
+    }
+  }
+
+  if (credentialId) {
+    return {
+      credentialId,
+      config: stripLegacyPrivateKey(config),
+    }
+  }
+
+  const credential = createCredentialRecord({
+    provider: SWARMMDOCK_CREDENTIAL_PROVIDER,
+    name: buildCredentialName(params.name),
+    apiKey: legacyPrivateKey,
+  })
+
+  return {
+    credentialId: credential.id,
+    config: stripLegacyPrivateKey(config),
+  }
+}
+
+export function ensureSwarmdockConnectorCredential(
+  connector: Connector,
+  options?: { allowMigrationFailureFallback?: boolean },
+): {
+  connector: Connector
+  fallbackPrivateKey: string | null
+} {
+  if (connector.platform !== 'swarmdock') {
+    return { connector, fallbackPrivateKey: null }
+  }
+
+  const legacyPrivateKey = getLegacyPrivateKey(connector.config)
+  if (!legacyPrivateKey) {
+    return { connector, fallbackPrivateKey: null }
+  }
+
+  const configuredCredentialId = clean(connector.credentialId)
+  if (configuredCredentialId) {
+    if (resolveCredentialSecret(configuredCredentialId)) {
+      return {
+        connector: persistConnectorSecretMigration(connector, configuredCredentialId),
+        fallbackPrivateKey: null,
+      }
+    }
+    return {
+      connector,
+      fallbackPrivateKey: legacyPrivateKey,
+    }
+  }
+
+  try {
+    const credential = createCredentialRecord({
+      provider: SWARMMDOCK_CREDENTIAL_PROVIDER,
+      name: buildCredentialName(connector.name),
+      apiKey: legacyPrivateKey,
+    })
+    return {
+      connector: persistConnectorSecretMigration(connector, credential.id),
+      fallbackPrivateKey: null,
+    }
+  } catch (error) {
+    if (!options?.allowMigrationFailureFallback) throw error
+    return {
+      connector,
+      fallbackPrivateKey: legacyPrivateKey,
+    }
+  }
+}

package/src/lib/server/connectors/swarmdock-tasks.ts

@@ -0,0 +1,119 @@
+import { genId } from '@/lib/id'
+import { loadTasks, saveTasks } from '@/lib/server/tasks/task-repository'
+import { logActivity } from '@/lib/server/activity/activity-log'
+import type { BoardTask } from '@/types/task'
+
+interface SwarmDockTask {
+  id: string
+  requesterId: string
+  title: string
+  description: string
+  skillRequirements: string[]
+  budgetMax: string
+  deadline: string | null
+}
+
+/**
+ * Create a SwarmClaw BoardTask from a SwarmDock task assignment.
+ * Uses `externalSource` to link back to the SwarmDock task (same pattern as GitHub issue import).
+ */
+export async function createBoardTaskFromAssignment(
+  task: SwarmDockTask,
+  agentId: string,
+  connectorId: string,
+  apiUrl: string,
+): Promise<string> {
+  const tasks = loadTasks() as Record<string, BoardTask>
+  const id = genId()
+  const now = Date.now()
+
+  const boardTask: BoardTask = {
+    id,
+    title: task.title,
+    description: task.description,
+    status: 'running',
+    agentId,
+    createdAt: now,
+    updatedAt: now,
+    startedAt: now,
+    lastActivityAt: now,
+    sourceType: 'import',
+    externalSource: {
+      source: 'swarmdock',
+      id: task.id,
+      state: 'in_progress',
+      url: `${apiUrl}/tasks/${task.id}`,
+    },
+    tags: task.skillRequirements,
+    objective: task.description,
+    followupConnectorId: connectorId,
+  }
+
+  if (task.deadline) {
+    boardTask.dueAt = new Date(task.deadline).getTime()
+  }
+
+  tasks[id] = boardTask
+  saveTasks(tasks)
+
+  logActivity({
+    entityType: 'task',
+    entityId: id,
+    action: 'created',
+    actor: 'system',
+    summary: `SwarmDock task assigned: "${task.title}"`,
+  })
+
+  return id
+}
+
+/**
+ * Update a SwarmClaw BoardTask based on a SwarmDock SSE event.
+ */
+export async function updateBoardTaskFromEvent(
+  swarmdockTaskId: string,
+  eventType: string,
+): Promise<void> {
+  const tasks = loadTasks() as Record<string, BoardTask>
+  const boardTask = Object.values(tasks).find(
+    (t) => t.externalSource?.source === 'swarmdock' && t.externalSource.id === swarmdockTaskId,
+  )
+  if (!boardTask) return
+
+  const now = Date.now()
+
+  switch (eventType) {
+    case 'task.completed':
+      boardTask.status = 'completed'
+      boardTask.completedAt = now
+      boardTask.checkoutRunId = null
+      break
+    case 'task.submitted':
+      // Results submitted, waiting for approval on SwarmDock
+      if (boardTask.externalSource) boardTask.externalSource.state = 'review'
+      break
+    case 'task.cancelled':
+      boardTask.status = 'cancelled'
+      boardTask.checkoutRunId = null
+      break
+    case 'task.failed':
+      boardTask.status = 'failed'
+      boardTask.checkoutRunId = null
+      break
+  }
+
+  boardTask.updatedAt = now
+  boardTask.lastActivityAt = now
+  saveTasks(tasks)
+}
+
+/**
+ * Find a SwarmClaw BoardTask ID by its SwarmDock task ID.
+ */
+export function findBoardTaskBySwarmdockId(swarmdockTaskId: string): string | null {
+  const tasks = loadTasks() as Record<string, BoardTask>
+  const task = Object.values(tasks).find(
+    (t) => t.externalSource?.source === 'swarmdock' && t.externalSource.id === swarmdockTaskId,
+  )
+  return task?.id || null
+}