@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/integrity-monitor.test.ts

@@ -0,0 +1,149 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let integrityMonitor: typeof import('./integrity-monitor')
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-integrity-'))
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  integrityMonitor = await import('./integrity-monitor')
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('integrity-monitor', () => {
+  it('returns disabled result when integrityMonitorEnabled is false', () => {
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: false })
+    assert.equal(result.enabled, false)
+    assert.equal(result.checkedFiles, 0)
+    assert.equal(result.drifts.length, 0)
+    assert.ok(result.checkedAt > 0)
+  })
+
+  it('returns disabled for string "false"', () => {
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: 'false' })
+    assert.equal(result.enabled, false)
+  })
+
+  it('returns disabled for string "0"', () => {
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: '0' })
+    assert.equal(result.enabled, false)
+  })
+
+  it('returns disabled for string "off"', () => {
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: 'off' })
+    assert.equal(result.enabled, false)
+  })
+
+  it('defaults to enabled when setting is null', () => {
+    const result = integrityMonitor.runIntegrityMonitor(null)
+    assert.equal(result.enabled, true)
+    assert.ok(result.checkedAt > 0)
+  })
+
+  it('defaults to enabled when setting is undefined', () => {
+    const result = integrityMonitor.runIntegrityMonitor()
+    assert.equal(result.enabled, true)
+  })
+
+  it('enabled with string "true"', () => {
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: 'true' })
+    assert.equal(result.enabled, true)
+  })
+
+  it('enabled with string "1"', () => {
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: '1' })
+    assert.equal(result.enabled, true)
+  })
+
+  it('enabled run returns result with checkedFiles and drifts array', () => {
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: true })
+    assert.equal(result.enabled, true)
+    assert.ok(typeof result.checkedFiles === 'number')
+    assert.ok(Array.isArray(result.drifts))
+    assert.ok(result.checkedAt > 0)
+  })
+
+  it('second run with no changes produces zero drifts', () => {
+    // First run establishes baselines
+    integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: true })
+    // Second run with no changes
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: true })
+    assert.equal(result.drifts.length, 0)
+  })
+
+  it('detects file modification as drift', () => {
+    // Create a plugin file in the data/plugins dir
+    const pluginDir = path.join(process.env.DATA_DIR!, 'plugins')
+    fs.mkdirSync(pluginDir, { recursive: true })
+    const pluginFile = path.join(pluginDir, 'test-integrity-plugin.js')
+    fs.writeFileSync(pluginFile, 'module.exports = { name: "test" }')
+
+    // First run: baseline
+    integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: true })
+
+    // Modify the file
+    fs.writeFileSync(pluginFile, 'module.exports = { name: "modified" }')
+
+    // Second run: should detect drift
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: true })
+    const drift = result.drifts.find((d) => d.filePath === path.resolve(pluginFile))
+    assert.ok(drift, 'should detect modified plugin file')
+    assert.equal(drift!.type, 'modified')
+    assert.ok(drift!.previousHash)
+    assert.ok(drift!.nextHash)
+    assert.notEqual(drift!.previousHash, drift!.nextHash)
+  })
+
+  it('deleted plugin file is no longer in watch targets (no drift)', () => {
+    // pushIfExists skips non-existent files, so deletion means the file
+    // simply drops out of the watch targets — no drift is generated.
+    const pluginDir = path.join(process.env.DATA_DIR!, 'plugins')
+    fs.mkdirSync(pluginDir, { recursive: true })
+    const pluginFile = path.join(pluginDir, 'test-delete-plugin.js')
+    fs.writeFileSync(pluginFile, 'module.exports = {}')
+
+    // Baseline
+    integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: true })
+
+    // Delete
+    fs.unlinkSync(pluginFile)
+
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: true })
+    const drift = result.drifts.find((d) => d.filePath === path.resolve(pluginFile))
+    assert.equal(drift, undefined, 'deleted file should not appear as drift')
+  })
+
+  it('new plugin file is baselined without drift on first run', () => {
+    const pluginDir = path.join(process.env.DATA_DIR!, 'plugins')
+    fs.mkdirSync(pluginDir, { recursive: true })
+    const pluginFile = path.join(pluginDir, 'brand-new-plugin.js')
+    fs.writeFileSync(pluginFile, 'module.exports = { name: "new" }')
+
+    const result = integrityMonitor.runIntegrityMonitor({ integrityMonitorEnabled: true })
+    // First time seeing the file — establishes baseline, no drift
+    const drift = result.drifts.find((d) => d.filePath === path.resolve(pluginFile))
+    assert.equal(drift, undefined, 'new file on first run should not produce drift')
+    assert.ok(result.checkedFiles > 0)
+  })
+})

package/src/lib/server/json-utils.ts

@@ -0,0 +1,22 @@
+export function safeJsonParse<T>(raw: unknown, fallback: T): T {
+  if (typeof raw !== 'string') return fallback
+  const trimmed = raw.trim()
+  if (!trimmed) return fallback
+  try {
+    return JSON.parse(trimmed) as T
+  } catch {
+    return fallback
+  }
+}
+
+export function safeJsonParseObject<T extends object = Record<string, unknown>>(raw: unknown): T | null {
+  const parsed = safeJsonParse<unknown>(raw, null)
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+    ? parsed as T
+    : null
+}
+
+export function safeJsonParseArray<T = unknown>(raw: unknown): T[] | null {
+  const parsed = safeJsonParse<unknown>(raw, null)
+  return Array.isArray(parsed) ? parsed as T[] : null
+}

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

@@ -117,17 +117,17 @@ function addRawMemory(data: {
 }): MemoryEntry {
   const id = crypto.randomBytes(6).toString('hex')
   const now = Date.now()
-  stmts.insert.run(
-    id,
-    data.agentId || null,
-    data.sessionId || null,
-    data.category,
-    data.title,
-    data.content,
-    data.metadata ? JSON.stringify(data.metadata) : null,
-    now,
-    now,
-  )
+  stmts.insert.run({
+    id: data.id || 'mem-1',
+    agentId: data.agentId || null,
+    sessionId: data.sessionId || null,
+    taskId: data.taskId || null,
+    url: data.url || null,
+    category: data.category,
+    textContent: data.textContent || null,
+    createdAt: now,
+    updatedAt: now
+  })
   return {
     id,
     agentId: data.agentId || null,
@@ -392,7 +392,7 @@ describe('isolation between knowledge and agent memory', () => {
   })
 
   it('knowledge entries do not appear in agent-scoped memory list', () => {
-    const agentMemories = (stmts.listByAgent.all('agent-xyz', 500) as Record<string, unknown>[]).map(rowToEntry)
+    const agentMemories = (stmts.listByAgent.all('agent-xyz') as Record<string, unknown>[]).map(rowToEntry)
     for (const e of agentMemories) {
       assert.notEqual(e.category, 'knowledge')
       assert.equal(e.agentId, 'agent-xyz')
@@ -402,7 +402,7 @@ describe('isolation between knowledge and agent memory', () => {
   it('knowledge entries do not appear in agent-scoped search', () => {
     const ftsQuery = buildFtsQuery('quantum entanglement')
     if (!ftsQuery) return
-    const agentResults = (stmts.searchByAgent.all(ftsQuery, 'agent-xyz') as Record<string, unknown>[]).map(rowToEntry)
+    const agentResults = (stmts.searchByAgent.all(ftsQuery) as Record<string, unknown>[]).map(rowToEntry)
     for (const e of agentResults) {
       assert.equal(e.agentId, 'agent-xyz')
     }

package/src/lib/server/link-understanding.ts

@@ -1,4 +1,5 @@
 import * as cheerio from 'cheerio'
+import { dedup } from '@/lib/shared-utils'
 import { truncate } from './session-tools/context'
 
 const BARE_LINK_RE = /https?:\/\/\S+/gi
@@ -11,7 +12,7 @@ export async function runLinkUnderstanding(message: string): Promise<string[]> {
   const links = message.match(BARE_LINK_RE)
   if (!links || links.length === 0) return []
 
-  const uniqueLinks = Array.from(new Set(links)).slice(0, 3) // Limit to first 3 links
+  const uniqueLinks = dedup(links).slice(0, 3) // Limit to first 3 links
   const results: string[] = []
 
   for (const url of uniqueLinks) {

package/src/lib/server/llm-response-cache.test.ts

@@ -7,7 +7,7 @@ import {
   getCachedLlmResponse,
   resolveLlmResponseCacheConfig,
   setCachedLlmResponse,
-} from './llm-response-cache.ts'
+} from './llm-response-cache'
 
 const HISTORY: Message[] = [
   { role: 'user', text: 'Plan a release.', time: 1 },

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

@@ -5,7 +5,7 @@ import path from 'node:path'
 import { spawnSync } from 'node:child_process'
 import { describe, it } from 'node:test'
 
-import { stripMainLoopMetaForPersistence } from './main-agent-loop.ts'
+import { stripMainLoopMetaForPersistence } from './main-agent-loop'
 
 const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
 
@@ -43,9 +43,9 @@ function runWithTempDataDir(script: string) {
 /** Shared setup script that creates one agent and one heartbeat-enabled main session */
 function sessionSetupScript(sessionOverrides?: string, extraSessions?: string): string {
   return `
-    const storageMod = await import('./src/lib/server/storage.ts')
+    const storageMod = await import('./src/lib/server/storage')
     const storage = storageMod.default || storageMod['module.exports'] || storageMod
-    const mainLoopMod = await import('./src/lib/server/main-agent-loop.ts')
+    const mainLoopMod = await import('./src/lib/server/main-agent-loop')
     const mainLoop = mainLoopMod.default || mainLoopMod['module.exports'] || mainLoopMod
 
     storage.saveAgents({
@@ -195,6 +195,68 @@ describe('main-agent-loop advanced', () => {
     assert.equal(output.followupOk, null, 'no followup on terminal ack')
   })
 
+  it('resets metadata miss count when structured metadata returns and keeps terminal acks at zero', () => {
+    const meta = heartbeatMetaLine('progress', 'deploy', 'continue')
+    const output = runWithTempDataDir(`
+      ${sessionSetupScript()}
+
+      const miss1 = mainLoop.handleMainLoopRunResult({
+        sessionId: 'main',
+        message: 'Continue objective.',
+        internal: true,
+        source: 'heartbeat',
+        resultText: 'Still working without structured metadata.',
+      })
+      const state1 = mainLoop.getMainLoopStateForSession('main')
+
+      const miss2 = mainLoop.handleMainLoopRunResult({
+        sessionId: 'main',
+        message: 'Continue objective.',
+        internal: true,
+        source: 'heartbeat',
+        resultText: 'Another plain-text update without metadata.',
+      })
+      const state2 = mainLoop.getMainLoopStateForSession('main')
+
+      const withMeta = mainLoop.handleMainLoopRunResult({
+        sessionId: 'main',
+        message: 'Continue objective.',
+        internal: true,
+        source: 'heartbeat',
+        resultText: \`Metadata restored.\\n${meta}\`,
+      })
+      const state3 = mainLoop.getMainLoopStateForSession('main')
+
+      const terminalAck = mainLoop.handleMainLoopRunResult({
+        sessionId: 'main',
+        message: 'Continue objective.',
+        internal: true,
+        source: 'heartbeat',
+        resultText: 'HEARTBEAT_OK',
+      })
+      const state4 = mainLoop.getMainLoopStateForSession('main')
+
+      console.log(JSON.stringify({
+        followupMiss1: miss1,
+        followupMiss2: miss2,
+        followupWithMeta: withMeta,
+        followupTerminalAck: terminalAck,
+        missCount1: state1?.metaMissCount ?? -1,
+        missCount2: state2?.metaMissCount ?? -1,
+        missCount3: state3?.metaMissCount ?? -1,
+        missCount4: state4?.metaMissCount ?? -1,
+        statusAfterAck: state4?.status ?? null,
+      }))
+    `)
+
+    assert.equal(output.missCount1, 1)
+    assert.equal(output.missCount2, 2)
+    assert.equal(output.missCount3, 0, 'structured metadata resets the miss counter')
+    assert.equal(output.missCount4, 0, 'terminal ack should not count as a metadata miss')
+    assert.equal(output.statusAfterAck, 'ok')
+    assert.equal(output.followupTerminalAck, null)
+  })
+
   // ─────────────────────────────────────────────────────────────────────
   // 3. Chain reset on error
   // ─────────────────────────────────────────────────────────────────────

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

@@ -35,9 +35,9 @@ function runWithTempDataDir(script: string) {
 describe('main-agent-loop', () => {
   it('fans out events to durable main sessions and shapes heartbeat prompts', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
+      const storageMod = await import('./src/lib/server/storage')
       const storage = storageMod.default || storageMod['module.exports'] || storageMod
-      const mainLoopMod = await import('./src/lib/server/main-agent-loop.ts')
+      const mainLoopMod = await import('./src/lib/server/main-agent-loop')
       const mainLoop = mainLoopMod.default || mainLoopMod['module.exports'] || mainLoopMod
 
       storage.saveAgents({
@@ -113,9 +113,9 @@ describe('main-agent-loop', () => {
 
   it('updates state from heartbeat metadata and returns a bounded follow-up', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
+      const storageMod = await import('./src/lib/server/storage')
       const storage = storageMod.default || storageMod['module.exports'] || storageMod
-      const mainLoopMod = await import('./src/lib/server/main-agent-loop.ts')
+      const mainLoopMod = await import('./src/lib/server/main-agent-loop')
       const mainLoop = mainLoopMod.default || mainLoopMod['module.exports'] || mainLoopMod
 
       storage.saveAgents({
@@ -195,9 +195,9 @@ describe('main-agent-loop', () => {
 
   it('does not keep chaining when the heartbeat explicitly reports ok', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
+      const storageMod = await import('./src/lib/server/storage')
       const storage = storageMod.default || storageMod['module.exports'] || storageMod
-      const mainLoopMod = await import('./src/lib/server/main-agent-loop.ts')
+      const mainLoopMod = await import('./src/lib/server/main-agent-loop')
       const mainLoop = mainLoopMod.default || mainLoopMod['module.exports'] || mainLoopMod
 
       storage.saveAgents({

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

@@ -1,3 +1,4 @@
+import { hmrSingleton } from '@/lib/shared-utils'
 import type { GoalContract, Message, MessageToolEvent, Session } from '@/types'
 import { mergeGoalContracts, parseGoalContractFromText, parseMainLoopPlan, parseMainLoopReview } from './autonomy-contract'
 import { enqueueSystemEvent } from './system-events'
@@ -77,9 +78,7 @@ export interface HandleMainLoopRunResultInput {
 
 type MainSessionLike = Partial<Session> & Record<string, unknown>
 
-const globalKey = '__swarmclaw_main_loop_state__' as const
-const globalScope = globalThis as typeof globalThis & { [globalKey]?: Map<string, MainLoopState> }
-const stateMap = globalScope[globalKey] ?? (globalScope[globalKey] = new Map<string, MainLoopState>())
+const stateMap = hmrSingleton('__swarmclaw_main_loop_state__', () => new Map<string, MainLoopState>())
 
 function now(): number {
   return Date.now()
@@ -506,6 +505,21 @@ export function getMainLoopStateForSession(sessionId: string): MainLoopState | n
   return state ? normalizeState(state) : null
 }
 
+/**
+ * Remove stateMap entries for sessions that no longer exist.
+ * Called periodically by the daemon health sweep.
+ */
+export function pruneMainLoopState(liveSessionIds: Set<string>): number {
+  let removed = 0
+  for (const sessionId of stateMap.keys()) {
+    if (!liveSessionIds.has(sessionId)) {
+      stateMap.delete(sessionId)
+      removed++
+    }
+  }
+  return removed
+}
+
 export function setMainLoopStateForSession(sessionId: string, patch: Partial<MainLoopState>): MainLoopState | null {
   const current = getOrCreateState(sessionId)
   if (!current) return null
@@ -608,15 +622,15 @@ export function handleMainLoopRunResult(input: HandleMainLoopRunResultInput): Ma
   state.updatedAt = nowTs
   state.missionTokens += Math.max(0, Math.trunc((input.inputTokens || 0) + (input.outputTokens || 0)))
   state.missionCostUsd += Math.max(0, Number(input.estimatedCost || 0))
-  state.metaMissCount = heartbeat || plan || review ? 0 : state.metaMissCount + 1
+  const cleanedResult = persistedText.trim()
+  const waitingForExternal = extractWaitSignal(resultText, toolEvents)
+  const gotTerminalAck = /^HEARTBEAT_OK$/i.test(cleanedResult) || /^NO_MESSAGE$/i.test(cleanedResult)
+  state.metaMissCount = heartbeat || plan || review || gotTerminalAck ? 0 : state.metaMissCount + 1
 
   if (input.internal) {
     state.pendingEvents = []
   }
 
-  const cleanedResult = persistedText.trim()
-  const waitingForExternal = extractWaitSignal(resultText, toolEvents)
-  const gotTerminalAck = /^HEARTBEAT_OK$/i.test(cleanedResult) || /^NO_MESSAGE$/i.test(cleanedResult)
   const needsReplan = review?.needs_replan === true || ((review?.confidence ?? 1) < 0.45)
   const limit = followupLimit()
 

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

@@ -7,7 +7,7 @@ import {
   mcpToolsToLangChain,
   disconnectMcpServer,
   connectMcpServer,
-} from './mcp-client.ts'
+} from './mcp-client'
 
 /* ============================================================
  * 1. sanitizeName

package/src/lib/server/mcp-conformance.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
-import { runMcpConformanceCheck } from './mcp-conformance.ts'
+import { runMcpConformanceCheck } from './mcp-conformance'
 
 test('runMcpConformanceCheck reports connect/list failure for unsupported transport', async () => {
   const result = await runMcpConformanceCheck({

package/src/lib/server/mcp-conformance.ts

@@ -1,5 +1,6 @@
 import type { McpServerConfig } from '@/types'
 import { connectMcpServer, disconnectMcpServer } from './mcp-client'
+import { errorMessage } from '@/lib/shared-utils'
 
 export interface McpConformanceIssue {
   level: 'error' | 'warning'
@@ -209,7 +210,7 @@ export async function runMcpConformanceCheck(
         issues.push({
           level: 'error',
           code: 'smoke_tool_failed',
-          message: err instanceof Error ? err.message : String(err),
+          message: errorMessage(err),
           toolName: smokeToolName,
         })
       } finally {
@@ -220,7 +221,7 @@ export async function runMcpConformanceCheck(
     issues.push({
       level: 'error',
       code: 'connect_or_list_failed',
-      message: err instanceof Error ? err.message : String(err),
+      message: errorMessage(err),
     })
   } finally {
     if (client && transport) {

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

@@ -1,5 +1,6 @@
 import { getMemoryDb } from './memory-db'
 import { HumanMessage } from '@langchain/core/messages'
+import { errorMessage } from '@/lib/shared-utils'
 
 /**
  * Produce daily digests per agent and prune stale entries.
@@ -89,7 +90,7 @@ export async function runDailyConsolidation(): Promise<{
 
       digestsCreated++
     } catch (err: unknown) {
-      errors.push(`Agent ${agentId}: ${err instanceof Error ? err.message : String(err)}`)
+      errors.push(`Agent ${agentId}: ${errorMessage(err)}`)
     }
   }