@swarmclawai/swarmclaw 0.8.4 → 0.8.7

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

@@ -1,8 +1,10 @@
 import crypto from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
+import type { WhatsAppApprovedContact } from '@/types'
+import { CONNECTORS_DATA_DIR } from '../data-dir'
+import { safeJsonParseObject } from '../json-utils'
 
-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
@@ -10,8 +12,7 @@ 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')
+  return path.join(CONNECTORS_DATA_DIR, 'pairing-store.json')
 }
 
 export type PairingPolicy = 'open' | 'allowlist' | 'pairing' | 'disabled'
@@ -68,6 +69,24 @@ function dedupe(items: string[]): string[] {
   return out
 }
 
+function normalizeApprovedContactPhone(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function normalizeApprovedContactLabel(value: unknown, fallback: string): string {
+  const trimmed = typeof value === 'string' ? value.trim() : ''
+  return trimmed || fallback
+}
+
+function approvedContactKey(phone: string): string {
+  const normalized = normalizeSenderId(phone)
+  if (!normalized) return ''
+  const digits = normalized.replace(/[^\d]/g, '')
+  if (digits) return digits
+  const jidUser = normalized.split('@')[0]?.split(':')[0]?.trim()
+  return jidUser || normalized
+}
+
 function prunePending(entries: PairingRequest[]): PairingRequest[] {
   const now = Date.now()
   return entries.filter((entry) => {
@@ -86,7 +105,7 @@ function loadStore(): PairingStore {
   try {
     if (!fs.existsSync(storePath)) return emptyStore()
     const raw = fs.readFileSync(storePath, 'utf8')
-    const parsed = JSON.parse(raw) as PairingStore
+    const parsed = safeJsonParseObject<PairingStore>(raw)
     if (!parsed || typeof parsed !== 'object' || typeof parsed.connectors !== 'object') {
       return emptyStore()
     }
@@ -151,6 +170,32 @@ export function parseAllowFromCsv(value: unknown): string[] {
   return dedupe(value.split(',').map((item) => item.trim()).filter(Boolean))
 }
 
+export function normalizeWhatsAppApprovedContacts(value: unknown): WhatsAppApprovedContact[] {
+  if (!Array.isArray(value)) return []
+
+  const seen = new Set<string>()
+  const out: WhatsAppApprovedContact[] = []
+  for (const entry of value) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue
+    const record = entry as Record<string, unknown>
+    const phone = normalizeApprovedContactPhone(record.phone)
+    if (!phone) continue
+    const dedupeKey = approvedContactKey(phone)
+    if (!dedupeKey || seen.has(dedupeKey)) continue
+    seen.add(dedupeKey)
+    out.push({
+      id: typeof record.id === 'string' && record.id.trim() ? record.id.trim() : `wa-contact-${out.length + 1}`,
+      label: normalizeApprovedContactLabel(record.label, phone),
+      phone,
+    })
+  }
+  return out
+}
+
+export function getWhatsAppApprovedSenderIds(value: unknown): string[] {
+  return normalizeWhatsAppApprovedContacts(value).map((entry) => entry.phone)
+}
+
 export function listStoredAllowedSenders(connectorId: string): string[] {
   const store = loadStore()
   const state = ensureConnectorState(store, connectorId)

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

@@ -2,8 +2,8 @@ import type { Connector, Session, SessionResetMode, SessionResetType } from '@/t
 import { getProvider } from '@/lib/providers'
 import type { InboundMessage } from './types'
 import { evaluateSessionFreshness, inferSessionResetType, resetSessionRuntime, resolveSessionResetPolicy } from '../session-reset-policy'
-import { listStoredAllowedSenders, parseAllowFromCsv, parsePairingPolicy } from './pairing'
-import { loadAgents, loadChatrooms, loadCredentials } from '../storage'
+import { getWhatsAppApprovedSenderIds, listStoredAllowedSenders, parseAllowFromCsv, parsePairingPolicy } from './pairing'
+import { loadAgents, loadChatrooms, loadCredentials, loadSettings } from '../storage'
 
 export type ConnectorSessionScope = 'main' | 'channel' | 'peer' | 'channel-peer' | 'thread'
 export type ConnectorReplyMode = 'off' | 'first' | 'all'
@@ -377,7 +377,13 @@ export function buildConnectorDoctorWarnings(params: {
     }
   }
   const dmPolicy = parsePairingPolicy(connector.config?.dmPolicy, 'open')
-  const configuredAllowFrom = parseAllowFromCsv(connector.config?.allowFrom)
+  const globalWhatsAppAllowFrom = connector.platform === 'whatsapp'
+    ? getWhatsAppApprovedSenderIds(loadSettings().whatsappApprovedContacts)
+    : []
+  const configuredAllowFrom = parseAllowFromCsv([
+    connector.config?.allowFrom,
+    ...globalWhatsAppAllowFrom,
+  ].filter(Boolean).join(','))
   const storedAllowFrom = listStoredAllowedSenders(connector.id)
   if (parseBool(connector.config?.statusReactions, true) && connector.platform === 'telegram') {
     warnings.push('Status reactions are enabled, but Telegram support is partial and may no-op depending on bot permissions.')

package/src/lib/server/connectors/reconnect-state.ts

@@ -0,0 +1,71 @@
+import { connectorRuntimeState, type ConnectorReconnectState } from './runtime-state'
+
+export type { ConnectorReconnectState }
+
+interface ConnectorReconnectPolicy {
+  initialBackoffMs?: number
+  maxBackoffMs?: number
+  maxAttempts?: number
+}
+
+export const connectorReconnectStateStore: Map<string, ConnectorReconnectState> =
+  connectorRuntimeState.reconnectStates
+
+const RECONNECT_INITIAL_BACKOFF_MS = 1_000
+const RECONNECT_MAX_BACKOFF_MS = 5 * 60 * 1_000
+const RECONNECT_MAX_ATTEMPTS = 10
+
+export function createConnectorReconnectState(
+  init: Partial<ConnectorReconnectState> = {},
+  policy: ConnectorReconnectPolicy = {},
+): ConnectorReconnectState {
+  return {
+    attempts: init.attempts ?? 0,
+    lastAttemptAt: init.lastAttemptAt ?? 0,
+    nextRetryAt: init.nextRetryAt ?? 0,
+    backoffMs: init.backoffMs ?? policy.initialBackoffMs ?? RECONNECT_INITIAL_BACKOFF_MS,
+    error: init.error ?? '',
+    exhausted: init.exhausted ?? false,
+  }
+}
+
+export function advanceConnectorReconnectState(
+  previous: ConnectorReconnectState,
+  error: string,
+  now = Date.now(),
+  policy: ConnectorReconnectPolicy = {},
+): ConnectorReconnectState {
+  const initialBackoffMs = policy.initialBackoffMs ?? RECONNECT_INITIAL_BACKOFF_MS
+  const maxBackoffMs = policy.maxBackoffMs ?? RECONNECT_MAX_BACKOFF_MS
+  const maxAttempts = policy.maxAttempts ?? RECONNECT_MAX_ATTEMPTS
+  const attempts = previous.attempts + 1
+  const backoffMs = Math.min(maxBackoffMs, initialBackoffMs * (2 ** Math.max(0, attempts - 1)))
+  return {
+    attempts,
+    lastAttemptAt: now,
+    nextRetryAt: now + backoffMs,
+    backoffMs,
+    error,
+    exhausted: attempts >= maxAttempts,
+  }
+}
+
+export function clearReconnectState(connectorId: string): void {
+  connectorReconnectStateStore.delete(connectorId)
+}
+
+export function setReconnectState(connectorId: string, state: ConnectorReconnectState): void {
+  connectorReconnectStateStore.set(connectorId, state)
+}
+
+export function getReconnectState(connectorId: string): ConnectorReconnectState | null {
+  return connectorReconnectStateStore.get(connectorId) ?? null
+}
+
+export function getAllReconnectStates(): Record<string, ConnectorReconnectState> {
+  const out: Record<string, ConnectorReconnectState> = {}
+  for (const [id, state] of connectorReconnectStateStore.entries()) {
+    out[id] = { ...state }
+  }
+  return out
+}

package/src/lib/server/connectors/response-media.ts

@@ -0,0 +1,256 @@
+import fs from 'fs'
+import path from 'path'
+import { UPLOAD_DIR } from '../storage'
+import { safeJsonParseObject } from '../json-utils'
+import type { InboundMessage, InboundMedia } from './types'
+
+function resolveUploadPathFromUrl(rawUrl: string): string | null {
+  if (!rawUrl) return null
+  const normalized = rawUrl.trim()
+  const match = normalized.match(/\/api\/uploads\/([^?#)\s]+)/)
+  if (!match) return null
+  let decoded: string
+  try { decoded = decodeURIComponent(match[1]) } catch { decoded = match[1] }
+  const safeName = decoded.replace(/[^a-zA-Z0-9._-]/g, '')
+  if (!safeName) return null
+  const filePath = path.join(UPLOAD_DIR, safeName)
+  return fs.existsSync(filePath) ? filePath : null
+}
+
+export function uploadApiUrlFromPath(filePath: string): string | null {
+  const rel = path.relative(UPLOAD_DIR, filePath)
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null
+  const fileName = path.basename(rel)
+  return `/api/uploads/${encodeURIComponent(fileName)}`
+}
+
+export function parseSseDataEvents(raw: string): Array<Record<string, unknown>> {
+  if (!raw) return []
+  const events: Array<Record<string, unknown>> = []
+  const lines = raw.split('\n')
+  for (const line of lines) {
+    if (!line.startsWith('data: ')) continue
+    const parsed = safeJsonParseObject(line.slice(6))
+    if (parsed) events.push(parsed)
+  }
+  return events
+}
+
+export function parseConnectorToolResult(toolOutput: string): { status?: string; to?: string; followUpId?: string; messageId?: string } | null {
+  const record = safeJsonParseObject(toolOutput)
+  if (!record) return null
+  const status = typeof record.status === 'string' ? String(record.status) : undefined
+  const to = typeof record.to === 'string' ? String(record.to) : undefined
+  const followUpId = typeof record.followUpId === 'string' ? String(record.followUpId) : undefined
+  const messageId = typeof record.messageId === 'string' ? String(record.messageId) : undefined
+  return { status, to, followUpId, messageId }
+}
+
+export function parseConnectorToolInput(toolInput: string): Record<string, unknown> | null {
+  return safeJsonParseObject(toolInput)
+}
+
+export function visibleConnectorToolText(input: Record<string, unknown> | null): string {
+  if (!input) return ''
+  const voiceText = typeof input.voiceText === 'string' ? input.voiceText.trim() : ''
+  if (voiceText) return voiceText
+  const message = typeof input.message === 'string' ? input.message.trim() : ''
+  if (message) return message
+  const caption = typeof input.caption === 'string' ? input.caption.trim() : ''
+  if (caption) return caption
+  const text = typeof input.text === 'string' ? input.text.trim() : ''
+  if (text) return text
+  return ''
+}
+
+function canonicalUploadMediaKey(filePath: string): string {
+  const base = path.basename(filePath)
+  const ext = path.extname(base).toLowerCase()
+  const normalized = base
+    .replace(/^\d{10,16}-/, '')
+    .replace(/^(?:browser|screenshot)-\d{10,16}(?:-\d+)?\./, 'playwright-capture.')
+    .toLowerCase()
+  return normalized || `unknown${ext}`
+}
+
+function shouldAllowMultipleMediaSends(userText: string): boolean {
+  const text = (userText || '').toLowerCase()
+  return /\b(all|both|multiple|several|many|every|each|two|three|4|four|screenshots|images|photos|files|documents)\b/.test(text)
+}
+
+function preferSingleBestMediaFile(files: Array<{ path: string; alt: string }>): Array<{ path: string; alt: string }> {
+  if (files.length <= 1) return files
+  const ranked = [...files].sort((a, b) => {
+    const score = (entry: { path: string }) => {
+      const base = path.basename(entry.path).toLowerCase()
+      let value = 0
+      if (/^\d{10,16}-/.test(base)) value += 20
+      if (!base.startsWith('browser-') && !base.startsWith('screenshot-')) value += 10
+      if (base.endsWith('.pdf')) value += 8
+      if (base.endsWith('.png') || base.endsWith('.jpg') || base.endsWith('.jpeg') || base.endsWith('.webp')) value += 6
+      try {
+        const stat = fs.statSync(entry.path)
+        value += Math.min(5, Math.round((stat.mtimeMs % 10_000) / 2_000))
+      } catch { /* ignore stat errors */ }
+      return value
+    }
+    return score(b) - score(a)
+  })
+  return [ranked[0]]
+}
+
+export function selectOutboundMediaFiles(
+  files: Array<{ path: string; alt: string }>,
+  userText: string,
+): Array<{ path: string; alt: string }> {
+  if (files.length === 0) return []
+  const mergedFiles: Array<{ path: string; alt: string }> = []
+  const seenMediaKeys = new Set<string>()
+  for (const candidate of files) {
+    const mediaKey = canonicalUploadMediaKey(candidate.path)
+    if (seenMediaKeys.has(mediaKey)) continue
+    seenMediaKeys.add(mediaKey)
+    mergedFiles.push(candidate)
+  }
+  return shouldAllowMultipleMediaSends(userText || '')
+    ? mergedFiles
+    : preferSingleBestMediaFile(mergedFiles)
+}
+
+export function extractEmbeddedMedia(text: string): { cleanText: string; files: Array<{ path: string; alt: string }> } {
+  const files: Array<{ path: string; alt: string }> = []
+  const seen = new Set<string>()
+  let cleanText = text
+
+  const pushFile = (filePath: string, alt: string) => {
+    if (!filePath || seen.has(filePath)) return
+    seen.add(filePath)
+    files.push({ path: filePath, alt: alt.trim() })
+  }
+
+  const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g
+  cleanText = cleanText.replace(imageRegex, (full, altRaw, urlRaw) => {
+    const filePath = resolveUploadPathFromUrl(String(urlRaw || ''))
+    if (!filePath) return full
+    pushFile(filePath, String(altRaw || ''))
+    return ''
+  })
+
+  const linkRegex = /(?<!!)\[([^\]]*)\]\(([^)]+)\)/g
+  cleanText = cleanText.replace(linkRegex, (full, altRaw, urlRaw) => {
+    const filePath = resolveUploadPathFromUrl(String(urlRaw || ''))
+    if (!filePath) return full
+    pushFile(filePath, String(altRaw || ''))
+    return ''
+  })
+
+  const bareUploadUrlRegex = /(?:https?:\/\/[^\s)]+)?\/api\/uploads\/[^\s)\]]+/g
+  cleanText = cleanText.replace(bareUploadUrlRegex, (full) => {
+    const filePath = resolveUploadPathFromUrl(full)
+    if (!filePath) return full
+    pushFile(filePath, '')
+    return ''
+  })
+
+  if (files.length === 0) return { cleanText: text, files }
+  cleanText = cleanText.replace(/\n{3,}/g, '\n\n').trim()
+  return { cleanText, files }
+}
+
+export function buildInboundAttachmentPaths(msg: InboundMessage): string[] {
+  if (!Array.isArray(msg.media) || msg.media.length === 0) return []
+  const paths: string[] = []
+  const seen = new Set<string>()
+  for (const media of msg.media) {
+    const localPath = typeof media.localPath === 'string' ? media.localPath.trim() : ''
+    if (!localPath || seen.has(localPath)) continue
+    if (!fs.existsSync(localPath)) continue
+    seen.add(localPath)
+    paths.push(localPath)
+  }
+  return paths
+}
+
+/**
+ * Normalize a phone number string to E.164 format (+<digits>).
+ * Strips formatting characters, `whatsapp:` prefixes, and ensures a leading `+`.
+ * Works for all country codes — no country-specific heuristics.
+ */
+export function normalizeE164(number: string): string {
+  const withoutPrefix = number.replace(/^whatsapp:/i, '').trim()
+  const digits = withoutPrefix.replace(/[^\d+]/g, '')
+  if (digits.startsWith('+')) return `+${digits.slice(1)}`
+  return `+${digits}`
+}
+
+const WHATSAPP_USER_JID_RE = /^(\d+)(?::\d+)?@s\.whatsapp\.net$/i
+const WHATSAPP_LID_RE = /^(\d+)(?::\d+)?@lid$/i
+const WHATSAPP_GROUP_JID_RE = /^[\d]+(-[\d]+)*@g\.us$/i
+
+/**
+ * Normalize a WhatsApp target (phone number, user JID, group JID) into
+ * a canonical JID suitable for sending messages.
+ *
+ * - Group JIDs (`…@g.us`) are preserved as-is.
+ * - User JIDs (`…@s.whatsapp.net`, `…@lid`) extract the phone number.
+ * - Plain phone numbers are cleaned to digits and suffixed with `@s.whatsapp.net`.
+ *
+ * Works for all country codes — ported from OpenClaw's normalizeWhatsAppTarget.
+ */
+export function normalizeWhatsappTarget(raw: string): string {
+  const trimmed = raw.replace(/^whatsapp:/i, '').trim()
+  if (!trimmed) return trimmed
+
+  // Group JIDs — preserve as-is
+  if (WHATSAPP_GROUP_JID_RE.test(trimmed)) return trimmed
+
+  // User JIDs — extract the phone number digits
+  const userMatch = trimmed.match(WHATSAPP_USER_JID_RE)
+  if (userMatch) return `${userMatch[1]}@s.whatsapp.net`
+
+  const lidMatch = trimmed.match(WHATSAPP_LID_RE)
+  if (lidMatch) return trimmed // LID JIDs can't be converted to phone-based JIDs
+
+  // Unknown JID format — return as-is to avoid mangling
+  if (trimmed.includes('@')) return trimmed
+
+  // Plain phone number — strip to digits and build JID
+  const digits = trimmed.replace(/[^\d+]/g, '')
+  const cleaned = digits.startsWith('+') ? digits.slice(1) : digits
+  return cleaned ? `${cleaned}@s.whatsapp.net` : trimmed
+}
+
+export function connectorSupportsBinaryMedia(platform: string): boolean {
+  return platform === 'whatsapp'
+    || platform === 'telegram'
+    || platform === 'slack'
+    || platform === 'discord'
+    || platform === 'openclaw'
+}
+
+export function formatMediaLine(media: InboundMedia): string {
+  const typeLabel = media.type.toUpperCase()
+  const name = media.fileName || media.mimeType || 'attachment'
+  const size = media.sizeBytes ? ` (${Math.max(1, Math.round(media.sizeBytes / 1024))} KB)` : ''
+  if (media.url) return `- ${typeLabel}: ${name}${size} -> ${media.url}`
+  return `- ${typeLabel}: ${name}${size}`
+}
+
+export function formatInboundUserText(msg: InboundMessage): string {
+  const baseText = (msg.text || '').trim()
+  const lines: string[] = []
+  if (baseText) lines.push(`[${msg.senderName}] ${baseText}`)
+  else lines.push(`[${msg.senderName}]`)
+
+  if (Array.isArray(msg.media) && msg.media.length > 0) {
+    lines.push('')
+    lines.push('Media received:')
+    const preview = msg.media.slice(0, 6)
+    for (const media of preview) lines.push(formatMediaLine(media))
+    if (msg.media.length > preview.length) {
+      lines.push(`- ...and ${msg.media.length - preview.length} more attachment(s)`)
+    }
+  }
+
+  return lines.join('\n').trim()
+}

package/src/lib/server/connectors/runtime-state.ts

@@ -0,0 +1,67 @@
+import type { Connector, Session } from '@/types'
+import type { ConnectorInstance, InboundMessage } from './types'
+import { hmrSingleton } from '@/lib/shared-utils'
+
+export interface ConnectorReconnectState {
+  attempts: number
+  lastAttemptAt: number
+  nextRetryAt: number
+  backoffMs: number
+  error: string
+  exhausted: boolean
+}
+
+export interface ScheduledConnectorFollowup {
+  id: string
+  connectorId?: string
+  platform?: string
+  channelId: string
+  sendAt: number
+  timer: ReturnType<typeof setTimeout>
+}
+
+export interface DebouncedInboundEntry {
+  connector: Connector
+  messages: InboundMessage[]
+  timer: ReturnType<typeof setTimeout>
+}
+
+export type RouteMessageHandler = (connector: Connector, msg: InboundMessage) => Promise<string>
+
+export interface ConnectorRuntimeState {
+  running: Map<string, ConnectorInstance>
+  lastInboundChannelByConnector: Map<string, string>
+  lastInboundTimeByConnector: Map<string, number>
+  locks: Map<string, Promise<void>>
+  generationCounter: Map<string, number>
+  scheduledFollowups: Map<string, ScheduledConnectorFollowup>
+  recentInboundByKey: Map<string, number>
+  pendingInboundDebounce: Map<string, DebouncedInboundEntry>
+  scheduledFollowupByDedupe: Map<string, { id: string; sendAt: number }>
+  reconnectStates: Map<string, ConnectorReconnectState>
+  routeMessageHandlerRef: { current: RouteMessageHandler }
+}
+
+export function getConnectorRuntimeState(): ConnectorRuntimeState {
+  return hmrSingleton('__swarmclaw_connector_runtime_state__', () => ({
+    running: hmrSingleton('__swarmclaw_running_connectors__', () => new Map<string, ConnectorInstance>()),
+    lastInboundChannelByConnector: hmrSingleton('__swarmclaw_connector_last_inbound__', () => new Map<string, string>()),
+    lastInboundTimeByConnector: hmrSingleton('__swarmclaw_connector_last_inbound_time__', () => new Map<string, number>()),
+    locks: hmrSingleton('__swarmclaw_connector_locks__', () => new Map<string, Promise<void>>()),
+    generationCounter: hmrSingleton('__swarmclaw_connector_gen__', () => new Map<string, number>()),
+    scheduledFollowups: hmrSingleton('__swarmclaw_connector_followups__', () => new Map<string, ScheduledConnectorFollowup>()),
+    recentInboundByKey: hmrSingleton('__swarmclaw_connector_inbound_dedupe__', () => new Map<string, number>()),
+    pendingInboundDebounce: hmrSingleton('__swarmclaw_connector_inbound_debounce__', () => new Map<string, DebouncedInboundEntry>()),
+    scheduledFollowupByDedupe: hmrSingleton('__swarmclaw_connector_followup_dedupe__', () => new Map<string, { id: string; sendAt: number }>()),
+    reconnectStates: hmrSingleton('__swarmclaw_connector_reconnect_state__', () => new Map<string, ConnectorReconnectState>()),
+    routeMessageHandlerRef: hmrSingleton('__swarmclaw_connector_route_handler__', () => ({
+      current: async () => '[Error] Connector router unavailable.',
+    })),
+  }))
+}
+
+export const connectorRuntimeState = getConnectorRuntimeState()
+
+export const runningConnectors = connectorRuntimeState.running
+
+export type ConnectorThreadSession = Session