@swarmclawai/swarmclaw 0.7.1 → 0.7.2

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

@@ -12,13 +12,15 @@ const MAX_DELEGATION_CHAIN_HOPS = 128
 interface DelegateContext {
   cwd?: string
   claudeTimeoutMs?: number
-  readStoredDelegateResumeId?: (key: 'claudeCode' | 'codex' | 'opencode') => string | null
-  persistDelegateResumeId?: (key: 'claudeCode' | 'codex' | 'opencode', id: string) => void
+  readStoredDelegateResumeId?: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini') => string | null
+  persistDelegateResumeId?: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini', id: string) => void
   ctx?: { platformAssignScope?: string; agentId?: string | null }
+  hasPlugin?: (name: string) => boolean
+  /** @deprecated Use hasPlugin */
   hasTool?: (name: string) => boolean
 }
 
-type DelegateBackend = 'claude' | 'codex' | 'opencode'
+type DelegateBackend = 'claude' | 'codex' | 'opencode' | 'gemini'
 
 function asTaskRecord(value: unknown): Record<string, unknown> | null {
   return value && typeof value === 'object' ? value as Record<string, unknown> : null
@@ -74,6 +76,7 @@ async function executeDelegateAction(args: Record<string, unknown>, bctx: Delega
     claude: findBinaryOnPath('claude'),
     codex: findBinaryOnPath('codex'),
     opencode: findBinaryOnPath('opencode'),
+    gemini: findBinaryOnPath('gemini'),
   }
   const binary = backends[backend as keyof typeof backends]
   if (!binary) return `Error: Backend "${backend}" unavailable.`
@@ -81,6 +84,7 @@ async function executeDelegateAction(args: Record<string, unknown>, bctx: Delega
   if (backend === 'claude') return runClaudeDelegate(binary, task, resume, resumeId, bctx)
   if (backend === 'codex') return runCodexDelegate(binary, task, resume, resumeId, bctx)
   if (backend === 'opencode') return runOpenCodeDelegate(binary, task, resume, resumeId, bctx)
+  if (backend === 'gemini') return runGeminiDelegate(binary, task, resume, resumeId, bctx)
   return `Error: Unsupported backend "${backend}".`
 }
 
@@ -273,6 +277,86 @@ async function runOpenCodeDelegate(binary: string, task: string, resume: boolean
   }
 }
 
+async function runGeminiDelegate(binary: string, task: string, resume: boolean, resumeId: string, bctx: DelegateContext): Promise<string> {
+  try {
+    const env = { ...process.env, TERM: 'dumb', NO_COLOR: '1' } as NodeJS.ProcessEnv
+    const storedResumeId = bctx.readStoredDelegateResumeId?.('gemini')
+    const resumeIdToUse = resumeId?.trim() || (resume ? storedResumeId : null)
+
+    return await new Promise<string>((resolve) => {
+      const args = ['--prompt', task, '--output-format', 'stream-json', '--yolo']
+      if (resumeIdToUse) args.push('--resume', resumeIdToUse)
+
+      const child = spawn(binary, args, { cwd: bctx.cwd, env, stdio: ['ignore', 'pipe', 'pipe'] })
+      let stdoutBuf = ''
+      let stderrBuf = ''
+      let responseText = ''
+      let discoveredId: string | null = null
+      let settled = false
+
+      const finish = (text: string) => {
+        if (settled) return
+        settled = true
+        resolve(truncate(text, MAX_OUTPUT))
+      }
+
+      const timeoutHandle = setTimeout(() => {
+        try { child.kill('SIGTERM') } catch { /* ignore */ }
+      }, bctx.claudeTimeoutMs || 300000)
+
+      child.stdout?.on('data', (chunk) => {
+        stdoutBuf += chunk.toString()
+        const lines = stdoutBuf.split('\n')
+        stdoutBuf = lines.pop() || ''
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (!trimmed) continue
+          try {
+            const ev = JSON.parse(trimmed) as Record<string, unknown>
+            // Capture session ID from init event
+            if (ev.type === 'init' && typeof ev.session_id === 'string') {
+              discoveredId = ev.session_id
+            }
+            // Capture assistant text from message events
+            if (ev.type === 'message' && ev.role === 'assistant' && typeof ev.content === 'string') {
+              responseText += ev.content
+            }
+            // Capture final result
+            if (ev.type === 'result' && ev.status === 'error') {
+              const errMsg = typeof ev.error === 'string' ? ev.error : 'Gemini error'
+              stderrBuf += `${errMsg}\n`
+            }
+          } catch {
+            responseText += `${line}\n`
+          }
+        }
+      })
+
+      child.stderr?.on('data', (chunk) => {
+        stderrBuf += chunk.toString()
+        if (stderrBuf.length > 16_000) stderrBuf = stderrBuf.slice(-16_000)
+      })
+
+      child.on('close', (code, signal) => {
+        clearTimeout(timeoutHandle)
+        if (discoveredId) bctx.persistDelegateResumeId?.('gemini', discoveredId)
+        const output = responseText.trim()
+        if (output) return finish(output)
+        const stderr = stderrBuf.trim()
+        if (stderr) return finish(`Error: ${stderr}`)
+        return finish(`Error: Gemini exited with code ${code ?? 'unknown'}${signal ? ` (${signal})` : ''}.`)
+      })
+
+      child.on('error', (err) => {
+        clearTimeout(timeoutHandle)
+        finish(`Error: ${err.message}`)
+      })
+    })
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
 async function runClaudeDelegate(binary: string, task: string, resume: boolean, resumeId: string, bctx: DelegateContext): Promise<string> {
   try {
     const env: NodeJS.ProcessEnv = stripEnvPrefixes({ ...process.env }, ['CLAUDE'])
@@ -335,16 +419,19 @@ async function runClaudeDelegate(binary: string, task: string, resume: boolean,
 const DelegatePlugin: Plugin = {
   name: 'Core Delegate',
   description: 'Delegate complex multi-file tasks to specialized CLI backends or other agents.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can hand off deep coding work to Claude Code, Codex, or Gemini CLI (`delegate`) for complex multi-file refactors and code generation. Resume IDs may come back via `[delegate_meta]`.',
+    getOperatingGuidance: () => ['CRITICAL: `execute_command` (not delegation) for running servers, installs, scripts. Delegation sessions end and kill processes.', 'Delegate only for deep multi-file code work: refactors, debugging, generation, test suites.'],
+  } as PluginHooks,
   tools: [
     {
       name: 'delegate',
-      description: 'Delegate to a specialized backend (Claude, Codex, OpenCode).',
+      description: 'Delegate to a specialized backend (Claude, Codex, OpenCode, Gemini).',
       parameters: {
         type: 'object',
         properties: {
           task: { type: 'string' },
-          backend: { type: 'string', enum: ['claude', 'codex', 'opencode'] },
+          backend: { type: 'string', enum: ['claude', 'codex', 'opencode', 'gemini'] },
           resume: { type: 'boolean' },
           resumeId: { type: 'string', description: 'Optional explicit session/thread ID to resume' }
         },
@@ -362,9 +449,9 @@ getPluginManager().registerBuiltin('delegate', DelegatePlugin)
  */
 export function buildDelegateTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   const tools: StructuredToolInterface[] = []
-  const { hasTool } = bctx
+  const { hasPlugin } = bctx
 
-  if (hasTool('delegate')) {
+  if (hasPlugin('delegate')) {
     tools.push(
       tool(
         async (args) => executeDelegateAction(args, bctx),

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

@@ -5,7 +5,7 @@ import { getPluginManager } from '../plugins'
 import type { Plugin, PluginHooks, ClawHubSkill } from '@/types'
 import { searchClawHub } from '../clawhub-client'
 import { normalizeToolInputArgs } from './normalize-tool-args'
-import { toolIdMatches } from '../tool-aliases'
+import { pluginIdMatches } from '../tool-aliases'
 import { loadSessions } from '../storage'
 
 /**
@@ -88,7 +88,7 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
         if (bctx?.ctx?.sessionId) {
           const allSessions = loadSessions()
           const currentSession = allSessions[bctx.ctx.sessionId]
-          if (currentSession && toolIdMatches(currentSession.tools, pluginId)) {
+          if (currentSession && pluginIdMatches(currentSession.tools, pluginId)) {
             return JSON.stringify({
               alreadyGranted: true,
               pluginId,

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

@@ -43,7 +43,9 @@ async function executeEditFile(args: { filePath: string; oldString: string; newS
 const EditFilePlugin: Plugin = {
   name: 'Core Edit File',
   description: 'Surgical search-and-replace within existing files.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can make precise edits to files (`edit_file`) — surgical find-and-replace without rewriting the whole file.',
+  } as PluginHooks,
   tools: [
     {
       name: 'edit_file',
@@ -68,7 +70,7 @@ getPluginManager().registerBuiltin('edit_file', EditFilePlugin)
  * Legacy Bridge
  */
 export function buildEditFileTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('edit_file')) return []
+  if (!bctx.hasPlugin('edit_file')) return []
   return [
     tool(
       async (args) => executeEditFile(args as any, { cwd: bctx.cwd }),

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

@@ -0,0 +1,322 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+import { loadSettings } from '../storage'
+import type { ToolBuildContext } from './context'
+
+interface SmtpConfig {
+  host: string
+  port: number
+  secure: boolean
+  username: string
+  password: string
+  fromAddress: string
+  fromName: string
+}
+
+function getSmtpConfig(): SmtpConfig {
+  const settings = loadSettings()
+  const ps = (settings.pluginSettings as Record<string, Record<string, unknown>> | undefined)?.email ?? {}
+  return {
+    host: (ps.host as string) || '',
+    port: Number(ps.port) || 587,
+    secure: ps.secure === true || ps.secure === 'true',
+    username: (ps.username as string) || '',
+    password: (ps.password as string) || '',
+    fromAddress: (ps.fromAddress as string) || '',
+    fromName: (ps.fromName as string) || 'SwarmClaw Agent',
+  }
+}
+
+/**
+ * Minimal SMTP client using raw sockets.
+ * Avoids nodemailer dependency — uses Node's built-in net/tls.
+ */
+async function sendSmtpEmail(cfg: SmtpConfig, to: string[], subject: string, body: string, html?: string): Promise<string> {
+  const net = await import('net')
+  const tls = await import('tls')
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error('SMTP timeout (30s)')), 30_000)
+    let socket: import('net').Socket
+    const lines: string[] = []
+    let phase = 'connect'
+
+    const cleanup = () => { clearTimeout(timeout); try { socket.destroy() } catch { /* ok */ } }
+
+    const readLine = (data: Buffer) => {
+      const text = data.toString()
+      lines.push(text)
+      const code = parseInt(text.slice(0, 3), 10)
+      return { text, code }
+    }
+
+    const send = (cmd: string) => { socket.write(cmd + '\r\n') }
+
+    // Build MIME message
+    const boundary = `----=_Part_${Date.now()}_${Math.random().toString(36).slice(2)}`
+    const date = new Date().toUTCString()
+    const msgId = `<${Date.now()}.${Math.random().toString(36).slice(2)}@${cfg.host}>`
+    const toHeader = to.join(', ')
+
+    let message = `From: ${cfg.fromName ? `"${cfg.fromName}" ` : ''}<${cfg.fromAddress}>\r\n`
+    message += `To: ${toHeader}\r\n`
+    message += `Subject: ${subject}\r\n`
+    message += `Date: ${date}\r\n`
+    message += `Message-ID: ${msgId}\r\n`
+    message += `MIME-Version: 1.0\r\n`
+
+    if (html) {
+      message += `Content-Type: multipart/alternative; boundary="${boundary}"\r\n\r\n`
+      message += `--${boundary}\r\n`
+      message += `Content-Type: text/plain; charset=utf-8\r\n\r\n`
+      message += body + '\r\n'
+      message += `--${boundary}\r\n`
+      message += `Content-Type: text/html; charset=utf-8\r\n\r\n`
+      message += html + '\r\n'
+      message += `--${boundary}--\r\n`
+    } else {
+      message += `Content-Type: text/plain; charset=utf-8\r\n\r\n`
+      message += body + '\r\n'
+    }
+
+    const connectOpts = { host: cfg.host, port: cfg.port }
+
+    const handleData = (data: Buffer) => {
+      const { code } = readLine(data)
+
+      switch (phase) {
+        case 'connect':
+          if (code === 220) { phase = 'ehlo'; send(`EHLO ${cfg.host}`) }
+          else { cleanup(); reject(new Error(`SMTP connect failed: ${data.toString().trim()}`)) }
+          break
+        case 'ehlo':
+          if (code === 250) {
+            if (cfg.secure && !('encrypted' in socket)) {
+              phase = 'starttls'; send('STARTTLS')
+            } else if (cfg.username) {
+              phase = 'auth'; send('AUTH LOGIN')
+            } else {
+              phase = 'mail_from'; send(`MAIL FROM:<${cfg.fromAddress}>`)
+            }
+          }
+          break
+        case 'starttls':
+          if (code === 220) {
+            const tlsSocket = tls.connect({ socket, host: cfg.host, rejectUnauthorized: false }, () => {
+              socket = tlsSocket as unknown as import('net').Socket
+              socket.on('data', handleData)
+              phase = 'ehlo2'; send(`EHLO ${cfg.host}`)
+            })
+            tlsSocket.on('error', (err: Error) => { cleanup(); reject(err) })
+          }
+          break
+        case 'ehlo2':
+          if (code === 250) {
+            if (cfg.username) { phase = 'auth'; send('AUTH LOGIN') }
+            else { phase = 'mail_from'; send(`MAIL FROM:<${cfg.fromAddress}>`) }
+          }
+          break
+        case 'auth':
+          if (code === 334) { phase = 'auth_user'; send(Buffer.from(cfg.username).toString('base64')) }
+          else { cleanup(); reject(new Error(`SMTP AUTH failed: ${data.toString().trim()}`)) }
+          break
+        case 'auth_user':
+          if (code === 334) { phase = 'auth_pass'; send(Buffer.from(cfg.password).toString('base64')) }
+          break
+        case 'auth_pass':
+          if (code === 235) { phase = 'mail_from'; send(`MAIL FROM:<${cfg.fromAddress}>`) }
+          else { cleanup(); reject(new Error(`SMTP auth failed: ${data.toString().trim()}`)) }
+          break
+        case 'mail_from':
+          if (code === 250) { phase = 'rcpt_to'; send(`RCPT TO:<${to[0]}>`) }
+          break
+        case 'rcpt_to':
+          if (code === 250) { phase = 'data'; send('DATA') }
+          else { cleanup(); reject(new Error(`SMTP RCPT rejected: ${data.toString().trim()}`)) }
+          break
+        case 'data':
+          if (code === 354) { phase = 'message'; send(message + '\r\n.') }
+          break
+        case 'message':
+          if (code === 250) { phase = 'quit'; send('QUIT'); cleanup(); resolve('Email sent successfully.') }
+          else { cleanup(); reject(new Error(`SMTP send failed: ${data.toString().trim()}`)) }
+          break
+        case 'quit':
+          cleanup()
+          break
+      }
+    }
+
+    if (cfg.secure && cfg.port === 465) {
+      socket = tls.connect({ ...connectOpts, rejectUnauthorized: false }, () => {
+        (socket as unknown as Record<string, boolean>).encrypted = true
+      }) as unknown as import('net').Socket
+    } else {
+      socket = net.createConnection(connectOpts)
+    }
+
+    socket.on('data', handleData)
+    socket.on('error', (err: Error) => { cleanup(); reject(err) })
+  })
+}
+
+async function executeEmail(args: Record<string, unknown>): Promise<string> {
+  const normalized = normalizeToolInputArgs(args)
+  const action = String(normalized.action || 'send')
+
+  if (action === 'send') {
+    const to = normalized.to
+    const recipients: string[] = Array.isArray(to) ? to.map(String) : typeof to === 'string' ? to.split(/[,;\s]+/).filter(Boolean) : []
+    if (recipients.length === 0) return 'Error: "to" (recipient email addresses) is required.'
+
+    const subject = String(normalized.subject || '').trim()
+    if (!subject) return 'Error: "subject" is required.'
+
+    const body = String(normalized.body || '').trim()
+    if (!body) return 'Error: "body" (plain text content) is required.'
+
+    const html = typeof normalized.html === 'string' ? normalized.html : undefined
+
+    const cfg = getSmtpConfig()
+    if (!cfg.host) return 'Error: SMTP host not configured. Ask the user to configure email in Plugin Settings > Email.'
+    if (!cfg.fromAddress) return 'Error: From address not configured in email plugin settings.'
+
+    try {
+      const result = await sendSmtpEmail(cfg, recipients, subject, body, html)
+      return `${result}\nTo: ${recipients.join(', ')}\nSubject: ${subject}`
+    } catch (err: unknown) {
+      return `Error sending email: ${err instanceof Error ? err.message : String(err)}`
+    }
+  }
+
+  if (action === 'status') {
+    const cfg = getSmtpConfig()
+    if (!cfg.host) return 'Email plugin not configured. No SMTP host set.'
+    return JSON.stringify({
+      configured: true,
+      host: cfg.host,
+      port: cfg.port,
+      secure: cfg.secure,
+      from: cfg.fromAddress,
+      fromName: cfg.fromName,
+    })
+  }
+
+  return `Error: Unknown action "${action}". Use "send" or "status".`
+}
+
+const EmailPlugin: Plugin = {
+  name: 'Email',
+  enabledByDefault: false,
+  description: 'Send emails via SMTP. Supports plain text and HTML, multiple recipients.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can send emails using `email`. Supports plain text and HTML bodies, multiple recipients.',
+  } as PluginHooks,
+  tools: [
+    {
+      name: 'email',
+      description: 'Send an email or check email configuration status. For sending: provide to, subject, and body. Optionally include html for rich formatting.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['send', 'status'], description: 'Action to perform (default: send)' },
+          to: {
+            anyOf: [
+              { type: 'string', description: 'Recipient email address(es), comma-separated' },
+              { type: 'array', items: { type: 'string' }, description: 'Array of recipient email addresses' },
+            ],
+          },
+          subject: { type: 'string', description: 'Email subject line' },
+          body: { type: 'string', description: 'Plain text email body' },
+          html: { type: 'string', description: 'Optional HTML email body (sent as multipart/alternative alongside plain text)' },
+        },
+        required: ['action'],
+      },
+      execute: async (args) => executeEmail(args),
+    },
+  ],
+  ui: {
+    settingsFields: [
+      {
+        key: 'host',
+        label: 'SMTP Host',
+        type: 'text',
+        required: true,
+        placeholder: 'smtp.gmail.com',
+        help: 'SMTP server hostname.',
+      },
+      {
+        key: 'port',
+        label: 'SMTP Port',
+        type: 'number',
+        defaultValue: 587,
+        help: '587 for STARTTLS, 465 for SSL, 25 for unencrypted.',
+      },
+      {
+        key: 'secure',
+        label: 'Use SSL/TLS (port 465)',
+        type: 'boolean',
+        defaultValue: false,
+        help: 'Enable for direct TLS connections (port 465). Leave off for STARTTLS (port 587).',
+      },
+      {
+        key: 'username',
+        label: 'Username',
+        type: 'text',
+        placeholder: 'you@gmail.com',
+        help: 'SMTP authentication username (usually your email address).',
+      },
+      {
+        key: 'password',
+        label: 'Password',
+        type: 'secret',
+        required: true,
+        placeholder: 'App password or SMTP password',
+        help: 'SMTP password. For Gmail, use an App Password.',
+      },
+      {
+        key: 'fromAddress',
+        label: 'From Address',
+        type: 'text',
+        required: true,
+        placeholder: 'agent@example.com',
+        help: 'The sender email address.',
+      },
+      {
+        key: 'fromName',
+        label: 'From Name',
+        type: 'text',
+        defaultValue: 'SwarmClaw Agent',
+        placeholder: 'SwarmClaw Agent',
+        help: 'Display name shown to recipients.',
+      },
+    ],
+  },
+}
+
+getPluginManager().registerBuiltin('email', EmailPlugin)
+
+export function buildEmailTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasPlugin('email')) return []
+
+  return [
+    tool(
+      async (args) => executeEmail(args),
+      {
+        name: 'email',
+        description: EmailPlugin.tools![0].description,
+        schema: z.object({
+          action: z.enum(['send', 'status']).optional().describe('Action (default: send)'),
+          to: z.union([z.string(), z.array(z.string())]).optional().describe('Recipient email address(es)'),
+          subject: z.string().optional().describe('Email subject line'),
+          body: z.string().optional().describe('Plain text email body'),
+          html: z.string().optional().describe('Optional HTML body'),
+        }),
+      },
+    ),
+  ]
+}

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

@@ -144,6 +144,7 @@ export function normalizeSendFilePaths(args: Record<string, unknown>): string[]
   const candidates: string[] = []
   collectSendFilePaths(args.filePath, candidates)
   collectSendFilePaths(args.path, candidates)
+  collectSendFilePaths(args.file, candidates)
   collectSendFilePaths(args.files, candidates)
 
   const nestedInput = args.input
@@ -202,7 +203,9 @@ async function executeSendFile(args: Record<string, unknown>, bctx: { cwd: strin
 const FilePlugin: Plugin = {
   name: 'Core Files',
   description: 'Complete file management: read, write, list, move, copy, delete, and send.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can read, write, copy, move, and send files (`read_file`, `write_file`, `list_files`, `copy_file`, `move_file`, `send_file`). Deleting files is destructive, so that may need explicit permission.',
+  } as PluginHooks,
   tools: [
     {
       name: 'files',
@@ -265,7 +268,7 @@ getPluginManager().registerBuiltin('files', FilePlugin)
  * Legacy Bridge
  */
 export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('files')) return []
+  if (!bctx.hasPlugin('files')) return []
 
   return [
     tool(

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

@@ -97,7 +97,7 @@ getPluginManager().registerBuiltin('git', GitPlugin)
  * Legacy Bridge
  */
 export function buildGitTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('git')) return []
+  if (!bctx.hasPlugin('git')) return []
   return [
     tool(
       async (args) => executeGitAction(args, { cwd: bctx.cwd }),

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

@@ -97,7 +97,7 @@ getPluginManager().registerBuiltin('http', HttpPlugin)
  * Legacy Bridge
  */
 export function buildHttpTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('http_request')) return []
+  if (!bctx.hasPlugin('http_request')) return []
 
   return [
     tool(