@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/session-tools/discovery-approvals.test.ts

@@ -0,0 +1,170 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-discovery-approval-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('discovery approval flows', () => {
+  it('request_tool_access creates a real approval and grants the tool when auto-approved', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const toolsMod = await import('./src/lib/server/session-tools/index.ts')
+      const storage = storageMod.default || storageMod
+      const toolsApi = toolsMod.default || toolsMod
+
+      storage.saveSettings({ approvalsEnabled: false })
+
+      const now = Date.now()
+      storage.saveSessions({
+        session_tools: {
+          id: 'session_tools',
+          name: 'Tool Access Test',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'default',
+          plugins: [],
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, [], {
+        sessionId: 'session_tools',
+        agentId: 'default',
+        platformAssignScope: 'self',
+      })
+      const tool = built.tools.find((entry) => entry.name === 'request_tool_access')
+      const raw = await tool.invoke({ toolId: 'shell', reason: 'Need terminal access.' })
+      const approvals = storage.loadApprovals()
+      const session = storage.loadSessions().session_tools
+      console.log(JSON.stringify({
+        raw,
+        approvalCount: Object.keys(approvals).length,
+        plugins: session.plugins || [],
+      }))
+    `)
+
+    assert.match(String(output.raw), /auto-approved|granted/i)
+    assert.equal(output.approvalCount, 1)
+    assert.equal(output.plugins.includes('shell'), true)
+  })
+
+  it('manage_capabilities request_access accepts query aliases for pluginId', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const toolsMod = await import('./src/lib/server/session-tools/index.ts')
+      const storage = storageMod.default || storageMod
+      const toolsApi = toolsMod.default || toolsMod
+
+      storage.saveSettings({ approvalsEnabled: false })
+
+      const now = Date.now()
+      storage.saveSessions({
+        session_caps: {
+          id: 'session_caps',
+          name: 'Capabilities Test',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'default',
+          plugins: [],
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, [], {
+        sessionId: 'session_caps',
+        agentId: 'default',
+        platformAssignScope: 'self',
+      })
+      const tool = built.tools.find((entry) => entry.name === 'manage_capabilities')
+      const raw = await tool.invoke({ action: 'request_access', query: 'shell', reason: 'Need terminal access.' })
+      const session = storage.loadSessions().session_caps
+      console.log(JSON.stringify({
+        raw,
+        plugins: session.plugins || [],
+      }))
+    `)
+
+    assert.match(String(output.raw), /auto-approved|granted/i)
+    assert.equal(output.plugins.includes('shell'), true)
+  })
+
+  it('granting manage_schedules does not surface the manage_platform umbrella tool', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const toolsMod = await import('./src/lib/server/session-tools/index.ts')
+      const storage = storageMod.default || storageMod
+      const toolsApi = toolsMod.default || toolsMod
+
+      const now = Date.now()
+      storage.saveSessions({
+        session_sched: {
+          id: 'session_sched',
+          name: 'Schedule Tool Isolation',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'default',
+          plugins: ['manage_schedules'],
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, ['manage_schedules'], {
+        sessionId: 'session_sched',
+        agentId: 'default',
+        platformAssignScope: 'self',
+      })
+      console.log(JSON.stringify({
+        toolNames: built.tools.map((entry) => entry.name).sort(),
+      }))
+    `)
+
+    assert.equal(output.toolNames.includes('manage_schedules'), true)
+    assert.equal(output.toolNames.includes('manage_platform'), false)
+  })
+})

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

@@ -15,15 +15,24 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
   const normalized = normalizeToolInputArgs(args)
   const action = normalized.action
   const approved = normalized.approved
-  const pluginId = typeof normalized.pluginId === 'string'
+  const explicitPluginId = typeof normalized.pluginId === 'string'
     ? normalized.pluginId.trim()
     : typeof normalized.plugin_id === 'string'
       ? normalized.plugin_id.trim()
-      : undefined
+      : typeof normalized.toolId === 'string'
+        ? normalized.toolId.trim()
+        : typeof normalized.tool_id === 'string'
+          ? normalized.tool_id.trim()
+          : typeof normalized.tool === 'string'
+            ? normalized.tool.trim()
+            : typeof normalized.name === 'string'
+              ? normalized.name.trim()
+              : undefined
   const url = typeof normalized.url === 'string' ? normalized.url.trim() : undefined
   const reason = normalized.reason as string | undefined
   const manager = getPluginManager()
   const q = typeof normalized.query === 'string' ? normalized.query : ''
+  const pluginId = explicitPluginId || (action === 'request_access' ? q.trim() : '')
 
   console.log('[discovery] Executing action:', action, { query: q, pluginId })
 
@@ -88,7 +97,8 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
         if (bctx?.ctx?.sessionId) {
           const allSessions = loadSessions()
           const currentSession = allSessions[bctx.ctx.sessionId]
-          if (currentSession && pluginIdMatches(currentSession.tools, pluginId)) {
+          const grantedTools = currentSession?.plugins || currentSession?.tools || []
+          if (currentSession && pluginIdMatches(grantedTools, pluginId)) {
             return JSON.stringify({
               alreadyGranted: true,
               pluginId,
@@ -96,8 +106,8 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
             })
           }
         }
-        const { requestApproval } = await import('../approvals')
-        requestApproval({
+        const { requestApprovalMaybeAutoApprove } = await import('../approvals')
+        const approval = await requestApprovalMaybeAutoApprove({
           category: 'tool_access',
           title: `Enable Plugin: ${pluginId}`,
           description: reason || `Agent is requesting access to the "${pluginId}" plugin.`,
@@ -105,6 +115,15 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
           agentId: bctx?.ctx?.agentId,
           sessionId: bctx?.ctx?.sessionId,
         })
+        if (approval.status === 'approved') {
+          return JSON.stringify({
+            alreadyGranted: true,
+            pluginId,
+            toolId: pluginId,
+            autoApproved: true,
+            message: `Access to "${pluginId}" was auto-approved and granted. Proceed to use it directly.`,
+          })
+        }
         return JSON.stringify({
           type: 'plugin_request',
           pluginId,
@@ -118,8 +137,8 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
           return JSON.stringify({ error: 'url is required for install_request.' })
         }
         if (approved !== true) {
-          const { requestApproval } = await import('../approvals')
-          requestApproval({
+          const { requestApprovalMaybeAutoApprove } = await import('../approvals')
+          const approval = await requestApprovalMaybeAutoApprove({
             category: 'plugin_install',
             title: `Install Plugin${pluginId ? `: ${pluginId}` : ' from URL'}`,
             description: reason || `Agent wants to install a plugin${url ? ` from ${url}` : ''}.`,
@@ -127,6 +146,15 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
             agentId: bctx?.ctx?.agentId,
             sessionId: bctx?.ctx?.sessionId,
           })
+          if (approval.status === 'approved') {
+            return JSON.stringify({
+              type: 'plugin_install_request',
+              url,
+              pluginId,
+              autoApproved: true,
+              message: `Plugin install from ${url} was auto-approved and has been applied.`,
+            })
+          }
           return JSON.stringify({
             type: 'plugin_install_request',
             url,
@@ -158,13 +186,13 @@ const DiscoveryPlugin: Plugin = {
   tools: [
     {
       name: 'manage_capabilities',
-      description: 'Search for available plugins locally or in external marketplaces.',
+      description: 'Discover currently available tools, search marketplaces, or request access to a direct tool/plugin name with action="request_access" (for example "shell", "manage_schedules", or "delegate").',
       parameters: {
         type: 'object',
         properties: {
           action: { type: 'string', enum: ['discover', 'search_marketplace', 'request_access', 'install_request'] },
-          query: { type: 'string', description: 'Search term for marketplace' },
-          pluginId: { type: 'string', description: 'The ID or filename of the plugin' },
+          query: { type: 'string', description: 'Search term for marketplace, or the direct tool/plugin name for request_access' },
+          pluginId: { type: 'string', description: 'The exact tool/plugin name to request, such as "shell" or "manage_schedules"' },
           url: { type: 'string', description: 'URL for new plugin install request' },
           reason: { type: 'string', description: 'Why you need this capability' }
         },
@@ -187,8 +215,8 @@ export function buildDiscoveryTools(bctx: ToolBuildContext): StructuredToolInter
         description: DiscoveryPlugin.tools![0].description,
         schema: z.object({
           action: z.enum(['discover', 'search_marketplace', 'request_access', 'install_request']).describe('The discovery action to perform'),
-          query: z.string().optional().describe('The search query for marketplace actions'),
-          pluginId: z.string().optional(),
+          query: z.string().optional().describe('The marketplace query, or the direct tool/plugin name to request access to'),
+          pluginId: z.string().optional().describe('The exact tool/plugin name to request, such as "shell" or "manage_schedules"'),
           url: z.string().optional(),
           reason: z.string().describe('Why you need to perform this discovery action')
         })

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

@@ -0,0 +1,283 @@
+import path from 'path'
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { genId } from '@/lib/id'
+import type { DocumentEntry, Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { loadDocuments, saveDocuments } from '../storage'
+import { extractDocumentArtifact } from '../document-utils'
+import type { ToolBuildContext } from './context'
+import { findBinaryOnPath, safePath } from './context'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+
+function parseMetadataInput(value: unknown): Record<string, unknown> {
+  if (!value) return {}
+  if (typeof value === 'object' && !Array.isArray(value)) return value as Record<string, unknown>
+  if (typeof value === 'string' && value.trim()) {
+    try {
+      const parsed = JSON.parse(value)
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed as Record<string, unknown>
+    } catch {
+      return {}
+    }
+  }
+  return {}
+}
+
+function resolveFilePath(cwd: string, value: unknown): string {
+  if (typeof value !== 'string' || !value.trim()) throw new Error('filePath is required.')
+  return path.isAbsolute(value) ? path.resolve(value) : safePath(cwd, value)
+}
+
+function previewTables(tables: Awaited<ReturnType<typeof extractDocumentArtifact>>['tables']) {
+  return tables.map((table) => ({
+    name: table.name,
+    headers: table.headers,
+    rowCount: table.rowCount,
+    rows: table.rows.slice(0, 20),
+    truncated: table.rowCount > 20,
+  }))
+}
+
+function searchStoredDocuments(documents: Record<string, DocumentEntry>, query: string, limit: number) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean)
+  return Object.values(documents)
+    .map((doc) => {
+      const hay = `${doc.title}\n${doc.fileName}\n${doc.content}`.toLowerCase()
+      if (!terms.every((term) => hay.includes(term))) return null
+      let score = hay.includes(query.toLowerCase()) ? 10 : 0
+      for (const term of terms) {
+        let at = hay.indexOf(term)
+        while (at !== -1) {
+          score += 1
+          at = hay.indexOf(term, at + term.length)
+        }
+      }
+      const firstTerm = terms[0] || query
+      const at = hay.indexOf(firstTerm.toLowerCase())
+      const start = at >= 0 ? Math.max(0, at - 120) : 0
+      const end = Math.min(doc.content.length, start + 360)
+      return {
+        id: doc.id,
+        title: doc.title,
+        fileName: doc.fileName,
+        score,
+        snippet: doc.content.slice(start, end).replace(/\s+/g, ' ').trim(),
+        updatedAt: doc.updatedAt,
+      }
+    })
+    .filter((entry): entry is NonNullable<typeof entry> => !!entry)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+}
+
+async function executeDocumentAction(
+  args: Record<string, unknown>,
+  bctx: { cwd: string; sessionId?: string | null; agentId?: string | null },
+) {
+  const normalized = normalizeToolInputArgs(args)
+  const action = String(normalized.action || 'status').trim().toLowerCase()
+
+  try {
+    if (action === 'status') {
+      return JSON.stringify({
+        pdftotext: findBinaryOnPath('pdftotext') || null,
+        textutil: findBinaryOnPath('textutil') || null,
+        tesseract: findBinaryOnPath('tesseract') || null,
+        supports: ['read', 'metadata', 'ocr', 'extract_tables', 'store', 'list', 'search', 'get', 'delete'],
+      })
+    }
+
+    if (action === 'list' || action === 'list_stored') {
+      const documents = loadDocuments() as Record<string, DocumentEntry>
+      const limit = typeof normalized.limit === 'number' ? Math.max(1, Math.min(normalized.limit, 200)) : 50
+      return JSON.stringify(
+        Object.values(documents)
+          .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0))
+          .slice(0, limit)
+          .map((doc) => ({
+            id: doc.id,
+            title: doc.title,
+            fileName: doc.fileName,
+            sourcePath: doc.sourcePath,
+            textLength: doc.textLength,
+            method: doc.method,
+            metadata: doc.metadata || {},
+            createdAt: doc.createdAt,
+            updatedAt: doc.updatedAt,
+          })),
+      )
+    }
+
+    if (action === 'search' || action === 'search_stored') {
+      const query = typeof normalized.query === 'string' ? normalized.query.trim() : ''
+      if (!query) return 'Error: query is required.'
+      const documents = loadDocuments() as Record<string, DocumentEntry>
+      const limit = typeof normalized.limit === 'number' ? Math.max(1, Math.min(normalized.limit, 50)) : 10
+      const matches = searchStoredDocuments(documents, query, limit)
+      return JSON.stringify({ query, total: matches.length, matches })
+    }
+
+    if (action === 'get' || action === 'get_stored') {
+      const id = typeof normalized.id === 'string' ? normalized.id.trim() : ''
+      if (!id) return 'Error: id is required.'
+      const documents = loadDocuments() as Record<string, DocumentEntry>
+      const doc = documents[id]
+      if (!doc) return `Error: document "${id}" not found.`
+      return JSON.stringify({
+        ...doc,
+        content: doc.content.length > 80_000 ? `${doc.content.slice(0, 80_000)}\n... [truncated]` : doc.content,
+      })
+    }
+
+    if (action === 'delete' || action === 'delete_stored') {
+      const id = typeof normalized.id === 'string' ? normalized.id.trim() : ''
+      if (!id) return 'Error: id is required.'
+      const documents = loadDocuments() as Record<string, DocumentEntry>
+      if (!documents[id]) return `Error: document "${id}" not found.`
+      delete documents[id]
+      saveDocuments(documents)
+      return JSON.stringify({ ok: true, id })
+    }
+
+    const filePath = resolveFilePath(bctx.cwd, normalized.filePath ?? normalized.path)
+    const artifact = await extractDocumentArtifact(filePath, {
+      preferOcr: action === 'ocr' || normalized.preferOcr === true,
+      maxChars: typeof normalized.maxChars === 'number' ? Math.max(5_000, normalized.maxChars) : undefined,
+    })
+
+    if (action === 'metadata') {
+      return JSON.stringify({
+        filePath: artifact.filePath,
+        fileName: artifact.fileName,
+        ext: artifact.ext,
+        method: artifact.method,
+        metadata: artifact.metadata,
+        textLength: artifact.text.length,
+        tableCount: artifact.tables.length,
+      })
+    }
+
+    if (action === 'extract_tables') {
+      return JSON.stringify({
+        filePath: artifact.filePath,
+        fileName: artifact.fileName,
+        tableCount: artifact.tables.length,
+        tables: previewTables(artifact.tables),
+      })
+    }
+
+    if (action === 'store') {
+      if (!artifact.text.trim()) return 'Error: extracted document text is empty.'
+      const documents = loadDocuments() as Record<string, DocumentEntry>
+      const now = Date.now()
+      const docId = genId(8)
+      const entry: DocumentEntry = {
+        id: docId,
+        title: typeof normalized.title === 'string' && normalized.title.trim() ? normalized.title.trim() : artifact.fileName,
+        fileName: artifact.fileName,
+        sourcePath: artifact.filePath,
+        content: artifact.text,
+        method: artifact.method,
+        textLength: artifact.text.length,
+        metadata: {
+          ...artifact.metadata,
+          ...parseMetadataInput(normalized.metadata),
+          ext: artifact.ext,
+          tableCount: artifact.tables.length,
+          storedByAgentId: bctx.agentId || null,
+          storedInSessionId: bctx.sessionId || null,
+        },
+        createdAt: now,
+        updatedAt: now,
+      }
+      documents[entry.id] = entry
+      saveDocuments(documents)
+      return JSON.stringify({
+        id: entry.id,
+        title: entry.title,
+        fileName: entry.fileName,
+        textLength: entry.textLength,
+        method: entry.method,
+        metadata: entry.metadata,
+      })
+    }
+
+    if (action === 'read' || action === 'ocr') {
+      return JSON.stringify({
+        filePath: artifact.filePath,
+        fileName: artifact.fileName,
+        ext: artifact.ext,
+        method: artifact.method,
+        text: artifact.text,
+        textLength: artifact.text.length,
+        metadata: artifact.metadata,
+        tableCount: artifact.tables.length,
+        tables: previewTables(artifact.tables),
+      })
+    }
+
+    return `Error: Unknown action "${action}".`
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+const DocumentPlugin: Plugin = {
+  name: 'Document',
+  enabledByDefault: false,
+  description: 'Extract text/tables/OCR from local documents and optionally store them for later retrieval.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can parse local documents with `document`, including PDFs, office docs, OCR-able images, CSV/XLSX tables, and stored document search.',
+  } as PluginHooks,
+  tools: [
+    {
+      name: 'document',
+      description: 'Document parsing tool. Actions: status, read, metadata, ocr, extract_tables, store, list, list_stored, search, search_stored, get, get_stored, delete, delete_stored.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['status', 'read', 'metadata', 'ocr', 'extract_tables', 'store', 'list', 'list_stored', 'search', 'search_stored', 'get', 'get_stored', 'delete', 'delete_stored'],
+          },
+          filePath: { type: 'string' },
+          id: { type: 'string' },
+          title: { type: 'string' },
+          query: { type: 'string' },
+          metadata: {},
+          limit: { type: 'number' },
+          maxChars: { type: 'number' },
+          preferOcr: { type: 'boolean' },
+        },
+        required: ['action'],
+      },
+      execute: async (args, context) => executeDocumentAction(args, {
+        cwd: context.session.cwd || process.cwd(),
+        sessionId: context.session.id,
+        agentId: context.session.agentId || null,
+      }),
+    },
+  ],
+}
+
+getPluginManager().registerBuiltin('document', DocumentPlugin)
+
+export function buildDocumentTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasPlugin('document')) return []
+  return [
+    tool(
+      async (args) => executeDocumentAction(args, {
+        cwd: bctx.cwd,
+        sessionId: bctx.ctx?.sessionId || null,
+        agentId: bctx.ctx?.agentId || null,
+      }),
+      {
+        name: 'document',
+        description: DocumentPlugin.tools![0].description,
+        schema: z.object({}).passthrough(),
+      },
+    ),
+  ]
+}

package/src/lib/server/session-tools/email.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 SmtpConfig {
@@ -17,8 +16,7 @@ interface SmtpConfig {
 }
 
 function getSmtpConfig(): SmtpConfig {
-  const settings = loadSettings()
-  const ps = (settings.pluginSettings as Record<string, Record<string, unknown>> | undefined)?.email ?? {}
+  const ps = getPluginManager().getPluginSettings('email')
   return {
     host: (ps.host as string) || '',
     port: Number(ps.port) || 587,