@swarmclawai/swarmclaw 0.3.1 → 0.4.5

package/src/lib/server/langgraph-checkpoint.ts

@@ -0,0 +1,274 @@
+import { BaseCheckpointSaver } from '@langchain/langgraph'
+import type { RunnableConfig } from '@langchain/core/runnables'
+import type {
+  Checkpoint,
+  CheckpointTuple,
+  CheckpointListOptions,
+} from '@langchain/langgraph-checkpoint'
+import type {
+  CheckpointMetadata,
+  PendingWrite,
+  CheckpointPendingWrite,
+} from '@langchain/langgraph-checkpoint'
+import Database from 'better-sqlite3'
+import path from 'path'
+import { DATA_DIR } from './data-dir'
+
+const DB_PATH = path.join(DATA_DIR, 'swarmclaw.db')
+
+function getDb(): Database.Database {
+  const db = new Database(DB_PATH)
+  db.pragma('journal_mode = WAL')
+  return db
+}
+
+// Ensure tables exist
+const initDb = getDb()
+initDb.exec(`
+  CREATE TABLE IF NOT EXISTS langgraph_checkpoints (
+    thread_id TEXT NOT NULL,
+    checkpoint_ns TEXT NOT NULL DEFAULT '',
+    checkpoint_id TEXT NOT NULL,
+    parent_checkpoint_id TEXT,
+    type TEXT NOT NULL DEFAULT 'json',
+    checkpoint BLOB NOT NULL,
+    metadata BLOB NOT NULL DEFAULT '{}',
+    created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+  )
+`)
+initDb.exec(`
+  CREATE TABLE IF NOT EXISTS langgraph_writes (
+    thread_id TEXT NOT NULL,
+    checkpoint_ns TEXT NOT NULL DEFAULT '',
+    checkpoint_id TEXT NOT NULL,
+    task_id TEXT NOT NULL,
+    idx INTEGER NOT NULL,
+    channel TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'json',
+    value BLOB,
+    PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
+  )
+`)
+initDb.close()
+
+function getThreadId(config: RunnableConfig): string {
+  return (config.configurable?.thread_id as string) || ''
+}
+
+function getCheckpointNs(config: RunnableConfig): string {
+  return (config.configurable?.checkpoint_ns as string) || ''
+}
+
+function getCheckpointId(config: RunnableConfig): string | undefined {
+  return config.configurable?.checkpoint_id as string | undefined
+}
+
+export class SqliteCheckpointSaver extends BaseCheckpointSaver {
+  private db: Database.Database
+
+  constructor() {
+    super()
+    this.db = getDb()
+  }
+
+  async getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined> {
+    const threadId = getThreadId(config)
+    if (!threadId) return undefined
+
+    const ns = getCheckpointNs(config)
+    const checkpointId = getCheckpointId(config)
+
+    let row: any
+    if (checkpointId) {
+      row = this.db.prepare(
+        `SELECT * FROM langgraph_checkpoints WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`
+      ).get(threadId, ns, checkpointId)
+    } else {
+      row = this.db.prepare(
+        `SELECT * FROM langgraph_checkpoints WHERE thread_id = ? AND checkpoint_ns = ? ORDER BY created_at DESC LIMIT 1`
+      ).get(threadId, ns)
+    }
+
+    if (!row) return undefined
+
+    const checkpoint = JSON.parse(
+      typeof row.checkpoint === 'string' ? row.checkpoint : Buffer.from(row.checkpoint).toString()
+    ) as Checkpoint
+    const metadata = JSON.parse(
+      typeof row.metadata === 'string' ? row.metadata : Buffer.from(row.metadata).toString()
+    ) as CheckpointMetadata
+
+    const resultConfig: RunnableConfig = {
+      configurable: {
+        thread_id: threadId,
+        checkpoint_ns: ns,
+        checkpoint_id: row.checkpoint_id,
+      },
+    }
+
+    const parentConfig = row.parent_checkpoint_id
+      ? {
+          configurable: {
+            thread_id: threadId,
+            checkpoint_ns: ns,
+            checkpoint_id: row.parent_checkpoint_id,
+          },
+        }
+      : undefined
+
+    // Load pending writes
+    const writeRows = this.db.prepare(
+      `SELECT task_id, channel, value FROM langgraph_writes WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ? ORDER BY idx`
+    ).all(threadId, ns, row.checkpoint_id) as any[]
+
+    const pendingWrites: CheckpointPendingWrite[] = writeRows.map((w) => [
+      w.task_id,
+      w.channel,
+      w.value ? JSON.parse(typeof w.value === 'string' ? w.value : Buffer.from(w.value).toString()) : undefined,
+    ])
+
+    return {
+      config: resultConfig,
+      checkpoint,
+      metadata,
+      parentConfig,
+      pendingWrites,
+    }
+  }
+
+  async *list(
+    config: RunnableConfig,
+    options?: CheckpointListOptions,
+  ): AsyncGenerator<CheckpointTuple> {
+    const threadId = getThreadId(config)
+    if (!threadId) return
+
+    const ns = getCheckpointNs(config)
+    const limit = options?.limit ?? 100
+
+    let query = `SELECT * FROM langgraph_checkpoints WHERE thread_id = ? AND checkpoint_ns = ?`
+    const params: any[] = [threadId, ns]
+
+    if (options?.before?.configurable?.checkpoint_id) {
+      query += ` AND checkpoint_id < ?`
+      params.push(options.before.configurable.checkpoint_id)
+    }
+
+    query += ` ORDER BY created_at DESC LIMIT ?`
+    params.push(limit)
+
+    const rows = this.db.prepare(query).all(...params) as any[]
+
+    for (const row of rows) {
+      const checkpoint = JSON.parse(
+        typeof row.checkpoint === 'string' ? row.checkpoint : Buffer.from(row.checkpoint).toString()
+      ) as Checkpoint
+      const metadata = JSON.parse(
+        typeof row.metadata === 'string' ? row.metadata : Buffer.from(row.metadata).toString()
+      ) as CheckpointMetadata
+
+      const resultConfig: RunnableConfig = {
+        configurable: {
+          thread_id: threadId,
+          checkpoint_ns: ns,
+          checkpoint_id: row.checkpoint_id,
+        },
+      }
+
+      const parentConfig = row.parent_checkpoint_id
+        ? {
+            configurable: {
+              thread_id: threadId,
+              checkpoint_ns: ns,
+              checkpoint_id: row.parent_checkpoint_id,
+            },
+          }
+        : undefined
+
+      yield {
+        config: resultConfig,
+        checkpoint,
+        metadata,
+        parentConfig,
+      }
+    }
+  }
+
+  async put(
+    config: RunnableConfig,
+    checkpoint: Checkpoint,
+    metadata: CheckpointMetadata,
+    _newVersions: Record<string, number | string>,
+  ): Promise<RunnableConfig> {
+    const threadId = getThreadId(config)
+    const ns = getCheckpointNs(config)
+    const parentId = getCheckpointId(config)
+
+    this.db.prepare(`
+      INSERT OR REPLACE INTO langgraph_checkpoints
+        (thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, checkpoint, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      threadId,
+      ns,
+      checkpoint.id,
+      parentId || null,
+      JSON.stringify(checkpoint),
+      JSON.stringify(metadata),
+      Date.now(),
+    )
+
+    return {
+      configurable: {
+        thread_id: threadId,
+        checkpoint_ns: ns,
+        checkpoint_id: checkpoint.id,
+      },
+    }
+  }
+
+  async putWrites(
+    config: RunnableConfig,
+    writes: PendingWrite[],
+    taskId: string,
+  ): Promise<void> {
+    const threadId = getThreadId(config)
+    const ns = getCheckpointNs(config)
+    const checkpointId = getCheckpointId(config)
+    if (!checkpointId) return
+
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO langgraph_writes
+        (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, value)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `)
+
+    const insertMany = this.db.transaction((items: PendingWrite[]) => {
+      items.forEach(([channel, value], idx) => {
+        stmt.run(
+          threadId,
+          ns,
+          checkpointId,
+          taskId,
+          idx,
+          channel as string,
+          value !== undefined ? JSON.stringify(value) : null,
+        )
+      })
+    })
+
+    insertMany(writes)
+  }
+
+  async deleteThread(threadId: string): Promise<void> {
+    this.db.prepare(`DELETE FROM langgraph_checkpoints WHERE thread_id = ?`).run(threadId)
+    this.db.prepare(`DELETE FROM langgraph_writes WHERE thread_id = ?`).run(threadId)
+  }
+}
+
+let _saver: SqliteCheckpointSaver | undefined
+export function getCheckpointSaver(): SqliteCheckpointSaver {
+  if (!_saver) _saver = new SqliteCheckpointSaver()
+  return _saver
+}

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

@@ -1,6 +1,7 @@
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
+import { z } from 'zod'
 import type { GoalContract, MessageToolEvent } from '@/types'
-import { loadSessions, saveSessions, loadTasks, saveTasks } from './storage'
+import { loadSessions, saveSessions, loadAgents, saveAgents, loadTasks, saveTasks } from './storage'
 import { log } from './logger'
 import { getMemoryDb } from './memory-db'
 import {
@@ -18,6 +19,7 @@ const MEMORY_NOTE_MIN_INTERVAL_MS = 90 * 60 * 1000
 const DEFAULT_FOLLOWUP_DELAY_SEC = 45
 const MAX_FOLLOWUP_CHAIN = 6
 const META_LINE_RE = /\[MAIN_LOOP_META\]\s*(\{[^\n]*\})/i
+const AGENT_HEARTBEAT_META_RE = /\[AGENT_HEARTBEAT_META\]\s*(\{[^\n]*\})/i
 const SCREENSHOT_GOAL_HINT = /\b(screenshot|screen shot|snapshot|capture)\b/i
 const DELIVERY_GOAL_HINT = /\b(send|deliver|return|share|upload|post|message)\b/i
 const SCHEDULE_GOAL_HINT = /\b(schedule|scheduled|every\s+\w+|interval|cron|recurr)\b/i
@@ -149,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,
@@ -224,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,
@@ -244,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,
@@ -301,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,
@@ -515,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,
@@ -822,10 +824,67 @@ export function pushMainLoopEventToMainSessions(input: PushMainLoopEventInput):
   return changed
 }
 
+const AgentHeartbeatMetaSchema = z.object({
+  goal: z.string().trim().optional(),
+  status: z.enum(['progress', 'ok', 'idle', 'blocked']).optional(),
+  next_action: z.string().trim().optional(),
+}).passthrough()
+
+type AgentHeartbeatMeta = z.infer<typeof AgentHeartbeatMetaSchema>
+
+function parseAgentHeartbeatMeta(text: string): AgentHeartbeatMeta | null {
+  const raw = (text || '').trim()
+  if (!raw) return null
+  const match = raw.match(AGENT_HEARTBEAT_META_RE)
+  if (!match?.[1]) return null
+  try {
+    const parsed = JSON.parse(match[1])
+    return AgentHeartbeatMetaSchema.parse(parsed)
+  } catch {
+    return null
+  }
+}
+
+function handleAgentHeartbeatResult(session: any, input: HandleMainLoopRunResultInput): null {
+  if (!input.internal || input.source !== 'heartbeat') return null
+  if (!session.agentId) return null
+  const text = input.resultText || ''
+  if (!text.trim()) return null
+
+  const meta = parseAgentHeartbeatMeta(text)
+  if (!meta) return null
+
+  const agents = loadAgents()
+  const agent = agents[session.agentId]
+  if (!agent) return null
+
+  let changed = false
+  if (meta.goal && meta.goal !== agent.heartbeatGoal) {
+    agent.heartbeatGoal = meta.goal
+    changed = true
+    log.info('agent-heartbeat', `Goal updated for agent ${agent.name}: ${meta.goal.slice(0, 120)}`)
+  }
+  if (meta.next_action) {
+    agent.heartbeatNextAction = meta.next_action
+    changed = true
+  }
+  if (meta.status) {
+    agent.heartbeatStatus = meta.status
+    changed = true
+  }
+
+  if (changed) {
+    agents[session.agentId] = agent
+    saveAgents(agents)
+  }
+  return null
+}
+
 export function handleMainLoopRunResult(input: HandleMainLoopRunResultInput): MainLoopFollowupRequest | null {
   const sessions = loadSessions()
   const session = sessions[input.sessionId]
-  if (!session || !isMainSession(session)) return null
+  if (!session) return null
+  if (!isMainSession(session)) return handleAgentHeartbeatResult(session, input)
 
   const now = Date.now()
   const state = normalizeState(session.mainLoopState, now)

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