@swarmclawai/swarmclaw 0.2.0

package/src/lib/server/clawhub-client.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+
+let originalFetch: typeof globalThis.fetch
+let originalEnv: string | undefined
+
+beforeEach(() => {
+  originalFetch = globalThis.fetch
+  originalEnv = process.env.CLAWHUB_API_URL
+  delete process.env.CLAWHUB_API_URL
+})
+
+afterEach(() => {
+  globalThis.fetch = originalFetch
+  if (originalEnv !== undefined) {
+    process.env.CLAWHUB_API_URL = originalEnv
+  } else {
+    delete process.env.CLAWHUB_API_URL
+  }
+})
+
+describe('searchClawHub', () => {
+  // Module caches CLAWHUB_BASE_URL at import time, so we need dynamic import
+  // after setting env. However the default is baked in at module load.
+  // We'll test the default URL by importing once.
+
+  it('constructs correct URL with query params and returns parsed JSON', async () => {
+    const mockData = { skills: [{ id: 's1', name: 'test-skill' }], total: 1, page: 1 }
+    let capturedUrl = ''
+
+    globalThis.fetch = async (input: RequestInfo | URL) => {
+      capturedUrl = String(input)
+      return new Response(JSON.stringify(mockData), { status: 200 })
+    }
+
+    const { searchClawHub } = await import('./clawhub-client.ts')
+    const result = await searchClawHub('hello world', 2, 10)
+
+    assert.ok(capturedUrl.includes('/skills?q=hello%20world&page=2&limit=10'))
+    assert.deepStrictEqual(result.skills, mockData.skills)
+    assert.equal(result.total, 1)
+    assert.equal(result.page, 1)
+  })
+
+  it('uses default page=1 and limit=20', async () => {
+    let capturedUrl = ''
+
+    globalThis.fetch = async (input: RequestInfo | URL) => {
+      capturedUrl = String(input)
+      return new Response(JSON.stringify({ skills: [], total: 0, page: 1 }), { status: 200 })
+    }
+
+    const { searchClawHub } = await import('./clawhub-client.ts')
+    await searchClawHub('test')
+
+    assert.ok(capturedUrl.includes('page=1'))
+    assert.ok(capturedUrl.includes('limit=20'))
+  })
+
+  it('uses default base URL when CLAWHUB_API_URL is not set', async () => {
+    let capturedUrl = ''
+
+    globalThis.fetch = async (input: RequestInfo | URL) => {
+      capturedUrl = String(input)
+      return new Response(JSON.stringify({ skills: [], total: 0, page: 1 }), { status: 200 })
+    }
+
+    const { searchClawHub } = await import('./clawhub-client.ts')
+    await searchClawHub('q')
+
+    assert.ok(capturedUrl.startsWith('https://clawhub.openclaw.dev/api/skills'))
+  })
+
+  it('returns empty results on non-200 response', async () => {
+    globalThis.fetch = async () => {
+      return new Response('Not Found', { status: 404 })
+    }
+
+    const { searchClawHub } = await import('./clawhub-client.ts')
+    const result = await searchClawHub('fail', 3)
+
+    assert.deepStrictEqual(result.skills, [])
+    assert.equal(result.total, 0)
+    assert.equal(result.page, 3)
+  })
+
+  it('returns empty results on fetch network error', async () => {
+    globalThis.fetch = async () => {
+      throw new Error('network failure')
+    }
+
+    const { searchClawHub } = await import('./clawhub-client.ts')
+    const result = await searchClawHub('err', 5)
+
+    assert.deepStrictEqual(result.skills, [])
+    assert.equal(result.total, 0)
+    assert.equal(result.page, 5)
+  })
+
+  it('encodes special characters in query', async () => {
+    let capturedUrl = ''
+
+    globalThis.fetch = async (input: RequestInfo | URL) => {
+      capturedUrl = String(input)
+      return new Response(JSON.stringify({ skills: [], total: 0, page: 1 }), { status: 200 })
+    }
+
+    const { searchClawHub } = await import('./clawhub-client.ts')
+    await searchClawHub('a&b=c')
+
+    assert.ok(capturedUrl.includes('q=a%26b%3Dc'))
+  })
+})
+
+describe('fetchSkillContent', () => {
+  it('fetches raw URL and returns text content', async () => {
+    const content = '# Skill README\nHello world'
+
+    globalThis.fetch = async (input: RequestInfo | URL) => {
+      assert.equal(String(input), 'https://example.com/raw/skill.md')
+      return new Response(content, { status: 200 })
+    }
+
+    const { fetchSkillContent } = await import('./clawhub-client.ts')
+    const result = await fetchSkillContent('https://example.com/raw/skill.md')
+
+    assert.equal(result, content)
+  })
+
+  it('throws on non-200 response', async () => {
+    globalThis.fetch = async () => {
+      return new Response('Server Error', { status: 500 })
+    }
+
+    const { fetchSkillContent } = await import('./clawhub-client.ts')
+
+    await assert.rejects(
+      () => fetchSkillContent('https://example.com/raw/fail.md'),
+      (err: Error) => {
+        assert.ok(err.message.includes('500'))
+        return true
+      }
+    )
+  })
+
+  it('throws on network error', async () => {
+    globalThis.fetch = async () => {
+      throw new TypeError('fetch failed')
+    }
+
+    const { fetchSkillContent } = await import('./clawhub-client.ts')
+
+    await assert.rejects(
+      () => fetchSkillContent('https://down.example.com/skill.md'),
+      (err: Error) => {
+        assert.ok(err.message.includes('fetch failed'))
+        return true
+      }
+    )
+  })
+})

package/src/lib/server/clawhub-client.ts

@@ -0,0 +1,26 @@
+import type { ClawHubSkill } from '@/types'
+
+export interface ClawHubSearchResult {
+  skills: ClawHubSkill[]
+  total: number
+  page: number
+}
+
+const CLAWHUB_BASE_URL = process.env.CLAWHUB_API_URL || 'https://clawhub.openclaw.dev/api'
+
+export async function searchClawHub(query: string, page = 1, limit = 20): Promise<ClawHubSearchResult> {
+  try {
+    const url = `${CLAWHUB_BASE_URL}/skills?q=${encodeURIComponent(query)}&page=${page}&limit=${limit}`
+    const res = await fetch(url)
+    if (!res.ok) throw new Error(`ClawHub responded with ${res.status}`)
+    return await res.json()
+  } catch {
+    return { skills: [], total: 0, page }
+  }
+}
+
+export async function fetchSkillContent(rawUrl: string): Promise<string> {
+  const res = await fetch(rawUrl)
+  if (!res.ok) throw new Error(`Failed to fetch skill content: ${res.status}`)
+  return res.text()
+}

package/src/lib/server/connectors/connector-routing.test.ts

@@ -0,0 +1,243 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { getPlatform, isNoMessage, formatMediaLine, formatInboundUserText } from './manager.ts'
+import { handleSignalEvent } from './signal.ts'
+import type { PlatformConnector } from './types.ts'
+import type { InboundMessage, InboundMedia } from './types.ts'
+
+// ---------------------------------------------------------------------------
+// 1. Connector module resolution (getPlatform)
+// ---------------------------------------------------------------------------
+describe('getPlatform — connector module resolution', () => {
+  const newPlatforms = ['matrix', 'googlechat', 'teams', 'signal'] as const
+
+  for (const name of newPlatforms) {
+    it(`returns a valid module for "${name}"`, async () => {
+      const mod = await getPlatform(name)
+      assert.ok(mod, `getPlatform("${name}") should return a module`)
+    })
+
+    it(`"${name}" module has a start function (PlatformConnector)`, async () => {
+      const mod: PlatformConnector = await getPlatform(name)
+      assert.equal(typeof mod.start, 'function')
+    })
+  }
+
+  // Legacy platforms still resolve
+  for (const name of ['discord', 'telegram', 'slack', 'whatsapp', 'openclaw'] as const) {
+    it(`resolves legacy platform "${name}"`, async () => {
+      const mod = await getPlatform(name)
+      assert.equal(typeof mod.start, 'function')
+    })
+  }
+
+  it('throws on unknown platform', async () => {
+    await assert.rejects(() => getPlatform('nonexistent'), {
+      message: 'Unknown platform: nonexistent',
+    })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 2. Signal — handleSignalEvent message parsing
+// ---------------------------------------------------------------------------
+describe('handleSignalEvent — Signal stdio message parsing', () => {
+  function makeFakeConnector() {
+    return {
+      id: 'sig-test',
+      name: 'Signal Test',
+      platform: 'signal',
+      agentId: 'agent-1',
+      credentialId: null,
+      config: { phoneNumber: '+15551234567', signalCliPath: 'signal-cli', signalCliMode: 'http' },
+      isEnabled: true,
+      status: 'running' as const,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    } as any
+  }
+
+  it('parses envelope with dataMessage.message field', async () => {
+    const received: InboundMessage[] = []
+    const connector = makeFakeConnector()
+    const event = {
+      envelope: {
+        source: '+15559876543',
+        sourceName: 'Alice',
+        dataMessage: { message: 'Hello from Signal' },
+      },
+    }
+    await handleSignalEvent(event, connector, async (msg) => {
+      received.push(msg)
+      return 'NO_MESSAGE'
+    })
+    assert.equal(received.length, 1)
+    assert.equal(received[0].text, 'Hello from Signal')
+    assert.equal(received[0].senderId, '+15559876543')
+    assert.equal(received[0].senderName, 'Alice')
+    assert.equal(received[0].platform, 'signal')
+    assert.equal(received[0].channelId, '+15559876543') // DM uses sender as channel
+  })
+
+  it('parses envelope with dataMessage.body field', async () => {
+    const received: InboundMessage[] = []
+    const connector = makeFakeConnector()
+    const event = {
+      envelope: {
+        source: '+15550001111',
+        sourceName: 'Bob',
+        dataMessage: { body: 'Body variant' },
+      },
+    }
+    await handleSignalEvent(event, connector, async (msg) => {
+      received.push(msg)
+      return 'NO_MESSAGE'
+    })
+    assert.equal(received.length, 1)
+    assert.equal(received[0].text, 'Body variant')
+  })
+
+  it('uses groupId as channelId when present', async () => {
+    const received: InboundMessage[] = []
+    const connector = makeFakeConnector()
+    const event = {
+      envelope: {
+        source: '+15550001111',
+        sourceName: 'Carol',
+        dataMessage: {
+          message: 'Group msg',
+          groupInfo: { groupId: 'grp-abc123' },
+        },
+      },
+    }
+    await handleSignalEvent(event, connector, async (msg) => {
+      received.push(msg)
+      return 'NO_MESSAGE'
+    })
+    assert.equal(received[0].channelId, 'grp-abc123')
+    assert.equal(received[0].channelName, 'group:grp-abc123')
+  })
+
+  it('handles flat event without .envelope wrapper', async () => {
+    const received: InboundMessage[] = []
+    const connector = makeFakeConnector()
+    // signal-cli can emit flat objects (envelope IS the top-level)
+    const event = {
+      source: '+15552222222',
+      sourceName: 'Dave',
+      dataMessage: { message: 'Flat format' },
+    }
+    await handleSignalEvent(event, connector, async (msg) => {
+      received.push(msg)
+      return 'NO_MESSAGE'
+    })
+    assert.equal(received.length, 1)
+    assert.equal(received[0].text, 'Flat format')
+    assert.equal(received[0].senderId, '+15552222222')
+  })
+
+  it('ignores events without dataMessage', async () => {
+    const received: InboundMessage[] = []
+    const connector = makeFakeConnector()
+    // Typing indicator — no dataMessage
+    const event = { envelope: { source: '+15551111111', typingMessage: { action: 'STARTED' } } }
+    await handleSignalEvent(event, connector, async (msg) => {
+      received.push(msg)
+      return 'ok'
+    })
+    assert.equal(received.length, 0)
+  })
+
+  it('ignores events where dataMessage has no message or body', async () => {
+    const received: InboundMessage[] = []
+    const connector = makeFakeConnector()
+    // Receipt with empty dataMessage
+    const event = { envelope: { source: '+15551111111', dataMessage: {} } }
+    await handleSignalEvent(event, connector, async (msg) => {
+      received.push(msg)
+      return 'ok'
+    })
+    assert.equal(received.length, 0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 3. isNoMessage helper
+// ---------------------------------------------------------------------------
+describe('isNoMessage', () => {
+  it('matches exact sentinel', () => {
+    assert.ok(isNoMessage('NO_MESSAGE'))
+  })
+  it('matches case-insensitive', () => {
+    assert.ok(isNoMessage('no_message'))
+    assert.ok(isNoMessage('No_Message'))
+  })
+  it('trims whitespace', () => {
+    assert.ok(isNoMessage('  NO_MESSAGE  \n'))
+  })
+  it('rejects non-sentinel text', () => {
+    assert.ok(!isNoMessage('hello'))
+    assert.ok(!isNoMessage('NO_MESSAGE extra'))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 4. formatMediaLine
+// ---------------------------------------------------------------------------
+describe('formatMediaLine', () => {
+  it('formats media with URL', () => {
+    const media: InboundMedia = { type: 'image', fileName: 'photo.jpg', sizeBytes: 2048, url: '/uploads/photo.jpg' }
+    const line = formatMediaLine(media)
+    assert.equal(line, '- IMAGE: photo.jpg (2 KB) -> /uploads/photo.jpg')
+  })
+
+  it('formats media without URL', () => {
+    const media: InboundMedia = { type: 'document', mimeType: 'application/pdf', sizeBytes: 512 }
+    const line = formatMediaLine(media)
+    assert.equal(line, '- DOCUMENT: application/pdf (1 KB)')
+  })
+
+  it('falls back to "attachment" when no fileName or mimeType', () => {
+    const media: InboundMedia = { type: 'file' }
+    const line = formatMediaLine(media)
+    assert.equal(line, '- FILE: attachment')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 5. formatInboundUserText
+// ---------------------------------------------------------------------------
+describe('formatInboundUserText', () => {
+  it('formats basic text message', () => {
+    const msg = { platform: 'signal', channelId: 'ch1', senderId: 's1', senderName: 'Alice', text: 'Hello' } as InboundMessage
+    assert.equal(formatInboundUserText(msg), '[Alice] Hello')
+  })
+
+  it('handles empty text with just sender name', () => {
+    const msg = { platform: 'signal', channelId: 'ch1', senderId: 's1', senderName: 'Bob', text: '' } as InboundMessage
+    assert.equal(formatInboundUserText(msg), '[Bob]')
+  })
+
+  it('appends media lines', () => {
+    const msg: InboundMessage = {
+      platform: 'signal', channelId: 'ch1', senderId: 's1', senderName: 'Eve', text: 'Check this',
+      media: [{ type: 'image', fileName: 'cat.png', url: '/cat.png' }],
+    }
+    const result = formatInboundUserText(msg)
+    assert.ok(result.includes('[Eve] Check this'))
+    assert.ok(result.includes('Media received:'))
+    assert.ok(result.includes('- IMAGE: cat.png'))
+  })
+
+  it('truncates media list at 6 with overflow note', () => {
+    const media: InboundMedia[] = Array.from({ length: 8 }, (_, i) => ({
+      type: 'file' as const, fileName: `f${i}.txt`,
+    }))
+    const msg: InboundMessage = {
+      platform: 'signal', channelId: 'ch1', senderId: 's1', senderName: 'Fran', text: 'files',
+      media,
+    }
+    const result = formatInboundUserText(msg)
+    assert.ok(result.includes('...and 2 more attachment(s)'))
+  })
+})

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

@@ -0,0 +1,116 @@
+import { Client, GatewayIntentBits, Events, Partials, AttachmentBuilder } from 'discord.js'
+import fs from 'fs'
+import path from 'path'
+import type { Connector } from '@/types'
+import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
+import { inferInboundMediaType, mimeFromPath, isImageMime } from './media'
+import { isNoMessage } from './manager'
+
+const discord: PlatformConnector = {
+  async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
+    const client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages,
+      ],
+      partials: [Partials.Channel], // Required to receive DM events
+    })
+
+    // Optional: restrict to specific channels
+    const allowedChannels = connector.config.channelIds
+      ? connector.config.channelIds.split(',').map((s) => s.trim()).filter(Boolean)
+      : null
+
+    client.on(Events.MessageCreate, async (message) => {
+      console.log(`[discord] Message from ${message.author.username} in ${message.channel.type === 1 ? 'DM' : '#' + ('name' in message.channel ? (message.channel as any).name : message.channelId)}: ${message.content.slice(0, 80)}`)
+      // Ignore bot messages
+      if (message.author.bot) return
+
+      // Filter by allowed channels if configured
+      if (allowedChannels && !allowedChannels.includes(message.channelId)) return
+
+      const attachmentList = Array.from(message.attachments.values())
+      const media = attachmentList.map((a) => ({
+        type: inferInboundMediaType(a.contentType || undefined, a.name || undefined),
+        fileName: a.name || undefined,
+        mimeType: a.contentType || undefined,
+        sizeBytes: a.size || undefined,
+        url: a.url || undefined,
+      }))
+      const firstImage = media.find((m) => m.type === 'image' && m.url)
+
+      const inbound: InboundMessage = {
+        platform: 'discord',
+        channelId: message.channelId,
+        channelName: 'name' in message.channel ? (message.channel as any).name : 'DM',
+        senderId: message.author.id,
+        senderName: message.author.displayName || message.author.username,
+        text: message.content || (media.length > 0 ? '(media message)' : ''),
+        imageUrl: firstImage?.url,
+        media,
+      }
+
+      try {
+        // Show typing indicator
+        await message.channel.sendTyping()
+        const response = await onMessage(inbound)
+
+        if (isNoMessage(response)) return
+
+        // Discord has a 2000 char limit per message
+        if (response.length <= 2000) {
+          await message.channel.send(response)
+        } else {
+          // Split into chunks
+          const chunks = response.match(/[\s\S]{1,1990}/g) || [response]
+          for (const chunk of chunks) {
+            await message.channel.send(chunk)
+          }
+        }
+      } catch (err: any) {
+        console.error(`[discord] Error handling message:`, err.message)
+        try {
+          await message.reply('Sorry, I encountered an error processing your message.')
+        } catch { /* ignore */ }
+      }
+    })
+
+    await client.login(botToken)
+    console.log(`[discord] Bot logged in as ${client.user?.tag}`)
+
+    return {
+      connector,
+      async sendMessage(channelId, text, options) {
+        const channel = await client.channels.fetch(channelId)
+        if (!channel || !('send' in channel) || typeof (channel as any).send !== 'function') {
+          throw new Error(`Cannot send to channel ${channelId}`)
+        }
+
+        const files: AttachmentBuilder[] = []
+        if (options?.mediaPath) {
+          if (!fs.existsSync(options.mediaPath)) throw new Error(`File not found: ${options.mediaPath}`)
+          files.push(new AttachmentBuilder(options.mediaPath, { name: options.fileName || path.basename(options.mediaPath) }))
+        } else if (options?.imageUrl) {
+          files.push(new AttachmentBuilder(options.imageUrl, { name: options.fileName || 'image.png' }))
+        } else if (options?.fileUrl) {
+          files.push(new AttachmentBuilder(options.fileUrl, { name: options.fileName || 'attachment' }))
+        }
+
+        const content = options?.caption || text || undefined
+        const msg = await (channel as any).send({
+          content: content || (files.length ? undefined : '(empty)'),
+          files: files.length ? files : undefined,
+        })
+        return { messageId: msg.id }
+      },
+      async stop() {
+        client.destroy()
+        console.log(`[discord] Bot disconnected`)
+      },
+    }
+  },
+}
+
+export default discord

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

@@ -0,0 +1,66 @@
+import type { PlatformConnector, ConnectorInstance } from './types'
+
+const googlechat: PlatformConnector = {
+  async start(connector, botToken, _onMessage): Promise<ConnectorInstance> {
+    const pkg = 'googleapis'
+    const { google } = await import(/* webpackIgnore: true */ pkg)
+
+    // Parse service account credentials from botToken
+    let credentials: any
+    try {
+      credentials = JSON.parse(botToken)
+    } catch {
+      throw new Error('botToken must be a valid JSON service account key')
+    }
+
+    const auth = new google.auth.GoogleAuth({
+      credentials,
+      scopes: ['https://www.googleapis.com/auth/chat.bot'],
+    })
+
+    const chat = google.chat({ version: 'v1', auth })
+
+    // Optional: restrict to specific spaces
+    const allowedSpaces = connector.config.spaceIds
+      ? connector.config.spaceIds.split(',').map((s: string) => s.trim()).filter(Boolean)
+      : null
+
+    // Google Chat requires a webhook or Pub/Sub for real-time inbound messages.
+    // This connector supports outbound messaging. For inbound messages, configure
+    // a webhook endpoint at /api/connectors/[id]/webhook that POSTs events here.
+    // Polling is not supported by the Google Chat API for bot messages.
+    let stopped = false
+
+    console.log(`[googlechat] Bot authenticated via service account`)
+    if (allowedSpaces) {
+      console.log(`[googlechat] Filtering to spaces: ${allowedSpaces.join(', ')}`)
+    }
+    console.log(`[googlechat] Note: Inbound messages require a webhook or Pub/Sub subscription. This connector supports outbound sends.`)
+
+    return {
+      connector,
+      async sendMessage(channelId, text) {
+        if (stopped) throw new Error('Connector is stopped')
+
+        // channelId should be a space name like "spaces/AAAA"
+        const parent = channelId.startsWith('spaces/') ? channelId : `spaces/${channelId}`
+
+        if (allowedSpaces && !allowedSpaces.some((s) => parent.includes(s))) {
+          throw new Error(`Space ${parent} not in allowed spaceIds`)
+        }
+
+        const res = await chat.spaces.messages.create({
+          parent,
+          requestBody: { text },
+        })
+        return { messageId: res.data.name || undefined }
+      },
+      async stop() {
+        stopped = true
+        console.log(`[googlechat] Bot disconnected`)
+      },
+    }
+  },
+}
+
+export default googlechat