@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/openclaw-skills-normalize.ts

@@ -0,0 +1,136 @@
+import type { OpenClawSkillEntry, SkillInstallOption, SkillRequirements } from '@/types'
+
+interface GatewayConfigCheck {
+  path?: string
+  satisfied?: boolean
+}
+
+interface GatewayInstallOption {
+  kind?: string
+  label?: string
+  bins?: string[]
+}
+
+interface GatewaySkillRequirements {
+  bins?: string[]
+  anyBins?: string[][]
+  env?: string[]
+  config?: string[]
+  os?: string[]
+}
+
+interface GatewaySkillEntry {
+  name?: string
+  description?: string
+  source?: string
+  eligible?: boolean
+  requirements?: GatewaySkillRequirements
+  missing?: GatewaySkillRequirements
+  disabled?: boolean
+  install?: GatewayInstallOption[]
+  configChecks?: GatewayConfigCheck[]
+  skillKey?: string
+  baseDir?: string
+}
+
+interface GatewaySkillsStatusPayload {
+  skills?: GatewaySkillEntry[]
+}
+
+function uniq(values: Array<string | undefined | null>): string[] {
+  return [...new Set(values.map((value) => (value ?? '').trim()).filter(Boolean))]
+}
+
+function normalizeSource(source: string | undefined): OpenClawSkillEntry['source'] {
+  switch ((source ?? '').trim()) {
+    case 'openclaw-bundled':
+    case 'bundled':
+      return 'bundled'
+    case 'managed':
+      return 'managed'
+    case 'personal':
+      return 'personal'
+    case 'workspace':
+      return 'workspace'
+    default:
+      return 'workspace'
+  }
+}
+
+function normalizeInstallOptions(install: GatewayInstallOption[] | undefined): SkillInstallOption[] | undefined {
+  if (!Array.isArray(install) || !install.length) return undefined
+  const normalized = install
+    .map((entry) => {
+      const kind = (entry.kind ?? '').trim()
+      if (!kind || !entry.label?.trim()) return null
+      if (!['brew', 'node', 'go', 'uv', 'download'].includes(kind)) return null
+      return {
+        kind: kind as SkillInstallOption['kind'],
+        label: entry.label.trim(),
+        bins: Array.isArray(entry.bins) ? uniq(entry.bins) : undefined,
+      } satisfies SkillInstallOption
+    })
+    .filter((value): value is NonNullable<typeof value> => value !== null)
+  return normalized.length ? normalized : undefined
+}
+
+function normalizeRequirements(input: GatewaySkillRequirements | undefined): SkillRequirements | undefined {
+  if (!input || typeof input !== 'object') return undefined
+  const bins = Array.isArray(input.bins) ? uniq(input.bins) : undefined
+  const anyBins = Array.isArray(input.anyBins)
+    ? input.anyBins
+        .map((group) => Array.isArray(group) ? uniq(group) : [])
+        .filter((group) => group.length > 0)
+    : undefined
+  const env = Array.isArray(input.env) ? uniq(input.env) : undefined
+  const config = Array.isArray(input.config) ? uniq(input.config) : undefined
+  const os = Array.isArray(input.os) ? uniq(input.os) : undefined
+  if (!bins && !anyBins && !env && !config && !os) return undefined
+  return { bins, anyBins, env, config, os }
+}
+
+function flattenMissing(input: GatewaySkillRequirements | undefined): string[] | undefined {
+  if (!input || typeof input !== 'object') return undefined
+  const out: string[] = []
+  for (const value of Array.isArray(input.bins) ? uniq(input.bins) : []) out.push(value)
+  for (const group of Array.isArray(input.anyBins) ? input.anyBins : []) {
+    const normalized = Array.isArray(group) ? uniq(group) : []
+    if (normalized.length) out.push(`one of: ${normalized.join(' | ')}`)
+  }
+  for (const value of Array.isArray(input.env) ? uniq(input.env) : []) out.push(`env ${value}`)
+  for (const value of Array.isArray(input.config) ? uniq(input.config) : []) out.push(`config ${value}`)
+  for (const value of Array.isArray(input.os) ? uniq(input.os) : []) out.push(`os ${value}`)
+  return out.length ? out : undefined
+}
+
+export function normalizeOpenClawSkillsPayload(payload: unknown): OpenClawSkillEntry[] {
+  const rawSkills = Array.isArray(payload)
+    ? payload as GatewaySkillEntry[]
+    : Array.isArray((payload as GatewaySkillsStatusPayload | null | undefined)?.skills)
+      ? (payload as GatewaySkillsStatusPayload).skills!
+      : []
+
+  return rawSkills
+    .map((skill) => {
+      const name = skill.name?.trim()
+      if (!name) return null
+      return {
+        name,
+        description: skill.description?.trim() || undefined,
+        source: normalizeSource(skill.source),
+        eligible: skill.eligible === true,
+        missing: flattenMissing(skill.missing),
+        disabled: skill.disabled === true,
+        installOptions: normalizeInstallOptions(skill.install),
+        skillRequirements: normalizeRequirements(skill.requirements),
+        configChecks: Array.isArray(skill.configChecks)
+          ? skill.configChecks
+              .filter((check) => check.path?.trim())
+              .map((check) => ({ key: check.path!.trim(), ok: check.satisfied === true }))
+          : undefined,
+        skillKey: skill.skillKey?.trim() || undefined,
+        baseDir: skill.baseDir?.trim() || undefined,
+      } satisfies OpenClawSkillEntry
+    })
+    .filter((skill): skill is NonNullable<typeof skill> => skill !== null)
+}

package/src/lib/server/openclaw-sync.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import crypto from 'node:crypto'
 import { DATA_DIR } from './data-dir'
+import { normalizeOpenClawAgentId } from '@/lib/openclaw-agent-id'
 import { loadSettings, loadAgents, saveAgents, loadSchedules, saveSchedules, loadCredentials, decryptKey, encryptKey } from './storage'
 import { getMemoryDb } from './memory-db'
 import type { AppSettings, MemoryEntry, Schedule } from '@/types'
@@ -182,7 +183,7 @@ export function pushAgentToOpenClaw(agentId: string): { written: string[] } {
   const agent = agents[agentId]
   if (!agent) throw new Error(`Agent not found: ${agentId}`)
 
-  const agentDir = path.join(config.workspacePath, 'agents', agent.name.toLowerCase().replace(/\s+/g, '-'))
+  const agentDir = path.join(config.workspacePath, 'agents', normalizeOpenClawAgentId(agent.name))
   ensureDir(agentDir)
 
   const written: string[] = []
@@ -214,7 +215,7 @@ export function pullAgentFromOpenClaw(agentId: string): { updated: string[] } {
   const agent = agents[agentId]
   if (!agent) throw new Error(`Agent not found: ${agentId}`)
 
-  const agentDir = path.join(config.workspacePath, 'agents', agent.name.toLowerCase().replace(/\s+/g, '-'))
+  const agentDir = path.join(config.workspacePath, 'agents', normalizeOpenClawAgentId(agent.name))
   const updated: string[] = []
 
   const soulPath = path.join(agentDir, 'SOUL.md')

package/src/lib/server/orchestrator-lg.ts

@@ -13,6 +13,7 @@ import { notify } from './ws-hub'
 import { pushMainLoopEventToMainSessions } from './main-agent-loop'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { getPluginManager } from './plugins'
+import './builtin-plugins'
 import { genId } from '@/lib/id'
 import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
 import type { Agent, TaskComment, MessageToolEvent } from '@/types'
@@ -118,7 +119,7 @@ async function executeSubTaskViaCli(agent: Agent, task: string, parentSessionId:
     messages: [],
     createdAt: Date.now(),
     lastActiveAt: Date.now(),
-    sessionType: 'orchestrated' as const,
+    sessionType: 'human' as const,
     agentId: agent.id,
     parentSessionId,
     plugins: agent.plugins || agent.tools || [],
@@ -177,7 +178,11 @@ export async function executeLangGraphOrchestrator(
         return `Agent "${agentName}" not found. Available: ${agents.map((a) => a.name).join(', ')}`
       }
       console.log(`[orchestrator-lg] Delegating to ${agent.name}: ${agentTask.slice(0, 80)}`)
-      getPluginManager().runHook('onAgentDelegation', { sourceAgentId: orchestrator.id, targetAgentId: agent.id, task: agentTask })
+      getPluginManager().runHook(
+        'onAgentDelegation',
+        { sourceAgentId: orchestrator.id, targetAgentId: agent.id, task: agentTask },
+        { enabledIds: orchestrator.plugins || [] },
+      )
       const result = await executeSubTaskViaCli(agent, agentTask, sessionId)
       saveMessage(sessionId, 'assistant', `Delegated to ${agent.name}: ${agentTask.slice(0, 100)}`, [{
         name: 'delegate_to_agent',
@@ -393,6 +398,7 @@ export async function executeLangGraphOrchestrator(
 
   const checkpointSaver = getCheckpointSaver()
   const isStrictMode = settings.capabilityPolicyMode === 'strict'
+  const approvalInterruptsEnabled = isStrictMode && settings.approvalsEnabled !== false
   const allTools = [delegateTool, storeMemoryTool, searchMemoryTool, getSecretTool, commentOnTaskTool, createTaskTool, markCompleteTool]
   const llmWithTools = llm.bindTools(allTools)
   const toolNode = new ToolNode(allTools)
@@ -472,7 +478,7 @@ export async function executeLangGraphOrchestrator(
 
   const compiledGraph = graph.compile({
     checkpointer: checkpointSaver,
-    ...(isStrictMode ? { interruptBefore: ['tools'] } : {}),
+    ...(approvalInterruptsEnabled ? { interruptBefore: ['tools'] } : {}),
   })
 
   // Export graph structure for introspection
@@ -534,7 +540,7 @@ export async function executeLangGraphOrchestrator(
     }
 
     // Check for interrupt (paused before tool execution in strict mode)
-    if (isStrictMode && taskId) {
+    if (approvalInterruptsEnabled && taskId) {
       const state = await compiledGraph.getState({ configurable: { thread_id: threadId } })
       const nextNodes = state?.next || []
       if (nextNodes.includes('tools')) {
@@ -606,8 +612,7 @@ export async function executeLangGraphOrchestrator(
   const completeMatch = finalResult.match(/ORCHESTRATION_COMPLETE:\s*([\s\S]+)/)
   const summary = completeMatch ? completeMatch[1].trim() : finalResult
   
-  // Append meta so the main-loop knows we are done
-  return `${summary}\n\n[MAIN_LOOP_META] {"status":"ok", "follow_up":false, "summary":${JSON.stringify(summary.slice(0, 300))}, "mission_task_id":${JSON.stringify(taskId || null)}}`
+  return summary
 }
 
 /**
@@ -628,7 +633,11 @@ export async function resumeLangGraphOrchestrator(
     async ({ agentName, task: agentTask }) => {
       const agent = agents.find((a) => a.name.toLowerCase() === agentName.toLowerCase())
       if (!agent) return `Agent "${agentName}" not found. Available: ${agents.map((a) => a.name).join(', ')}`
-      getPluginManager().runHook('onAgentDelegation', { sourceAgentId: orchestrator.id, targetAgentId: agent.id, task: agentTask })
+      getPluginManager().runHook(
+        'onAgentDelegation',
+        { sourceAgentId: orchestrator.id, targetAgentId: agent.id, task: agentTask },
+        { enabledIds: orchestrator.plugins || [] },
+      )
       const result = await executeSubTaskViaCli(agent, agentTask, sessionId)
       saveMessage(sessionId, 'assistant', `Delegated to ${agent.name}: ${agentTask.slice(0, 100)}`, [{
         name: 'delegate_to_agent',
@@ -753,6 +762,7 @@ export async function resumeLangGraphOrchestrator(
   const checkpointSaver = getCheckpointSaver()
   const settings = loadSettings()
   const isStrictMode = settings.capabilityPolicyMode === 'strict'
+  const approvalInterruptsEnabled = isStrictMode && settings.approvalsEnabled !== false
 
   const allTools = [delegateTool, storeMemoryTool, searchMemoryTool, getSecretTool, commentOnTaskTool, createTaskTool, markCompleteTool]
   const llmWithTools = llm.bindTools(allTools)
@@ -782,7 +792,7 @@ export async function resumeLangGraphOrchestrator(
     .addEdge('router', 'agent')
     .compile({
       checkpointer: checkpointSaver,
-      ...(isStrictMode ? { interruptBefore: ['tools'] } : {}),
+      ...(approvalInterruptsEnabled ? { interruptBefore: ['tools'] } : {}),
     })
 
   let finalResult = ''

package/src/lib/server/orchestrator.ts

@@ -42,7 +42,7 @@ 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,
     plugins: Array.isArray(orchestrator.plugins) ? [...orchestrator.plugins] : (Array.isArray(orchestrator.tools) ? [...orchestrator.tools] : []),
@@ -86,6 +86,7 @@ async function executeOrchestratorLegacy(
   sessionId: string,
   taskId?: string,
 ): Promise<string> {
+  void taskId
   const allAgents = loadAgents()
   const sessions = loadSessions()
   const session = sessions[sessionId]
@@ -241,7 +242,7 @@ async function executeOrchestratorLegacy(
 
       if (cmd.done) {
         result = cmd.summary || fullText
-        return `${result}\n\n[MAIN_LOOP_META] {"status":"ok", "follow_up":false, "summary":${JSON.stringify(result.slice(0, 300))}, "mission_task_id":${JSON.stringify(taskId || null)}}`
+        return result
       }
     }
 
@@ -256,7 +257,7 @@ async function executeOrchestratorLegacy(
     result = `Loop stopped after reaching max turns (${maxTurns}).`
   }
 
-  return `${result}\n\n[MAIN_LOOP_META] {"status":"ok", "follow_up":false, "summary":${JSON.stringify(result.slice(0, 300))}, "mission_task_id":${JSON.stringify(taskId || null)}}`
+  return result
 }
 
 async function executeSubTask(
@@ -288,7 +289,7 @@ async function executeSubTask(
     messages: [] as any[],
     createdAt: Date.now(),
     lastActiveAt: Date.now(),
-    sessionType: 'orchestrated' as const,
+    sessionType: 'human' as const,
     agentId: agent.id,
     parentSessionId,
     plugins: agent.plugins || agent.tools || [],

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,215 @@
+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, pluginIdMatches } 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)
+  })
+
+  it('does not expand a specific platform tool back into manage_platform', () => {
+    const expanded = expandPluginIds(['manage_schedules'])
+    assert.equal(expanded.includes('manage_schedules'), true)
+    assert.equal(expanded.includes('manage_platform'), false)
+    assert.equal(pluginIdMatches(['manage_platform'], 'manage_schedules'), true)
+    assert.equal(pluginIdMatches(['manage_schedules'], 'manage_platform'), false)
+  })
+})
+
+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)
+  })
+})