@swarmclawai/swarmclaw 0.8.4 → 0.8.7

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

@@ -12,6 +12,7 @@ import {
 import type { ToolBuildContext } from './context'
 import { safePath } from './context'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { dedup, errorMessage } from '@/lib/shared-utils'
 
 interface TableCondition {
   column: string
@@ -278,14 +279,14 @@ function groupTable(table: StructuredTable, by: string[], metrics: GroupMetric[]
           next[name] = numeric.length ? Math.max(...numeric) : null
           break
         case 'values':
-          next[name] = Array.from(new Set(values.map((value) => scalarToString(value)).filter(Boolean)))
+          next[name] = dedup(values.map((value) => scalarToString(value)).filter(Boolean))
           break
       }
     }
     return next
   })
 
-  const headers = Array.from(new Set([...by, ...metrics.map((metric) => metric.as || (metric.column ? `${metric.op}_${metric.column}` : metric.op))]))
+  const headers = dedup([...by, ...metrics.map((metric) => metric.as || (metric.column ? `${metric.op}_${metric.column}` : metric.op))])
   return {
     name: `${table.name || 'table'}_grouped`,
     headers,
@@ -342,7 +343,7 @@ function joinTables(
 
   return {
     name: `${left.name || 'left'}_joined_${right.name || 'right'}`,
-    headers: Array.from(new Set([...left.headers, ...rightHeaders])),
+    headers: dedup([...left.headers, ...rightHeaders]),
     rows,
     rowCount: rows.length,
   }
@@ -355,7 +356,7 @@ function pivotTable(
   valueField: string,
   aggregate: 'count' | 'sum' | 'first',
 ): StructuredTable {
-  const columnValues = Array.from(new Set(table.rows.map((row) => scalarToString(row[columnField])).filter(Boolean)))
+  const columnValues = dedup(table.rows.map((row) => scalarToString(row[columnField])).filter(Boolean))
   const grouped = new Map<string, Record<string, unknown>[]>()
   for (const row of table.rows) {
     const key = JSON.stringify(indexColumns.map((column) => row[column] ?? null))
@@ -506,7 +507,7 @@ async function executeTableAction(args: Record<string, unknown>, bctx: { cwd: st
     const persisted = await maybePersistOutput(normalized, bctx.cwd, table)
     return JSON.stringify({ action, ...previewTable(table), output: persisted })
   } catch (err: unknown) {
-    return `Error: ${err instanceof Error ? err.message : String(err)}`
+    return `Error: ${errorMessage(err)}`
   }
 }
 

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

@@ -122,7 +122,7 @@ describe('wallet tool generic execution', () => {
     assert.equal(result.action, 'sign_message')
 
     const approvals = storage.loadApprovals()
-    const pending = Object.values(approvals).find((approval) => approval.category === 'wallet_action')
+    const pending: any = Object.values(approvals).find((approval: any) => approval.category === 'wallet_action')
     assert.ok(pending)
     assert.equal(pending?.status, 'pending')
   })
@@ -147,7 +147,7 @@ describe('wallet tool generic execution', () => {
     assert.equal(approvalRequest.type, 'plugin_wallet_action_request')
 
     const approvals = storage.loadApprovals()
-    const pending = approvalRequest.approvalId ? approvals[approvalRequest.approvalId] : undefined
+    const pending: any = approvalRequest.approvalId ? approvals[approvalRequest.approvalId] : undefined
     assert.ok(pending)
     storage.upsertApproval(pending!.id, {
       ...pending,
@@ -243,7 +243,7 @@ describe('wallet tool generic execution', () => {
     assert.equal(approvalRequest.action, 'swap')
 
     const approvals = storage.loadApprovals()
-    const pending = approvalRequest.approvalId ? approvals[approvalRequest.approvalId] : undefined
+    const pending: any = approvalRequest.approvalId ? approvals[approvalRequest.approvalId] : undefined
     assert.ok(pending)
     assert.equal(pending?.status, 'pending')
     assert.equal(String(pending?.data.amountAtomic), '1000000')

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

@@ -49,6 +49,7 @@ import {
   getWalletsByAgentId,
   isValidWalletAddress,
 } from '../wallet-service'
+import { errorMessage } from '@/lib/shared-utils'
 
 const WALLET_TOOL_ACTIONS = [
   'setup',
@@ -81,7 +82,7 @@ function parseJsonValue<T>(value: unknown, label: string): T | undefined {
     try {
       return JSON.parse(trimmed) as T
     } catch (err: unknown) {
-      throw new Error(`${label} must be valid JSON: ${err instanceof Error ? err.message : String(err)}`)
+      throw new Error(`${label} must be valid JSON: ${errorMessage(err)}`)
     }
   }
   return value as T
@@ -423,7 +424,7 @@ async function executeWalletAction(args: unknown, context: { agentId?: string |
   try {
     requestedChain = getWalletChainOrDefault(normalized.chain ?? normalized.provider, 'solana')
   } catch (err: unknown) {
-    return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+    return JSON.stringify({ error: errorMessage(err) })
   }
 
   const wallets = getWalletsByAgentId(agentId)
@@ -446,7 +447,7 @@ async function executeWalletAction(args: unknown, context: { agentId?: string |
           ],
         })
       } catch (err: unknown) {
-        return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+        return JSON.stringify({ error: errorMessage(err) })
       }
     }
 
@@ -476,7 +477,7 @@ async function executeWalletAction(args: unknown, context: { agentId?: string |
         ],
       })
     } catch (err: unknown) {
-      return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+      return JSON.stringify({ error: errorMessage(err) })
     }
   }
 
@@ -548,7 +549,7 @@ async function executeWalletAction(args: unknown, context: { agentId?: string |
           if (BigInt(amountAtomic) <= BigInt(0)) return JSON.stringify({ error: 'amount must be positive' })
           formattedAmount = formatWalletAmount(wallet.chain, amountAtomic, { minFractionDigits: 4, maxFractionDigits: 6 })
         } catch (err: unknown) {
-          return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+          return JSON.stringify({ error: errorMessage(err) })
         }
 
         const perTxLimitAtomic = getWalletLimitAtomic(wallet, 'perTx')
@@ -1167,7 +1168,7 @@ async function executeWalletAction(args: unknown, context: { agentId?: string |
         return JSON.stringify({ error: `Unknown action: ${action}` })
     }
   } catch (err: unknown) {
-    return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+    return JSON.stringify({ error: errorMessage(err) })
   }
 }
 

package/src/lib/server/session-tools/web-browser-config.test.ts

@@ -25,6 +25,7 @@ describe('browser tool connection config', () => {
 
   it('strips host Playwright MCP env overrides before applying the local browser config', () => {
     const env = sanitizePlaywrightMcpEnv({
+      NODE_ENV: 'test',
       PLAYWRIGHT_MCP_CONFIG: '/tmp/evil-config.json',
       PLAYWRIGHT_MCP_SHARED_BROWSER_CONTEXT: '1',
       PLAYWRIGHT_MCP_TIMEOUT_ACTION: '999999',

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

@@ -0,0 +1,317 @@
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath, pathToFileURL } from 'url'
+import { UPLOAD_DIR } from '../storage'
+import { safePath, truncate, MAX_OUTPUT } from './context'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+import type { SearchResult } from './search-providers'
+
+function cleanSearchField(value: string | undefined): string {
+  return (value || '').replace(/\s+/g, ' ').trim()
+}
+
+export function formatWebSearchResults(query: string, results: SearchResult[], maxChars = MAX_OUTPUT): string {
+  const cleanedQuery = cleanSearchField(query)
+  const header = cleanedQuery ? `Search results for: ${cleanedQuery}` : 'Search results'
+  const sections: string[] = [header]
+  const joinSections = (items: string[]) => items.filter(Boolean).join('\n\n')
+
+  for (let index = 0; index < results.length; index++) {
+    const result = results[index]
+    const title = cleanSearchField(result?.title) || cleanSearchField(result?.url) || `Result ${index + 1}`
+    const url = cleanSearchField(result?.url)
+    const snippet = cleanSearchField(result?.snippet)
+    const lines = [`${index + 1}. ${title}`]
+    if (url) lines.push(`URL: ${url}`)
+    if (snippet) lines.push(`Snippet: ${snippet}`)
+    const candidate = joinSections([...sections, lines.join('\n')])
+    if (candidate.length <= maxChars) {
+      sections.push(lines.join('\n'))
+      continue
+    }
+
+    if (url) {
+      const minimalLines = [`${index + 1}. ${title}`, `URL: ${url}`]
+      const minimalCandidate = joinSections([...sections, minimalLines.join('\n')])
+      if (minimalCandidate.length <= maxChars) {
+        sections.push(minimalLines.join('\n'))
+      }
+    }
+
+    const omitted = results.length - index
+    if (omitted > 0) {
+      const remainingNotice = `(${omitted} additional result${omitted === 1 ? '' : 's'} omitted for brevity)`
+      const withNotice = joinSections([...sections, remainingNotice])
+      if (withNotice.length <= maxChars) sections.push(remainingNotice)
+    }
+    return truncate(joinSections(sections), maxChars)
+  }
+
+  return truncate(joinSections(sections), maxChars)
+}
+
+export function buildBrowserConnectionOptions(profileDir: string) {
+  return {
+    browser: {
+      userDataDir: profileDir,
+      launchOptions: { headless: true },
+      contextOptions: {
+        viewport: { width: 1440, height: 900 },
+      },
+    },
+    imageResponses: 'allow' as const,
+    capabilities: ['core', 'pdf', 'vision', 'network', 'storage'],
+    sharedBrowserContext: false,
+    timeouts: {
+      action: 15_000,
+      navigation: 60_000,
+    },
+  }
+}
+
+export function buildBrowserStdioServerParams(profileDir: string) {
+  const cliCandidates = [
+    path.join(process.cwd(), 'node_modules', '@playwright', 'mcp', 'cli.js'),
+    path.join(process.cwd(), '[project]', 'node_modules', '@playwright', 'mcp', 'cli.js'),
+  ]
+  const cliPath = cliCandidates.find((candidate) => fs.existsSync(candidate)) || cliCandidates[0]
+  const outputDir = path.join(profileDir, 'mcp-output')
+  const env = sanitizePlaywrightMcpEnv()
+  return {
+    command: process.execPath,
+    args: [
+      cliPath,
+      '--headless',
+      '--user-data-dir', profileDir,
+      '--output-dir', outputDir,
+      '--caps', 'vision,pdf',
+      '--image-responses', 'allow',
+      '--output-mode', 'file',
+      '--timeout-action', '15000',
+      '--timeout-navigation', '60000',
+    ],
+    env: {
+      ...env,
+      PLAYWRIGHT_MCP_USER_DATA_DIR: profileDir,
+      PLAYWRIGHT_MCP_HEADLESS: '1',
+      PLAYWRIGHT_MCP_IMAGE_RESPONSES: 'allow',
+      PLAYWRIGHT_MCP_OUTPUT_DIR: outputDir,
+      PLAYWRIGHT_MCP_OUTPUT_MODE: 'file',
+      PLAYWRIGHT_MCP_TIMEOUT_ACTION: '15000',
+      PLAYWRIGHT_MCP_TIMEOUT_NAVIGATION: '60000',
+    },
+    stderr: 'inherit' as const,
+  }
+}
+
+export function sanitizePlaywrightMcpEnv(baseEnv: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...baseEnv }
+  for (const key of Object.keys(env)) {
+    if (!key.toUpperCase().startsWith('PLAYWRIGHT_MCP_')) continue
+    delete env[key]
+  }
+  return env
+}
+
+export function inferWebActionFromArgs(params: {
+  action?: string
+  query?: string
+  url?: string
+}): 'search' | 'fetch' | undefined {
+  if (params.action === 'search' || params.action === 'fetch') return params.action
+  if (typeof params.url === 'string' && /^https?:\/\//i.test(params.url.trim())) return 'fetch'
+  if (typeof params.query === 'string' && params.query.trim()) return 'search'
+  if (typeof params.url === 'string' && params.url.trim()) return 'search'
+  return undefined
+}
+
+function parseStructuredJsonValue(value: unknown): unknown {
+  if (typeof value !== 'string') return value
+  const trimmed = value.trim()
+  if (!trimmed || (!trimmed.startsWith('{') && !trimmed.startsWith('['))) return value
+  try {
+    return JSON.parse(trimmed)
+  } catch {
+    return value
+  }
+}
+
+function parseJsonObjectValue(value: unknown): Record<string, unknown> | null {
+  const parsed = parseStructuredJsonValue(value)
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+    ? parsed as Record<string, unknown>
+    : null
+}
+
+export function parseJsonArrayValue(value: unknown): unknown[] | null {
+  const parsed = parseStructuredJsonValue(value)
+  return Array.isArray(parsed) ? parsed : null
+}
+
+export function pickNonEmptyBrowserString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value !== 'string') continue
+    const trimmed = value.trim()
+    if (trimmed) return trimmed
+  }
+  return undefined
+}
+
+function wrapBrowserEvaluateFunction(code: string): string {
+  const trimmed = code.trim()
+  if (!trimmed) return trimmed
+  if (/^(?:async\s+)?function\b/.test(trimmed)) return trimmed
+  if (/^(?:async\s*)?\([^)]*\)\s*=>/.test(trimmed)) return trimmed
+  return /[;{}]/.test(trimmed)
+    ? `() => { ${trimmed} }`
+    : `() => (${trimmed})`
+}
+
+function wrapBrowserRunCodeFunction(code: string): string {
+  const trimmed = code.trim()
+  if (!trimmed) return trimmed
+  if (/^(?:async\s+)?function\b/.test(trimmed)) return trimmed
+  if (/^(?:async\s*)?\([^)]*\)\s*=>/.test(trimmed)) return trimmed
+  return /[;{}]/.test(trimmed)
+    ? `async (page) => { ${trimmed} }`
+    : `async (page) => (${trimmed})`
+}
+
+export function normalizeBrowserActionParams(rawParams: Record<string, unknown>): Record<string, unknown> {
+  const normalized = normalizeToolInputArgs(rawParams)
+  const action = String(normalized.action || '').trim().toLowerCase()
+  const params: Record<string, unknown> = { ...normalized }
+
+  const parsedFields = parseJsonArrayValue(params.fields)
+  if (parsedFields) params.fields = parsedFields
+
+  const parsedForm = parseJsonObjectValue(params.form)
+  if (parsedForm) params.form = parsedForm
+
+  if (typeof params.selector === 'string' && !pickNonEmptyBrowserString(params.element)) {
+    params.element = params.selector
+  }
+
+  if (action === 'submit_form' && typeof params.selector === 'string' && !pickNonEmptyBrowserString(params.submitElement)) {
+    params.submitElement = params.selector
+  }
+
+  if (action === 'select') {
+    const parsedValues = parseJsonArrayValue(params.values ?? params.option ?? params.value)
+    if (parsedValues) params.values = parsedValues
+    else if (params.values === undefined) {
+      const scalar = pickNonEmptyBrowserString(params.option, params.value, params.text)
+      if (scalar) params.values = [scalar]
+    }
+  }
+
+  if (action === 'evaluate' && !pickNonEmptyBrowserString(params.function)) {
+    const code = pickNonEmptyBrowserString(params.code, params.script, params.javascript, params.js)
+    if (code) params.function = wrapBrowserEvaluateFunction(code)
+  }
+
+  if (action === 'run_code') {
+    const code = pickNonEmptyBrowserString(params.code, params.function, params.script, params.javascript, params.js)
+    if (code) params.code = wrapBrowserRunCodeFunction(code)
+  }
+
+  return params
+}
+
+export function pickBrowserTargetFromParams(params: Record<string, unknown>): string | null {
+  for (const value of [
+    params.url,
+    params.filePath,
+    params.path,
+    params.href,
+    params.link,
+    params.target,
+    params.page,
+  ]) {
+    if (typeof value !== 'string') continue
+    const trimmed = value.trim()
+    if (trimmed) return trimmed
+  }
+  return null
+}
+
+function resolveUploadFilePath(target: string): string | null {
+  const normalized = target.replace(/^sandbox:/, '')
+  const match = normalized.match(/^\/api\/uploads\/([^?#]+)/)
+  if (!match) return null
+  let decoded = match[1]
+  try {
+    decoded = decodeURIComponent(decoded)
+  } catch {
+    // keep raw segment
+  }
+  const safeName = decoded.replace(/[^a-zA-Z0-9._-]/g, '')
+  const resolved = path.join(UPLOAD_DIR, safeName)
+  return fs.existsSync(resolved) ? resolved : null
+}
+
+function resolveBrowserFileUrlPath(target: string): string | null {
+  if (!/^file:/i.test(target)) return null
+  try {
+    const resolved = fileURLToPath(target)
+    return fs.existsSync(resolved) ? resolved : null
+  } catch {
+    return null
+  }
+}
+
+function tryResolveBrowserLocalPath(cwd: string, target: string): string | null {
+  const uploadPath = resolveUploadFilePath(target)
+  if (uploadPath) return uploadPath
+
+  const fileUrlPath = resolveBrowserFileUrlPath(target)
+  if (fileUrlPath) return fileUrlPath
+
+  if (/^(?:https?:|about:|data:)/i.test(target)) return null
+
+  const normalized = target.replace(/^sandbox:/, '')
+  const looksLikePath = normalized.startsWith('/')
+    || normalized.startsWith('./')
+    || normalized.startsWith('../')
+    || normalized.includes('/')
+    || /\.(?:html?|xhtml|txt|md|json|ya?ml|csv|ts|tsx|js|jsx|mjs|cjs|css|png|jpe?g|gif|webp|svg|pdf)$/i.test(normalized)
+  if (!looksLikePath) return null
+
+  const candidates = new Set<string>()
+  if (path.isAbsolute(normalized)) candidates.add(normalized)
+  try { candidates.add(safePath(cwd, normalized)) } catch { /* ignore */ }
+  try { candidates.add(path.resolve(cwd, normalized)) } catch { /* ignore */ }
+
+  for (const candidate of candidates) {
+    if (!candidate || !fs.existsSync(candidate)) continue
+    const stat = fs.statSync(candidate)
+    if (stat.isDirectory()) {
+      const indexPath = path.join(candidate, 'index.html')
+      if (fs.existsSync(indexPath)) return indexPath
+      return null
+    }
+    return candidate
+  }
+  return null
+}
+
+function localHtmlFileToDataUrl(filePath: string): string | null {
+  const ext = path.extname(filePath).toLowerCase()
+  if (ext !== '.html' && ext !== '.htm') return null
+  try {
+    const html = fs.readFileSync(filePath, 'utf8')
+    const hasRelativeAssetReferences = /<(?:script|img|source|video|audio)\b[^>]+\b(?:src|poster)\s*=\s*["'](?![a-z]+:|\/\/|#|\/)([^"']+)["']|<link\b[^>]+\bhref\s*=\s*["'](?![a-z]+:|\/\/|#|\/)([^"']+)["']/i.test(html)
+    if (hasRelativeAssetReferences) return null
+    return `data:text/html;charset=utf-8,${encodeURIComponent(html)}`
+  } catch {
+    return null
+  }
+}
+
+export function resolveBrowserNavigationTarget(cwd: string, target: string): string {
+  const trimmed = target.trim()
+  if (!trimmed) return trimmed
+  const localPath = tryResolveBrowserLocalPath(cwd, trimmed)
+  if (localPath) return localHtmlFileToDataUrl(localPath) || pathToFileURL(localPath).toString()
+  return trimmed.replace(/^sandbox:/, '')
+}