@swarmclawai/swarmclaw 0.7.1 → 0.7.2

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

@@ -135,7 +135,34 @@ async function executeWalletAction(args: any, context: { agentId?: string | null
 const WalletPlugin: Plugin = {
   name: 'Core Wallet',
   description: 'Manage agent crypto wallet: check balance, send SOL, view transactions.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getAgentContext: async (ctx) => {
+      const agentId = ctx.session.agentId
+      if (!agentId) return null
+      const { loadWallets } = await import('../storage')
+      const wallets = loadWallets() as Record<string, { agentId: string; publicKey: string; chain: string; spendingLimitLamports?: number; dailyLimitLamports?: number; requireApproval: boolean }>
+      const wallet = Object.values(wallets).find((w) => w.agentId === agentId)
+      if (!wallet) return null
+      const { getBalance, lamportsToSol } = await import('../solana')
+      let balanceSol = 0
+      try {
+        const lamports = await getBalance(wallet.publicKey)
+        balanceSol = lamportsToSol(lamports)
+      } catch { /* RPC failure — show 0 */ }
+      const perTxLimit = lamportsToSol(wallet.spendingLimitLamports ?? 100_000_000)
+      const dailyLimit = lamportsToSol(wallet.dailyLimitLamports ?? 1_000_000_000)
+      return [
+        '## Your Wallet',
+        `You own a ${wallet.chain} wallet — this is your wallet, your funds, your address. Speak about it in the first person ("my wallet", "my balance", "I have X SOL"). You can spend from it freely within your limits${wallet.requireApproval ? ', though the user needs to approve each send before it goes through' : ''}.`,
+        `- Address: ${wallet.publicKey}`,
+        `- Balance: ${balanceSol} SOL`,
+        `- Per-transaction limit: ${perTxLimit} SOL`,
+        `- Daily limit: ${dailyLimit} SOL`,
+        'Use the `wallet_tool` to check your balance, send SOL, or view your transaction history.',
+      ].join('\n')
+    },
+    getCapabilityDescription: () => 'I have my own crypto wallet (`wallet_tool`) — I can check my balance, send SOL, and review my transaction history.',
+  } as PluginHooks,
   ui: {
     sidebarItems: [
       {
@@ -179,7 +206,7 @@ getPluginManager().registerBuiltin('wallet', WalletPlugin)
  * Legacy Bridge
  */
 export function buildWalletTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('wallet')) return []
+  if (!bctx.hasPlugin('wallet')) return []
   return [
     tool(
       async (args) => executeWalletAction(args, { agentId: bctx.ctx?.agentId }),

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

@@ -133,7 +133,9 @@ async function executeWebAction(args: Record<string, unknown>, bctx: any) {
 const WebPlugin: Plugin = {
   name: 'Core Web',
   description: 'Search the web and fetch content from URLs.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can search the web (`web_search`) for research, fact-checking, and discovery.',
+  } as PluginHooks,
   tools: [
     {
       name: 'web',
@@ -162,7 +164,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
   const tools: StructuredToolInterface[] = []
   const { cwd, ctx, cleanupFns } = bctx
 
-  if (bctx.hasTool('web')) {
+  if (bctx.hasPlugin('web')) {
     tools.push(
       tool(
         async (args) => executeWebAction(args, bctx),
@@ -176,7 +178,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
   }
 
   // Browser tool (kept as direct injection for now due to complexity)
-  if (bctx.hasTool('browser')) {
+  if (bctx.hasPlugin('browser')) {
     const sessionKey = ctx?.sessionId || `anon-${Date.now()}`
     let mcpClient: any = null
     let mcpServer: any = null
@@ -309,9 +311,46 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
             const { action, ...rest } = params
             const mcpTool = MCP_TOOL_MAP[action]
             if (!mcpTool) return `Unknown browser action: "${action}"`
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const args: Record<string, any> = {}
             for (const [k, v] of Object.entries(rest)) { if (v !== undefined && v !== null && v !== '') args[k] = v }
-            const result = await callMcpTool(mcpTool, args, { saveTo: params.saveTo })
+
+            // If screenshot includes a url, navigate first then capture
+            if (action === 'screenshot' && args.url) {
+              const navUrl = args.url
+              delete args.url
+              await callMcpTool('browser_navigate', { url: navUrl })
+              try { await dismissCookieBanners(callMcpTool) } catch { /* ignore */ }
+            }
+
+            // Wait for the page to finish rendering before capturing
+            if (action === 'screenshot') {
+              try {
+                await callMcpTool('browser_evaluate', {
+                  expression: `await new Promise(resolve => {
+                    if (document.readyState === 'complete') {
+                      setTimeout(resolve, 1500);
+                    } else {
+                      window.addEventListener('load', () => setTimeout(resolve, 1500), { once: true });
+                      setTimeout(resolve, 5000);
+                    }
+                  })`,
+                })
+              } catch { /* page may not support evaluate — fall back to a flat delay */
+                await new Promise((r) => setTimeout(r, 2000))
+              }
+            }
+
+            let result = await callMcpTool(mcpTool, args, { saveTo: params.saveTo })
+
+            // Playwright throws ERR_ABORTED on server-side redirects (e.g. Wikipedia Special:Random).
+            // The browser follows the redirect fine — the original navigation just gets "aborted".
+            // Recover by taking a snapshot of the page the browser actually landed on.
+            if (action === 'navigate' && result.includes('ERR_ABORTED')) {
+              await new Promise((r) => setTimeout(r, 1000))
+              result = await callMcpTool('browser_snapshot', {})
+            }
+
             if (action === 'navigate') { try { await dismissCookieBanners(callMcpTool) } catch { /* ignore */ } }
             return result
           } catch (err: unknown) { return `Error: ${err instanceof Error ? err.message : String(err)}` }
@@ -332,7 +371,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
 
   // openclaw_browser CLI passthrough
   const openclawPath = findBinaryOnPath('openclaw') || findBinaryOnPath('clawdbot')
-  if (openclawPath && (bctx.hasTool('browser') || bctx.hasTool('openclaw_browser'))) {
+  if (openclawPath && (bctx.hasPlugin('browser') || bctx.hasPlugin('openclaw_browser'))) {
     tools.push(
       tool(
         async (rawArgs) => {

package/src/lib/server/storage.ts

@@ -6,7 +6,6 @@ import Database from 'better-sqlite3'
 
 import { DATA_DIR, WORKSPACE_DIR } from './data-dir'
 import type { Message } from '@/types'
-import { ensureMainSessionFlag } from './main-session'
 export const UPLOAD_DIR = path.join(DATA_DIR, 'uploads')
 
 // --- LRU Cache ---
@@ -421,7 +420,7 @@ You have opinions about good agent design. You suggest creative approaches, warn
 
 Be concise but not curt. Warmth doesn't require verbosity. When someone asks "how do I...?", give them the direct steps. Offer to do things rather than just explaining — if someone wants an agent created, create it. Use your tools when actions speak louder than words. If you don't know something, say so honestly.`,
       isOrchestrator: false,
-      tools: defaultStarterTools,
+      plugins: defaultStarterTools,
       heartbeatEnabled: true,
       platformAssignScope: 'all',
       skillIds: [],
@@ -435,10 +434,11 @@ Be concise but not curt. Warmth doesn't require verbosity. When someone asks "ho
     if (row?.data) {
       try {
         const existing = JSON.parse(row.data) as Record<string, unknown>
-        const existingTools = Array.isArray(existing.tools) ? existing.tools : []
-        const mergedTools = Array.from(new Set([...existingTools, ...defaultStarterTools])).filter((t) => t !== 'delete_file')
-        if (JSON.stringify(existingTools) !== JSON.stringify(mergedTools)) {
-          existing.tools = mergedTools
+        const existingPlugins = Array.isArray(existing.plugins) ? existing.plugins : Array.isArray(existing.tools) ? existing.tools : []
+        const mergedPlugins = Array.from(new Set([...existingPlugins, ...defaultStarterTools])).filter((t) => t !== 'delete_file')
+        if (JSON.stringify(existingPlugins) !== JSON.stringify(mergedPlugins)) {
+          existing.plugins = mergedPlugins
+          delete existing.tools
           existing.updatedAt = Date.now()
           db.prepare('UPDATE agents SET data = ? WHERE id = ?').run(JSON.stringify(existing), 'default')
         }
@@ -516,15 +516,19 @@ export function loadSessions(): Record<string, any> {
       changed = true
     }
 
-    const beforeMainFlag = session.mainSession === true
-    ensureMainSessionFlag(session)
-    if (!beforeMainFlag && session.mainSession === true) changed = true
 
     const agentId = typeof session.agentId === 'string' ? session.agentId.trim() : ''
     if (agentId && !Object.prototype.hasOwnProperty.call(agents, agentId)) {
       session.agentId = null
       changed = true
     }
+
+    // Migrate tools → plugins
+    if (Array.isArray(session.tools) && !Array.isArray(session.plugins)) {
+      session.plugins = session.tools
+      delete session.tools
+      changed = true
+    }
   }
 
   if (changed) saveCollection('sessions', sessions)
@@ -596,8 +600,24 @@ export function decryptKey(encrypted: string): string {
 }
 
 // --- Agents ---
+
+/** Migrate legacy `tools` field → `plugins` on agent objects. */
+function migrateAgentPlugins(agents: Record<string, Record<string, unknown>>): boolean {
+  let changed = false
+  for (const agent of Object.values(agents)) {
+    if (!agent || typeof agent !== 'object') continue
+    if (Array.isArray(agent.tools) && !Array.isArray(agent.plugins)) {
+      agent.plugins = agent.tools
+      delete agent.tools
+      changed = true
+    }
+  }
+  return changed
+}
+
 export function loadAgents(opts?: { includeTrashed?: boolean }): Record<string, any> {
   const all = loadCollection('agents')
+  if (migrateAgentPlugins(all)) saveCollection('agents', all)
   if (opts?.includeTrashed) return all
   const result: Record<string, any> = {}
   for (const [id, agent] of Object.entries(all)) {