@swarmclawai/swarmclaw 0.6.8 → 0.7.0

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

@@ -1,7 +1,7 @@
 import { z } from 'zod'
-import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { tool } from '@langchain/core/tools'
+import fs from 'fs'
 import {
-  clearManagedProcess,
   getManagedProcess,
   killManagedProcess,
   listManagedProcesses,
@@ -13,159 +13,187 @@ import {
 } from '../process-manager'
 import type { ToolBuildContext } from './context'
 import { safePath, truncate, coerceEnvMap, MAX_OUTPUT } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
-export function buildShellTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  const tools: StructuredToolInterface[] = []
-  const { cwd, ctx, hasTool, commandTimeoutMs } = bctx
-
-  if (hasTool('shell')) {
-    tools.push(
-      tool(
-        async ({ command, background, yieldMs, timeoutSec, env, workdir }) => {
-          try {
-            const result = await startManagedProcess({
-              command,
-              cwd: workdir ? safePath(cwd, workdir) : cwd,
-              env: coerceEnvMap(env),
-              agentId: ctx?.agentId || null,
-              sessionId: ctx?.sessionId || null,
-              background: !!background,
-              yieldMs: typeof yieldMs === 'number' ? yieldMs : undefined,
-              timeoutMs: typeof timeoutSec === 'number'
-                ? Math.max(1, Math.trunc(timeoutSec)) * 1000
-                : commandTimeoutMs,
-            })
-            if (result.status === 'completed') {
-              return truncate(result.output || '(no output)', MAX_OUTPUT)
-            }
-            return JSON.stringify({
-              status: 'running',
-              processId: result.processId,
-              tail: result.tail || '',
-            }, null, 2)
-          } catch (err: any) {
-            return truncate(`Error: ${err.message || String(err)}`, MAX_OUTPUT)
-          }
-        },
-        {
-          name: 'execute_command',
-          description: 'Run a shell command in my working directory. This is how I run servers, install packages, execute scripts, use git, and do anything hands-on. Use background=true for long-running processes like dev servers. Supports timeout/yield controls.',
-          schema: z.object({
-            command: z.string().describe('The shell command to execute'),
-            background: z.boolean().optional().describe('If true, start command in background immediately'),
-            yieldMs: z.number().optional().describe('If command runs longer than this, return a running process id instead of blocking'),
-            timeoutSec: z.number().optional().describe('Per-command timeout in seconds'),
-            workdir: z.string().optional().describe('Relative working directory override'),
-            env: z.record(z.string(), z.string()).optional().describe('Environment variable overrides'),
-          }),
-        },
-      ),
-    )
-  }
+function resolveShellWorkdir(baseCwd: string, requestedWorkdir?: string): string {
+  const raw = typeof requestedWorkdir === 'string' ? requestedWorkdir.trim() : ''
+  if (!raw) return baseCwd
+  try {
+    const resolved = safePath(baseCwd, raw)
+    if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) return resolved
+  } catch { /* ignore */ }
+  return safePath(baseCwd, raw)
+}
 
-  if (hasTool('process')) {
-    tools.push(
-      tool(
-        async ({ action, processId, offset, limit, data, eof, signal }) => {
-          try {
-            if (action === 'list') {
-              return JSON.stringify(listManagedProcesses(ctx?.agentId || null).map((p) => ({
-                id: p.id,
-                command: p.command,
-                status: p.status,
-                pid: p.pid,
-                startedAt: p.startedAt,
-                endedAt: p.endedAt,
-                exitCode: p.exitCode,
-                signal: p.signal,
-              })), null, 2)
-            }
+function isLikelyServerCommand(command: string): boolean {
+  const cmd = command.trim()
+  return /\bnpm\s+run\s+(dev|start|serve)\b/.test(cmd) || 
+         /\bnpx\s+(serve|next|vite|nuxt|astro)\b/.test(cmd) ||
+         /\bpython3?\s+-m\s+http\.server\b/.test(cmd)
+}
 
-            if (!processId) return 'Error: processId is required for this action.'
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  return value as Record<string, unknown>
+}
 
-            const ownerCheck = getManagedProcess(processId)
-            if (ownerCheck && ctx?.sessionId && ownerCheck.sessionId && ownerCheck.sessionId !== ctx.sessionId) {
-              return `Error: process ${processId} belongs to a different session.`
-            }
+function parseNestedInput(raw: unknown): Record<string, unknown> | null {
+  if (typeof raw === 'string') {
+    try {
+      return asRecord(JSON.parse(raw))
+    } catch {
+      return null
+    }
+  }
+  return asRecord(raw)
+}
 
-            if (action === 'poll') {
-              const res = pollManagedProcess(processId)
-              if (!res) return `Process not found: ${processId}`
-              return JSON.stringify({
-                id: res.process.id,
-                status: res.process.status,
-                exitCode: res.process.exitCode,
-                signal: res.process.signal,
-                chunk: res.chunk,
-              }, null, 2)
-            }
+function pickString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value !== 'string') continue
+    const trimmed = value.trim()
+    if (trimmed) return trimmed
+  }
+  return undefined
+}
 
-            if (action === 'log') {
-              const res = readManagedProcessLog(processId, offset, limit)
-              if (!res) return `Process not found: ${processId}`
-              return JSON.stringify({
-                id: res.process.id,
-                status: res.process.status,
-                totalLines: res.totalLines,
-                text: res.text,
-              }, null, 2)
-            }
+function pickNumber(...values: unknown[]): number | undefined {
+  for (const value of values) {
+    if (typeof value === 'number' && Number.isFinite(value)) return value
+    if (typeof value === 'string' && value.trim()) {
+      const parsed = Number(value)
+      if (Number.isFinite(parsed)) return parsed
+    }
+  }
+  return undefined
+}
 
-            if (action === 'write') {
-              const out = writeManagedProcessStdin(processId, data || '', !!eof)
-              return out.ok ? `Wrote to process ${processId}` : `Error: ${out.error}`
-            }
+function pickBoolean(...values: unknown[]): boolean | undefined {
+  for (const value of values) {
+    if (typeof value === 'boolean') return value
+  }
+  return undefined
+}
 
-            if (action === 'kill') {
-              const out = killManagedProcess(processId, (signal as NodeJS.Signals) || 'SIGTERM')
-              return out.ok ? `Killed process ${processId}` : `Error: ${out.error}`
-            }
+export function normalizeShellArgs(rawArgs: Record<string, unknown>): Record<string, unknown> {
+  const base = normalizeToolInputArgs(rawArgs)
+  const nested = parseNestedInput(base.input)
 
-            if (action === 'clear') {
-              const out = clearManagedProcess(processId)
-              return out.ok ? `Cleared process ${processId}` : `Error: ${out.error}`
-            }
+  const command = pickString(
+    base.command,
+    base.cmd,
+    base.execute_command,
+    nested?.command,
+    nested?.cmd,
+    nested?.execute_command,
+  )
+  const action = pickString(base.action, nested?.action) ?? (command ? 'execute' : undefined)
 
-            if (action === 'remove') {
-              const out = removeManagedProcess(processId)
-              return out.ok ? `Removed process ${processId}` : `Error: ${out.error}`
-            }
+  return {
+    action,
+    command,
+    processId: pickString(base.processId, base.process_id, nested?.processId, nested?.process_id),
+    background: pickBoolean(base.background, nested?.background),
+    workdir: pickString(base.workdir, base.cwd, nested?.workdir, nested?.cwd),
+    env: asRecord(base.env) || asRecord(nested?.env),
+    timeoutSec: pickNumber(base.timeoutSec, base.timeout, nested?.timeoutSec, nested?.timeout),
+    data: pickString(base.data, base.stdin, nested?.data, nested?.stdin),
+    signal: pickString(base.signal, base.killSignal, nested?.signal, nested?.killSignal),
+    offset: pickNumber(base.offset, nested?.offset),
+    limit: pickNumber(base.limit, nested?.limit),
+  }
+}
 
-            if (action === 'status') {
-              const p = getManagedProcess(processId)
-              if (!p) return `Process not found: ${processId}`
-              return JSON.stringify({
-                id: p.id,
-                status: p.status,
-                pid: p.pid,
-                startedAt: p.startedAt,
-                endedAt: p.endedAt,
-                exitCode: p.exitCode,
-                signal: p.signal,
-              }, null, 2)
-            }
+/**
+ * Unified Shell Execution Logic
+ */
+async function executeShellAction(args: Record<string, unknown>, bctx: { cwd: string; agentId?: string | null; sessionId?: string | null }) {
+  const normalized = normalizeShellArgs(args)
+  const action = normalized.action as string | undefined
+  const command = normalized.command as string | undefined
+  const processId = normalized.processId as string | undefined
+  const background = normalized.background as boolean | undefined
+  const workdir = normalized.workdir as string | undefined
+  const env = normalized.env
+  const timeoutSec = normalized.timeoutSec as number | undefined
+  const data = normalized.data as string | undefined
+  const signal = normalized.signal as string | undefined
+  const offset = normalized.offset as number | undefined
+  const limit = normalized.limit as number | undefined
+  try {
+    switch (action) {
+      case 'execute': {
+        if (!command) return 'Error: command or cmd is required for execute action.'
+        const effectiveBackground = !!background || (typeof command === 'string' && isLikelyServerCommand(command))
+        const result = await startManagedProcess({
+          command: command,
+          cwd: resolveShellWorkdir(bctx.cwd, workdir),
+          env: coerceEnvMap(env),
+          agentId: bctx.agentId || null,
+          sessionId: bctx.sessionId || null,
+          background: effectiveBackground,
+          timeoutMs: typeof timeoutSec === 'number' ? timeoutSec * 1000 : 30000,
+        })
+        if (result.status === 'completed') return truncate(result.output || '(no output)', MAX_OUTPUT)
+        return JSON.stringify({ status: 'running', processId: result.processId, tail: result.tail || '' }, null, 2)
+      }
+      case 'list': return JSON.stringify(listManagedProcesses(bctx.agentId || null), null, 2)
+      case 'status': return JSON.stringify(getManagedProcess(processId!) || `Not found: ${processId}`, null, 2)
+      case 'poll': return JSON.stringify(pollManagedProcess(processId!) || `Not found: ${processId}`, null, 2)
+      case 'log': return JSON.stringify(readManagedProcessLog(processId!, offset, limit) || `Not found: ${processId}`, null, 2)
+      case 'write': return writeManagedProcessStdin(processId!, data || '', false).ok ? `Wrote to ${processId}` : `Error`
+      case 'kill': {
+        const killSignal = (typeof signal === 'string' && signal.trim() ? signal : 'SIGTERM') as NodeJS.Signals
+        return killManagedProcess(processId!, killSignal).ok ? `Killed ${processId}` : `Error`
+      }
+      case 'remove': return removeManagedProcess(processId!).ok ? `Removed ${processId}` : `Error`
+      default: return `Error: Unknown action "${action}"`
+    }
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
 
-            return `Unknown action "${action}".`
-          } catch (err: any) {
-            return `Error: ${err.message || String(err)}`
-          }
+/**
+ * Register as a Built-in Plugin
+ */
+const ShellPlugin: Plugin = {
+  name: 'Core Shell',
+  description: 'Execute shell commands and manage background processes.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'shell',
+      description: 'Execute commands and manage processes.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['execute', 'list', 'status', 'poll', 'log', 'write', 'kill', 'remove'] },
+          command: { type: 'string' },
+          processId: { type: 'string' },
+          background: { type: 'boolean' },
         },
-        {
-          name: 'process_tool',
-          description: 'Manage long-running shell processes started by execute_command. Supports list, status, poll, log, write, kill, clear, and remove.',
-          schema: z.object({
-            action: z.enum(['list', 'status', 'poll', 'log', 'write', 'kill', 'clear', 'remove']),
-            processId: z.string().optional(),
-            offset: z.number().optional(),
-            limit: z.number().optional(),
-            data: z.string().optional(),
-            eof: z.boolean().optional(),
-            signal: z.string().optional().describe('Signal for kill action, e.g. SIGTERM or SIGKILL'),
-          }),
-        },
-      ),
-    )
-  }
+        required: ['action']
+      },
+      execute: async (args, context) => executeShellAction(args, { ...context.session, cwd: context.session.cwd || process.cwd() })
+    }
+  ]
+}
+
+getPluginManager().registerBuiltin('shell', ShellPlugin)
 
-  return tools
+export function buildShellTools(bctx: ToolBuildContext) {
+  if (!bctx.hasTool('shell')) return []
+  return [
+    tool(
+      async (args) => executeShellAction(args, { ...bctx.ctx, cwd: bctx.cwd }),
+      {
+        name: 'shell',
+        description: ShellPlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
+    )
+  ]
 }

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

@@ -1,106 +1,106 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import { genId } from '@/lib/id'
+import { DEFAULT_DELEGATION_MAX_DEPTH } from '@/lib/runtime-loop'
 import { loadAgents, loadSessions, saveSessions } from '../storage'
 import { executeSessionChatTurn } from '../chat-execution'
 import { log } from '../logger'
+import { loadRuntimeSettings } from '../runtime-settings'
 import type { ToolBuildContext } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
-const MAX_RECURSION_DEPTH = 3
-
-function getSessionDepth(sessionId: string | undefined): number {
+function getSessionDepth(sessionId: string | undefined, maxDepth: number): number {
   if (!sessionId) return 0
   const sessions = loadSessions()
   let depth = 0
   let current = sessionId
-  while (current && depth < MAX_RECURSION_DEPTH + 1) {
+  while (current && depth < maxDepth + 1) {
     const session = sessions[current]
     if (!session?.parentSessionId) break
-    current = session.parentSessionId
+    current = session.parentSessionId as string
     depth++
   }
   return depth
 }
 
-export function buildSubagentTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  const { ctx, hasTool } = bctx
-  if (!hasTool('spawn_subagent')) return []
+/**
+ * Core Subagent Execution Logic
+ */
+async function executeSubagentAction(args: any, context: { sessionId?: string; cwd: string }) {
+  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
+  const agentId = (normalized.agentId ?? normalized.agent_id) as string | undefined
+  const message = normalized.message as string | undefined
+  const cwd = normalized.cwd as string | undefined
+  try {
+    const runtime = loadRuntimeSettings()
+    const maxDepth = runtime.delegationMaxDepth || DEFAULT_DELEGATION_MAX_DEPTH
+    const agents = loadAgents()
+    if (!agentId) return 'Error: agentId is required.'
+    if (!message) return 'Error: message is required.'
+    const agent = agents[agentId]
+    if (!agent) return `Error: Agent "${agentId}" not found.`
 
-  return [
-    tool(
-      async ({ agentId, message, cwd }) => {
-        try {
-          // Validate agent exists
-          const agents = loadAgents()
-          const agent = agents[agentId]
-          if (!agent) return `Error: Agent "${agentId}" not found. Available agents: ${Object.values(agents).map((a) => `"${a.id}" (${a.name})`).join(', ')}`
+    const depth = getSessionDepth(context.sessionId, maxDepth)
+    if (depth >= maxDepth) return `Error: Max subagent depth reached.`
 
-          // Check recursion depth
-          const depth = getSessionDepth(ctx?.sessionId ?? undefined)
-          if (depth >= MAX_RECURSION_DEPTH) {
-            return `Error: Maximum subagent recursion depth (${MAX_RECURSION_DEPTH}) reached. Cannot spawn further subagents.`
-          }
+    const sid = genId()
+    const now = Date.now()
+    const sessions = loadSessions()
+    sessions[sid] = {
+      id: sid, name: `subagent-${agent.name}`, cwd: cwd || context.cwd, user: 'agent',
+      provider: agent.provider, model: agent.model, credentialId: agent.credentialId || null,
+      messages: [], createdAt: now, lastActiveAt: now, sessionType: 'orchestrated',
+      agentId: agent.id, parentSessionId: context.sessionId || null, tools: agent.tools || [],
+    }
+    saveSessions(sessions)
 
-          // Create ephemeral session
-          const sessionId = genId()
-          const now = Date.now()
-          const sessions = loadSessions()
-          sessions[sessionId] = {
-            id: sessionId,
-            name: `subagent-${agent.name}-${sessionId.slice(0, 6)}`,
-            cwd: cwd || bctx.cwd,
-            user: 'agent',
-            provider: agent.provider,
-            model: agent.model,
-            credentialId: agent.credentialId || null,
-            fallbackCredentialIds: agent.fallbackCredentialIds || [],
-            apiEndpoint: agent.apiEndpoint || null,
-            claudeSessionId: null,
-            messages: [],
-            createdAt: now,
-            lastActiveAt: now,
-            sessionType: 'orchestrated',
-            agentId: agent.id,
-            parentSessionId: ctx?.sessionId || null,
-            tools: agent.tools || [],
-          }
-          saveSessions(sessions)
+    const result = await executeSessionChatTurn({ sessionId: sid, message, internal: true, source: 'subagent' })
+    return JSON.stringify({ agentId, agentName: agent.name, sessionId: sid, response: result.text.slice(0, 8000) })
+  } catch (err: any) { return `Error: ${err.message}` }
+}
 
-          log.info('subagent', `Spawning subagent "${agent.name}" (depth=${depth + 1})`, {
-            parentSessionId: ctx?.sessionId,
-            childSessionId: sessionId,
-            agentId,
-          })
+/**
+ * Register as a Built-in Plugin
+ */
+const SubagentPlugin: Plugin = {
+  name: 'Core Subagents',
+  description: 'Delegate tasks to other specialized agents.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'spawn_subagent',
+      description: 'Delegate a task to another agent.',
+      parameters: {
+        type: 'object',
+        properties: {
+          agentId: { type: 'string' },
+          message: { type: 'string' },
+          cwd: { type: 'string' }
+        },
+        required: ['agentId', 'message']
+      },
+      execute: async (args, context) => executeSubagentAction(args, { sessionId: context.session.id, cwd: context.session.cwd || process.cwd() })
+    }
+  ]
+}
 
-          // Execute the chat turn
-          const result = await executeSessionChatTurn({
-            sessionId,
-            message,
-            internal: true,
-            source: 'subagent',
-          })
+getPluginManager().registerBuiltin('subagent', SubagentPlugin)
 
-          return JSON.stringify({
-            agentId,
-            agentName: agent.name,
-            sessionId,
-            response: result.text.slice(0, 8000),
-            toolEvents: result.toolEvents?.length || 0,
-            error: result.error || null,
-          })
-        } catch (err: unknown) {
-          return `Error spawning subagent: ${err instanceof Error ? err.message : String(err)}`
-        }
-      },
+/**
+ * Legacy Bridge
+ */
+export function buildSubagentTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('spawn_subagent')) return []
+  return [
+    tool(
+      async (args) => executeSubagentAction(args, { sessionId: bctx.ctx?.sessionId || undefined, cwd: bctx.cwd }),
       {
         name: 'spawn_subagent',
-        description: `Delegate a task to another agent. The subagent runs independently and returns its response. Use this to leverage specialized agents for subtasks. Max recursion depth: ${MAX_RECURSION_DEPTH}.`,
-        schema: z.object({
-          agentId: z.string().describe('ID of the agent to delegate to'),
-          message: z.string().describe('The message/task to send to the subagent'),
-          cwd: z.string().optional().describe('Optional working directory for the subagent (defaults to current)'),
-        }),
-      },
-    ),
+        description: SubagentPlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
+    )
   ]
 }