@swarmclawai/swarmclaw 0.2.0

package/src/lib/server/orchestrator.ts

@@ -0,0 +1,364 @@
+import crypto from 'crypto'
+import {
+  loadSessions, saveSessions, loadAgents,
+  loadCredentials, decryptKey, loadSettings, loadSkills,
+} from './storage'
+import { loadRuntimeSettings, getLegacyOrchestratorMaxTurns } from './runtime-settings'
+import { getMemoryDb } from './memory-db'
+import { getProvider } from '../providers'
+import type { Agent } from '@/types'
+
+/**
+ * Creates the orchestrator session and returns its ID immediately.
+ * Call executeOrchestrator() separately to run the loop in the background.
+ */
+export function createOrchestratorSession(
+  orchestrator: Agent,
+  task: string,
+  parentSessionId?: string,
+  cwd?: string,
+): string {
+  const sessions = loadSessions()
+  const sessionId = crypto.randomBytes(4).toString('hex')
+  sessions[sessionId] = {
+    id: sessionId,
+    name: `[Orch] ${orchestrator.name}: ${task.slice(0, 40)}`,
+    cwd: cwd || process.cwd(),
+    user: 'system',
+    provider: orchestrator.provider,
+    model: orchestrator.model,
+    credentialId: orchestrator.credentialId || null,
+    apiEndpoint: orchestrator.apiEndpoint || null,
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    delegateResumeIds: {
+      claudeCode: null,
+      codex: null,
+      opencode: null,
+    },
+    messages: [] as any[],
+    createdAt: Date.now(),
+    lastActiveAt: Date.now(),
+    sessionType: 'orchestrated' as const,
+    agentId: orchestrator.id,
+    parentSessionId: parentSessionId || null,
+    tools: Array.isArray(orchestrator.tools) ? [...orchestrator.tools] : [],
+    heartbeatEnabled: false,
+  }
+  saveSessions(sessions)
+  return sessionId
+}
+
+export async function runOrchestrator(
+  orchestrator: Agent,
+  task: string,
+  parentSessionId?: string,
+): Promise<string> {
+  const sessionId = createOrchestratorSession(orchestrator, task, parentSessionId)
+  return executeOrchestrator(orchestrator, task, sessionId)
+}
+
+export async function executeOrchestrator(
+  orchestrator: Agent,
+  task: string,
+  sessionId: string,
+): Promise<string> {
+  // Use LangGraph for all non-CLI providers (including OpenAI-compatible custom providers)
+  const isCliProvider = orchestrator.provider === 'claude-cli' || orchestrator.provider === 'codex-cli' || orchestrator.provider === 'opencode-cli'
+  if (!isCliProvider) {
+    console.log(`[orchestrator] Using LangGraph engine for ${orchestrator.name} (${orchestrator.provider})`)
+    const { executeLangGraphOrchestrator } = await import('./orchestrator-lg')
+    return executeLangGraphOrchestrator(orchestrator, task, sessionId)
+  }
+
+  // claude-cli fallback (no structured tool calling)
+  console.warn(`[orchestrator] Using legacy regex-based engine for ${orchestrator.name} (claude-cli)`)
+  return executeOrchestratorLegacy(orchestrator, task, sessionId)
+}
+
+async function executeOrchestratorLegacy(
+  orchestrator: Agent,
+  task: string,
+  sessionId: string,
+): Promise<string> {
+  const allAgents = loadAgents()
+  const sessions = loadSessions()
+  const session = sessions[sessionId]
+  if (!session) throw new Error('Orchestrator session not found')
+
+  // Build available agents list
+  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 skills = a.skills?.length ? ` [skills: ${a.skills.join(', ')}]` : ''
+    return `- ${a.name}: ${a.description}${tools}${skills}`
+  }).join('\n')
+
+  // Load relevant memories
+  const db = getMemoryDb()
+  const memories = db.getByAgent(orchestrator.id)
+  const memoryContext = memories.length
+    ? '\n\nRelevant memories:\n' + memories.slice(0, 10).map((m) => `[${m.category}] ${m.title}: ${m.content.slice(0, 200)}`).join('\n')
+    : ''
+
+  // Build system prompt: [userPrompt] \n\n [soul] \n\n [systemPrompt] \n\n [orchestrator context]
+  const settings = loadSettings()
+  const promptParts: string[] = []
+  if (settings.userPrompt) promptParts.push(settings.userPrompt)
+  if (orchestrator.soul) promptParts.push(orchestrator.soul)
+  if (orchestrator.systemPrompt) promptParts.push(orchestrator.systemPrompt)
+  if (orchestrator.skillIds?.length) {
+    const allSkills = loadSkills()
+    for (const skillId of orchestrator.skillIds) {
+      const skill = allSkills[skillId]
+      if (skill?.content) promptParts.push(`## Skill: ${skill.name}\n${skill.content}`)
+    }
+  }
+  const basePrompt = promptParts.join('\n\n')
+
+  const systemPrompt = [
+    basePrompt,
+    '\n\nYou are an orchestrator agent. You can delegate tasks to these agents:',
+    agentList || '(no agents available)',
+    '\n\nTo delegate a task, output a JSON block on its own line:',
+    '{"delegate": {"agent": "agent-name", "task": "what to do"}}',
+    '\n\nTo store something in memory:',
+    '{"memory_store": {"category": "keyword", "title": "...", "content": "..."}}',
+    '\n\nTo read memories:',
+    '{"memory_read": {"query": "search terms"}}',
+    '\n\nAgents with [tools: browser] have access to a Playwright browser and can navigate websites, scrape data, fill forms, take screenshots, and interact with web pages.',
+    '\n\nWhen you are done, output: {"done": true, "summary": "what was accomplished"}',
+    memoryContext,
+  ].join('\n')
+
+  // Conversation loop
+  const conversationHistory: { role: string; text: string }[] = []
+  conversationHistory.push({ role: 'user', text: task })
+
+  let result = ''
+  const runtime = loadRuntimeSettings()
+  const maxTurns = getLegacyOrchestratorMaxTurns(runtime)
+  const loopStart = Date.now()
+
+  for (let turn = 0; turn < maxTurns; turn++) {
+    if (runtime.loopMode === 'ongoing' && runtime.ongoingLoopMaxRuntimeMs) {
+      const elapsed = Date.now() - loopStart
+      if (elapsed >= runtime.ongoingLoopMaxRuntimeMs) {
+        const timeoutMsg = 'Ongoing loop stopped after reaching the configured runtime limit.'
+        session.messages.push({ role: 'assistant' as const, text: timeoutMsg, time: Date.now() })
+        session.lastActiveAt = Date.now()
+        const s = loadSessions()
+        s[sessionId] = session
+        saveSessions(s)
+        return timeoutMsg
+      }
+    }
+
+    const fullText = await callProvider(orchestrator, systemPrompt, conversationHistory)
+    conversationHistory.push({ role: 'assistant', text: fullText })
+
+    // Save to session
+    session.messages.push({ role: 'user' as const, text: turn === 0 ? task : '[system response]', time: Date.now() })
+    session.messages.push({ role: 'assistant' as const, text: fullText, time: Date.now() })
+    session.lastActiveAt = Date.now()
+    const s = loadSessions()
+    s[sessionId] = session
+    saveSessions(s)
+
+    // Parse JSON commands from the response
+    const commands = extractJsonCommands(fullText)
+    let hasDelegate = false
+
+    for (const cmd of commands) {
+      if (cmd.delegate) {
+        hasDelegate = true
+        const agent = agents.find((a) => a.name.toLowerCase() === cmd.delegate.agent.toLowerCase())
+        if (!agent) {
+          conversationHistory.push({
+            role: 'user',
+            text: `[System] Agent "${cmd.delegate.agent}" not found. Available agents: ${agents.map((a) => a.name).join(', ')}`,
+          })
+          continue
+        }
+
+        // Execute sub-task
+        const subResult = await executeSubTask(agent, cmd.delegate.task, sessionId)
+        conversationHistory.push({
+          role: 'user',
+          text: `[Agent ${agent.name} result]:\n${subResult}`,
+        })
+      }
+
+      if (cmd.memory_store) {
+        db.add({
+          agentId: orchestrator.id,
+          sessionId,
+          category: cmd.memory_store.category || 'note',
+          title: cmd.memory_store.title || 'Untitled',
+          content: cmd.memory_store.content || '',
+        })
+        conversationHistory.push({
+          role: 'user',
+          text: '[System] Memory stored successfully.',
+        })
+      }
+
+      if (cmd.memory_read) {
+        const results = db.search(cmd.memory_read.query, orchestrator.id)
+        const memText = results.length
+          ? results.map((m) => `[${m.category}] ${m.title}: ${m.content.slice(0, 300)}`).join('\n')
+          : 'No matching memories found.'
+        conversationHistory.push({
+          role: 'user',
+          text: `[Memory search results]:\n${memText}`,
+        })
+      }
+
+      if (cmd.done) {
+        result = cmd.summary || fullText
+        return result
+      }
+    }
+
+    if (!hasDelegate && commands.length === 0) {
+      // No commands found, treat as final response
+      result = fullText
+      break
+    }
+  }
+
+  if (!result) {
+    result = `Loop stopped after reaching max turns (${maxTurns}).`
+  }
+
+  return result
+}
+
+async function executeSubTask(
+  agent: Agent,
+  task: string,
+  parentSessionId: string,
+): Promise<string> {
+  // Look up parent session cwd to inherit
+  const sessions = loadSessions()
+  const parentSession = sessions[parentSessionId]
+  const childId = crypto.randomBytes(4).toString('hex')
+  const childSession = {
+    id: childId,
+    name: `[Agent] ${agent.name}: ${task.slice(0, 40)}`,
+    cwd: parentSession?.cwd || process.cwd(),
+    user: 'system',
+    provider: agent.provider,
+    model: agent.model,
+    credentialId: agent.credentialId || null,
+    apiEndpoint: agent.apiEndpoint || null,
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    delegateResumeIds: {
+      claudeCode: null,
+      codex: null,
+      opencode: null,
+    },
+    messages: [] as any[],
+    createdAt: Date.now(),
+    lastActiveAt: Date.now(),
+    sessionType: 'orchestrated' as const,
+    agentId: agent.id,
+    parentSessionId,
+    tools: agent.tools || [],
+  }
+  sessions[childId] = childSession
+  saveSessions(sessions)
+
+  const history = [{ role: 'user', text: task }]
+  const result = await callProvider(agent, agent.systemPrompt, history)
+
+  childSession.messages.push({ role: 'user', text: task, time: Date.now() })
+  childSession.messages.push({ role: 'assistant', text: result, time: Date.now() })
+  childSession.lastActiveAt = Date.now()
+  const s = loadSessions()
+  s[childId] = childSession
+  saveSessions(s)
+
+  return result
+}
+
+export async function callProvider(
+  agent: Agent,
+  systemPrompt: string,
+  history: { role: string; text: string }[],
+): Promise<string> {
+  const provider = getProvider(agent.provider)
+  if (!provider) throw new Error(`Unknown provider: ${agent.provider}`)
+
+  let apiKey: string | null = null
+  if (agent.credentialId) {
+    const creds = loadCredentials()
+    const cred = creds[agent.credentialId]
+    if (cred?.encryptedKey) {
+      try { apiKey = decryptKey(cred.encryptedKey) } catch { /* ignore */ }
+    }
+  }
+
+  // Build a mock session for the provider
+  const mockSession = {
+    id: 'orch-' + crypto.randomBytes(2).toString('hex'),
+    provider: agent.provider,
+    model: agent.model,
+    credentialId: agent.credentialId,
+    apiEndpoint: agent.apiEndpoint,
+    cwd: process.cwd(),
+    tools: agent.tools || [],
+    messages: history.map((h) => ({
+      role: h.role as 'user' | 'assistant',
+      text: h.text,
+      time: Date.now(),
+    })),
+  }
+
+  let fullText = ''
+  const { active } = await import('./storage')
+
+  await provider.handler.streamChat({
+    session: mockSession,
+    message: history[history.length - 1].text,
+    apiKey,
+    write: (data: string) => {
+      // Parse SSE data to extract text
+      if (data.startsWith('data: ')) {
+        try {
+          const event = JSON.parse(data.slice(6))
+          if (event.t === 'd' || event.t === 'md' || event.t === 'r') {
+            if (event.t === 'd') fullText += event.text || ''
+            else fullText = event.text || ''
+          }
+        } catch { /* ignore */ }
+      }
+    },
+    active,
+    loadHistory: () => mockSession.messages,
+  })
+
+  return fullText
+}
+
+function extractJsonCommands(text: string): any[] {
+  const commands: any[] = []
+  // Match JSON blocks on their own lines
+  const regex = /^\s*(\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\})\s*$/gm
+  let match
+  while ((match = regex.exec(text)) !== null) {
+    try {
+      const parsed = JSON.parse(match[1])
+      if (parsed.delegate || parsed.memory_store || parsed.memory_read || parsed.done) {
+        commands.push(parsed)
+      }
+    } catch {
+      // Not valid JSON, skip
+    }
+  }
+  return commands
+}

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

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * MCP proxy for Playwright that intercepts browser_screenshot responses,
+ * saves images to the uploads directory, and tells Claude the image URL
+ * so it can reference it in its response.
+ */
+import { spawn } from 'child_process'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+const UPLOAD_DIR = process.env.SWARMCLAW_UPLOAD_DIR || path.join(os.tmpdir(), 'swarmclaw-uploads')
+if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+
+const child = spawn('npx', ['@playwright/mcp@latest'], {
+  stdio: ['pipe', 'pipe', 'pipe'],
+})
+
+// Forward stdin → child
+process.stdin.on('data', (chunk) => child.stdin.write(chunk))
+process.stdin.on('end', () => child.stdin.end())
+
+// Parse MCP Content-Length framed messages from child stdout, intercept screenshots
+let buf = ''
+child.stdout.on('data', (chunk) => {
+  buf += chunk.toString()
+  while (true) {
+    const headerEnd = buf.indexOf('\r\n\r\n')
+    if (headerEnd === -1) break
+    const header = buf.slice(0, headerEnd)
+    const match = header.match(/Content-Length:\s*(\d+)/i)
+    if (!match) { buf = buf.slice(headerEnd + 4); continue }
+    const contentLength = parseInt(match[1])
+    const bodyStart = headerEnd + 4
+    if (buf.length < bodyStart + contentLength) break
+    const body = buf.slice(bodyStart, bodyStart + contentLength)
+    buf = buf.slice(bodyStart + contentLength)
+
+    let output
+    try {
+      const msg = JSON.parse(body)
+      if (msg.result?.content && Array.isArray(msg.result.content)) {
+        const newContent = []
+        for (const block of msg.result.content) {
+          if (block.type === 'image' && block.data) {
+            const filename = `screenshot-${Date.now()}.png`
+            fs.writeFileSync(path.join(UPLOAD_DIR, filename), Buffer.from(block.data, 'base64'))
+            newContent.push({
+              type: 'text',
+              text: `Screenshot saved. Show it to the user with this markdown: ![Screenshot](/api/uploads/${filename})`,
+            })
+            newContent.push(block) // keep image so Claude can see it
+          } else {
+            newContent.push(block)
+          }
+        }
+        msg.result.content = newContent
+      }
+      output = JSON.stringify(msg)
+    } catch {
+      output = body
+    }
+    const frame = `Content-Length: ${Buffer.byteLength(output)}\r\n\r\n${output}`
+    process.stdout.write(frame)
+  }
+})
+
+child.stderr.on('data', (chunk) => process.stderr.write(chunk))
+child.on('close', (code) => process.exit(code || 0))
+child.on('error', (err) => { process.stderr.write(`Proxy error: ${err.message}\n`); process.exit(1) })

package/src/lib/server/plugins.ts

@@ -0,0 +1,229 @@
+import fs from 'fs'
+import path from 'path'
+import { createRequire } from 'module'
+import type { Plugin, PluginHooks, PluginMeta } from '@/types'
+
+import { DATA_DIR } from './data-dir'
+
+const PLUGINS_DIR = path.join(DATA_DIR, 'plugins')
+const PLUGINS_CONFIG = path.join(DATA_DIR, 'plugins.json')
+
+// OpenClaw plugin format: { name, version, activate(ctx), deactivate() }
+interface OpenClawPlugin {
+  name: string
+  version?: string
+  activate: (ctx: Record<string, (fn: (...args: any[]) => any) => void>) => void
+  deactivate?: () => void
+}
+
+/**
+ * Normalize a module export into SwarmClaw's Plugin interface.
+ * Supports both SwarmClaw format ({ name, hooks }) and OpenClaw format
+ * ({ name, activate(ctx) }) where activate receives event hook registrars.
+ */
+function normalizePlugin(mod: any): Plugin | null {
+  const raw = mod.default || mod
+
+  // SwarmClaw native format
+  if (raw.name && raw.hooks) {
+    return raw as Plugin
+  }
+
+  // OpenClaw format: { name, activate(ctx), deactivate() }
+  if (raw.name && typeof raw.activate === 'function') {
+    const oc = raw as OpenClawPlugin
+    const hooks: PluginHooks = {}
+
+    // OpenClaw's activate receives an object of hook registrars.
+    // Map OpenClaw lifecycle names to SwarmClaw hook names.
+    const registrar: Record<string, (fn: (...args: any[]) => any) => void> = {
+      onAgentStart: (fn) => { hooks.beforeAgentStart = fn },
+      onAgentComplete: (fn) => { hooks.afterAgentComplete = fn },
+      onToolCall: (fn) => { hooks.beforeToolExec = fn },
+      onToolResult: (fn) => { hooks.afterToolExec = fn },
+      onMessage: (fn) => { hooks.onMessage = fn },
+    }
+
+    try {
+      oc.activate(registrar)
+    } catch (err: any) {
+      console.error(`[plugins] OpenClaw activate() failed for ${oc.name}:`, err.message)
+      return null
+    }
+
+    return {
+      name: oc.name,
+      description: `OpenClaw plugin (v${oc.version || '0.0.0'})`,
+      hooks,
+    }
+  }
+
+  return null
+}
+
+// Ensure directories exist
+if (!fs.existsSync(PLUGINS_DIR)) fs.mkdirSync(PLUGINS_DIR, { recursive: true })
+if (!fs.existsSync(PLUGINS_CONFIG)) fs.writeFileSync(PLUGINS_CONFIG, '{}')
+
+// Use createRequire to avoid Turbopack static analysis of require()
+const dynamicRequire = createRequire(import.meta.url || __filename)
+
+interface LoadedPlugin {
+  meta: PluginMeta
+  hooks: PluginHooks
+}
+
+class PluginManager {
+  private plugins: LoadedPlugin[] = []
+  private loaded = false
+
+  load() {
+    if (this.loaded) return
+    this.plugins = []
+
+    const config = this.loadConfig()
+
+    try {
+      const files = fs.readdirSync(PLUGINS_DIR).filter(
+        (f) => f.endsWith('.js') || f.endsWith('.mjs'),
+      )
+
+      for (const file of files) {
+        try {
+          const fullPath = path.join(PLUGINS_DIR, file)
+          // Clear require cache to allow reloads
+          delete dynamicRequire.cache[fullPath]
+          const mod = dynamicRequire(fullPath)
+          const plugin = normalizePlugin(mod)
+
+          if (!plugin) {
+            console.warn(`[plugins] Skipping ${file}: unrecognized plugin format`)
+            continue
+          }
+
+          const isEnabled = config[file]?.enabled !== false // enabled by default
+
+          if (isEnabled) {
+            this.plugins.push({
+              meta: {
+                name: plugin.name,
+                description: plugin.description,
+                filename: file,
+                enabled: true,
+              },
+              hooks: plugin.hooks,
+            })
+            console.log(`[plugins] Loaded: ${plugin.name} (${file})`)
+          }
+        } catch (err: any) {
+          console.error(`[plugins] Failed to load ${file}:`, err.message)
+        }
+      }
+    } catch {
+      // plugins dir doesn't exist or can't be read
+    }
+
+    this.loaded = true
+  }
+
+  async runHook<K extends keyof PluginHooks>(
+    hookName: K,
+    ctx: Parameters<NonNullable<PluginHooks[K]>>[0],
+  ): Promise<void> {
+    this.load()
+    for (const plugin of this.plugins) {
+      const hook = plugin.hooks[hookName]
+      if (hook) {
+        try {
+          await (hook as any)(ctx)
+        } catch (err: any) {
+          console.error(`[plugins] Error in ${plugin.meta.name}.${hookName}:`, err.message)
+        }
+      }
+    }
+  }
+
+  listPlugins(): PluginMeta[] {
+    this.load()
+    const config = this.loadConfig()
+
+    // Include both loaded and disabled plugins
+    const metas: PluginMeta[] = this.plugins.map((p) => p.meta)
+
+    try {
+      const files = fs.readdirSync(PLUGINS_DIR).filter(
+        (f) => f.endsWith('.js') || f.endsWith('.mjs'),
+      )
+      for (const file of files) {
+        if (!metas.find((m) => m.filename === file)) {
+          metas.push({
+            name: file.replace(/\.(js|mjs)$/, ''),
+            filename: file,
+            enabled: config[file]?.enabled !== false,
+          })
+        }
+      }
+    } catch { /* ignore */ }
+
+    return metas
+  }
+
+  setEnabled(filename: string, enabled: boolean) {
+    const config = this.loadConfig()
+    config[filename] = { ...config[filename], enabled }
+    fs.writeFileSync(PLUGINS_CONFIG, JSON.stringify(config, null, 2))
+    // Force reload on next hook call
+    this.loaded = false
+    this.plugins = []
+  }
+
+  async installPlugin(url: string, filename: string): Promise<{ ok: boolean; error?: string }> {
+    if (!url.startsWith('https://')) {
+      return { ok: false, error: 'URL must be HTTPS' }
+    }
+    const sanitized = path.basename(filename)
+    if (sanitized !== filename || !filename.endsWith('.js')) {
+      return { ok: false, error: 'Invalid filename' }
+    }
+
+    try {
+      const res = await fetch(url)
+      if (!res.ok) throw new Error(`Download failed: ${res.status}`)
+      const code = await res.text()
+
+      if (!fs.existsSync(PLUGINS_DIR)) {
+        fs.mkdirSync(PLUGINS_DIR, { recursive: true })
+      }
+
+      fs.writeFileSync(path.join(PLUGINS_DIR, sanitized), code, 'utf8')
+      this.reload()
+      return { ok: true }
+    } catch (err: any) {
+      return { ok: false, error: err.message }
+    }
+  }
+
+  private loadConfig(): Record<string, { enabled: boolean }> {
+    try {
+      return JSON.parse(fs.readFileSync(PLUGINS_CONFIG, 'utf8'))
+    } catch {
+      return {}
+    }
+  }
+
+  reload() {
+    this.loaded = false
+    this.plugins = []
+    this.load()
+  }
+}
+
+let _manager: PluginManager | null = null
+
+export function getPluginManager(): PluginManager {
+  if (!_manager) {
+    _manager = new PluginManager()
+    _manager.load()
+  }
+  return _manager
+}