@swarmclawai/swarmclaw 0.6.7 → 0.7.0

package/src/lib/server/session-tools/openclaw-nodes.ts

@@ -1,112 +1,95 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import type { ToolBuildContext } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
-export function buildOpenClawNodeTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('openclaw_nodes')) return []
+/**
+ * Core OpenClaw Nodes Execution Logic
+ */
+async function executeNodesAction(args: any) {
+  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
+  const action = normalized.action as string | undefined
+  const nodeId = (normalized.nodeId ?? normalized.node_id) as string | undefined
+  const message = normalized.message as string | undefined
+  const params = normalized.params as Record<string, unknown> | undefined
+  try {
+    const { listRunningConnectors, getRunningInstance } = await import('../connectors/manager')
+    const openclawConnectors = listRunningConnectors('openclaw')
+    if (!openclawConnectors.length) {
+      return JSON.stringify({
+        status: 'not_connected',
+        message: 'No running OpenClaw connector found.',
+        hint: 'Start an OpenClaw connector in the Connectors panel, then retry.',
+      })
+    }
+    const inst = getRunningInstance(openclawConnectors[0].id)
+    if (!inst) {
+      return JSON.stringify({
+        status: 'not_connected',
+        message: 'OpenClaw connector instance not accessible.',
+        connectorId: openclawConnectors[0].id,
+      })
+    }
 
-  const tools: StructuredToolInterface[] = []
+    if (action === 'list') {
+      return JSON.stringify({ status: 'nodes.list not supported on gateway yet', connectorId: openclawConnectors[0].id })
+    }
+    if (action === 'notify') {
+      return JSON.stringify({ status: 'nodes.notify not supported on gateway yet', nodeId, message })
+    }
+    if (action === 'invoke') {
+      return JSON.stringify({ status: 'nodes.invoke not supported on gateway yet', nodeId, invokeAction: params?.action })
+    }
 
-  tools.push(
-    tool(
-      async () => {
-        try {
-          const { listRunningConnectors } = await import('../connectors/manager')
-          const openclawConnectors = listRunningConnectors('openclaw')
-          if (!openclawConnectors.length) {
-            return JSON.stringify({ error: 'No running OpenClaw connector found.' })
-          }
-          const { getRunningInstance } = await import('../connectors/manager')
-          const inst = getRunningInstance(openclawConnectors[0].id)
-          if (!inst) return JSON.stringify({ error: 'OpenClaw connector instance not accessible.' })
+    return JSON.stringify({ status: 'error', error: `Unknown nodes action "${action}".` })
+  } catch (err: any) {
+    return JSON.stringify({ error: err.message })
+  }
+}
 
-          // Proxy through RPC — use sendMessage as a workaround to invoke RPC
-          // We need direct RPC access, so check if the instance exposes it
-          // For now, return a helpful message about the integration
-          return JSON.stringify({
-            status: 'openclaw_nodes_list requires nodes.list RPC support on the gateway',
-            connectorId: openclawConnectors[0].id,
-            note: 'This feature requires the OpenClaw gateway to support nodes.* RPCs.',
-          })
-        } catch (err: unknown) {
-          return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-        }
+/**
+ * Register as a Built-in Plugin
+ */
+const NodesPlugin: Plugin = {
+  name: 'OpenClaw Nodes',
+  description: 'Integrate with mobile apps and IoT devices via the OpenClaw gateway.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'openclaw_nodes',
+      description: 'Interact with connected OpenClaw nodes/devices.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['list', 'notify', 'invoke'] },
+          nodeId: { type: 'string' },
+          message: { type: 'string' },
+          params: { type: 'object' }
+        },
+        required: ['action']
       },
-      {
-        name: 'openclaw_nodes_list',
-        description: 'List connected nodes/IoT devices through the OpenClaw gateway. Requires a running OpenClaw connector with nodes.* RPC support.',
-        schema: z.object({}),
-      },
-    ),
-  )
-
-  tools.push(
-    tool(
-      async ({ nodeId, action, params }) => {
-        try {
-          const { listRunningConnectors, getRunningInstance } = await import('../connectors/manager')
-          const openclawConnectors = listRunningConnectors('openclaw')
-          if (!openclawConnectors.length) {
-            return JSON.stringify({ error: 'No running OpenClaw connector found.' })
-          }
-          const inst = getRunningInstance(openclawConnectors[0].id)
-          if (!inst) return JSON.stringify({ error: 'OpenClaw connector instance not accessible.' })
+      execute: async (args) => executeNodesAction(args)
+    }
+  ]
+}
 
-          return JSON.stringify({
-            status: 'openclaw_node_invoke requires nodes.invoke RPC support on the gateway',
-            nodeId,
-            action,
-            params: params || null,
-            connectorId: openclawConnectors[0].id,
-          })
-        } catch (err: unknown) {
-          return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-        }
-      },
-      {
-        name: 'openclaw_node_invoke',
-        description: 'Invoke an action on a connected node/IoT device through the OpenClaw gateway.',
-        schema: z.object({
-          nodeId: z.string().describe('Target node ID'),
-          action: z.string().describe('Action to invoke on the node'),
-          params: z.record(z.string(), z.unknown()).optional().describe('Optional parameters for the action'),
-        }),
-      },
-    ),
-  )
+getPluginManager().registerBuiltin('openclaw_nodes', NodesPlugin)
 
-  tools.push(
+/**
+ * Legacy Bridge
+ */
+export function buildOpenClawNodeTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('openclaw_nodes')) return []
+  return [
     tool(
-      async ({ nodeId, message }) => {
-        try {
-          const { listRunningConnectors, getRunningInstance } = await import('../connectors/manager')
-          const openclawConnectors = listRunningConnectors('openclaw')
-          if (!openclawConnectors.length) {
-            return JSON.stringify({ error: 'No running OpenClaw connector found.' })
-          }
-          const inst = getRunningInstance(openclawConnectors[0].id)
-          if (!inst) return JSON.stringify({ error: 'OpenClaw connector instance not accessible.' })
-
-          return JSON.stringify({
-            status: 'openclaw_node_notify requires nodes.notify RPC support on the gateway',
-            nodeId,
-            message,
-            connectorId: openclawConnectors[0].id,
-          })
-        } catch (err: unknown) {
-          return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-        }
-      },
+      async (args) => executeNodesAction(args),
       {
-        name: 'openclaw_node_notify',
-        description: 'Send a notification to a connected node/IoT device through the OpenClaw gateway.',
-        schema: z.object({
-          nodeId: z.string().describe('Target node ID'),
-          message: z.string().describe('Notification message'),
-        }),
-      },
-    ),
-  )
-
-  return tools
+        name: 'openclaw_nodes',
+        description: NodesPlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
+    )
+  ]
 }

package/src/lib/server/session-tools/openclaw-workspace.ts

@@ -6,7 +6,10 @@ import * as path from 'path'
 import * as os from 'os'
 import { loadSettings } from '../storage'
 import type { ToolBuildContext } from './context'
-import { MAX_OUTPUT } from './context'
+import { MAX_OUTPUT, truncate } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
 const execFileAsync = promisify(execFile)
 
@@ -28,105 +31,112 @@ async function gitInWorkspace(args: string[], timeoutMs = 15_000): Promise<{ std
   })
 }
 
-export function buildOpenClawWorkspaceTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('openclaw_workspace')) return []
+/**
+ * Core OpenClaw Workspace Execution Logic
+ */
+async function executeWorkspaceAction(args: any) {
+  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
+  const message = normalized.message as string | undefined
+  const commitHash = normalized.commitHash as string | undefined
+  const limit = normalized.limit as number | undefined
+  const action = typeof normalized.action === 'string' && normalized.action.trim() ? normalized.action.trim() : 'history'
+  try {
+    const workspace = resolveWorkspacePath()
+    const inGitRepo = async (): Promise<boolean> => {
+      try {
+        await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: workspace, timeout: 5000 })
+        return true
+      } catch {
+        return false
+      }
+    }
 
-  return [
-    tool(
-      async ({ message }) => {
-        try {
-          const workspace = resolveWorkspacePath()
-          // Verify it's a git repo
-          await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], {
-            cwd: workspace,
-            timeout: 5000,
-          })
+    if (action === 'backup') {
+      if (!(await inGitRepo())) {
+        return JSON.stringify({ ok: false, error: `Workspace is not a git repo: ${workspace}` })
+      }
+      const label = message || new Date().toISOString().replace(/[:.]/g, '-')
+      await gitInWorkspace(['add', '-A'])
+      const status = await gitInWorkspace(['status', '--porcelain'])
+      if (!status.stdout.trim()) return JSON.stringify({ ok: true, message: 'Clean.' })
+      await gitInWorkspace(['commit', '-m', `backup: ${label}`])
+      const { stdout } = await gitInWorkspace(['rev-parse', 'HEAD'])
+      return JSON.stringify({ ok: true, commitHash: stdout.trim() })
+    }
 
-          const label = message || new Date().toISOString().replace(/[:.]/g, '-')
-          await gitInWorkspace(['add', '-A'])
+    if (action === 'rollback') {
+      if (!(await inGitRepo())) {
+        return JSON.stringify({ ok: false, error: `Workspace is not a git repo: ${workspace}` })
+      }
+      let target = commitHash
+      if (!target) {
+        const { stdout } = await gitInWorkspace(['log', '--oneline', '--format=%H %s', '-50'])
+        const lines = stdout.trim().split('\n').filter(Boolean)
+        const stable = lines.find(l => !/^(rollback|daily|auto|backup:)/i.test(l.substring(41)))
+        if (!stable) return JSON.stringify({ ok: false, error: 'No stable commit.' })
+        target = stable.substring(0, 40)
+      }
+      await gitInWorkspace(['reset', '--hard', target])
+      return JSON.stringify({ ok: true, rolledBackTo: target })
+    }
 
-          // Check if there's anything to commit
-          const status = await gitInWorkspace(['status', '--porcelain'])
-          if (!status.stdout.trim()) {
-            return JSON.stringify({ ok: true, commitHash: null, message: 'Nothing to commit — workspace is clean.' })
-          }
+    if (action === 'history') {
+      if (!(await inGitRepo())) {
+        return JSON.stringify({ ok: false, error: `Workspace is not a git repo: ${workspace}` })
+      }
+      const count = Math.max(1, Math.min(limit ?? 20, 100))
+      const { stdout } = await gitInWorkspace(['log', '--oneline', `--format=%H %s`, `-${count}`])
+      const commits = stdout.trim().split('\n').filter(Boolean).map(l => ({ hash: l.substring(0, 40), message: l.substring(41) }))
+      return JSON.stringify({ commits })
+    }
 
-          await gitInWorkspace(['commit', '-m', `backup: ${label}`])
-          const { stdout } = await gitInWorkspace(['rev-parse', 'HEAD'])
-          return JSON.stringify({ ok: true, commitHash: stdout.trim() })
-        } catch (err: unknown) {
-          const execErr = err as { stderr?: string; message?: string }
-          return JSON.stringify({ ok: false, error: execErr.stderr || execErr.message || String(err) })
-        }
-      },
-      {
-        name: 'openclaw_workspace_backup',
-        description: 'Create a git backup of the OpenClaw workspace. Stages all changes and commits.',
-        schema: z.object({
-          message: z.string().optional().describe('Optional backup message (defaults to timestamp)'),
-        }),
-      },
-    ),
-    tool(
-      async ({ commitHash }) => {
-        try {
-          if (!commitHash) {
-            // Find first stable commit (skip auto-generated ones)
-            const { stdout } = await gitInWorkspace(['log', '--oneline', '--format=%H %s', '-50'])
-            const lines = stdout.trim().split('\n').filter(Boolean)
-            const autoPattern = /^(rollback|daily-backup|auto-backup|guardian-auto|backup:)/i
-            const stable = lines.find((line) => {
-              const msg = line.substring(41) // after hash + space
-              return !autoPattern.test(msg)
-            })
-            if (!stable) {
-              return JSON.stringify({ ok: false, error: 'No stable commit found to roll back to.' })
-            }
-            commitHash = stable.substring(0, 40)
-          }
+    return `Unknown action "${action}".`
+  } catch (err: any) {
+    return JSON.stringify({ ok: false, error: err.stderr || err.message })
+  }
+}
 
-          const { stdout: prevHead } = await gitInWorkspace(['rev-parse', 'HEAD'])
-          await gitInWorkspace(['reset', '--hard', commitHash])
-          return JSON.stringify({ ok: true, rolledBackTo: commitHash, previousHead: prevHead.trim() })
-        } catch (err: unknown) {
-          const execErr = err as { stderr?: string; message?: string }
-          return JSON.stringify({ ok: false, error: execErr.stderr || execErr.message || String(err) })
-        }
+/**
+ * Register as a Built-in Plugin
+ */
+const WorkspacePlugin: Plugin = {
+  name: 'OpenClaw Workspace',
+  description: 'Manage OpenClaw workspace versioning: backup, rollback, and history.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'openclaw_workspace',
+      description: 'Versioning tools for the OpenClaw workspace.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['backup', 'rollback', 'history'] },
+          message: { type: 'string' },
+          commitHash: { type: 'string' },
+          limit: { type: 'number' }
+        },
+        required: ['action']
       },
-      {
-        name: 'openclaw_workspace_rollback',
-        description: 'Roll back the OpenClaw workspace to a specific commit, or automatically find the last stable (non-auto-generated) commit.',
-        schema: z.object({
-          commitHash: z.string().optional().describe('Target commit hash (if omitted, uses the last stable commit)'),
-        }),
-      },
-    ),
+      execute: async (args) => executeWorkspaceAction(args)
+    }
+  ]
+}
+
+getPluginManager().registerBuiltin('openclaw_workspace', WorkspacePlugin)
+
+/**
+ * Legacy Bridge
+ */
+export function buildOpenClawWorkspaceTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('openclaw_workspace')) return []
+  return [
     tool(
-      async ({ limit }) => {
-        try {
-          const count = Math.max(1, Math.min(limit ?? 20, 100))
-          const { stdout } = await gitInWorkspace(['log', '--oneline', `--format=%H %s`, `-${count}`])
-          const commits = stdout
-            .trim()
-            .split('\n')
-            .filter(Boolean)
-            .map((line) => ({
-              hash: line.substring(0, 40),
-              message: line.substring(41),
-            }))
-          return JSON.stringify({ commits })
-        } catch (err: unknown) {
-          const execErr = err as { stderr?: string; message?: string }
-          return JSON.stringify({ ok: false, error: execErr.stderr || execErr.message || String(err) })
-        }
-      },
+      async (args) => executeWorkspaceAction(args),
       {
-        name: 'openclaw_workspace_history',
-        description: 'List recent git commits in the OpenClaw workspace.',
-        schema: z.object({
-          limit: z.number().optional().describe('Number of commits to return (default 20, max 100)'),
-        }),
-      },
-    ),
+        name: 'openclaw_workspace',
+        description: WorkspacePlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
+    )
   ]
 }

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

@@ -0,0 +1,86 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { buildCrudTools } from './crud'
+import type { ToolBuildContext } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+
+/**
+ * Unified Platform Execution Logic
+ */
+async function executePlatformAction(args: any, bctx: any) {
+  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
+  const { resource, action, id, data, ...rest } = normalized
+  
+  // We reuse the existing CRUD tool logic but expose it via a single tool
+  const crudTools = buildCrudTools({
+    ...bctx,
+    hasTool: (id: string) => [
+      'manage_agents',
+      'manage_tasks',
+      'manage_schedules',
+      'manage_skills',
+      'manage_documents',
+      'manage_secrets',
+      'manage_connectors',
+      'manage_sessions'
+    ].includes(id)
+  })
+
+  const targetToolName = `manage_${resource}`
+  const targetTool = crudTools.find(t => t.name === targetToolName)
+  
+  if (!targetTool) {
+    return `Error: Unknown resource type "${resource}". Valid resources: agents, tasks, schedules, skills, documents, secrets, connectors, sessions.`
+  }
+
+  // Forward to the specific CRUD tool implementation
+  return targetTool.invoke({ action, id, data, ...rest })
+}
+
+/**
+ * Register as a Built-in Plugin
+ */
+const PlatformPlugin: Plugin = {
+  name: 'Core Platform',
+  description: 'Unified management of agents, tasks, schedules, skills, documents, and secrets.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'manage_platform',
+      description: 'Unified tool for managing all SwarmClaw resources.',
+      parameters: {
+        type: 'object',
+        properties: {
+          resource: { type: 'string', enum: ['agents', 'tasks', 'schedules', 'skills', 'documents', 'secrets', 'connectors', 'sessions'] },
+          action: { type: 'string', enum: ['list', 'get', 'create', 'update', 'delete'] },
+          id: { type: 'string' },
+          data: { type: 'string' }
+        },
+        required: ['resource', 'action']
+      },
+      execute: async (args, context) => executePlatformAction(args, { ...context.session, ctx: context.session })
+    }
+  ]
+}
+
+getPluginManager().registerBuiltin('manage_platform', PlatformPlugin)
+
+/**
+ * Legacy Bridge
+ */
+export function buildPlatformTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('manage_platform')) return []
+
+  return [
+    tool(
+      async (args) => executePlatformAction(args, bctx),
+      {
+        name: 'manage_platform',
+        description: PlatformPlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
+    )
+  ]
+}