@swarmclawai/swarmclaw 0.6.8 → 0.7.0

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

@@ -6,11 +6,22 @@ import { spawnSync } from 'child_process'
 import { UPLOAD_DIR } from '../storage'
 import { findBinaryOnPath, truncate, MAX_OUTPUT } from './context'
 import type { ToolBuildContext } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
 function getDenoPath(): string | null {
   return findBinaryOnPath('deno')
 }
 
+function getNodePath(): string | null {
+  return findBinaryOnPath('node')
+}
+
+function getTsxPath(): string | null {
+  return findBinaryOnPath('tsx')
+}
+
 function getPythonPath(): string | null {
   return findBinaryOnPath('python3') ?? findBinaryOnPath('python')
 }
@@ -21,175 +32,191 @@ const EXT_MAP: Record<string, string> = {
   python: 'py',
 }
 
+/**
+ * Core Sandbox Execution Logic
+ */
+async function executeSandboxExec(args: any, context: { sessionId?: string; cwd?: string }) {
+  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
+  const language = normalized.language as string
+  const code = normalized.code as string
+  const timeoutSec = normalized.timeoutSec as number | undefined
+  const timeout = Math.min(Math.max(timeoutSec ?? 60, 5), 300) * 1000
+  const ext = EXT_MAP[language]
+  const sessionId = context.sessionId ?? 'unknown'
+  const sandboxDir = path.join('/tmp', `swarmclaw-sandbox-${sessionId}-${Date.now()}`)
+  const denoPath = getDenoPath()
+  const nodePath = getNodePath()
+  const tsxPath = getTsxPath()
+  const pythonPath = getPythonPath()
+
+  if (language === 'javascript' && !denoPath && !nodePath) {
+    return JSON.stringify({ error: 'No JavaScript runtime available. Install Deno or Node.js.' })
+  }
+  if (language === 'typescript' && !denoPath && !tsxPath) {
+    return JSON.stringify({ error: 'No TypeScript runtime available. Install Deno or tsx.' })
+  }
+  if (language === 'python' && !pythonPath) {
+    return JSON.stringify({ error: 'Python is not installed.' })
+  }
+
+  try {
+    fs.mkdirSync(sandboxDir, { recursive: true })
+    const scriptFile = `script.${ext}`
+    const scriptPath = path.join(sandboxDir, scriptFile)
+    fs.writeFileSync(scriptPath, code, 'utf-8')
+
+    let result: ReturnType<typeof spawnSync>
+
+    if (language === 'javascript') {
+      if (denoPath) {
+        result = spawnSync(denoPath, [
+          'run', '--allow-read=.', '--allow-write=.', '--allow-net', '--deny-env', '--no-prompt', scriptFile,
+        ], { cwd: sandboxDir, encoding: 'utf-8', timeout, maxBuffer: MAX_OUTPUT })
+      } else {
+        result = spawnSync(nodePath!, [scriptPath], {
+          cwd: sandboxDir, encoding: 'utf-8', timeout, maxBuffer: MAX_OUTPUT,
+          env: { PATH: process.env.PATH || '/usr/bin:/bin' } as any,
+        })
+      }
+    } else if (language === 'typescript') {
+      if (denoPath) {
+        result = spawnSync(denoPath, [
+          'run', '--allow-read=.', '--allow-write=.', '--allow-net', '--deny-env', '--no-prompt', scriptFile,
+        ], { cwd: sandboxDir, encoding: 'utf-8', timeout, maxBuffer: MAX_OUTPUT })
+      } else {
+        result = spawnSync(tsxPath!, [scriptPath], {
+          cwd: sandboxDir, encoding: 'utf-8', timeout, maxBuffer: MAX_OUTPUT,
+          env: { PATH: process.env.PATH || '/usr/bin:/bin' } as any,
+        })
+      }
+    } else {
+      result = spawnSync(pythonPath!, [scriptPath], {
+        cwd: sandboxDir, encoding: 'utf-8', timeout, maxBuffer: MAX_OUTPUT,
+        env: { PATH: process.env.PATH || '/usr/bin:/bin' } as any,
+      })
+    }
+
+    const stdout = truncate((result.stdout || '').toString(), MAX_OUTPUT)
+    const stderr = truncate((result.stderr || '').toString(), MAX_OUTPUT)
+    const exitCode = result.status ?? (result.error ? 1 : 0)
+    const timedOut = !!(result.error?.message?.includes('ETIMEDOUT') || result.signal === 'SIGTERM')
+
+    const artifacts: { name: string; url: string }[] = []
+    try {
+      const files = fs.readdirSync(sandboxDir)
+      for (const file of files) {
+        if (file === scriptFile) continue
+        const src = path.join(sandboxDir, file)
+        if (!fs.statSync(src).isFile()) continue
+        fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+        const destName = `sandbox-${Date.now()}-${file}`
+        const dest = path.join(UPLOAD_DIR, destName)
+        fs.copyFileSync(src, dest)
+        artifacts.push({ name: file, url: `/api/uploads/${encodeURIComponent(destName)}` })
+      }
+    } catch { /* ignore */ }
+
+    return JSON.stringify({ exitCode, timedOut, stdout, stderr, artifacts })
+  } catch (err: any) {
+    return JSON.stringify({ error: err.message })
+  } finally {
+    try { fs.rmSync(sandboxDir, { recursive: true, force: true }) } catch { /* ignore */ }
+  }
+}
+
+async function executeListRuntimes() {
+  const runtimes: Record<string, any> = {}
+  for (const [name, bin] of [['deno', getDenoPath()], ['node', getNodePath()], ['tsx', getTsxPath()], ['python', getPythonPath()]] as const) {
+    if (bin) {
+      const ver = spawnSync(bin, ['--version'], { encoding: 'utf-8', timeout: 3000 })
+      runtimes[name] = { available: true, version: (ver.stdout || '').split('\n')[0]?.trim() || null }
+    } else {
+      runtimes[name] = { available: false }
+    }
+  }
+  return JSON.stringify(runtimes)
+}
+
+/**
+ * Register as a Built-in Plugin
+ */
+const SandboxPlugin: Plugin = {
+  name: 'Core Sandbox',
+  description: 'Secure isolated code execution for JS, TS, and Python.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'sandbox_exec',
+      description: 'Execute code in an isolated sandbox.',
+      parameters: {
+        type: 'object',
+        properties: {
+          language: { type: 'string', enum: ['javascript', 'typescript', 'python'] },
+          code: { type: 'string' },
+          timeoutSec: { type: 'number' }
+        },
+        required: ['language', 'code']
+      },
+      execute: async (args, context) => executeSandboxExec(args, { sessionId: context.session.id })
+    },
+    {
+      name: 'sandbox_list_runtimes',
+      description: 'List available sandbox runtimes.',
+      parameters: { type: 'object', properties: {} },
+      execute: async () => executeListRuntimes()
+    }
+  ]
+}
+
+getPluginManager().registerBuiltin('sandbox', SandboxPlugin)
+
+/**
+ * Legacy Bridge
+ */
 export function buildSandboxTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   if (!bctx.hasTool('sandbox')) return []
-
   const tools: StructuredToolInterface[] = []
 
   tools.push(
     tool(
-      async ({ language, code, timeoutSec }) => {
-        const timeout = Math.min(Math.max(timeoutSec ?? 60, 5), 300) * 1000
-        const ext = EXT_MAP[language]
-        const sessionId = bctx.ctx?.sessionId ?? 'unknown'
-        const sandboxDir = path.join('/tmp', `swarmclaw-sandbox-${sessionId}-${Date.now()}`)
-
-        // Check runtime availability
-        if ((language === 'javascript' || language === 'typescript') && !getDenoPath()) {
-          return JSON.stringify({ error: 'Deno is not installed. Install it with: curl -fsSL https://deno.land/install.sh | sh' })
-        }
-        if (language === 'python' && !getPythonPath()) {
-          return JSON.stringify({ error: 'Python is not installed. Install python3 to use Python sandbox.' })
-        }
-
-        try {
-          fs.mkdirSync(sandboxDir, { recursive: true })
-          const scriptFile = `script.${ext}`
-          const scriptPath = path.join(sandboxDir, scriptFile)
-          fs.writeFileSync(scriptPath, code, 'utf-8')
-
-          let result: ReturnType<typeof spawnSync>
-
-          if (language === 'javascript' || language === 'typescript') {
-            const denoPath = getDenoPath()!
-            result = spawnSync(denoPath, [
-              'run',
-              '--allow-read=.',
-              '--allow-write=.',
-              '--allow-net',
-              '--deny-env',
-              '--no-prompt',
-              scriptFile,
-            ], {
-              cwd: sandboxDir,
-              encoding: 'utf-8',
-              timeout,
-              maxBuffer: MAX_OUTPUT,
-            })
-          } else {
-            const pythonPath = getPythonPath()!
-            result = spawnSync(pythonPath, [scriptPath], {
-              cwd: sandboxDir,
-              encoding: 'utf-8',
-              timeout,
-              maxBuffer: MAX_OUTPUT,
-              env: { PATH: process.env.PATH || '/usr/bin:/bin' } as unknown as NodeJS.ProcessEnv,
-            })
-          }
-
-          const stdout = truncate((result.stdout || '').toString(), MAX_OUTPUT)
-          const stderr = truncate((result.stderr || '').toString(), MAX_OUTPUT)
-          const exitCode = result.status ?? (result.error ? 1 : 0)
-          const timedOut = result.error?.message?.includes('ETIMEDOUT') || result.signal === 'SIGTERM'
-
-          // Scan for created files (exclude the script itself)
-          const artifacts: { name: string; url: string }[] = []
-          try {
-            const files = fs.readdirSync(sandboxDir)
-            for (const file of files) {
-              if (file === scriptFile) continue
-              const src = path.join(sandboxDir, file)
-              const stat = fs.statSync(src)
-              if (!stat.isFile()) continue
-              // Copy to upload dir
-              fs.mkdirSync(UPLOAD_DIR, { recursive: true })
-              const destName = `sandbox-${Date.now()}-${file}`
-              const dest = path.join(UPLOAD_DIR, destName)
-              fs.copyFileSync(src, dest)
-              artifacts.push({
-                name: file,
-                url: `/api/uploads/${encodeURIComponent(destName)}`,
-              })
-            }
-          } catch {
-            // ignore scan errors
-          }
-
-          return JSON.stringify({
-            exitCode,
-            timedOut,
-            stdout,
-            stderr,
-            artifacts,
-          })
-        } catch (err: unknown) {
-          return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-        } finally {
-          try { fs.rmSync(sandboxDir, { recursive: true, force: true }) } catch { /* ignore */ }
-        }
-      },
+      async (args) => executeSandboxExec(args, { sessionId: bctx.ctx?.sessionId || undefined }),
       {
         name: 'sandbox_exec',
-        description:
-          'Execute code in an isolated sandbox. JS/TS runs via Deno with network access but no env vars. Python runs with a stripped environment. ' +
-          'Files created in the sandbox directory are returned as downloadable artifact URLs. Use this for data processing, API calls, calculations, and file generation.',
-        schema: z.object({
-          language: z.enum(['javascript', 'typescript', 'python']).describe('Programming language to execute'),
-          code: z.string().describe('Source code to run'),
-          timeoutSec: z.number().optional().describe('Execution timeout in seconds (default 60, max 300)'),
-        }),
-      },
+        description: SandboxPlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
     ),
-  )
-
-  tools.push(
     tool(
-      async () => {
-        const denoPath = getDenoPath()
-        const pythonPath = getPythonPath()
-
-        const runtimes: Record<string, { available: boolean; path: string | null; version: string | null }> = {}
-
-        for (const [name, bin] of [['deno', denoPath], ['python', pythonPath]] as const) {
-          if (bin) {
-            const ver = spawnSync(bin, ['--version'], { encoding: 'utf-8', timeout: 3000 })
-            const version = (ver.stdout || '').split('\n')[0]?.trim() || null
-            runtimes[name] = { available: true, path: bin, version }
-          } else {
-            runtimes[name] = { available: false, path: null, version: null }
-          }
-        }
-
-        return JSON.stringify(runtimes)
-      },
+      async () => executeListRuntimes(),
       {
         name: 'sandbox_list_runtimes',
-        description: 'List available sandbox runtimes (Deno for JS/TS, Python) and their versions. Use this to check what languages are available before running code.',
-        schema: z.object({}),
-      },
-    ),
+        description: SandboxPlugin.tools![1].description,
+        schema: z.object({}).passthrough()
+      }
+    )
   )
 
-  // ---- openclaw_sandbox (CLI passthrough) -----------------------------------
-
-  const openclawSandboxPath = findBinaryOnPath('openclaw') || findBinaryOnPath('clawdbot')
-  if (openclawSandboxPath) {
+  const openclawPath = findBinaryOnPath('openclaw') || findBinaryOnPath('clawdbot')
+  if (openclawPath) {
     tools.push(
       tool(
-        async ({ code, explain }) => {
+        async (rawArgs) => {
+          const normalized = normalizeToolInputArgs((rawArgs ?? {}) as Record<string, unknown>)
+          const code = normalized.code as string | undefined
+          const explain = normalized.explain as boolean | undefined
           try {
+            if (!code) return JSON.stringify({ error: 'code is required' })
             const args = explain ? ['sandbox', 'explain', code] : ['sandbox', 'run', code]
-            const result = spawnSync(openclawSandboxPath, args, {
-              encoding: 'utf-8',
-              timeout: 60_000,
-              maxBuffer: MAX_OUTPUT,
-            })
-            const stdout = truncate((result.stdout || '').trim(), MAX_OUTPUT)
-            const stderr = truncate((result.stderr || '').trim(), MAX_OUTPUT)
-            return JSON.stringify({ exitCode: result.status ?? 0, stdout, stderr })
-          } catch (err: unknown) {
-            return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-          }
+            const result = spawnSync(openclawPath, args, { encoding: 'utf-8', timeout: 60_000, maxBuffer: MAX_OUTPUT })
+            return JSON.stringify({ exitCode: result.status ?? 0, stdout: truncate(result.stdout || '', MAX_OUTPUT), stderr: truncate(result.stderr || '', MAX_OUTPUT) })
+          } catch (err: any) { return JSON.stringify({ error: err.message }) }
         },
         {
           name: 'openclaw_sandbox',
-          description: 'Execute or explain code through the OpenClaw CLI sandbox. CLI passthrough to `openclaw sandbox run|explain <code>`. Requires openclaw/clawdbot CLI on PATH.',
-          schema: z.object({
-            code: z.string().describe('Code to run or explain'),
-            explain: z.boolean().optional().describe('If true, explain the code instead of running it'),
-          }),
-        },
-      ),
+          description: 'Execute or explain code through OpenClaw CLI.',
+          schema: z.object({ code: z.string(), explain: z.boolean().optional() }),
+        }
+      )
     )
   }
 

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

@@ -3,41 +3,76 @@ import { z } from 'zod'
 import { enqueueSystemEvent } from '../system-events'
 import { requestHeartbeatNow } from '../heartbeat-wake'
 import type { ToolBuildContext } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
-export function buildScheduleTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  const tools: StructuredToolInterface[] = []
-  const { ctx, hasTool } = bctx
+/**
+ * Core Schedule Execution Logic
+ */
+async function executeScheduleWake(args: { delayMinutes: number; message: string }, context: { sessionId?: string }) {
+  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
+  const delayMinutes = normalized.delayMinutes as number
+  const message = normalized.message as string
+  if (!context.sessionId) return 'Cannot schedule wake: no session context.'
+  if (delayMinutes < 0 || delayMinutes > 1440) return 'delayMinutes must be between 0 and 1440 (24 hours).'
 
-  if (hasTool('schedule_wake')) {
-    tools.push(
-      tool(
-        async ({ delayMinutes, message }) => {
-          if (!ctx?.sessionId) return 'Cannot schedule wake: no session context.'
-          if (delayMinutes <= 0 || delayMinutes > 1440) return 'delayMinutes must be between 1 and 1440 (24 hours).'
+  if (delayMinutes === 0) {
+    enqueueSystemEvent(context.sessionId, `[Scheduled Wake Event / Reminder] ${message}`)
+    requestHeartbeatNow({ sessionId: context.sessionId, reason: 'scheduled_wake' })
+    return 'Successfully scheduled an immediate wake event.'
+  }
 
-          // Non-durable in-memory timeout for conversational wake events
-          // (For durable cron, use manage_schedules)
-          const delayMs = delayMinutes * 60 * 1000
-          setTimeout(() => {
-            if (ctx.sessionId) {
-              enqueueSystemEvent(ctx.sessionId, `[Scheduled Wake Event / Reminder] ${message}`)
-              requestHeartbeatNow({ sessionId: ctx.sessionId, reason: 'scheduled_wake' })
-            }
-          }, delayMs)
+  const delayMs = delayMinutes * 60 * 1000
+  setTimeout(() => {
+    if (context.sessionId) {
+      enqueueSystemEvent(context.sessionId, `[Scheduled Wake Event / Reminder] ${message}`)
+      requestHeartbeatNow({ sessionId: context.sessionId, reason: 'scheduled_wake' })
+    }
+  }, delayMs)
 
-          return `Successfully scheduled a wake event in ${delayMinutes} minutes with message: "${message}".`
-        },
-        {
-          name: 'schedule_wake',
-          description: 'Schedule a wake event (reminder) for yourself in this chatroom. Use this to proactively check back on a long-running process or to remind yourself to follow up with the user later.',
-          schema: z.object({
-            delayMinutes: z.number().describe('How many minutes from now to wake up (1-1440).'),
-            message: z.string().describe('The reminder text that will be passed back to you when you wake.'),
-          }),
+  return `Successfully scheduled a wake event in ${delayMinutes} minutes.`
+}
+
+/**
+ * Register as a Built-in Plugin
+ */
+const SchedulePlugin: Plugin = {
+  name: 'Core Scheduler',
+  description: 'Schedule wake events and reminders for agents.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'schedule_wake',
+      description: 'Schedule a wake event (reminder) for yourself in this chatroom.',
+      parameters: {
+        type: 'object',
+        properties: {
+          delayMinutes: { type: 'number' },
+          message: { type: 'string' }
         },
-      ),
-    )
-  }
+        required: ['delayMinutes', 'message']
+      },
+      execute: async (args, context) => executeScheduleWake(args as any, { sessionId: context.session.id })
+    }
+  ]
+}
+
+getPluginManager().registerBuiltin('schedule', SchedulePlugin)
 
-  return tools
+/**
+ * Legacy Bridge
+ */
+export function buildScheduleTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('schedule_wake')) return []
+  return [
+    tool(
+      async (args) => executeScheduleWake(args as any, { sessionId: bctx.ctx?.sessionId || undefined }),
+      {
+        name: 'schedule_wake',
+        description: SchedulePlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
+    )
+  ]
 }