@swarmclawai/swarmclaw 0.7.2 → 0.7.3

package/src/lib/server/session-tools/primitive-tools.test.ts

@@ -0,0 +1,257 @@
+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'
+import type { Session } from '@/types'
+
+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 workspaceDir = ''
+let buildDocumentTools: typeof import('./document').buildDocumentTools
+let buildExtractTools: typeof import('./extract').buildExtractTools
+let buildTableTools: typeof import('./table').buildTableTools
+let buildMailboxTools: typeof import('./mailbox').buildMailboxTools
+let buildHumanLoopTools: typeof import('./human-loop').buildHumanLoopTools
+let buildCrawlTools: typeof import('./crawl').buildCrawlTools
+let sessionMailbox: typeof import('../session-mailbox')
+let watchJobs: typeof import('../watch-jobs')
+let storage: typeof import('../storage')
+
+function makeSession(overrides?: Partial<Session>): Session {
+  return {
+    id: 'session_1',
+    name: 'Test Session',
+    cwd: workspaceDir,
+    user: 'tester',
+    provider: 'ollama',
+    model: 'qwen3.5',
+    apiEndpoint: 'http://localhost:11434',
+    claudeSessionId: null,
+    messages: [],
+    createdAt: Date.now(),
+    lastActiveAt: Date.now(),
+    plugins: [],
+    ...overrides,
+  }
+}
+
+function makeBuildContext(overrides?: {
+  cwd?: string
+  session?: Session
+}) {
+  const session = overrides?.session || makeSession()
+  return {
+    cwd: overrides?.cwd || workspaceDir,
+    ctx: {
+      sessionId: session.id,
+      agentId: session.agentId || 'agent_1',
+    },
+    hasPlugin: () => true,
+    hasTool: () => true,
+    cleanupFns: [],
+    commandTimeoutMs: 5000,
+    claudeTimeoutMs: 5000,
+    cliProcessTimeoutMs: 5000,
+    persistDelegateResumeId: () => {},
+    readStoredDelegateResumeId: () => null,
+    resolveCurrentSession: () => session,
+    activePlugins: [],
+  }
+}
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-primitive-tools-'))
+  workspaceDir = path.join(tempDir, 'workspace')
+  fs.mkdirSync(workspaceDir, { recursive: true })
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = workspaceDir
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  fs.mkdirSync(process.env.DATA_DIR, { recursive: true })
+
+  ;({ buildDocumentTools } = await import('./document'))
+  ;({ buildExtractTools } = await import('./extract'))
+  ;({ buildTableTools } = await import('./table'))
+  ;({ buildMailboxTools } = await import('./mailbox'))
+  ;({ buildHumanLoopTools } = await import('./human-loop'))
+  ;({ buildCrawlTools } = await import('./crawl'))
+  sessionMailbox = await import('../session-mailbox')
+  watchJobs = await import('../watch-jobs')
+  storage = await import('../storage')
+})
+
+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('primitive tools', () => {
+  it('document tool reads, stores, and searches extracted text', async () => {
+    const sourcePath = path.join(workspaceDir, 'note.txt')
+    fs.writeFileSync(sourcePath, 'Invoice 42 for ACME\nTotal: $120.50\n')
+
+    const [documentTool] = buildDocumentTools(makeBuildContext())
+    const read = JSON.parse(String(await documentTool.invoke({ action: 'read', filePath: 'note.txt' })))
+    assert.match(read.text, /Invoice 42/)
+
+    const stored = JSON.parse(String(await documentTool.invoke({ action: 'store', filePath: 'note.txt', title: 'Invoice Note' })))
+    const search = JSON.parse(String(await documentTool.invoke({ action: 'search', query: 'ACME' })))
+    const fetched = JSON.parse(String(await documentTool.invoke({ action: 'get', id: stored.id })))
+
+    assert.equal(search.matches[0].id, stored.id)
+    assert.equal(fetched.title, 'Invoice Note')
+  })
+
+  it('table tool transforms inline data and writes results', async () => {
+    const [tableTool] = buildTableTools(makeBuildContext())
+    const rows = [
+      { id: '1', name: 'Ada', score: 10 },
+      { id: '2', name: 'Grace', score: 25 },
+      { id: '2', name: 'Grace', score: 25 },
+    ]
+
+    const filtered = JSON.parse(String(await tableTool.invoke({
+      action: 'filter',
+      rows,
+      where: [{ column: 'score', op: 'gt', value: 15 }],
+    })))
+    assert.equal(filtered.rowCount, 2)
+
+    const deduped = JSON.parse(String(await tableTool.invoke({
+      action: 'dedupe',
+      rows,
+      on: ['id'],
+    })))
+    assert.equal(deduped.rowCount, 2)
+
+    const joined = JSON.parse(String(await tableTool.invoke({
+      action: 'join',
+      leftRows: [{ id: '1', team: 'red' }],
+      rightRows: [{ id: '1', email: 'ada@example.com' }],
+      on: 'id',
+    })))
+    assert.equal(joined.rows[0].email, 'ada@example.com')
+
+    const writeResult = JSON.parse(String(await tableTool.invoke({
+      action: 'write',
+      rows,
+      outputPath: 'exports/report.csv',
+    })))
+    assert.equal(fs.existsSync(writeResult.output.filePath), true)
+  })
+
+  it('human-loop tool creates durable mailbox and approval waits', async () => {
+    const [humanTool] = buildHumanLoopTools(makeBuildContext())
+    const sessions = storage.loadSessions()
+    sessions.session_1 = makeSession({ id: 'session_1', agentId: 'agent_1' })
+    storage.saveSessions(sessions)
+
+    const requestInput = JSON.parse(String(await humanTool.invoke({
+      action: 'request_input',
+      question: 'Ship it?',
+      correlationId: 'corr_123',
+    })))
+    assert.equal(requestInput.ok, true)
+
+    const replyWatch = JSON.parse(String(await humanTool.invoke({
+      action: 'wait_for_reply',
+      correlationId: 'corr_123',
+    })))
+    const replyEnvelope = sessionMailbox.sendMailboxEnvelope({
+      toSessionId: 'session_1',
+      type: 'human_reply',
+      payload: 'yes',
+      correlationId: 'corr_123',
+    })
+    watchJobs.triggerMailboxWatchJobs({ sessionId: 'session_1', envelope: replyEnvelope })
+    assert.equal(watchJobs.getWatchJob(replyWatch.id)?.status, 'triggered')
+
+    const approval = JSON.parse(String(await humanTool.invoke({
+      action: 'request_approval',
+      title: 'Need signoff',
+      question: 'Allow publish?',
+    })))
+    const approvalWatch = JSON.parse(String(await humanTool.invoke({
+      action: 'wait_for_approval',
+      approvalId: approval.id,
+    })))
+    watchJobs.triggerApprovalWatchJobs({ approvalId: approval.id, status: 'approved' })
+    assert.equal(watchJobs.getWatchJob(approvalWatch.id)?.status, 'triggered')
+  })
+
+  it('mailbox tool reports configuration status without requiring network', async () => {
+    const [mailboxTool] = buildMailboxTools(makeBuildContext())
+    const status = JSON.parse(String(await mailboxTool.invoke({ action: 'status' })))
+    assert.equal(status.configured, false)
+    assert.equal(status.folder, 'INBOX')
+  })
+
+  it('extract tool reports active model context', async () => {
+    const [extractTool] = buildExtractTools(makeBuildContext({
+      session: makeSession({
+        provider: 'ollama',
+        model: 'qwen3.5',
+        apiEndpoint: 'http://localhost:11434',
+      }),
+    }))
+    const status = JSON.parse(String(await extractTool.invoke({ action: 'status' })))
+    assert.equal(status.provider, 'ollama')
+    assert.equal(Array.isArray(status.supports), true)
+  })
+
+  it('crawl tool crawls and dedupes fetched pages without a live server', async () => {
+    const originalFetch = global.fetch
+    global.fetch = (async (input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString()
+      if (url.endsWith('/page-2')) {
+        return new Response('<html><head><title>Page Two</title></head><body><article><h1>Second</h1><p>Next content</p></article></body></html>', {
+          status: 200,
+          headers: { 'content-type': 'text/html' },
+        })
+      }
+      return new Response('<html><head><title>Root</title></head><body><article><h1>Home</h1><p>Welcome</p></article><a href="/page-2" rel="next">Next</a></body></html>', {
+        status: 200,
+        headers: { 'content-type': 'text/html' },
+      })
+    }) as typeof fetch
+
+    try {
+      const [crawlTool] = buildCrawlTools(makeBuildContext())
+      const baseUrl = 'https://example.test/'
+
+      const crawled = JSON.parse(String(await crawlTool.invoke({
+        action: 'crawl_site',
+        url: baseUrl,
+        limit: 2,
+      })))
+      assert.equal(crawled.count, 2)
+      assert.equal(crawled.pages[0].title, 'Root')
+
+      const extracted = JSON.parse(String(await crawlTool.invoke({
+        action: 'extract_sitemap',
+        url: baseUrl,
+        limit: 2,
+      })))
+      assert.equal(extracted.count, 2)
+      assert.equal(extracted.urls.includes('https://example.test/page-2'), true)
+
+      const deduped = JSON.parse(String(await crawlTool.invoke({
+        action: 'dedupe_pages',
+        pages: [crawled.pages[0], crawled.pages[0], crawled.pages[1]],
+      })))
+      assert.equal(deduped.count, 2)
+    } finally {
+      global.fetch = originalFetch
+    }
+  })
+})

package/src/lib/server/session-tools/replicate.ts

@@ -3,7 +3,6 @@ import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
-import { loadSettings } from '../storage'
 import type { ToolBuildContext } from './context'
 
 interface ReplicateConfig {
@@ -14,8 +13,7 @@ interface ReplicateConfig {
 }
 
 function getConfig(): ReplicateConfig {
-  const settings = loadSettings()
-  const ps = (settings.pluginSettings as Record<string, Record<string, unknown>> | undefined)?.replicate ?? {}
+  const ps = getPluginManager().getPluginSettings('replicate')
   return {
     apiToken: (ps.apiToken as string) || '',
     defaultModel: (ps.defaultModel as string) || '',

package/src/lib/server/session-tools/schedule.ts

@@ -6,6 +6,7 @@ import type { ToolBuildContext } from './context'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { createWatchJob } from '../watch-jobs'
 
 /**
  * Core Schedule Execution Logic
@@ -15,7 +16,7 @@ async function executeScheduleWake(args: { delayMinutes: number; message: string
   const delayMinutes = normalized.delayMinutes as number
   const message = normalized.message as string
   if (!context.sessionId) return 'Cannot schedule wake: no session context.'
-  if (delayMinutes < 0 || delayMinutes > 1440) return 'delayMinutes must be between 0 and 1440 (24 hours).'
+  if (delayMinutes < 0 || delayMinutes > 43_200) return 'delayMinutes must be between 0 and 43200 (30 days).'
 
   if (delayMinutes === 0) {
     enqueueSystemEvent(context.sessionId, `[Scheduled Wake Event / Reminder] ${message}`)
@@ -23,15 +24,24 @@ async function executeScheduleWake(args: { delayMinutes: number; message: string
     return 'Successfully scheduled an immediate wake event.'
   }
 
-  const delayMs = delayMinutes * 60 * 1000
-  setTimeout(() => {
-    if (context.sessionId) {
-      enqueueSystemEvent(context.sessionId, `[Scheduled Wake Event / Reminder] ${message}`)
-      requestHeartbeatNow({ sessionId: context.sessionId, reason: 'scheduled_wake' })
-    }
-  }, delayMs)
+  const runAt = Date.now() + delayMinutes * 60 * 1000
+  const watch = await createWatchJob({
+    type: 'time',
+    sessionId: context.sessionId,
+    resumeMessage: message,
+    description: `Scheduled wake in ${delayMinutes} minutes`,
+    target: { source: 'schedule_wake' },
+    condition: {},
+    runAt,
+  })
 
-  return `Successfully scheduled a wake event in ${delayMinutes} minutes.`
+  return JSON.stringify({
+    ok: true,
+    jobId: watch.id,
+    delayMinutes,
+    runAt,
+    message,
+  })
 }
 
 /**
@@ -39,7 +49,7 @@ async function executeScheduleWake(args: { delayMinutes: number; message: string
  */
 const SchedulePlugin: Plugin = {
   name: 'Core Scheduler',
-  description: 'Schedule wake events and reminders for agents.',
+  description: 'Schedule durable wake events and reminders for agents.',
   hooks: {
     getCapabilityDescription: () => 'I can set a conversational timer (`schedule_wake`) to remind myself to check back on something later in this chat.',
   } as PluginHooks,

package/src/lib/server/session-tools/session-info.ts

@@ -33,6 +33,7 @@ async function executeSessionsAction(args: any, context: { sessionId?: string; a
   const limit = normalized.limit as number | undefined
   const agentId = (normalized.agentId ?? normalized.agent_id) as string | undefined
   const name = normalized.name as string | undefined
+  const updates = normalized.updates as Record<string, unknown> | undefined
   try {
     const sessions = loadSessions()
     if (action === 'list') {
@@ -53,12 +54,43 @@ async function executeSessionsAction(args: any, context: { sessionId?: string; a
       sessions[id] = {
         id, name: (name || `${agent.name} Chat`).trim(), cwd: context.cwd, user: 'system',
         provider: agent.provider, model: agent.model, credentialId: agent.credentialId || null,
-        messages: [], createdAt: now, lastActiveAt: now, sessionType: 'orchestrated',
+        messages: [], createdAt: now, lastActiveAt: now, sessionType: 'human',
         agentId: agent.id, parentSessionId: context.sessionId || undefined, plugins: agent.plugins || agent.tools || [],
       }
       saveSessions(sessions)
       return JSON.stringify({ sessionId: id, name: agent.name })
     }
+    if (action === 'update') {
+      const targetId = sessionId || context.sessionId || ''
+      if (!targetId) return 'sessionId required.'
+      const target = sessions[targetId]
+      if (!target) return 'Not found.'
+      const allowedKeys = new Set([
+        'thinkingLevel',
+        'connectorThinkLevel',
+        'sessionResetMode',
+        'sessionIdleTimeoutSec',
+        'sessionMaxAgeSec',
+        'sessionDailyResetAt',
+        'sessionResetTimezone',
+        'connectorSessionScope',
+        'connectorReplyMode',
+        'connectorThreadBinding',
+        'connectorGroupPolicy',
+        'connectorIdleTimeoutSec',
+        'connectorMaxAgeSec',
+        'identityState',
+        'provider',
+        'model',
+      ])
+      const patch = updates && typeof updates === 'object' ? updates : {}
+      for (const [key, value] of Object.entries(patch)) {
+        if (!allowedKeys.has(key)) continue
+        target[key] = value
+      }
+      saveSessions(sessions)
+      return JSON.stringify({ sessionId: targetId, updated: Object.keys(patch).filter((key) => allowedKeys.has(key)) })
+    }
     return `Unknown action "${action}".`
   } catch (err: any) { return `Error: ${err.message}` }
 }
@@ -86,11 +118,12 @@ const SessionInfoPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['list', 'history', 'spawn', 'status', 'stop'] },
+          action: { type: 'string', enum: ['list', 'history', 'spawn', 'status', 'stop', 'update'] },
           sessionId: { type: 'string' },
           agentId: { type: 'string' },
           message: { type: 'string' },
-          limit: { type: 'number' }
+          limit: { type: 'number' },
+          updates: { type: 'object' },
         },
         required: ['action']
       },

package/src/lib/server/session-tools/session-tools-wiring.test.ts

@@ -24,6 +24,21 @@ describe('module exports', () => {
     const mem = await import('./memory')
     assert.equal(typeof mem.buildMemoryTools, 'function')
   })
+
+  it('primitive tool builders are exported', async () => {
+    const document = await import('./document')
+    const extract = await import('./extract')
+    const table = await import('./table')
+    const crawl = await import('./crawl')
+    const mailbox = await import('./mailbox')
+    const humanLoop = await import('./human-loop')
+    assert.equal(typeof document.buildDocumentTools, 'function')
+    assert.equal(typeof extract.buildExtractTools, 'function')
+    assert.equal(typeof table.buildTableTools, 'function')
+    assert.equal(typeof crawl.buildCrawlTools, 'function')
+    assert.equal(typeof mailbox.buildMailboxTools, 'function')
+    assert.equal(typeof humanLoop.buildHumanLoopTools, 'function')
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -60,46 +75,45 @@ describe('buildSessionTools signature', () => {
 })
 
 // ---------------------------------------------------------------------------
-// 4. Memory tool schema — knowledge actions
+// 4. Memory tool schema
 //    buildMemoryTools calls getMemoryDb() eagerly so we cannot invoke it
 //    without a real SQLite DB. Instead we read the source and verify the
-//    action enum includes the knowledge actions.
+//    declared action enum matches the current JSON schema definition.
 // ---------------------------------------------------------------------------
 describe('memory tool knowledge actions (source verification)', () => {
-  it('action enum in memory.ts includes knowledge_store and knowledge_search', async () => {
+  it('action enum in memory.ts includes the declared base actions', async () => {
     const fs = await import('fs')
     const src = fs.readFileSync(
       new URL('./memory.ts', import.meta.url).pathname,
       'utf-8',
     )
 
-    // Find the z.enum([...]) for the action field
-    const enumMatch = src.match(/z\.enum\(\[([^\]]+)\]\)\.describe\([^)]*action/s)
-    assert.ok(enumMatch, 'Should find a z.enum() for the action field')
+    const enumMatch = src.match(/action:\s*\{\s*type:\s*'string',\s*enum:\s*\[([^\]]+)\]/s)
+    assert.ok(enumMatch, 'Should find the action enum in the memory tool schema')
 
     const enumBody = enumMatch![1]
-    assert.ok(enumBody.includes("'knowledge_store'"), 'action enum should include knowledge_store')
-    assert.ok(enumBody.includes("'knowledge_search'"), 'action enum should include knowledge_search')
+    const expectedActions = ['store', 'get', 'search', 'list', 'delete']
+    for (const action of expectedActions) {
+      assert.ok(
+        enumBody.includes(`'${action}'`),
+        `action enum should include '${action}'`,
+      )
+    }
   })
 
-  it('action enum includes all expected base actions', async () => {
+  it('action enum does not advertise removed knowledge actions', async () => {
     const fs = await import('fs')
     const src = fs.readFileSync(
       new URL('./memory.ts', import.meta.url).pathname,
       'utf-8',
     )
 
-    const enumMatch = src.match(/z\.enum\(\[([^\]]+)\]\)/)
+    const enumMatch = src.match(/action:\s*\{\s*type:\s*'string',\s*enum:\s*\[([^\]]+)\]/s)
     assert.ok(enumMatch)
     const enumBody = enumMatch![1]
 
-    const expectedActions = ['store', 'get', 'search', 'list', 'delete', 'link', 'unlink', 'knowledge_store', 'knowledge_search']
-    for (const action of expectedActions) {
-      assert.ok(
-        enumBody.includes(`'${action}'`),
-        `action enum should include '${action}'`,
-      )
-    }
+    assert.equal(enumBody.includes("'knowledge_store'"), false)
+    assert.equal(enumBody.includes("'knowledge_search'"), false)
   })
 })