@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/tool-aliases.ts

@@ -1,10 +1,10 @@
-const TOOL_ALIAS_GROUPS: string[][] = [
+const PLUGIN_ALIAS_GROUPS: string[][] = [
   ['shell', 'execute_command', 'process_tool', 'process'],
   ['files', 'read_file', 'write_file', 'list_files', 'copy_file', 'move_file', 'delete_file', 'send_file'],
   ['edit_file'],
   ['web', 'web_search', 'web_fetch'],
   ['browser', 'openclaw_browser'],
-  ['delegate', 'claude_code', 'codex_cli', 'opencode_cli', 'delegate_to_claude_code', 'delegate_to_codex_cli', 'delegate_to_opencode_cli'],
+  ['delegate', 'claude_code', 'codex_cli', 'opencode_cli', 'gemini_cli', 'delegate_to_claude_code', 'delegate_to_codex_cli', 'delegate_to_opencode_cli', 'delegate_to_gemini_cli'],
   ['manage_platform', 'manage_agents', 'manage_tasks', 'manage_schedules', 'manage_skills', 'manage_documents', 'manage_webhooks', 'manage_secrets', 'manage_sessions'],
   ['manage_connectors', 'connectors', 'connector_message_tool'],
   ['manage_chatrooms', 'chatroom'],
@@ -20,37 +20,75 @@ const TOOL_ALIAS_GROUPS: string[][] = [
   ['context_mgmt', 'context_status', 'context_summarize'],
   ['openclaw_workspace'],
   ['openclaw_nodes'],
+  ['image_gen', 'generate_image'],
+  ['email', 'send_email'],
+  ['calendar', 'calendar_events'],
+  ['replicate', 'replicate_run', 'replicate_models'],
+  ['mailbox', 'inbox'],
+  ['ask_human', 'human_loop'],
+  ['document', 'ocr_document', 'parse_document'],
+  ['extract', 'extract_structured'],
+  ['table', 'dataframe'],
+  ['crawl', 'site_crawler'],
 ]
 
-const TOOL_ALIAS_MAP = (() => {
+const PLUGIN_CANONICAL_MAP = (() => {
+  const map = new Map<string, string>()
+  for (const group of PLUGIN_ALIAS_GROUPS) {
+    const normalized = group.map((id) => id.trim().toLowerCase()).filter(Boolean)
+    const canonical = normalized[0]
+    if (!canonical) continue
+    for (const id of normalized) map.set(id, canonical)
+  }
+  return map
+})()
+
+const PLUGIN_ALIAS_MAP = (() => {
   const map = new Map<string, Set<string>>()
-  for (const group of TOOL_ALIAS_GROUPS) {
-    const normalized = group.map((tool) => tool.trim().toLowerCase()).filter(Boolean)
-    for (const tool of normalized) {
-      const current = map.get(tool) || new Set<string>()
+  for (const group of PLUGIN_ALIAS_GROUPS) {
+    const normalized = group.map((id) => id.trim().toLowerCase()).filter(Boolean)
+    for (const id of normalized) {
+      const current = map.get(id) || new Set<string>()
       for (const alias of normalized) current.add(alias)
-      map.set(tool, current)
+      map.set(id, current)
     }
   }
   return map
 })()
 
-export function normalizeToolId(value: unknown): string {
+export function normalizePluginId(value: unknown): string {
   return typeof value === 'string' ? value.trim().toLowerCase() : ''
 }
 
-export function expandToolIds(values: string[] | null | undefined): string[] {
+export function canonicalizePluginId(value: unknown): string {
+  const raw = typeof value === 'string' ? value.trim() : ''
+  const normalized = normalizePluginId(value)
+  if (!normalized) return raw
+  return PLUGIN_CANONICAL_MAP.get(normalized) || raw
+}
+
+export function getPluginAliases(value: unknown): string[] {
+  const normalized = normalizePluginId(value)
+  if (!normalized) return []
+  const aliases = PLUGIN_ALIAS_MAP.get(normalized)
+  if (!aliases) return [normalized]
+  return Array.from(aliases)
+}
+
+export function expandPluginIds(values: string[] | null | undefined): string[] {
   if (!Array.isArray(values) || values.length === 0) return []
   const expanded = new Set<string>()
   const queue: string[] = values
-    .map((tool) => normalizeToolId(tool))
+    .map((id) => typeof id === 'string' ? id.trim() : '')
     .filter(Boolean)
 
   while (queue.length > 0) {
     const next = queue.shift()!
-    if (expanded.has(next)) continue
-    expanded.add(next)
-    const aliases = TOOL_ALIAS_MAP.get(next)
+    const normalized = normalizePluginId(next)
+    const aliases = PLUGIN_ALIAS_MAP.get(normalized)
+    const key = aliases ? normalized : next
+    if (expanded.has(key)) continue
+    expanded.add(key)
     if (!aliases) continue
     for (const alias of aliases) {
       if (!expanded.has(alias)) queue.push(alias)
@@ -60,9 +98,19 @@ export function expandToolIds(values: string[] | null | undefined): string[] {
   return Array.from(expanded)
 }
 
-export function toolIdMatches(enabledTools: string[] | null | undefined, toolId: string): boolean {
-  const normalized = normalizeToolId(toolId)
-  if (!normalized) return false
-  return expandToolIds(enabledTools).includes(normalized)
+export function pluginIdMatches(enabledPlugins: string[] | null | undefined, pluginId: string): boolean {
+  const raw = typeof pluginId === 'string' ? pluginId.trim() : ''
+  const normalized = normalizePluginId(pluginId)
+  if (!normalized && !raw) return false
+  const expanded = expandPluginIds(enabledPlugins)
+  return expanded.includes(raw) || expanded.includes(normalized) || expanded.includes(canonicalizePluginId(pluginId))
 }
 
+/** @deprecated Use normalizePluginId */
+export const normalizeToolId = normalizePluginId
+/** @deprecated Use canonicalizePluginId */
+export const canonicalizeToolId = canonicalizePluginId
+/** @deprecated Use expandPluginIds */
+export const expandToolIds = expandPluginIds
+/** @deprecated Use pluginIdMatches */
+export const toolIdMatches = pluginIdMatches

package/src/lib/server/tool-capability-policy.test.ts

@@ -7,15 +7,15 @@ import {
 
 test('capability policy permissive mode allows non-blocked tools', () => {
   const decision = resolveSessionToolPolicy(['shell', 'web_search'], { capabilityPolicyMode: 'permissive' })
-  assert.deepEqual(decision.enabledTools, ['shell', 'web_search'])
-  assert.equal(decision.blockedTools.length, 0)
+  assert.deepEqual(decision.enabledPlugins, ['shell', 'web_search'])
+  assert.equal(decision.blockedPlugins.length, 0)
 })
 
 test('capability policy balanced mode blocks destructive delete_file', () => {
   const decision = resolveSessionToolPolicy(['files', 'delete_file'], { capabilityPolicyMode: 'balanced' })
-  assert.deepEqual(decision.enabledTools, ['files'])
-  assert.equal(decision.blockedTools.length, 1)
-  assert.equal(decision.blockedTools[0].tool, 'delete_file')
+  assert.deepEqual(decision.enabledPlugins, ['files'])
+  assert.equal(decision.blockedPlugins.length, 1)
+  assert.equal(decision.blockedPlugins[0].tool, 'delete_file')
 })
 
 test('capability policy strict mode blocks execution/platform families', () => {
@@ -23,9 +23,9 @@ test('capability policy strict mode blocks execution/platform families', () => {
     ['shell', 'manage_tasks', 'web_search', 'memory'],
     { capabilityPolicyMode: 'strict' },
   )
-  assert.deepEqual(decision.enabledTools, ['web_search', 'memory'])
-  assert.equal(decision.blockedTools.some((entry) => entry.tool === 'shell'), true)
-  assert.equal(decision.blockedTools.some((entry) => entry.tool === 'manage_tasks'), true)
+  assert.deepEqual(decision.enabledPlugins, ['web_search', 'memory'])
+  assert.equal(decision.blockedPlugins.some((entry) => entry.tool === 'shell'), true)
+  assert.equal(decision.blockedPlugins.some((entry) => entry.tool === 'manage_tasks'), true)
 })
 
 test('capability policy respects explicit allow overrides', () => {
@@ -36,7 +36,7 @@ test('capability policy respects explicit allow overrides', () => {
       capabilityAllowedTools: ['shell'],
     },
   )
-  assert.deepEqual(decision.enabledTools, ['shell', 'web_search'])
+  assert.deepEqual(decision.enabledPlugins, ['shell', 'web_search'])
 })
 
 test('concrete tool checks inherit blocked family rules', () => {

package/src/lib/server/tool-capability-policy.ts

@@ -8,13 +8,16 @@ export interface CapabilityPolicyBlock {
   source: 'safety' | 'policy'
 }
 
-export interface SessionToolPolicyDecision {
+export interface PluginPolicyDecision {
   mode: CapabilityPolicyMode
-  requestedTools: string[]
-  enabledTools: string[]
-  blockedTools: CapabilityPolicyBlock[]
+  requestedPlugins: string[]
+  enabledPlugins: string[]
+  blockedPlugins: CapabilityPolicyBlock[]
 }
 
+/** @deprecated Use PluginPolicyDecision */
+export type SessionToolPolicyDecision = PluginPolicyDecision
+
 type CapabilityCategory =
   | 'filesystem'
   | 'execution'
@@ -47,10 +50,11 @@ const TOOL_DESCRIPTORS: Record<string, ToolDescriptor> = {
   web_search: { categories: ['network'], concreteTools: ['web_search'] },
   web_fetch: { categories: ['network'], concreteTools: ['web_fetch'] },
   browser: { categories: ['browser', 'network'], concreteTools: ['browser', 'openclaw_browser'] },
-  delegate: { categories: ['delegation', 'execution'], concreteTools: ['delegate', 'delegate_to_claude_code', 'delegate_to_codex_cli', 'delegate_to_opencode_cli'] },
+  delegate: { categories: ['delegation', 'execution'], concreteTools: ['delegate', 'delegate_to_claude_code', 'delegate_to_codex_cli', 'delegate_to_opencode_cli', 'delegate_to_gemini_cli'] },
   claude_code: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_claude_code'] },
   codex_cli: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_codex_cli'] },
   opencode_cli: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_opencode_cli'] },
+  gemini_cli: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_gemini_cli'] },
   memory: { categories: ['memory'], concreteTools: ['memory', 'memory_tool', 'context_status', 'context_summarize'] },
   sandbox: { categories: ['execution', 'filesystem'], concreteTools: ['sandbox', 'sandbox_exec', 'sandbox_list_runtimes', 'openclaw_sandbox'] },
   git: { categories: ['execution', 'filesystem'], concreteTools: ['git'] },
@@ -78,6 +82,12 @@ const TOOL_DESCRIPTORS: Record<string, ToolDescriptor> = {
   context_mgmt: { categories: ['memory'], concreteTools: ['context_mgmt', 'context_status', 'context_summarize'] },
   plugin_creator: { categories: ['filesystem', 'execution'], concreteTools: ['plugin_creator', 'plugin_creator_tool'] },
   sample_ui: { categories: ['platform'], concreteTools: ['sample_ui', 'show_plugin_card'] },
+  mailbox: { categories: ['network', 'platform', 'outbound'], concreteTools: ['mailbox', 'inbox'] },
+  ask_human: { categories: ['platform'], concreteTools: ['ask_human', 'human_loop'] },
+  document: { categories: ['filesystem', 'platform'], concreteTools: ['document', 'ocr_document', 'parse_document'] },
+  extract: { categories: ['filesystem', 'network'], concreteTools: ['extract', 'extract_structured'] },
+  table: { categories: ['filesystem'], concreteTools: ['table', 'dataframe'] },
+  crawl: { categories: ['network'], concreteTools: ['crawl', 'site_crawler'] },
 }
 
 const CONCRETE_TOOL_TO_SESSION_TOOL = new Map<string, string>()
@@ -144,6 +154,7 @@ function safetyMatchesTool(safetyBlocked: Set<string>, toolName: string, descrip
   if (toolName === 'claude_code' && safetyBlocked.has('delegate_to_claude_code')) return true
   if (toolName === 'codex_cli' && safetyBlocked.has('delegate_to_codex_cli')) return true
   if (toolName === 'opencode_cli' && safetyBlocked.has('delegate_to_opencode_cli')) return true
+  if (toolName === 'gemini_cli' && safetyBlocked.has('delegate_to_gemini_cli')) return true
   return false
 }
 
@@ -196,51 +207,51 @@ export function resolveSessionToolPolicy(
     blockedCategories,
   } = parsePolicyConfig(normalizedSettings)
 
-  const requestedTools = Array.isArray(sessionTools)
-    ? Array.from(new Set(sessionTools.map((tool) => normalizeName(tool)).filter(Boolean)))
+  const requestedPlugins = Array.isArray(sessionTools)
+    ? Array.from(new Set(sessionTools.map((id) => normalizeName(id)).filter(Boolean)))
     : []
 
-  const enabledTools: string[] = []
-  const blockedTools: CapabilityPolicyBlock[] = []
+  const enabledPlugins: string[] = []
+  const blockedPlugins: CapabilityPolicyBlock[] = []
 
-  for (const toolName of requestedTools) {
-    const descriptor = TOOL_DESCRIPTORS[toolName]
+  for (const pluginName of requestedPlugins) {
+    const descriptor = TOOL_DESCRIPTORS[pluginName]
 
-    if (safetyMatchesTool(safetyBlocked, toolName, descriptor)) {
-      blockedTools.push({ tool: toolName, reason: 'blocked by safety policy', source: 'safety' })
+    if (safetyMatchesTool(safetyBlocked, pluginName, descriptor)) {
+      blockedPlugins.push({ tool: pluginName, reason: 'blocked by safety policy', source: 'safety' })
       continue
     }
 
-    if (policyAllowedNames.has(toolName)) {
-      enabledTools.push(toolName)
+    if (policyAllowedNames.has(pluginName)) {
+      enabledPlugins.push(pluginName)
       continue
     }
 
-    if (policyMatchesTool(policyBlockedNames, toolName, descriptor)) {
-      blockedTools.push({ tool: toolName, reason: 'blocked by explicit policy rule', source: 'policy' })
+    if (policyMatchesTool(policyBlockedNames, pluginName, descriptor)) {
+      blockedPlugins.push({ tool: pluginName, reason: 'blocked by explicit policy rule', source: 'policy' })
       continue
     }
 
     const categoryReason = categoryBlockReason(blockedCategories, descriptor)
     if (categoryReason) {
-      blockedTools.push({ tool: toolName, reason: categoryReason, source: 'policy' })
+      blockedPlugins.push({ tool: pluginName, reason: categoryReason, source: 'policy' })
       continue
     }
 
-    const modeReason = modeBlocksTool(mode, toolName, descriptor)
+    const modeReason = modeBlocksTool(mode, pluginName, descriptor)
     if (modeReason) {
-      blockedTools.push({ tool: toolName, reason: modeReason, source: 'policy' })
+      blockedPlugins.push({ tool: pluginName, reason: modeReason, source: 'policy' })
       continue
     }
 
-    enabledTools.push(toolName)
+    enabledPlugins.push(pluginName)
   }
 
   return {
     mode,
-    requestedTools,
-    enabledTools,
-    blockedTools,
+    requestedPlugins,
+    enabledPlugins,
+    blockedPlugins,
   }
 }
 
@@ -270,11 +281,11 @@ export function resolveConcreteToolPolicyBlock(
   }
 
   if (mappedTool) {
-    const blockedRoot = decision.blockedTools.find((entry) => entry.tool === mappedTool)
+    const blockedRoot = decision.blockedPlugins.find((entry) => entry.tool === mappedTool)
     if (blockedRoot) return blockedRoot.reason
 
-    const enabledRoot = decision.enabledTools.includes(mappedTool)
-    if (!enabledRoot) return `tool family "${mappedTool}" is not enabled for this session`
+    const enabledRoot = decision.enabledPlugins.includes(mappedTool)
+    if (!enabledRoot) return `plugin family "${mappedTool}" is not enabled for this chat`
   }
 
   return null

package/src/lib/server/tool-retry.ts

@@ -6,6 +6,7 @@ export interface RetryOptions {
   maxAttempts?: number
   backoffMs?: number
   retryable?: RegExp[]
+  onRetry?: (attempt: number, lastResult: string) => Promise<void> | void
 }
 
 const DEFAULT_RETRYABLE: RegExp[] = [
@@ -49,6 +50,7 @@ export async function withRetry<TArgs>(
 
     // Only retry if the result looks like a retryable error
     if (attempt < maxAttempts && isRetryableError(lastResult, retryable)) {
+      await opts?.onRetry?.(attempt, lastResult)
       const delay = backoffMs * Math.pow(2, attempt - 1)
       console.warn(
         `[tool-retry] Attempt ${attempt}/${maxAttempts} matched retryable pattern, retrying in ${delay}ms`,

package/src/lib/server/watch-jobs.test.ts

@@ -0,0 +1,173 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let watchJobs: typeof import('./watch-jobs')
+let storage: typeof import('./storage')
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-watch-jobs-'))
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  watchJobs = await import('./watch-jobs')
+  storage = await import('./storage')
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('watch-jobs', () => {
+  it('validates required targets for durable watches', async () => {
+    await assert.rejects(
+      watchJobs.createWatchJob({
+        type: 'http',
+        resumeMessage: 'resume',
+        target: {},
+        condition: {},
+      }),
+      /url target/,
+    )
+
+    await assert.rejects(
+      watchJobs.createWatchJob({
+        type: 'time',
+        resumeMessage: 'resume',
+        target: { source: 'test' },
+        condition: {},
+      }),
+      /runAt or delayMinutes/,
+    )
+  })
+
+  it('triggers time and task watches durably', async () => {
+    const tasks = storage.loadTasks()
+    tasks.task_done = {
+      id: 'task_done',
+      title: 'done',
+      status: 'completed',
+      result: 'ok',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    }
+    storage.saveTasks(tasks)
+
+    const timeJob = await watchJobs.createWatchJob({
+      type: 'time',
+      resumeMessage: 'wake up',
+      target: { source: 'schedule_wake' },
+      condition: {},
+      runAt: Date.now() - 1000,
+    })
+    const taskJob = await watchJobs.createWatchJob({
+      type: 'task',
+      resumeMessage: 'task finished',
+      target: { taskId: 'task_done' },
+      condition: { statusIn: ['completed'] },
+    })
+
+    const outcome = await watchJobs.processDueWatchJobs(Date.now())
+
+    assert.equal(outcome.triggered >= 2, true)
+    assert.equal(watchJobs.getWatchJob(timeJob.id)?.status, 'triggered')
+    assert.equal(watchJobs.getWatchJob(taskJob.id)?.status, 'triggered')
+    assert.equal(watchJobs.getWatchJob(taskJob.id)?.result?.status, 'completed')
+  })
+
+  it('captures file changes and webhook triggers', async () => {
+    const watchedFile = path.join(tempDir, 'watch.txt')
+    fs.writeFileSync(watchedFile, 'alpha')
+
+    const fileJob = await watchJobs.createWatchJob({
+      type: 'file',
+      resumeMessage: 'file changed',
+      target: { path: watchedFile },
+      condition: { changed: true },
+    })
+    const webhookJob = await watchJobs.createWatchJob({
+      type: 'webhook',
+      resumeMessage: 'webhook arrived',
+      target: { webhookId: 'wh_1' },
+      condition: { event: 'build.finished' },
+    })
+
+    fs.writeFileSync(watchedFile, 'beta')
+    await watchJobs.processDueWatchJobs(Date.now())
+    const webhookMatches = watchJobs.triggerWebhookWatchJobs({
+      webhookId: 'wh_1',
+      event: 'build.finished',
+      payloadPreview: '{"ok":true}',
+    })
+
+    assert.equal(watchJobs.getWatchJob(fileJob.id)?.status, 'triggered')
+    assert.match(String(watchJobs.getWatchJob(fileJob.id)?.result?.preview || ''), /beta/)
+    assert.equal(webhookMatches.length, 1)
+    assert.equal(watchJobs.getWatchJob(webhookJob.id)?.status, 'triggered')
+  })
+
+  it('wakes mailbox and approval watches from event triggers', async () => {
+    storage.upsertApproval('approval_1', {
+      id: 'approval_1',
+      category: 'human_loop',
+      title: 'Need approval',
+      description: 'Approve the action',
+      data: {},
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      status: 'pending',
+    })
+
+    const mailboxJob = await watchJobs.createWatchJob({
+      type: 'mailbox',
+      resumeMessage: 'human replied',
+      target: { sessionId: 'session_1' },
+      condition: { type: 'human_reply', correlationId: 'corr_1' },
+    })
+    const approvalJob = await watchJobs.createWatchJob({
+      type: 'approval',
+      resumeMessage: 'approval updated',
+      target: { approvalId: 'approval_1' },
+      condition: { statusIn: ['approved'] },
+    })
+
+    const mailboxMatches = watchJobs.triggerMailboxWatchJobs({
+      sessionId: 'session_1',
+      envelope: {
+        id: 'env_1',
+        type: 'human_reply',
+        payload: 'approved',
+        toSessionId: 'session_1',
+        correlationId: 'corr_1',
+        status: 'new',
+        createdAt: Date.now(),
+      },
+    })
+    const approvalMatches = watchJobs.triggerApprovalWatchJobs({
+      approvalId: 'approval_1',
+      status: 'approved',
+    })
+
+    assert.equal(mailboxMatches.length, 1)
+    assert.equal(approvalMatches.length, 1)
+    assert.equal(watchJobs.getWatchJob(mailboxJob.id)?.status, 'triggered')
+    assert.equal(watchJobs.getWatchJob(approvalJob.id)?.status, 'triggered')
+    assert.equal(watchJobs.getWatchJob(mailboxJob.id)?.result?.correlationId, 'corr_1')
+    assert.equal(watchJobs.getWatchJob(approvalJob.id)?.result?.status, 'approved')
+  })
+})