@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/session-tools/plugin-creator.ts

@@ -27,6 +27,8 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
   const action = normalized.action as string | undefined
   const filename = (normalized.filename ?? normalized.fileName) as string | undefined
   const code = (normalized.code ?? normalized.content) as string | undefined
+  const packageJson = normalized.packageJson ?? normalized.package_json ?? normalized.manifest
+  const packageManager = typeof normalized.packageManager === 'string' ? normalized.packageManager : undefined
   const approved = normalized.approved as boolean | undefined
 
   try {
@@ -40,15 +42,23 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
 
       // REQUIRE USER APPROVAL
       if (approved !== true) {
-        const { requestApproval } = await import('../approvals')
-        requestApproval({
+        const { requestApprovalMaybeAutoApprove } = await import('../approvals')
+        const approval = await requestApprovalMaybeAutoApprove({
           category: 'plugin_scaffold',
           title: `Scaffold Plugin: ${filename}`,
           description: `Create new plugin file with ${code.length} chars of code.`,
-          data: { filename, code, createdByAgentId: pctx.agentId || null },
+          data: { filename, code, packageJson, packageManager, createdByAgentId: pctx.agentId || null },
           agentId: pctx.agentId,
           sessionId: pctx.sessionId,
         })
+        if (approval.status === 'approved') {
+          return JSON.stringify({
+            type: 'plugin_scaffold_request',
+            filename,
+            autoApproved: true,
+            message: `Plugin "${filename}" was auto-approved and scaffolded. It is now available in this chat.`,
+          })
+        }
         return JSON.stringify({
           type: 'plugin_scaffold_request',
           filename,
@@ -56,12 +66,13 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
         })
       }
 
-      const filePath = path.join(PLUGINS_DIR, filename)
-      fs.writeFileSync(filePath, code, 'utf8')
-
-      // Reload the plugin manager so the new plugin is discovered
       const manager = getPluginManager()
-      manager.reload()
+      await manager.savePluginSource(filename, code, {
+        packageJson,
+        packageManager,
+        installDependencies: packageJson !== undefined,
+      })
+      const filePath = path.join(PLUGINS_DIR, filename)
 
       // Auto-enable the plugin for the agent that created it
       if (pctx.agentId && pctx.sessionId) {
@@ -70,9 +81,9 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
           const sessions = loadSessions()
           const session = sessions[pctx.sessionId!]
           if (session) {
-            const currentTools = session.tools || []
+            const currentTools = session.plugins || []
             if (!currentTools.includes(filename)) {
-              session.tools = [...currentTools, filename]
+              session.plugins = [...currentTools, filename]
               saveSessions(sessions)
             }
           }
@@ -82,10 +93,53 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
       return `Plugin saved to ${filePath} and PluginManager reloaded. It is now enabled for this chat.`
     }
 
+    if (action === 'install_dependencies') {
+      if (!filename) return 'Error: filename is required for install_dependencies.'
+
+      if (approved !== true) {
+        const { requestApprovalMaybeAutoApprove } = await import('../approvals')
+        const approval = await requestApprovalMaybeAutoApprove({
+          category: 'plugin_install',
+          title: `Install Plugin Dependencies: ${filename}`,
+          description: `Install package dependencies for plugin ${filename}${packageManager ? ` using ${packageManager}` : ''}.`,
+          data: { filename, packageJson, packageManager, createdByAgentId: pctx.agentId || null },
+          agentId: pctx.agentId,
+          sessionId: pctx.sessionId,
+        })
+        if (approval.status === 'approved') {
+          return JSON.stringify({
+            type: 'plugin_install_request',
+            filename,
+            autoApproved: true,
+            message: `Dependencies for "${filename}" were auto-approved and are being installed.`,
+          })
+        }
+        return JSON.stringify({
+          type: 'plugin_install_request',
+          filename,
+          message: `I've requested approval to install dependencies for "${filename}". Once approved, the plugin manager will run the selected package manager automatically.`,
+        })
+      }
+
+      const manager = getPluginManager()
+      if (packageJson !== undefined) {
+        const source = manager.readPluginSource(filename)
+        await manager.savePluginSource(filename, source, {
+          packageJson,
+          packageManager,
+          installDependencies: false,
+        })
+      }
+      const result = await manager.installPluginDependencies(filename, {
+        packageManager: packageManager as import('@/types').PluginPackageManager | undefined,
+      })
+      return `Dependencies installed for ${filename} using ${result.packageManager || packageManager || 'npm'}.`
+    }
+
     if (action === 'get_spec') {
       return `
 SwarmClaw Plugin Specification:
-A plugin is a CommonJS module (.js) that must be DUAL-COMPATIBLE with both SwarmClaw and OpenClaw platforms.
+A plugin is a JavaScript module (.js or .mjs) that can be dual-compatible with both SwarmClaw and OpenClaw platforms.
 
 \`\`\`js
 module.exports = {
@@ -100,10 +154,11 @@ module.exports = {
   hooks: {
     beforeAgentStart: async ({ session, message }) => {},
     afterAgentComplete: async ({ session, response }) => {},
-    beforeToolExec: async ({ session, toolName, args }) => {},
-    afterToolExec: async ({ session, toolName, result }) => {},
+    beforeToolExec: async ({ toolName, input }) => input,
+    afterToolExec: async ({ session, toolName, input, output }) => {},
     transformInboundMessage: async ({ session, text }) => { return text; },
     transformOutboundMessage: async ({ session, text }) => { return text; },
+    afterChatTurn: async ({ session, message, response, source, internal }) => {},
   },
 
   tools: [
@@ -140,27 +195,31 @@ module.exports = {
 \`\`\`
 
 Key rules:
-- Export BOTH SwarmClaw hooks/tools AND a register(api) method for cross-platform compatibility
-- SwarmClaw checks for hooks/tools first; OpenClaw checks for register()
+- Export SwarmClaw hooks/tools. Add register(api) too if you want OpenClaw compatibility.
+- SwarmClaw checks hooks/tools first; OpenClaw checks register()
 - Tools must have name, description, parameters (JSON Schema), and execute function
 - Hooks are optional — only include the ones you need
+- If your plugin needs npm/pnpm/yarn/bun packages, include a packageJson object during scaffold or call install_dependencies later.
+- Dependency installs are run by the plugin manager inside a per-plugin workspace using the selected package manager with scripts disabled.
+- Plugin settings are declared through ui.settingsFields and stored per plugin ID
 - Keep plugins focused: one clear purpose per plugin
 `
     }
 
     if (action === 'read') {
       if (!filename) return 'Error: filename required.'
-      const filePath = path.join(PLUGINS_DIR, filename)
-      if (!fs.existsSync(filePath)) return `File not found: ${filename}`
-      return fs.readFileSync(filePath, 'utf8')
+      return getPluginManager().readPluginSource(filename)
     }
 
     if (action === 'edit') {
       if (!filename || !code) return 'Error: filename and code are required for edit.'
-      const filePath = path.join(PLUGINS_DIR, filename)
-      if (!fs.existsSync(filePath)) return `File not found: ${filename}. Use scaffold to create new plugins.`
-      fs.writeFileSync(filePath, code, 'utf8')
-      getPluginManager().reload()
+      const manager = getPluginManager()
+      try {
+        manager.readPluginSource(filename)
+      } catch {
+        return `File not found: ${filename}. Use scaffold to create new plugins.`
+      }
+      await manager.savePluginSource(filename, code)
       return `Updated ${filename} and reloaded plugin manager.`
     }
 
@@ -175,7 +234,7 @@ Key rules:
       return `File not found: ${filename}`
     }
 
-    return `Unknown action "${action}". Valid actions: get_spec, scaffold, read, edit, delete`
+    return `Unknown action "${action}". Valid actions: get_spec, scaffold, read, edit, delete, install_dependencies`
   } catch (err: unknown) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`
   }
@@ -195,9 +254,11 @@ const PluginCreatorPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['get_spec', 'scaffold', 'read', 'edit', 'delete'], description: 'get_spec: learn format. scaffold: create (needs approval). read: view code. edit: update existing. delete: remove.' },
+          action: { type: 'string', enum: ['get_spec', 'scaffold', 'read', 'edit', 'delete', 'install_dependencies'], description: 'get_spec: learn format. scaffold: create (needs approval). read: view code. edit: update existing. delete: remove. install_dependencies: write/read package.json and install runtime deps.' },
           filename: { type: 'string', description: 'Plugin filename, e.g. my-plugin.js. Required for scaffold and delete.' },
           code: { type: 'string', description: 'The raw JavaScript code for the plugin. Required for scaffold.' },
+          packageJson: { type: 'object', description: 'Optional package.json object for dependency-aware plugins. Use with scaffold or install_dependencies.' },
+          packageManager: { type: 'string', enum: ['npm', 'pnpm', 'yarn', 'bun'], description: 'Optional package manager to use for dependency installs.' },
           approved: { type: 'boolean', description: 'Internal flag — do NOT set this. The approval system handles it automatically.' }
         },
         required: ['action']
@@ -220,7 +281,7 @@ getPluginManager().registerBuiltin('plugin_creator', PluginCreatorPlugin)
  * Legacy Bridge
  */
 export function buildPluginCreatorTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('plugin_creator')) return []
+  if (!bctx.hasPlugin('plugin_creator')) return []
   return [
     tool(
       async (args) => executePluginCreatorAction(args, bctx),
@@ -228,9 +289,11 @@ export function buildPluginCreatorTools(bctx: ToolBuildContext): StructuredToolI
         name: 'plugin_creator_tool',
         description: PluginCreatorPlugin.tools![0].description,
         schema: z.object({
-          action: z.enum(['get_spec', 'scaffold', 'read', 'edit', 'delete']),
+          action: z.enum(['get_spec', 'scaffold', 'read', 'edit', 'delete', 'install_dependencies']),
           filename: z.string().optional(),
           code: z.string().optional(),
+          packageJson: z.record(z.string(), z.any()).optional(),
+          packageManager: z.enum(['npm', 'pnpm', 'yarn', 'bun']).optional(),
           approved: z.boolean().optional()
         })
       }

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