@swarmclawai/swarmclaw 0.7.2 → 0.7.3

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

@@ -0,0 +1,142 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { normalizePlatformActionArgs } from './platform'
+
+describe('normalizePlatformActionArgs', () => {
+  it('packs top-level create fields into data', () => {
+    const out = normalizePlatformActionArgs({
+      resource: 'tasks',
+      action: 'create',
+      title: 'Write docs',
+      agentId: 'default',
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Write docs',
+      agentId: 'default',
+    })
+  })
+
+  it('merges object data with top-level overrides', () => {
+    const out = normalizePlatformActionArgs({
+      resource: 'tasks',
+      action: 'create',
+      data: { title: 'Old title', agentId: 'coder' },
+      title: 'New title',
+    })
+
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'New title',
+      agentId: 'coder',
+    })
+  })
+
+  it('normalizes legacy resources envelope with parameters payload', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        resources: [
+          {
+            resource: 'tasks',
+            action: 'create',
+            parameters: {
+              title: 'Legacy task',
+              assigned_agent: 'default',
+            },
+          },
+        ],
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Legacy task',
+      assigned_agent: 'default',
+    })
+  })
+
+  it('normalizes singular resource names and resource payload objects', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        resource: 'task',
+        action: 'create',
+        task: {
+          title: 'Legacy singular task',
+          assigned_to: 'default',
+        },
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Legacy singular task',
+      assigned_to: 'default',
+    })
+  })
+
+  it('normalizes legacy backlog task resource names to tasks', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        resource: 'backlog_task',
+        action: 'create',
+        backlog_task: {
+          title: 'Legacy backlog task',
+          description: 'Keep the intended task payload',
+        },
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Legacy backlog task',
+      description: 'Keep the intended task payload',
+    })
+  })
+
+  it('normalizes resources entries that use type instead of resource', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        action: 'create',
+        resources: [
+          {
+            type: 'task',
+            parameters: {
+              title: 'Typed task resource',
+              description: 'Created through a typed resources envelope',
+            },
+          },
+        ],
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Typed task resource',
+      description: 'Created through a typed resources envelope',
+    })
+  })
+
+  it('infers schedules resource from create_schedule style actions', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        action: 'create_schedule',
+        data: {
+          name: 'Surgery check-in',
+          scheduleType: 'once',
+        },
+      }),
+    })
+
+    assert.equal(out.resource, 'schedules')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      name: 'Surgery check-in',
+      scheduleType: 'once',
+    })
+  })
+})

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

@@ -6,12 +6,150 @@ import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 
+function parsePlatformData(value: unknown): Record<string, unknown> | null {
+  if (!value) return null
+  if (typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>
+  }
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  if (!trimmed) return null
+  try {
+    const parsed = JSON.parse(trimmed)
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>
+    }
+  } catch {
+    // Preserve non-JSON data strings as-is in the caller.
+  }
+  return null
+}
+
+function firstPlatformResource(value: unknown): Record<string, unknown> | null {
+  if (!Array.isArray(value)) return null
+  const first = value.find((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+  return first && typeof first === 'object' && !Array.isArray(first)
+    ? first as Record<string, unknown>
+    : null
+}
+
+function normalizePlatformResourceName(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const normalized = value.trim().toLowerCase()
+  if (!normalized) return undefined
+  const singularMap: Record<string, string> = {
+    agent: 'agents',
+    task: 'tasks',
+    backlog_task: 'tasks',
+    'backlog-task': 'tasks',
+    backlogtask: 'tasks',
+    task_backlog: 'tasks',
+    'task-backlog': 'tasks',
+    work_item: 'tasks',
+    'work-item': 'tasks',
+    schedule: 'schedules',
+    skill: 'skills',
+    document: 'documents',
+    secret: 'secrets',
+    connector: 'connectors',
+    session: 'sessions',
+  }
+  return singularMap[normalized] || normalized
+}
+
+function inferPlatformResourceFromAction(value: unknown): { resource?: string; action?: string } {
+  if (typeof value !== 'string') return {}
+  const normalized = value.trim().toLowerCase().replace(/-/g, '_')
+  if (!normalized) return {}
+  const match = normalized.match(/^(list|get|create|update|delete)_([a-z_]+)$/)
+  if (!match) return {}
+  const [, action, rawResource] = match
+  const resource = normalizePlatformResourceName(rawResource)
+  if (!resource) return {}
+  return { resource, action }
+}
+
+function extractPlatformFields(value: Record<string, unknown>): Record<string, unknown> {
+  const fields: Record<string, unknown> = {}
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (fieldValue === undefined || fieldValue === null) continue
+    if (['input', 'args', 'arguments', 'payload', 'resources', 'parameters', 'resource', 'type', 'action', 'id'].includes(key)) continue
+    fields[key] = fieldValue
+  }
+  return fields
+}
+
+export function normalizePlatformActionArgs(rawArgs: Record<string, unknown>): Record<string, unknown> {
+  const normalized = normalizeToolInputArgs(rawArgs)
+  const resourceEntry = firstPlatformResource(normalized.resources)
+  const { resource, action, id, data, ...rest } = normalized
+  const payload: Record<string, unknown> = {}
+  const resourceValue = resource ?? resourceEntry?.resource ?? resourceEntry?.type
+  const rawResourceName = typeof resourceValue === 'string'
+    ? String(resourceValue).trim()
+    : undefined
+
+  const rawAction = action ?? resourceEntry?.action
+  const inferredFromAction = resourceValue === undefined
+    ? inferPlatformResourceFromAction(rawAction)
+    : {}
+  const effectiveResource = normalizePlatformResourceName(resourceValue) ?? inferredFromAction.resource
+  const effectiveAction = inferredFromAction.action && resourceValue === undefined
+    ? inferredFromAction.action
+    : rawAction
+  const effectiveId = id ?? resourceEntry?.id
+
+  if (effectiveResource !== undefined) payload.resource = effectiveResource
+  if (effectiveAction !== undefined) payload.action = effectiveAction
+  if (effectiveId !== undefined) payload.id = effectiveId
+
+  const directFields = extractPlatformFields(rest)
+  const resourcePayloadCandidates = effectiveResource
+    ? uniqueStrings([
+        rawResourceName,
+        effectiveResource,
+        effectiveResource.replace(/s$/, ''),
+      ])
+    : []
+  const directResourcePayload = resourcePayloadCandidates
+    .map((candidate) => parsePlatformData(normalized[candidate]))
+    .find(Boolean)
+    || null
+  if (effectiveResource) {
+    for (const candidate of resourcePayloadCandidates) delete directFields[candidate]
+  }
+  const parameterFields = {
+    ...(parsePlatformData(resourceEntry?.parameters) || {}),
+    ...(parsePlatformData(resourceEntry?.params) || {}),
+    ...(parsePlatformData(normalized.parameters) || {}),
+    ...(directResourcePayload || {}),
+  }
+  const parsedData = parsePlatformData(data)
+  const mergedData = {
+    ...(parsedData || {}),
+    ...parameterFields,
+    ...directFields,
+  }
+
+  if (Object.keys(mergedData).length > 0) {
+    payload.data = JSON.stringify(mergedData)
+  } else if (typeof data === 'string' && data.trim()) {
+    payload.data = data
+  }
+
+  return payload
+}
+
+function uniqueStrings(values: Array<string | undefined>): string[] {
+  return [...new Set(values.filter((value): value is string => Boolean(value)))]
+}
+
 /**
  * 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
+  const normalized = normalizePlatformActionArgs((args ?? {}) as Record<string, unknown>)
+  const { resource, action, id, data } = normalized
   
   // We reuse the existing CRUD tool logic but expose it via a single tool
   const crudTools = buildCrudTools({
@@ -36,7 +174,7 @@ async function executePlatformAction(args: any, bctx: any) {
   }
 
   // Forward to the specific CRUD tool implementation
-  return targetTool.invoke({ action, id, data, ...rest })
+  return targetTool.invoke({ action, id, data })
 }
 
 /**
@@ -52,7 +190,7 @@ const PlatformPlugin: Plugin = {
   tools: [
     {
       name: 'manage_platform',
-      description: 'Unified tool for managing all SwarmClaw resources.',
+      description: 'Unified tool for managing all SwarmClaw resources. For create/update, pass resource + action, then either put fields inside data, pass them as top-level fields, or use a single resources[0].parameters envelope.',
       parameters: {
         type: 'object',
         properties: {

package/src/lib/server/session-tools/plugin-creator.ts

@@ -27,6 +27,8 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
   const action = normalized.action as string | undefined
   const filename = (normalized.filename ?? normalized.fileName) as string | undefined
   const code = (normalized.code ?? normalized.content) as string | undefined
+  const packageJson = normalized.packageJson ?? normalized.package_json ?? normalized.manifest
+  const packageManager = typeof normalized.packageManager === 'string' ? normalized.packageManager : undefined
   const approved = normalized.approved as boolean | undefined
 
   try {
@@ -40,15 +42,23 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
 
       // REQUIRE USER APPROVAL
       if (approved !== true) {
-        const { requestApproval } = await import('../approvals')
-        requestApproval({
+        const { requestApprovalMaybeAutoApprove } = await import('../approvals')
+        const approval = await requestApprovalMaybeAutoApprove({
           category: 'plugin_scaffold',
           title: `Scaffold Plugin: ${filename}`,
           description: `Create new plugin file with ${code.length} chars of code.`,
-          data: { filename, code, createdByAgentId: pctx.agentId || null },
+          data: { filename, code, packageJson, packageManager, createdByAgentId: pctx.agentId || null },
           agentId: pctx.agentId,
           sessionId: pctx.sessionId,
         })
+        if (approval.status === 'approved') {
+          return JSON.stringify({
+            type: 'plugin_scaffold_request',
+            filename,
+            autoApproved: true,
+            message: `Plugin "${filename}" was auto-approved and scaffolded. It is now available in this chat.`,
+          })
+        }
         return JSON.stringify({
           type: 'plugin_scaffold_request',
           filename,
@@ -56,12 +66,13 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
         })
       }
 
-      const filePath = path.join(PLUGINS_DIR, filename)
-      fs.writeFileSync(filePath, code, 'utf8')
-
-      // Reload the plugin manager so the new plugin is discovered
       const manager = getPluginManager()
-      manager.reload()
+      await manager.savePluginSource(filename, code, {
+        packageJson,
+        packageManager,
+        installDependencies: packageJson !== undefined,
+      })
+      const filePath = path.join(PLUGINS_DIR, filename)
 
       // Auto-enable the plugin for the agent that created it
       if (pctx.agentId && pctx.sessionId) {
@@ -82,10 +93,53 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
       return `Plugin saved to ${filePath} and PluginManager reloaded. It is now enabled for this chat.`
     }
 
+    if (action === 'install_dependencies') {
+      if (!filename) return 'Error: filename is required for install_dependencies.'
+
+      if (approved !== true) {
+        const { requestApprovalMaybeAutoApprove } = await import('../approvals')
+        const approval = await requestApprovalMaybeAutoApprove({
+          category: 'plugin_install',
+          title: `Install Plugin Dependencies: ${filename}`,
+          description: `Install package dependencies for plugin ${filename}${packageManager ? ` using ${packageManager}` : ''}.`,
+          data: { filename, packageJson, packageManager, createdByAgentId: pctx.agentId || null },
+          agentId: pctx.agentId,
+          sessionId: pctx.sessionId,
+        })
+        if (approval.status === 'approved') {
+          return JSON.stringify({
+            type: 'plugin_install_request',
+            filename,
+            autoApproved: true,
+            message: `Dependencies for "${filename}" were auto-approved and are being installed.`,
+          })
+        }
+        return JSON.stringify({
+          type: 'plugin_install_request',
+          filename,
+          message: `I've requested approval to install dependencies for "${filename}". Once approved, the plugin manager will run the selected package manager automatically.`,
+        })
+      }
+
+      const manager = getPluginManager()
+      if (packageJson !== undefined) {
+        const source = manager.readPluginSource(filename)
+        await manager.savePluginSource(filename, source, {
+          packageJson,
+          packageManager,
+          installDependencies: false,
+        })
+      }
+      const result = await manager.installPluginDependencies(filename, {
+        packageManager: packageManager as import('@/types').PluginPackageManager | undefined,
+      })
+      return `Dependencies installed for ${filename} using ${result.packageManager || packageManager || 'npm'}.`
+    }
+
     if (action === 'get_spec') {
       return `
 SwarmClaw Plugin Specification:
-A plugin is a CommonJS module (.js) that must be DUAL-COMPATIBLE with both SwarmClaw and OpenClaw platforms.
+A plugin is a JavaScript module (.js or .mjs) that can be dual-compatible with both SwarmClaw and OpenClaw platforms.
 
 \`\`\`js
 module.exports = {
@@ -100,10 +154,11 @@ module.exports = {
   hooks: {
     beforeAgentStart: async ({ session, message }) => {},
     afterAgentComplete: async ({ session, response }) => {},
-    beforeToolExec: async ({ session, toolName, args }) => {},
-    afterToolExec: async ({ session, toolName, result }) => {},
+    beforeToolExec: async ({ toolName, input }) => input,
+    afterToolExec: async ({ session, toolName, input, output }) => {},
     transformInboundMessage: async ({ session, text }) => { return text; },
     transformOutboundMessage: async ({ session, text }) => { return text; },
+    afterChatTurn: async ({ session, message, response, source, internal }) => {},
   },
 
   tools: [
@@ -140,27 +195,31 @@ module.exports = {
 \`\`\`
 
 Key rules:
-- Export BOTH SwarmClaw hooks/tools AND a register(api) method for cross-platform compatibility
-- SwarmClaw checks for hooks/tools first; OpenClaw checks for register()
+- Export SwarmClaw hooks/tools. Add register(api) too if you want OpenClaw compatibility.
+- SwarmClaw checks hooks/tools first; OpenClaw checks register()
 - Tools must have name, description, parameters (JSON Schema), and execute function
 - Hooks are optional — only include the ones you need
+- If your plugin needs npm/pnpm/yarn/bun packages, include a packageJson object during scaffold or call install_dependencies later.
+- Dependency installs are run by the plugin manager inside a per-plugin workspace using the selected package manager with scripts disabled.
+- Plugin settings are declared through ui.settingsFields and stored per plugin ID
 - Keep plugins focused: one clear purpose per plugin
 `
     }
 
     if (action === 'read') {
       if (!filename) return 'Error: filename required.'
-      const filePath = path.join(PLUGINS_DIR, filename)
-      if (!fs.existsSync(filePath)) return `File not found: ${filename}`
-      return fs.readFileSync(filePath, 'utf8')
+      return getPluginManager().readPluginSource(filename)
     }
 
     if (action === 'edit') {
       if (!filename || !code) return 'Error: filename and code are required for edit.'
-      const filePath = path.join(PLUGINS_DIR, filename)
-      if (!fs.existsSync(filePath)) return `File not found: ${filename}. Use scaffold to create new plugins.`
-      fs.writeFileSync(filePath, code, 'utf8')
-      getPluginManager().reload()
+      const manager = getPluginManager()
+      try {
+        manager.readPluginSource(filename)
+      } catch {
+        return `File not found: ${filename}. Use scaffold to create new plugins.`
+      }
+      await manager.savePluginSource(filename, code)
       return `Updated ${filename} and reloaded plugin manager.`
     }
 
@@ -175,7 +234,7 @@ Key rules:
       return `File not found: ${filename}`
     }
 
-    return `Unknown action "${action}". Valid actions: get_spec, scaffold, read, edit, delete`
+    return `Unknown action "${action}". Valid actions: get_spec, scaffold, read, edit, delete, install_dependencies`
   } catch (err: unknown) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`
   }
@@ -195,9 +254,11 @@ const PluginCreatorPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['get_spec', 'scaffold', 'read', 'edit', 'delete'], description: 'get_spec: learn format. scaffold: create (needs approval). read: view code. edit: update existing. delete: remove.' },
+          action: { type: 'string', enum: ['get_spec', 'scaffold', 'read', 'edit', 'delete', 'install_dependencies'], description: 'get_spec: learn format. scaffold: create (needs approval). read: view code. edit: update existing. delete: remove. install_dependencies: write/read package.json and install runtime deps.' },
           filename: { type: 'string', description: 'Plugin filename, e.g. my-plugin.js. Required for scaffold and delete.' },
           code: { type: 'string', description: 'The raw JavaScript code for the plugin. Required for scaffold.' },
+          packageJson: { type: 'object', description: 'Optional package.json object for dependency-aware plugins. Use with scaffold or install_dependencies.' },
+          packageManager: { type: 'string', enum: ['npm', 'pnpm', 'yarn', 'bun'], description: 'Optional package manager to use for dependency installs.' },
           approved: { type: 'boolean', description: 'Internal flag — do NOT set this. The approval system handles it automatically.' }
         },
         required: ['action']
@@ -228,9 +289,11 @@ export function buildPluginCreatorTools(bctx: ToolBuildContext): StructuredToolI
         name: 'plugin_creator_tool',
         description: PluginCreatorPlugin.tools![0].description,
         schema: z.object({
-          action: z.enum(['get_spec', 'scaffold', 'read', 'edit', 'delete']),
+          action: z.enum(['get_spec', 'scaffold', 'read', 'edit', 'delete', 'install_dependencies']),
           filename: z.string().optional(),
           code: z.string().optional(),
+          packageJson: z.record(z.string(), z.any()).optional(),
+          packageManager: z.enum(['npm', 'pnpm', 'yarn', 'bun']).optional(),
           approved: z.boolean().optional()
         })
       }