@swarmclawai/swarmclaw 0.3.0 → 0.4.0

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 { 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
@@ -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)