@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/orchestrator.ts

@@ -42,10 +42,10 @@ export function createOrchestratorSession(
     messages: [] as any[],
     createdAt: Date.now(),
     lastActiveAt: Date.now(),
-    sessionType: 'orchestrated' as const,
+    sessionType: 'human' as const,
     agentId: orchestrator.id,
     parentSessionId: parentSessionId || null,
-    tools: Array.isArray(orchestrator.tools) ? [...orchestrator.tools] : [],
+    plugins: Array.isArray(orchestrator.plugins) ? [...orchestrator.plugins] : (Array.isArray(orchestrator.tools) ? [...orchestrator.tools] : []),
     heartbeatEnabled: false,
   }
   saveSessions(sessions)
@@ -95,9 +95,9 @@ async function executeOrchestratorLegacy(
   const agentIds = orchestrator.subAgentIds || []
   const agents = agentIds.map((id) => allAgents[id]).filter(Boolean)
   const agentList = agents.map((a) => {
-    const tools = a.tools?.length ? ` [tools: ${a.tools.join(', ')}]` : ''
+    const plugins = (a.plugins || a.tools)?.length ? ` [plugins: ${(a.plugins || a.tools)!.join(', ')}]` : ''
     const skills = a.skills?.length ? ` [skills: ${a.skills.join(', ')}]` : ''
-    return `- ${a.name}: ${a.description}${tools}${skills}`
+    return `- ${a.name}: ${a.description}${plugins}${skills}`
   }).join('\n')
 
   // Load relevant memories
@@ -288,10 +288,10 @@ async function executeSubTask(
     messages: [] as any[],
     createdAt: Date.now(),
     lastActiveAt: Date.now(),
-    sessionType: 'orchestrated' as const,
+    sessionType: 'human' as const,
     agentId: agent.id,
     parentSessionId,
-    tools: agent.tools || [],
+    plugins: agent.plugins || agent.tools || [],
   }
   sessions[childId] = childSession
   saveSessions(sessions)
@@ -339,7 +339,7 @@ export async function callProvider(
     credentialId: agent.credentialId,
     apiEndpoint: agent.apiEndpoint,
     cwd: WORKSPACE_DIR,
-    tools: agent.tools || [],
+    plugins: agent.plugins || agent.tools || [],
     messages: history.map((h) => ({
       role: h.role as 'user' | 'assistant',
       text: h.text,

package/src/lib/server/playwright-proxy.mjs

@@ -11,9 +11,33 @@ import path from 'path'
 const UPLOAD_DIR = process.env.SWARMCLAW_UPLOAD_DIR || path.join(process.env.DATA_DIR || path.join(process.cwd(), 'data'), 'uploads')
 if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })
 
-const child = spawn('npx', ['@playwright/mcp@latest'], {
-  stdio: ['pipe', 'pipe', 'pipe'],
-})
+function resolvePlaywrightCli() {
+  const candidates = [
+    path.join(process.cwd(), 'node_modules', '@playwright', 'mcp', 'cli.js'),
+    path.join(process.cwd(), '[project]', 'node_modules', '@playwright', 'mcp', 'cli.js'),
+  ]
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null
+}
+
+function sanitizePlaywrightEnv(baseEnv) {
+  const env = { ...baseEnv }
+  for (const key of Object.keys(env)) {
+    if (!key.toUpperCase().startsWith('PLAYWRIGHT_MCP_')) continue
+    delete env[key]
+  }
+  return env
+}
+
+const cliPath = resolvePlaywrightCli()
+const child = cliPath
+  ? spawn(process.execPath, [cliPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: sanitizePlaywrightEnv(process.env),
+    })
+  : spawn('npx', ['@playwright/mcp@latest'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: sanitizePlaywrightEnv(process.env),
+    })
 
 // Forward stdin → child
 process.stdin.on('data', (chunk) => child.stdin.write(chunk))

package/src/lib/server/plugins.test.ts

@@ -0,0 +1,207 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import fs from 'node:fs'
+import path from 'node:path'
+import { getPluginManager, normalizeMarketplacePluginUrl, sanitizePluginFilename } from './plugins'
+import { canonicalizePluginId, expandPluginIds } from './tool-aliases'
+import { DATA_DIR } from './data-dir'
+
+let testPluginSeq = 0
+
+function uniquePluginId(prefix: string): string {
+  testPluginSeq += 1
+  return `${prefix}_${Date.now()}_${testPluginSeq}`
+}
+
+describe('plugin id canonicalization', () => {
+  it('normalizes built-in aliases to canonical plugin families', () => {
+    assert.equal(canonicalizePluginId('session_info'), 'manage_sessions')
+    assert.equal(canonicalizePluginId('connectors'), 'manage_connectors')
+    assert.equal(canonicalizePluginId('subagent'), 'spawn_subagent')
+    assert.equal(canonicalizePluginId('http'), 'http_request')
+    assert.equal(canonicalizePluginId('human_loop'), 'ask_human')
+    assert.equal(canonicalizePluginId('dataframe'), 'table')
+    assert.equal(canonicalizePluginId('extract_structured'), 'extract')
+  })
+
+  it('expands aliases to include the canonical family id', () => {
+    const expanded = expandPluginIds(['session_info', 'http', 'human_loop'])
+    assert.equal(expanded.includes('manage_sessions'), true)
+    assert.equal(expanded.includes('session_info'), true)
+    assert.equal(expanded.includes('http_request'), true)
+    assert.equal(expanded.includes('http'), true)
+    assert.equal(expanded.includes('ask_human'), true)
+    assert.equal(expanded.includes('human_loop'), true)
+  })
+})
+
+describe('plugin install helpers', () => {
+  it('rewrites legacy marketplace URLs to the canonical raw source', () => {
+    const normalized = normalizeMarketplacePluginUrl('https://github.com/swarmclawai/plugins/blob/master/foo/bar.js')
+    assert.equal(normalized, 'https://raw.githubusercontent.com/swarmclawai/swarmforge/main/foo/bar.js')
+  })
+
+  it('allows .js and .mjs plugin filenames and blocks traversal', () => {
+    assert.equal(sanitizePluginFilename('plugin.js'), 'plugin.js')
+    assert.equal(sanitizePluginFilename('plugin.mjs'), 'plugin.mjs')
+    assert.throws(() => sanitizePluginFilename('../plugin.js'), /Invalid filename/)
+    assert.throws(() => sanitizePluginFilename('plugin.ts'), /Filename must end/)
+  })
+})
+
+describe('plugin manager hook execution', () => {
+  it('applies beforeToolExec mutations only for explicitly enabled plugins', async () => {
+    const pluginId = uniquePluginId('before_tool_exec')
+    getPluginManager().registerBuiltin(pluginId, {
+      name: 'Before Tool Exec Test',
+      hooks: {
+        beforeToolExec: ({ input }) => ({ ...(input || {}), patched: true }),
+      },
+    })
+
+    const withoutEnable = await getPluginManager().runBeforeToolExec(
+      { toolName: 'shell', input: { original: true } },
+      {},
+    )
+    assert.deepEqual(withoutEnable, { original: true })
+
+    const withEnable = await getPluginManager().runBeforeToolExec(
+      { toolName: 'shell', input: { original: true } },
+      { enabledIds: [pluginId] },
+    )
+    assert.deepEqual(withEnable, { original: true, patched: true })
+  })
+
+  it('chains text transforms in plugin order', async () => {
+    const pluginA = uniquePluginId('transform_a')
+    const pluginB = uniquePluginId('transform_b')
+    getPluginManager().registerBuiltin(pluginA, {
+      name: 'Transform A',
+      hooks: {
+        transformOutboundMessage: ({ text }) => `${text} A`,
+      },
+    })
+    getPluginManager().registerBuiltin(pluginB, {
+      name: 'Transform B',
+      hooks: {
+        transformOutboundMessage: ({ text }) => `${text} B`,
+      },
+    })
+
+    const transformed = await getPluginManager().transformText(
+      'transformOutboundMessage',
+      {
+        session: {
+          id: 's1',
+          name: 'Test Session',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: Date.now(),
+          lastActiveAt: Date.now(),
+          plugins: [pluginA, pluginB],
+        },
+        text: 'base',
+      },
+      { enabledIds: [pluginA, pluginB] },
+    )
+
+    assert.equal(transformed, 'base A B')
+  })
+
+  it('does not run generic hooks unless scope is provided explicitly', async () => {
+    const pluginId = uniquePluginId('scoped_hook')
+    let callCount = 0
+    getPluginManager().registerBuiltin(pluginId, {
+      name: 'Scoped Hook Test',
+      hooks: {
+        afterChatTurn: () => {
+          callCount += 1
+        },
+      },
+    })
+
+    await getPluginManager().runHook(
+      'afterChatTurn',
+      {
+        session: {
+          id: 's2',
+          name: 'Scoped Hook Session',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: Date.now(),
+          lastActiveAt: Date.now(),
+        },
+        message: 'hi',
+        response: 'hello',
+        source: 'chat',
+        internal: false,
+      },
+      {},
+    )
+    assert.equal(callCount, 0)
+
+    await getPluginManager().runHook(
+      'afterChatTurn',
+      {
+        session: {
+          id: 's3',
+          name: 'Scoped Hook Session Enabled',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: Date.now(),
+          lastActiveAt: Date.now(),
+          plugins: [pluginId],
+        },
+        message: 'hi',
+        response: 'hello',
+        source: 'chat',
+        internal: false,
+      },
+      { enabledIds: [pluginId] },
+    )
+    assert.equal(callCount, 1)
+  })
+
+  it('stores dependency-aware plugins in managed workspaces', async () => {
+    const filename = `${uniquePluginId('workspace_plugin')}.js`
+    const manager = getPluginManager()
+
+    await manager.savePluginSource(
+      filename,
+      'module.exports = { name: "Workspace Plugin", tools: [] }',
+      {
+        packageJson: {
+          name: 'workspace-plugin',
+          dependencies: {
+            lodash: '^4.17.21',
+          },
+        },
+        packageManager: 'npm',
+      },
+    )
+
+    const meta = manager.listPlugins().find((plugin) => plugin.filename === filename)
+    assert.equal(meta?.isBuiltin, false)
+    assert.equal(meta?.hasDependencyManifest, true)
+    assert.equal(meta?.dependencyCount, 1)
+    assert.equal(meta?.packageManager, 'npm')
+    assert.equal(manager.readPluginSource(filename).includes('Workspace Plugin'), true)
+
+    const shimPath = path.join(DATA_DIR, 'plugins', filename)
+    assert.equal(fs.readFileSync(shimPath, 'utf8').includes('Auto-generated plugin workspace shim'), true)
+
+    assert.equal(manager.deletePlugin(filename), true)
+  })
+})