@swarmclawai/swarmclaw 0.6.7 → 0.7.0

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

@@ -4,6 +4,9 @@ import { execFile } from 'child_process'
 import { promisify } from 'util'
 import type { ToolBuildContext } from './context'
 import { findBinaryOnPath, safePath, truncate, MAX_OUTPUT } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
 const execFileAsync = promisify(execFile)
 
@@ -13,59 +16,96 @@ const GIT_ACTIONS = [
   'tag', 'reset', 'show',
 ] as const
 
-export function buildGitTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('git')) return []
-
+/**
+ * Core Git Execution Logic
+ */
+async function executeGitAction(args: Record<string, unknown>, bctx: { cwd: string }) {
+  const normalized = normalizeToolInputArgs(args)
+  const action = typeof normalized.action === 'string' ? normalized.action : ''
+  const cmdArgsRaw = (normalized.args ?? normalized.commandArgs ?? normalized.cmdArgs) as string[] | undefined
+  const repoPath = (normalized.repoPath ?? normalized.path) as string | undefined
+  const timeoutSec = (normalized.timeoutSec ?? normalized.timeout) as number | undefined
   const gitPath = findBinaryOnPath('git')
-  if (!gitPath) return []
+  if (!gitPath) return JSON.stringify({ error: 'Git binary not found on system path' })
+  if (!action || !GIT_ACTIONS.includes(action as (typeof GIT_ACTIONS)[number])) {
+    return JSON.stringify({ error: `Invalid or missing git action. Allowed: ${GIT_ACTIONS.join(', ')}` })
+  }
 
-  return [
-    tool(
-      async ({ action, args, repoPath, timeoutSec }) => {
-        try {
-          const cwd = repoPath ? safePath(bctx.cwd, repoPath) : bctx.cwd
-          const timeout = Math.max(5, Math.min(timeoutSec ?? 60, 300)) * 1000
+  try {
+    const cwd = repoPath ? safePath(bctx.cwd, repoPath) : bctx.cwd
+    const timeout = Math.max(5, Math.min(timeoutSec ?? 60, 300)) * 1000
+
+    if (action !== 'clone') {
+      try {
+        await execFileAsync(gitPath, ['rev-parse', '--is-inside-work-tree'], { cwd, timeout: 5000 })
+      } catch {
+        return JSON.stringify({ error: `Not a git repository: ${cwd}` })
+      }
+    }
 
-          // Verify we're in a git repo (except for clone)
-          if (action !== 'clone') {
-            try {
-              await execFileAsync(gitPath, ['rev-parse', '--is-inside-work-tree'], { cwd, timeout: 5000 })
-            } catch {
-              return JSON.stringify({ error: `Not a git repository: ${cwd}` })
-            }
-          }
+    const cmdArgs = [action, ...(cmdArgsRaw ?? [])]
+    const result = await execFileAsync(gitPath, cmdArgs, {
+      cwd,
+      timeout,
+      maxBuffer: MAX_OUTPUT,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    })
+    return JSON.stringify({
+      exitCode: 0,
+      stdout: truncate(result.stdout ?? '', MAX_OUTPUT),
+      stderr: truncate(result.stderr ?? '', MAX_OUTPUT),
+    })
+  } catch (err: unknown) {
+    const execErr = err as { code?: number; stdout?: string; stderr?: string; message?: string }
+    return JSON.stringify({
+      exitCode: execErr.code ?? 1,
+      stdout: truncate(execErr.stdout ?? '', MAX_OUTPUT),
+      stderr: truncate(execErr.stderr ?? execErr.message ?? String(err), MAX_OUTPUT),
+    })
+  }
+}
 
-          const cmdArgs = [action, ...(args ?? [])]
-          const result = await execFileAsync(gitPath, cmdArgs, {
-            cwd,
-            timeout,
-            maxBuffer: MAX_OUTPUT,
-            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
-          })
-          return JSON.stringify({
-            exitCode: 0,
-            stdout: truncate(result.stdout ?? '', MAX_OUTPUT),
-            stderr: truncate(result.stderr ?? '', MAX_OUTPUT),
-          })
-        } catch (err: unknown) {
-          const execErr = err as { code?: number; stdout?: string; stderr?: string; message?: string }
-          return JSON.stringify({
-            exitCode: execErr.code ?? 1,
-            stdout: truncate(execErr.stdout ?? '', MAX_OUTPUT),
-            stderr: truncate(execErr.stderr ?? execErr.message ?? String(err), MAX_OUTPUT),
-          })
-        }
+/**
+ * Register as a Built-in Plugin
+ */
+const GitPlugin: Plugin = {
+  name: 'Core Git',
+  description: 'Structured git operations: status, commit, push, diff, and more.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'git',
+      description: 'Run git operations in the workspace.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: [...GIT_ACTIONS] },
+          args: { type: 'array', items: { type: 'string' } },
+          repoPath: { type: 'string' },
+          timeoutSec: { type: 'number' }
+        },
+        required: ['action']
       },
+      execute: async (args, context) => executeGitAction(args, { cwd: context.session.cwd || process.cwd() })
+    }
+  ]
+}
+
+getPluginManager().registerBuiltin('git', GitPlugin)
+
+/**
+ * Legacy Bridge
+ */
+export function buildGitTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('git')) return []
+  return [
+    tool(
+      async (args) => executeGitAction(args, { cwd: bctx.cwd }),
       {
         name: 'git',
-        description: 'Run git operations. Verify the repo exists before committing or pushing. Use args for subcommand flags (e.g. args: ["-m", "message"] for commit).',
-        schema: z.object({
-          action: z.enum(GIT_ACTIONS).describe('Git subcommand to run'),
-          args: z.array(z.string()).optional().describe('Additional arguments (e.g. ["-m", "fix: typo"], ["--oneline", "-n", "5"])'),
-          repoPath: z.string().optional().describe('Relative path to git repo (defaults to working directory)'),
-          timeoutSec: z.number().optional().describe('Timeout in seconds (default 60, max 300)'),
-        }),
-      },
-    ),
+        description: GitPlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
+    )
   ]
 }

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

@@ -2,47 +2,109 @@ import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import type { ToolBuildContext } from './context'
 import { truncate, MAX_OUTPUT } from './context'
+import { withRetry } from '../tool-retry'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
+interface HttpRequestArgs {
+  method: string
+  url: string
+  headers?: Record<string, string>
+  body?: string
+  timeoutSec?: number
+  followRedirects?: boolean
+}
+
+/**
+ * Core HTTP Execution Logic
+ */
+async function executeHttpAction(args: HttpRequestArgs) {
+  const normalized = normalizeToolInputArgs((args ?? {}) as unknown as Record<string, unknown>)
+  const requestArgs: HttpRequestArgs = {
+    method: String(normalized.method || '').toUpperCase(),
+    url: String(normalized.url || ''),
+    headers: normalized.headers as Record<string, string> | undefined,
+    body: typeof normalized.body === 'string' ? normalized.body : undefined,
+    timeoutSec: typeof normalized.timeoutSec === 'number' ? normalized.timeoutSec : undefined,
+    followRedirects: typeof normalized.followRedirects === 'boolean' ? normalized.followRedirects : undefined,
+  }
+  return withRetry(async (_a: HttpRequestArgs) => {
+    try {
+      const timeout = Math.max(1, Math.min(_a.timeoutSec ?? 30, 120)) * 1000
+      const init: RequestInit = {
+        method: _a.method,
+        headers: (_a.headers ?? undefined) as Record<string, string> | undefined,
+        signal: AbortSignal.timeout(timeout),
+      }
+      if (_a.body && _a.method !== 'GET' && _a.method !== 'HEAD') {
+        init.body = _a.body
+      }
+      if (_a.followRedirects === false) {
+        init.redirect = 'manual'
+      }
+      const res = await fetch(_a.url, init)
+      const resHeaders: Record<string, string> = {}
+      for (const key of ['content-type', 'location', 'x-request-id', 'retry-after', 'content-length']) {
+        const val = res.headers.get(key)
+        if (val) resHeaders[key] = val
+      }
+      let resBody: string
+      const ct = res.headers.get('content-type') ?? ''
+      if (ct.includes('image/') || ct.includes('audio/') || ct.includes('video/') || ct.includes('application/octet-stream')) {
+        resBody = `[binary content, ${res.headers.get('content-length') ?? 'unknown'} bytes]`
+      } else {
+        resBody = truncate(await res.text(), MAX_OUTPUT)
+      }
+      return JSON.stringify({ status: res.status, statusText: res.statusText, headers: resHeaders, body: resBody })
+    } catch (err: unknown) {
+      return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+    }
+  }, requestArgs)
+}
+
+/**
+ * Register as a Built-in Plugin
+ */
+const HttpPlugin: Plugin = {
+  name: 'Core HTTP',
+  description: 'Make direct HTTP API calls with custom methods, headers, and bodies.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'http_request',
+      description: 'Make an HTTP API request.',
+      parameters: {
+        type: 'object',
+        properties: {
+          method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'] },
+          url: { type: 'string' },
+          headers: { type: 'object', additionalProperties: { type: 'string' } },
+          body: { type: 'string' },
+          timeoutSec: { type: 'number' },
+          followRedirects: { type: 'boolean' }
+        },
+        required: ['method', 'url']
+      },
+      execute: async (args) => executeHttpAction(args as unknown as HttpRequestArgs)
+    }
+  ]
+}
+
+getPluginManager().registerBuiltin('http', HttpPlugin)
+
+/**
+ * Legacy Bridge
+ */
 export function buildHttpTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   if (!bctx.hasTool('http_request')) return []
 
   return [
     tool(
-      async ({ method, url, headers, body, timeoutSec, followRedirects }) => {
-        try {
-          const timeout = Math.max(1, Math.min(timeoutSec ?? 30, 120)) * 1000
-          const init: RequestInit = {
-            method,
-            headers: (headers ?? undefined) as Record<string, string> | undefined,
-            signal: AbortSignal.timeout(timeout),
-          }
-          if (body && method !== 'GET' && method !== 'HEAD') {
-            init.body = body
-          }
-          if (followRedirects === false) {
-            init.redirect = 'manual'
-          }
-          const res = await fetch(url, init)
-          const resHeaders: Record<string, string> = {}
-          for (const key of ['content-type', 'location', 'x-request-id', 'retry-after', 'content-length']) {
-            const val = res.headers.get(key)
-            if (val) resHeaders[key] = val
-          }
-          let resBody: string
-          const ct = res.headers.get('content-type') ?? ''
-          if (ct.includes('image/') || ct.includes('audio/') || ct.includes('video/') || ct.includes('application/octet-stream')) {
-            resBody = `[binary content, ${res.headers.get('content-length') ?? 'unknown'} bytes]`
-          } else {
-            resBody = truncate(await res.text(), MAX_OUTPUT)
-          }
-          return JSON.stringify({ status: res.status, statusText: res.statusText, headers: resHeaders, body: resBody })
-        } catch (err: unknown) {
-          return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-        }
-      },
+      (args: HttpRequestArgs) => executeHttpAction(args),
       {
         name: 'http_request',
-        description: 'Make an HTTP API request. Supports all methods, custom headers, and request bodies. Returns status, headers, and body.',
+        description: HttpPlugin.tools![0].description,
         schema: z.object({
           method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']).describe('HTTP method'),
           url: z.string().describe('Full URL to request'),