@swarmclawai/swarmclaw 0.7.2 → 0.7.4

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

@@ -14,22 +14,20 @@ 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')
-}
-
 const EXT_MAP: Record<string, string> = {
   javascript: 'js',
   typescript: 'ts',
-  python: 'py',
+}
+
+function sandboxUnavailableError(reason: string): string {
+  return JSON.stringify({
+    error: reason,
+    guidance: [
+      'Install Deno or run `npm run setup:easy` to enable sandbox_exec.',
+      'Use http_request for straightforward API calls.',
+      'Use plugin_creator plus manage_schedules for recurring automations.',
+    ],
+  })
 }
 
 /**
@@ -45,18 +43,13 @@ async function executeSandboxExec(args: any, context: { sessionId?: string; cwd?
   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 !== 'javascript' && language !== 'typescript') {
+    return sandboxUnavailableError('sandbox_exec currently supports only JavaScript and TypeScript via Deno.')
   }
-  if (language === 'python' && !pythonPath) {
-    return JSON.stringify({ error: 'Python is not installed.' })
+
+  if (!denoPath) {
+    return sandboxUnavailableError('Deno is required for sandbox_exec. Unsafe Node/Python fallbacks are disabled.')
   }
 
   try {
@@ -65,36 +58,15 @@ async function executeSandboxExec(args: any, context: { sessionId?: string; cwd?
     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 result = spawnSync(denoPath, [
+      'run',
+      '--allow-read=.',
+      '--allow-write=.',
+      '--allow-net',
+      '--deny-env',
+      '--no-prompt',
+      scriptFile,
+    ], { cwd: sandboxDir, encoding: 'utf-8', timeout, maxBuffer: MAX_OUTPUT })
 
     const stdout = truncate((result.stdout || '').toString(), MAX_OUTPUT)
     const stderr = truncate((result.stderr || '').toString(), MAX_OUTPUT)
@@ -125,16 +97,18 @@ async function executeSandboxExec(args: any, context: { sessionId?: string; cwd?
 }
 
 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 }
-    }
+  const denoPath = getDenoPath()
+  if (!denoPath) {
+    return sandboxUnavailableError('Deno is not available for sandbox_exec.')
   }
-  return JSON.stringify(runtimes)
+  const ver = spawnSync(denoPath, ['--version'], { encoding: 'utf-8', timeout: 3000 })
+  return JSON.stringify({
+    deno: {
+      available: true,
+      version: (ver.stdout || '').split('\n')[0]?.trim() || null,
+    },
+    sandboxReady: true,
+  })
 }
 
 /**
@@ -142,18 +116,23 @@ async function executeListRuntimes() {
  */
 const SandboxPlugin: Plugin = {
   name: 'Core Sandbox',
-  description: 'Secure isolated code execution for JS, TS, and Python.',
+  description: 'Deno-based isolated code execution for JavaScript and TypeScript when custom code is necessary.',
   hooks: {
-    getCapabilityDescription: () => 'I can run code in a sandbox (`sandbox_exec`) — JS/TS via Deno or Python, in an isolated environment. I get stdout, stderr, and any files created.',
+    getCapabilityDescription: () => 'I can run JavaScript or TypeScript in a Deno sandbox (`sandbox_exec`) when custom code is necessary. For straightforward API calls, use `http_request` instead.',
+    getOperatingGuidance: () => [
+      'Use `http_request` for straightforward REST/JSON API calls instead of writing code in `sandbox_exec`.',
+      'Use `sandbox_exec` only when custom parsing or transformation code is actually needed.',
+      'For recurring automations, prefer `plugin_creator` plus `manage_schedules` over repeated sandbox runs.',
+    ],
   } as PluginHooks,
   tools: [
     {
       name: 'sandbox_exec',
-      description: 'Execute code in an isolated sandbox.',
+      description: 'Execute JavaScript or TypeScript in a Deno sandbox when custom code is necessary.',
       parameters: {
         type: 'object',
         properties: {
-          language: { type: 'string', enum: ['javascript', 'typescript', 'python'] },
+          language: { type: 'string', enum: ['javascript', 'typescript'] },
           code: { type: 'string' },
           timeoutSec: { type: 'number' }
         },
@@ -163,7 +142,7 @@ const SandboxPlugin: Plugin = {
     },
     {
       name: 'sandbox_list_runtimes',
-      description: 'List available sandbox runtimes.',
+      description: 'Report whether the Deno sandbox runtime is available.',
       parameters: { type: 'object', properties: {} },
       execute: async () => executeListRuntimes()
     }
@@ -185,7 +164,11 @@ export function buildSandboxTools(bctx: ToolBuildContext): StructuredToolInterfa
       {
         name: 'sandbox_exec',
         description: SandboxPlugin.tools![0].description,
-        schema: z.object({}).passthrough()
+        schema: z.object({
+          language: z.enum(['javascript', 'typescript']),
+          code: z.string(),
+          timeoutSec: z.number().optional(),
+        })
       }
     ),
     tool(
@@ -198,29 +181,5 @@ export function buildSandboxTools(bctx: ToolBuildContext): StructuredToolInterfa
     )
   )
 
-  const openclawPath = findBinaryOnPath('openclaw') || findBinaryOnPath('clawdbot')
-  if (openclawPath) {
-    tools.push(
-      tool(
-        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(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 OpenClaw CLI.',
-          schema: z.object({ code: z.string(), explain: z.boolean().optional() }),
-        }
-      )
-    )
-  }
-
   return tools
 }

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

@@ -6,6 +6,7 @@ import type { ToolBuildContext } from './context'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { createWatchJob } from '../watch-jobs'
 
 /**
  * Core Schedule Execution Logic
@@ -15,7 +16,7 @@ async function executeScheduleWake(args: { delayMinutes: number; message: string
   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 (delayMinutes < 0 || delayMinutes > 43_200) return 'delayMinutes must be between 0 and 43200 (30 days).'
 
   if (delayMinutes === 0) {
     enqueueSystemEvent(context.sessionId, `[Scheduled Wake Event / Reminder] ${message}`)
@@ -23,15 +24,24 @@ async function executeScheduleWake(args: { delayMinutes: number; message: string
     return 'Successfully scheduled an immediate wake event.'
   }
 
-  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)
+  const runAt = Date.now() + delayMinutes * 60 * 1000
+  const watch = await createWatchJob({
+    type: 'time',
+    sessionId: context.sessionId,
+    resumeMessage: message,
+    description: `Scheduled wake in ${delayMinutes} minutes`,
+    target: { source: 'schedule_wake' },
+    condition: {},
+    runAt,
+  })
 
-  return `Successfully scheduled a wake event in ${delayMinutes} minutes.`
+  return JSON.stringify({
+    ok: true,
+    jobId: watch.id,
+    delayMinutes,
+    runAt,
+    message,
+  })
 }
 
 /**
@@ -39,7 +49,7 @@ async function executeScheduleWake(args: { delayMinutes: number; message: string
  */
 const SchedulePlugin: Plugin = {
   name: 'Core Scheduler',
-  description: 'Schedule wake events and reminders for agents.',
+  description: 'Schedule durable wake events and reminders for agents.',
   hooks: {
     getCapabilityDescription: () => 'I can set a conversational timer (`schedule_wake`) to remind myself to check back on something later in this chat.',
   } as PluginHooks,

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

@@ -25,14 +25,36 @@ async function executeWhoAmI(context: { sessionId?: string; agentId?: string })
   } catch (err: any) { return `Error: ${err.message}` }
 }
 
+function inferSessionsAction(
+  normalized: Record<string, unknown>,
+  context: { sessionId?: string; agentId?: string },
+): string | undefined {
+  const explicit = typeof normalized.action === 'string' ? normalized.action.trim() : ''
+  if (explicit) return explicit
+
+  const hasUpdates = !!normalized.updates && typeof normalized.updates === 'object'
+  const hasSpawnTarget = typeof normalized.agentId === 'string' || typeof normalized.agent_id === 'string'
+  const hasHistoryTarget =
+    typeof normalized.sessionId === 'string'
+    || typeof normalized.session_id === 'string'
+    || typeof normalized.limit === 'number'
+    || !!context.sessionId
+
+  if (hasUpdates) return 'update'
+  if (hasSpawnTarget) return 'spawn'
+  if (hasHistoryTarget) return 'history'
+  return 'list'
+}
+
 async function executeSessionsAction(args: any, context: { sessionId?: string; agentId?: string; cwd: string }) {
   const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
-  const action = normalized.action as string | undefined
+  const action = inferSessionsAction(normalized, context)
   const sessionId = (normalized.sessionId ?? normalized.session_id) as string | undefined
   const message = normalized.message as string | undefined
   const limit = normalized.limit as number | undefined
   const agentId = (normalized.agentId ?? normalized.agent_id) as string | undefined
   const name = normalized.name as string | undefined
+  const updates = normalized.updates as Record<string, unknown> | undefined
   try {
     const sessions = loadSessions()
     if (action === 'list') {
@@ -53,12 +75,43 @@ async function executeSessionsAction(args: any, context: { sessionId?: string; a
       sessions[id] = {
         id, name: (name || `${agent.name} Chat`).trim(), cwd: context.cwd, user: 'system',
         provider: agent.provider, model: agent.model, credentialId: agent.credentialId || null,
-        messages: [], createdAt: now, lastActiveAt: now, sessionType: 'orchestrated',
+        messages: [], createdAt: now, lastActiveAt: now, sessionType: 'human',
         agentId: agent.id, parentSessionId: context.sessionId || undefined, plugins: agent.plugins || agent.tools || [],
       }
       saveSessions(sessions)
       return JSON.stringify({ sessionId: id, name: agent.name })
     }
+    if (action === 'update') {
+      const targetId = sessionId || context.sessionId || ''
+      if (!targetId) return 'sessionId required.'
+      const target = sessions[targetId]
+      if (!target) return 'Not found.'
+      const allowedKeys = new Set([
+        'thinkingLevel',
+        'connectorThinkLevel',
+        'sessionResetMode',
+        'sessionIdleTimeoutSec',
+        'sessionMaxAgeSec',
+        'sessionDailyResetAt',
+        'sessionResetTimezone',
+        'connectorSessionScope',
+        'connectorReplyMode',
+        'connectorThreadBinding',
+        'connectorGroupPolicy',
+        'connectorIdleTimeoutSec',
+        'connectorMaxAgeSec',
+        'identityState',
+        'provider',
+        'model',
+      ])
+      const patch = updates && typeof updates === 'object' ? updates : {}
+      for (const [key, value] of Object.entries(patch)) {
+        if (!allowedKeys.has(key)) continue
+        target[key] = value
+      }
+      saveSessions(sessions)
+      return JSON.stringify({ sessionId: targetId, updated: Object.keys(patch).filter((key) => allowedKeys.has(key)) })
+    }
     return `Unknown action "${action}".`
   } catch (err: any) { return `Error: ${err.message}` }
 }
@@ -86,11 +139,12 @@ const SessionInfoPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['list', 'history', 'spawn', 'status', 'stop'] },
+          action: { type: 'string', enum: ['list', 'history', 'spawn', 'status', 'stop', 'update'] },
           sessionId: { type: 'string' },
           agentId: { type: 'string' },
           message: { type: 'string' },
-          limit: { type: 'number' }
+          limit: { type: 'number' },
+          updates: { type: 'object' },
         },
         required: ['action']
       },

package/src/lib/server/session-tools/session-tools-wiring.test.ts

@@ -24,6 +24,23 @@ describe('module exports', () => {
     const mem = await import('./memory')
     assert.equal(typeof mem.buildMemoryTools, 'function')
   })
+
+  it('primitive tool builders are exported', async () => {
+    const document = await import('./document')
+    const extract = await import('./extract')
+    const table = await import('./table')
+    const crawl = await import('./crawl')
+    const mailbox = await import('./mailbox')
+    const humanLoop = await import('./human-loop')
+    const sandbox = await import('./sandbox')
+    assert.equal(typeof document.buildDocumentTools, 'function')
+    assert.equal(typeof extract.buildExtractTools, 'function')
+    assert.equal(typeof table.buildTableTools, 'function')
+    assert.equal(typeof crawl.buildCrawlTools, 'function')
+    assert.equal(typeof mailbox.buildMailboxTools, 'function')
+    assert.equal(typeof humanLoop.buildHumanLoopTools, 'function')
+    assert.equal(typeof sandbox.buildSandboxTools, 'function')
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -57,49 +74,69 @@ describe('buildSessionTools signature', () => {
     // Verify the function has arity of at least 2
     assert.ok(buildSessionTools.length >= 2, 'buildSessionTools should accept at least 2 params')
   })
+
+  it('sandbox builder exposes only the local Deno sandbox tools', async () => {
+    const { buildSandboxTools } = await import('./sandbox')
+    const bctx: import('./context').ToolBuildContext = {
+      cwd: process.cwd(),
+      ctx: { sessionId: 'sandbox-test' },
+      hasPlugin: (name) => name === 'sandbox',
+      hasTool: (name) => name === 'sandbox',
+      cleanupFns: [],
+      commandTimeoutMs: 1_000,
+      claudeTimeoutMs: 1_000,
+      cliProcessTimeoutMs: 1_000,
+      persistDelegateResumeId: () => {},
+      readStoredDelegateResumeId: () => null,
+      resolveCurrentSession: () => null,
+      activePlugins: ['sandbox'],
+    }
+
+    const tools = buildSandboxTools(bctx).map((tool) => tool.name).sort()
+    assert.deepEqual(tools, ['sandbox_exec', 'sandbox_list_runtimes'])
+  })
 })
 
 // ---------------------------------------------------------------------------
-// 4. Memory tool schema — knowledge actions
+// 4. Memory tool schema
 //    buildMemoryTools calls getMemoryDb() eagerly so we cannot invoke it
 //    without a real SQLite DB. Instead we read the source and verify the
-//    action enum includes the knowledge actions.
+//    declared action enum matches the current JSON schema definition.
 // ---------------------------------------------------------------------------
 describe('memory tool knowledge actions (source verification)', () => {
-  it('action enum in memory.ts includes knowledge_store and knowledge_search', async () => {
+  it('action enum in memory.ts includes the declared base actions', async () => {
     const fs = await import('fs')
     const src = fs.readFileSync(
       new URL('./memory.ts', import.meta.url).pathname,
       'utf-8',
     )
 
-    // Find the z.enum([...]) for the action field
-    const enumMatch = src.match(/z\.enum\(\[([^\]]+)\]\)\.describe\([^)]*action/s)
-    assert.ok(enumMatch, 'Should find a z.enum() for the action field')
+    const enumMatch = src.match(/action:\s*\{\s*type:\s*'string',\s*enum:\s*\[([^\]]+)\]/s)
+    assert.ok(enumMatch, 'Should find the action enum in the memory tool schema')
 
     const enumBody = enumMatch![1]
-    assert.ok(enumBody.includes("'knowledge_store'"), 'action enum should include knowledge_store')
-    assert.ok(enumBody.includes("'knowledge_search'"), 'action enum should include knowledge_search')
+    const expectedActions = ['store', 'get', 'search', 'list', 'delete']
+    for (const action of expectedActions) {
+      assert.ok(
+        enumBody.includes(`'${action}'`),
+        `action enum should include '${action}'`,
+      )
+    }
   })
 
-  it('action enum includes all expected base actions', async () => {
+  it('action enum does not advertise removed knowledge actions', async () => {
     const fs = await import('fs')
     const src = fs.readFileSync(
       new URL('./memory.ts', import.meta.url).pathname,
       'utf-8',
     )
 
-    const enumMatch = src.match(/z\.enum\(\[([^\]]+)\]\)/)
+    const enumMatch = src.match(/action:\s*\{\s*type:\s*'string',\s*enum:\s*\[([^\]]+)\]/s)
     assert.ok(enumMatch)
     const enumBody = enumMatch![1]
 
-    const expectedActions = ['store', 'get', 'search', 'list', 'delete', 'link', 'unlink', 'knowledge_store', 'knowledge_search']
-    for (const action of expectedActions) {
-      assert.ok(
-        enumBody.includes(`'${action}'`),
-        `action enum should include '${action}'`,
-      )
-    }
+    assert.equal(enumBody.includes("'knowledge_store'"), false)
+    assert.equal(enumBody.includes("'knowledge_search'"), false)
   })
 })
 

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

@@ -163,8 +163,8 @@ const ShellPlugin: Plugin = {
   name: 'Core Shell',
   description: 'Execute shell commands and manage background processes.',
   hooks: {
-    getCapabilityDescription: () => 'I can run shell commands (`execute_command`) — servers, installs, scripts, git, builds, anything. I can run things in the background for long-lived processes like dev servers.',
-    getOperatingGuidance: () => ['Shell: use `execute_command` for servers, installs, scripts, git. Use `background=true` for long-lived processes.', 'Verify servers with `process_tool` status/log and liveness probes before claiming success.', 'Resolve IPs/URLs via shell — never use placeholders. Retry path errors without workdir override.'],
+    getCapabilityDescription: () => 'I can run shell commands with the unified `shell` tool. Use action `execute` for commands, and `list` / `status` / `poll` / `log` for long-lived processes.',
+    getOperatingGuidance: () => ['Shell: use `shell` with `{"action":"execute","command":"..."}` for servers, installs, scripts, and git. Use `background=true` for long-lived processes.', 'Verify servers with `shell` status/log actions and liveness probes before claiming success.', 'Resolve IPs/URLs via shell — never use placeholders. Retry path errors without workdir override.'],
   } as PluginHooks,
   tools: [
     {