@swarmclawai/swarmclaw 1.2.8 → 1.2.9

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
+}

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

@@ -0,0 +1,255 @@
+import { log } from '@/lib/server/logger'
+import { hmrSingleton } from '@/lib/shared-utils'
+import { logActivity } from '@/lib/server/activity/activity-log'
+import type { Connector, InboundMessage } from '@/types/connector'
+import type { PlatformConnector, ConnectorInstance } from '@/lib/server/connectors/types'
+import { createBoardTaskFromAssignment, updateBoardTaskFromEvent, findBoardTaskBySwarmdockId } from './swarmdock-tasks'
+import { shouldAutoBid, submitAutoBid } from './swarmdock-bidding'
+import type { TaskSubmitInput } from '@swarmdock/shared'
+
+const TAG = 'swarmdock'
+
+// SDK types inlined until @swarmdock/sdk is built and linked
+interface SwarmDockTask {
+  id: string
+  requesterId: string
+  assigneeId: string | null
+  title: string
+  description: string
+  skillRequirements: string[]
+  budgetMax: string
+  status: string
+  deadline: string | null
+}
+
+interface SwarmDockSSEEvent {
+  type: string
+  data: Record<string, unknown>
+  timestamp: string
+}
+
+interface SwarmDockConfig {
+  apiUrl: string
+  walletAddress: string
+  agentDescription: string
+  skills: string
+  autoDiscover: boolean
+  maxBudget: string
+}
+
+function parseConfig(connector: Connector): SwarmDockConfig {
+  const c = connector.config || {}
+  return {
+    apiUrl: c.apiUrl || 'https://api.swarmdock.ai',
+    walletAddress: c.walletAddress || '',
+    agentDescription: c.agentDescription || connector.name || '',
+    skills: c.skills || '',
+    autoDiscover: c.autoDiscover === 'true',
+    maxBudget: c.maxBudget || '0',
+  }
+}
+
+function buildTaskPrompt(task: SwarmDockTask): string {
+  const lines: string[] = [
+    `# SwarmDock Task: ${task.title}`,
+    '',
+    task.description,
+    '',
+    `**Required Skills:** ${task.skillRequirements.join(', ')}`,
+    `**Budget:** ${formatUsdc(task.budgetMax)}`,
+  ]
+  if (task.deadline) lines.push(`**Deadline:** ${task.deadline}`)
+  lines.push('', 'Complete this task and provide your deliverables. Your response will be submitted as the task result on the SwarmDock marketplace.')
+  return lines.join('\n')
+}
+
+function formatUsdc(microUnits: string): string {
+  const cents = BigInt(microUnits)
+  const dollars = Number(cents) / 1_000_000
+  return `$${dollars.toFixed(2)} USDC`
+}
+
+export async function submitSwarmdockTaskResult(
+  client: { tasks: { submit: (taskId: string, input: TaskSubmitInput) => Promise<unknown> } },
+  swarmdockTaskId: string,
+  text: string,
+): Promise<void> {
+  const payload: TaskSubmitInput = {
+    artifacts: [{ type: 'text/markdown', content: text }],
+    files: [],
+  }
+  await client.tasks.submit(swarmdockTaskId, payload)
+}
+
+/** Runtime state: maps SwarmDock task IDs → SwarmClaw BoardTask IDs */
+const taskIdMap = hmrSingleton('__swarmclaw_swarmdock_task_map__', () => new Map<string, string>())
+
+const swarmdock: PlatformConnector = {
+  async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
+    const config = parseConfig(connector)
+    const connectorId = connector.id
+    const agentId = connector.agentId || ''
+    const privateKey = _botToken || ''
+
+    if (!privateKey) throw new Error('SwarmDock connector requires an Ed25519 private key credential')
+    if (!config.walletAddress) throw new Error('SwarmDock connector requires a Base L2 wallet address in config')
+
+    // Dynamic import of the SDK (must be built and linked first)
+    let SwarmDockClient: typeof import('@swarmdock/sdk').SwarmDockClient
+    try {
+      const sdk = await import('@swarmdock/sdk')
+      SwarmDockClient = sdk.SwarmDockClient
+    } catch {
+      throw new Error('SwarmDock SDK (@swarmdock/sdk) is not installed. Run: npm install @swarmdock/sdk')
+    }
+
+    const client = new SwarmDockClient({
+      baseUrl: config.apiUrl,
+      privateKey,
+    })
+
+    // Register agent on SwarmDock (Ed25519 challenge-response)
+    const skillList = config.skills
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean)
+      .map((skillId) => ({
+        skillId,
+        skillName: skillId.replace(/-/g, ' '),
+        description: `${skillId} capability`,
+        category: skillId,
+        basePrice: '1000000', // $1.00 default
+      }))
+
+    log.info(TAG, `Registering agent "${connector.name}" on SwarmDock at ${config.apiUrl}`)
+    const registration = await client.register({
+      displayName: connector.name,
+      description: config.agentDescription,
+      framework: 'swarmclaw',
+      walletAddress: config.walletAddress,
+      skills: skillList,
+    })
+    log.info(TAG, `Registered as ${registration.agent.did} (trust level ${registration.agent.trustLevel})`)
+
+    logActivity({
+      entityType: 'connector',
+      entityId: connectorId,
+      action: 'swarmdock-registered',
+      actor: 'system',
+      summary: `Agent "${connector.name}" registered on SwarmDock as ${registration.agent.did}`,
+    })
+
+    // Set up SSE event stream
+    let alive = true
+
+    const handleSSEEvent = async (event: SwarmDockSSEEvent) => {
+      if (!alive) return
+      try {
+        switch (event.type) {
+          case 'task.created': {
+            if (!config.autoDiscover) break
+            const task = event.data as unknown as SwarmDockTask
+            if (shouldAutoBid(task, config)) {
+              await submitAutoBid(client, task.id, config)
+              logActivity({
+                entityType: 'connector',
+                entityId: connectorId,
+                action: 'swarmdock-bid',
+                actor: 'system',
+                summary: `Auto-bid on SwarmDock task: "${task.title}"`,
+              })
+            }
+            break
+          }
+
+          case 'task.assigned': {
+            const task = event.data as unknown as SwarmDockTask
+            if (!task.assigneeId) break
+
+            // Signal work started on SwarmDock
+            try { await client.tasks.start(task.id) } catch {}
+
+            // Create a BoardTask in SwarmClaw
+            const boardTaskId = await createBoardTaskFromAssignment(task, agentId, connectorId, config.apiUrl)
+            taskIdMap.set(task.id, boardTaskId)
+
+            // Dispatch as inbound message to the assigned agent
+            const inbound: InboundMessage = {
+              platform: 'swarmdock',
+              channelId: `swarmdock-task:${task.id}`,
+              channelName: `SwarmDock: ${task.title}`,
+              senderId: task.requesterId,
+              senderName: `SwarmDock Requester`,
+              text: buildTaskPrompt(task),
+              messageId: task.id,
+            }
+            await onMessage(inbound)
+            break
+          }
+
+          case 'task.completed':
+          case 'task.cancelled':
+          case 'task.failed': {
+            const taskId = (event.data as Record<string, string>).taskId
+            if (taskId) await updateBoardTaskFromEvent(taskId, event.type)
+            break
+          }
+
+          case 'payment.released': {
+            const data = event.data as Record<string, string>
+            logActivity({
+              entityType: 'connector',
+              entityId: connectorId,
+              action: 'swarmdock-payment',
+              actor: 'system',
+              summary: `Payment received: ${formatUsdc(data.amount || '0')} for task ${data.taskId}`,
+            })
+            break
+          }
+        }
+      } catch (err) {
+        log.error(TAG, `Error handling SSE event ${event.type}: ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }
+
+    client.events.subscribe(handleSSEEvent as (event: unknown) => void)
+
+    // Token refresh heartbeat (23h, token lasts 24h)
+    const heartbeatInterval = setInterval(async () => {
+      try {
+        await client.heartbeat()
+        log.debug(TAG, 'SwarmDock token refreshed')
+      } catch (err) {
+        log.error(TAG, `SwarmDock heartbeat failed: ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }, 23 * 60 * 60 * 1000)
+
+    return {
+      connector,
+
+      stop: async () => {
+        alive = false
+        clearInterval(heartbeatInterval)
+        client.events.unsubscribe()
+        log.info(TAG, 'SwarmDock connector stopped')
+      },
+
+      sendMessage: async (channelId: string, text: string) => {
+        // channelId format: "swarmdock-task:{taskId}"
+        const swarmdockTaskId = channelId.replace('swarmdock-task:', '')
+        if (!swarmdockTaskId) return
+
+        await submitSwarmdockTaskResult(client, swarmdockTaskId, text)
+        log.info(TAG, `Submitted results for SwarmDock task ${swarmdockTaskId}`)
+
+        if (findBoardTaskBySwarmdockId(swarmdockTaskId)) {
+          await updateBoardTaskFromEvent(swarmdockTaskId, 'task.submitted')
+        }
+
+        return { messageId: swarmdockTaskId }
+      },
+    }
+  },
+}
+
+export default swarmdock