@swarmclawai/swarmclaw 0.4.0 → 0.4.5

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

@@ -0,0 +1,256 @@
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const DEFAULT_DATA_DIR = path.join(process.cwd(), 'data')
+const STORE_VERSION = 1
+const PENDING_TTL_MS = 24 * 60 * 60 * 1000
+const MAX_PENDING_PER_CONNECTOR = 100
+const PAIR_CODE_LENGTH = 8
+const PAIR_CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'
+
+function resolveStorePath(): string {
+  const dataDir = process.env.DATA_DIR || DEFAULT_DATA_DIR
+  return path.join(dataDir, 'connectors', 'pairing-store.json')
+}
+
+export type PairingPolicy = 'open' | 'allowlist' | 'pairing' | 'disabled'
+
+export interface PairingRequest {
+  code: string
+  senderId: string
+  senderName?: string
+  channelId?: string
+  createdAt: number
+  updatedAt: number
+}
+
+interface ConnectorPairingState {
+  allowedSenderIds: string[]
+  pending: PairingRequest[]
+}
+
+interface PairingStore {
+  version: number
+  connectors: Record<string, ConnectorPairingState>
+}
+
+function normalizeSenderId(value: string): string {
+  return value.trim().toLowerCase()
+}
+
+function dedupe(items: string[]): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const item of items) {
+    const normalized = normalizeSenderId(item)
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    out.push(normalized)
+  }
+  return out
+}
+
+function prunePending(entries: PairingRequest[]): PairingRequest[] {
+  const now = Date.now()
+  return entries.filter((entry) => {
+    if (!entry?.code || !entry?.senderId) return false
+    if (!Number.isFinite(entry.createdAt) || !Number.isFinite(entry.updatedAt)) return false
+    return (now - entry.updatedAt) <= PENDING_TTL_MS
+  }).slice(-MAX_PENDING_PER_CONNECTOR)
+}
+
+function emptyStore(): PairingStore {
+  return { version: STORE_VERSION, connectors: {} }
+}
+
+function loadStore(): PairingStore {
+  const storePath = resolveStorePath()
+  try {
+    if (!fs.existsSync(storePath)) return emptyStore()
+    const raw = fs.readFileSync(storePath, 'utf8')
+    const parsed = JSON.parse(raw) as PairingStore
+    if (!parsed || typeof parsed !== 'object' || typeof parsed.connectors !== 'object') {
+      return emptyStore()
+    }
+
+    const normalized: PairingStore = emptyStore()
+    for (const [connectorId, value] of Object.entries(parsed.connectors || {})) {
+      const state = value as Partial<ConnectorPairingState>
+      const allowedSenderIds = dedupe(Array.isArray(state.allowedSenderIds) ? state.allowedSenderIds.map(String) : [])
+      const pending = prunePending(Array.isArray(state.pending) ? state.pending as PairingRequest[] : [])
+      normalized.connectors[connectorId] = { allowedSenderIds, pending }
+    }
+    return normalized
+  } catch {
+    return emptyStore()
+  }
+}
+
+function saveStore(store: PairingStore): void {
+  const storePath = resolveStorePath()
+  fs.mkdirSync(path.dirname(storePath), { recursive: true })
+  fs.writeFileSync(storePath, `${JSON.stringify(store, null, 2)}\n`)
+}
+
+function ensureConnectorState(store: PairingStore, connectorId: string): ConnectorPairingState {
+  const existing = store.connectors[connectorId]
+  if (existing) {
+    existing.allowedSenderIds = dedupe(existing.allowedSenderIds || [])
+    existing.pending = prunePending(existing.pending || [])
+    return existing
+  }
+  const created: ConnectorPairingState = {
+    allowedSenderIds: [],
+    pending: [],
+  }
+  store.connectors[connectorId] = created
+  return created
+}
+
+function randomPairCode(existing: Set<string>): string {
+  for (let i = 0; i < 256; i++) {
+    const bytes = crypto.randomBytes(PAIR_CODE_LENGTH)
+    let out = ''
+    for (let j = 0; j < PAIR_CODE_LENGTH; j++) {
+      out += PAIR_CODE_ALPHABET[bytes[j] % PAIR_CODE_ALPHABET.length]
+    }
+    if (!existing.has(out)) return out
+  }
+  throw new Error('Unable to generate unique pairing code')
+}
+
+export function parsePairingPolicy(value: unknown, fallback: PairingPolicy = 'open'): PairingPolicy {
+  if (typeof value !== 'string') return fallback
+  const normalized = value.trim().toLowerCase()
+  if (normalized === 'open' || normalized === 'allowlist' || normalized === 'pairing' || normalized === 'disabled') {
+    return normalized
+  }
+  return fallback
+}
+
+export function parseAllowFromCsv(value: unknown): string[] {
+  if (typeof value !== 'string') return []
+  return dedupe(value.split(',').map((item) => item.trim()).filter(Boolean))
+}
+
+export function listStoredAllowedSenders(connectorId: string): string[] {
+  const store = loadStore()
+  const state = ensureConnectorState(store, connectorId)
+  return state.allowedSenderIds.slice()
+}
+
+export function listPendingPairingRequests(connectorId: string): PairingRequest[] {
+  const store = loadStore()
+  const state = ensureConnectorState(store, connectorId)
+  return state.pending.slice().sort((a, b) => b.updatedAt - a.updatedAt)
+}
+
+export function addAllowedSender(connectorId: string, senderId: string): { added: boolean; normalized: string } {
+  const normalized = normalizeSenderId(senderId)
+  if (!normalized) return { added: false, normalized }
+
+  const store = loadStore()
+  const state = ensureConnectorState(store, connectorId)
+  const hasExisting = state.allowedSenderIds.includes(normalized)
+  if (!hasExisting) {
+    state.allowedSenderIds.push(normalized)
+  }
+
+  // Remove any pending requests for the same sender after approval.
+  state.pending = state.pending.filter((entry) => normalizeSenderId(entry.senderId) !== normalized)
+
+  saveStore(store)
+  return { added: !hasExisting, normalized }
+}
+
+export function createOrTouchPairingRequest(params: {
+  connectorId: string
+  senderId: string
+  senderName?: string
+  channelId?: string
+}): { code: string; created: boolean } {
+  const normalized = normalizeSenderId(params.senderId)
+  if (!normalized) throw new Error('senderId is required')
+
+  const store = loadStore()
+  const state = ensureConnectorState(store, params.connectorId)
+  const now = Date.now()
+
+  const existing = state.pending.find((entry) => normalizeSenderId(entry.senderId) === normalized)
+  if (existing) {
+    existing.updatedAt = now
+    existing.senderName = params.senderName || existing.senderName
+    existing.channelId = params.channelId || existing.channelId
+    saveStore(store)
+    return { code: existing.code, created: false }
+  }
+
+  const existingCodes = new Set(state.pending.map((entry) => entry.code.toUpperCase()))
+  const code = randomPairCode(existingCodes)
+  state.pending.push({
+    code,
+    senderId: normalized,
+    senderName: params.senderName,
+    channelId: params.channelId,
+    createdAt: now,
+    updatedAt: now,
+  })
+  state.pending = prunePending(state.pending)
+  saveStore(store)
+  return { code, created: true }
+}
+
+export function approvePairingCode(connectorId: string, codeRaw: string): {
+  ok: boolean
+  senderId?: string
+  senderName?: string
+  reason?: string
+} {
+  const code = codeRaw.trim().toUpperCase()
+  if (!code) return { ok: false, reason: 'Missing code' }
+
+  const store = loadStore()
+  const state = ensureConnectorState(store, connectorId)
+  const idx = state.pending.findIndex((entry) => entry.code.toUpperCase() === code)
+  if (idx < 0) return { ok: false, reason: 'Code not found or expired' }
+
+  const pending = state.pending[idx]
+  state.pending.splice(idx, 1)
+
+  const normalizedSender = normalizeSenderId(pending.senderId)
+  if (!state.allowedSenderIds.includes(normalizedSender)) {
+    state.allowedSenderIds.push(normalizedSender)
+    state.allowedSenderIds = dedupe(state.allowedSenderIds)
+  }
+
+  saveStore(store)
+  return {
+    ok: true,
+    senderId: normalizedSender,
+    senderName: pending.senderName,
+  }
+}
+
+export function isSenderAllowed(params: {
+  connectorId: string
+  senderId: string
+  configAllowFrom?: string[]
+}): boolean {
+  const normalized = normalizeSenderId(params.senderId)
+  if (!normalized) return false
+
+  const configSet = new Set((params.configAllowFrom || []).map((item) => normalizeSenderId(item)).filter(Boolean))
+  if (configSet.has(normalized)) return true
+
+  const store = loadStore()
+  const state = ensureConnectorState(store, params.connectorId)
+  return state.allowedSenderIds.includes(normalized)
+}
+
+export function clearConnectorPairingState(connectorId: string): void {
+  const store = loadStore()
+  if (!store.connectors[connectorId]) return
+  delete store.connectors[connectorId]
+  saveStore(store)
+}

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

@@ -147,6 +147,7 @@ export async function handleSignalEvent(
     senderId: sender,
     senderName: envelope.sourceName || sender,
     text,
+    isGroup: !!groupId,
   }
 
   try {

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

@@ -22,11 +22,11 @@ const teams: PlatformConnector = {
     const conversationReferences = new Map<string, any>()
     let stopped = false
 
-    // Process incoming activities — called from the webhook endpoint
-    // POST /api/connectors/[id]/webhook should pipe req/res through this
-    const processActivity = async (req: any, res: any) => {
+    // Process incoming activities — called from the webhook endpoint.
+    // We use processActivityDirect so this works from Next.js route handlers.
+    const processActivity = async (activity: any) => {
       if (stopped) return
-      await adapter.processActivity(req, res, async (context: any) => {
+      await adapter.processActivityDirect(activity, async (context: any) => {
         if (context.activity.type !== 'message') return
         if (!context.activity.text) return
 
@@ -57,7 +57,7 @@ const teams: PlatformConnector = {
       })
     }
 
-    // Store processActivity on globalThis so the webhook route can access it
+    // Store processActivity on globalThis so the webhook route can access it.
     const handlerKey = `__swarmclaw_teams_handler_${connector.id}__`
     ;(globalThis as any)[handlerKey] = processActivity
 

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

@@ -21,9 +21,11 @@ export interface InboundMessage {
   senderId: string         // platform-specific user ID
   senderName: string       // display name
   text: string
+  isGroup?: boolean
   imageUrl?: string
   media?: InboundMedia[]
   replyToMessageId?: string
+  agentIdOverride?: string
 }
 
 /** A running connector instance */
@@ -50,6 +52,14 @@ export interface ConnectorInstance {
   authenticated?: boolean
   /** Whether the connector has existing saved credentials (WhatsApp only) */
   hasCredentials?: boolean
+  /** Rich messaging: send a reaction emoji to a message */
+  sendReaction?: (channelId: string, messageId: string, emoji: string) => Promise<void>
+  /** Rich messaging: edit a previously sent message */
+  editMessage?: (channelId: string, messageId: string, newText: string) => Promise<void>
+  /** Rich messaging: delete a message */
+  deleteMessage?: (channelId: string, messageId: string) => Promise<void>
+  /** Rich messaging: pin a message */
+  pinMessage?: (channelId: string, messageId: string) => Promise<void>
 }
 
 /** Platform-specific connector implementation */

package/src/lib/server/execution-log.ts

@@ -1,7 +1,7 @@
 import fs from 'fs'
 import path from 'path'
-import crypto from 'crypto'
 import Database from 'better-sqlite3'
+import { genId } from '@/lib/id'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -94,7 +94,7 @@ export function logExecution(
     detail?: Record<string, unknown>
   },
 ): string {
-  const id = crypto.randomBytes(8).toString('hex')
+  const id = genId(8)
   const ts = Date.now()
   try {
     insertStmt().run(
@@ -133,7 +133,7 @@ export function logExecutionBatch(
   const tx = db.transaction(() => {
     for (const e of entries) {
       stmt.run(
-        crypto.randomBytes(8).toString('hex'),
+        genId(8),
         e.sessionId,
         e.runId ?? null,
         e.agentId ?? null,

package/src/lib/server/heartbeat-service.ts

@@ -158,6 +158,7 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
     soul ? `Persona: ${soul.slice(0, 300)}` : '',
     heartbeatFileContent ? `\nHEARTBEAT.md contents:\n${heartbeatFileContent.slice(0, 2000)}` : '',
     recentContext ? `Recent conversation:\n${recentContext}` : '',
+    fallbackPrompt !== DEFAULT_HEARTBEAT_PROMPT ? `\nAgent instructions:\n${fallbackPrompt}` : '',
     '',
     'You are running an autonomous heartbeat tick. Review your goal and recent context.',
     'If there is meaningful work to do toward your goal, use your tools and take action.',
@@ -167,7 +168,6 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
     'To update your goal or plan, include this line in your response:',
     '[AGENT_HEARTBEAT_META]{"goal": "your evolved goal", "status": "progress", "next_action": "what you plan to do next"}',
     'You can evolve your goal as you learn more. Set status to "progress" while working, "ok" when done, "idle" when waiting.',
-    fallbackPrompt !== DEFAULT_HEARTBEAT_PROMPT ? `\nAdditional instructions: ${fallbackPrompt}` : '',
   ].filter(Boolean).join('\n')
 }
 

package/src/lib/server/knowledge-db.test.ts

@@ -104,39 +104,8 @@ function rowToEntry(row: Record<string, unknown>): MemoryEntry {
   }
 }
 
-// ---- Knowledge helpers (mirrors memory-db.ts exported functions) ----
-
-const MEMORY_FTS_STOP_WORDS = new Set([
-  'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from', 'how',
-  'i', 'if', 'in', 'is', 'it', 'of', 'on', 'or', 'that', 'the', 'this',
-  'to', 'was', 'we', 'were', 'what', 'when', 'where', 'which', 'who', 'with',
-  'you', 'your',
-])
-const MAX_FTS_QUERY_TERMS = 6
-const MAX_FTS_TERM_LENGTH = 48
-
-function buildFtsQuery(input: string): string {
-  const tokens = String(input || '')
-    .toLowerCase()
-    .match(/[a-z0-9][a-z0-9._:/-]*/g) || []
-  if (!tokens.length) return ''
-  const unique: string[] = []
-  const seen = new Set<string>()
-  for (const token of tokens) {
-    const term = token.slice(0, MAX_FTS_TERM_LENGTH)
-    if (term.length < 3) continue
-    if (MEMORY_FTS_STOP_WORDS.has(term)) continue
-    if (seen.has(term)) continue
-    seen.add(term)
-    unique.push(term)
-    if (unique.length >= MAX_FTS_QUERY_TERMS) break
-  }
-  if (unique.length === 1) {
-    return unique[0].length >= 5 ? `"${unique[0].replace(/"/g, '')}"` : ''
-  }
-  const selected = unique.slice(0, Math.min(4, MAX_FTS_QUERY_TERMS))
-  return selected.map((term) => `"${term.replace(/"/g, '')}"`).join(' AND ')
-}
+// ---- Knowledge helpers (re-exported from memory-db.ts) ----
+import { buildFtsQuery } from './memory-db'
 
 function addRawMemory(data: {
   agentId?: string | null

package/src/lib/server/main-agent-loop.ts

@@ -1,4 +1,4 @@
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { z } from 'zod'
 import type { GoalContract, MessageToolEvent } from '@/types'
 import { loadSessions, saveSessions, loadAgents, saveAgents, loadTasks, saveTasks } from './storage'
@@ -151,7 +151,7 @@ function appendTimeline(
   const recent = state.timeline.at(-1)
   if (recent && recent.source === source && recent.note === normalizedNote && now - recent.at < 45_000) return
   state.timeline.push({
-    id: `tl_${crypto.randomBytes(4).toString('hex')}`,
+    id: `tl_${genId()}`,
     at: now,
     source,
     note: normalizedNote,
@@ -226,7 +226,7 @@ function normalizeState(raw: any, now = Date.now()): MainLoopState {
         const text = toOneLine(typeof e?.text === 'string' ? e.text : '')
         if (!text) return null
         return {
-          id: typeof e?.id === 'string' && e.id.trim() ? e.id.trim() : `evt_${crypto.randomBytes(3).toString('hex')}`,
+          id: typeof e?.id === 'string' && e.id.trim() ? e.id.trim() : `evt_${genId(3)}`,
           type: typeof e?.type === 'string' && e.type.trim() ? e.type.trim() : 'event',
           text,
           createdAt: typeof e?.createdAt === 'number' ? e.createdAt : now,
@@ -246,7 +246,7 @@ function normalizeState(raw: any, now = Date.now()): MainLoopState {
           ? entry.status
           : undefined
         return {
-          id: typeof entry?.id === 'string' && entry.id.trim() ? entry.id.trim() : `tl_${crypto.randomBytes(3).toString('hex')}`,
+          id: typeof entry?.id === 'string' && entry.id.trim() ? entry.id.trim() : `tl_${genId(3)}`,
           at: typeof entry?.at === 'number' ? entry.at : now,
           source: typeof entry?.source === 'string' && entry.source.trim() ? entry.source.trim() : 'event',
           note,
@@ -303,7 +303,7 @@ function appendEvent(state: MainLoopState, type: string, text: string, now = Dat
     return false
   }
   state.pendingEvents.push({
-    id: `evt_${crypto.randomBytes(4).toString('hex')}`,
+    id: `evt_${genId()}`,
     type,
     text: normalizedText,
     createdAt: now,
@@ -517,7 +517,7 @@ function upsertMissionTask(session: any, state: MainLoopState, now: number): str
   ].filter(Boolean).join('\n')
 
   if (!task) {
-    const id = crypto.randomBytes(4).toString('hex')
+    const id = genId()
     task = {
       id,
       title,

package/src/lib/server/memory-db.ts

@@ -1,7 +1,7 @@
 import Database from 'better-sqlite3'
 import path from 'path'
-import crypto from 'crypto'
 import fs from 'fs'
+import { genId } from '@/lib/id'
 import type { MemoryEntry, FileReference, MemoryImage, MemoryReference } from '@/types'
 import { getEmbedding, cosineSimilarity, serializeEmbedding, deserializeEmbedding } from './embeddings'
 import { loadSettings } from './storage'
@@ -20,12 +20,12 @@ const IMAGES_DIR = path.join(DATA_DIR, 'memory-images')
 
 const MAX_IMAGE_INPUT_BYTES = 10 * 1024 * 1024 // 10MB
 const IMAGE_EXT_WHITELIST = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.tiff'])
-const MAX_FTS_QUERY_TERMS = 6
-const MAX_FTS_TERM_LENGTH = 48
+export const MAX_FTS_QUERY_TERMS = 6
+export const MAX_FTS_TERM_LENGTH = 48
 const MAX_FTS_RESULT_ROWS = 30
 const MAX_MERGED_RESULTS = 50
 
-const MEMORY_FTS_STOP_WORDS = new Set([
+export const MEMORY_FTS_STOP_WORDS = new Set([
   'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from', 'how',
   'i', 'if', 'in', 'is', 'it', 'of', 'on', 'or', 'that', 'the', 'this',
   'to', 'was', 'we', 'were', 'what', 'when', 'where', 'which', 'who', 'with',
@@ -184,7 +184,7 @@ function canonicalText(value: unknown): string {
     .trim()
 }
 
-function buildFtsQuery(input: string): string {
+export function buildFtsQuery(input: string): string {
   const tokens = String(input || '')
     .toLowerCase()
     .match(/[a-z0-9][a-z0-9._:/-]*/g) || []
@@ -546,7 +546,7 @@ function initDb() {
 
   return {
     add(data: Omit<MemoryEntry, 'id' | 'createdAt' | 'updatedAt'>): MemoryEntry {
-      const id = crypto.randomBytes(6).toString('hex')
+      const id = genId(6)
       const now = Date.now()
       const references = normalizeReferences(data.references, data.filePaths)
       const legacyFilePaths = referencesToLegacyFilePaths(references)

package/src/lib/server/openclaw-approvals.ts

@@ -0,0 +1,105 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import net from 'node:net'
+import { resolveOpenClawWorkspace } from './openclaw-sync'
+
+const APPROVAL_TIMEOUT_MS = 30_000
+
+interface ApprovalRequest {
+  toolName: string
+  args: Record<string, unknown>
+  socketPath?: string
+}
+
+interface ApprovalResponse {
+  approved: boolean
+  reason?: string
+}
+
+function resolveSocketPath(): string | null {
+  try {
+    const workspace = resolveOpenClawWorkspace()
+    const socketPath = path.join(workspace, 'exec-approvals.sock')
+    if (fs.existsSync(socketPath)) return socketPath
+  } catch { /* workspace not found */ }
+  return null
+}
+
+function resolveApprovalToken(): string | null {
+  try {
+    const workspace = resolveOpenClawWorkspace()
+    const tokenPath = path.join(workspace, 'exec-approvals.json')
+    if (!fs.existsSync(tokenPath)) return null
+    const raw = JSON.parse(fs.readFileSync(tokenPath, 'utf8'))
+    return typeof raw?.token === 'string' ? raw.token : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Forward a tool approval request to OpenClaw's exec-approvals Unix socket.
+ * Returns the approval decision, or null if the socket is unavailable.
+ */
+export async function forwardApprovalToOpenClaw(request: ApprovalRequest): Promise<ApprovalResponse | null> {
+  const socketPath = request.socketPath || resolveSocketPath()
+  if (!socketPath) return null
+
+  const token = resolveApprovalToken()
+
+  return new Promise<ApprovalResponse | null>((resolve) => {
+    const socket = net.createConnection({ path: socketPath }, () => {
+      const payload = JSON.stringify({
+        type: 'approval_request',
+        toolName: request.toolName,
+        args: request.args,
+        token,
+        timestamp: Date.now(),
+      })
+      socket.write(payload + '\n')
+    })
+
+    let data = ''
+    const timer = setTimeout(() => {
+      socket.destroy()
+      resolve(null) // Timeout — fall through to SwarmClaw UI
+    }, APPROVAL_TIMEOUT_MS)
+
+    socket.on('data', (chunk) => {
+      data += chunk.toString()
+      // Try to parse complete JSON response
+      try {
+        const response = JSON.parse(data.trim())
+        clearTimeout(timer)
+        socket.destroy()
+        resolve({
+          approved: response.approved === true,
+          reason: typeof response.reason === 'string' ? response.reason : undefined,
+        })
+      } catch {
+        // Incomplete data, wait for more
+      }
+    })
+
+    socket.on('error', () => {
+      clearTimeout(timer)
+      resolve(null) // Socket error — fall through
+    })
+
+    socket.on('close', () => {
+      clearTimeout(timer)
+      // If we haven't resolved yet, try to parse what we have
+      if (data.trim()) {
+        try {
+          const response = JSON.parse(data.trim())
+          resolve({
+            approved: response.approved === true,
+            reason: typeof response.reason === 'string' ? response.reason : undefined,
+          })
+          return
+        } catch { /* fall through */ }
+      }
+      resolve(null)
+    })
+  })
+}