@swarmclawai/swarmclaw 0.8.4 → 0.8.7

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

@@ -2,18 +2,19 @@ import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import fs from 'fs'
 import path from 'path'
-import { fileURLToPath, pathToFileURL } from 'url'
 import * as cheerio from 'cheerio'
 import { UPLOAD_DIR } from '../storage'
 import type { ToolBuildContext } from './context'
 import { spawnSync } from 'child_process'
 import { safePath, truncate, MAX_OUTPUT, findBinaryOnPath } from './context'
-import { getSearchProvider, type SearchResult } from './search-providers'
+import { getSearchProvider } from './search-providers'
 import { dedupeScreenshotMarkdownLines } from './web-output'
 import { withRetry } from '../tool-retry'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { dedup, errorMessage, hmrSingleton, sleep } from '@/lib/shared-utils'
+import { resolvePathWithinBaseDir } from '../path-utils'
 import {
   ensureSessionBrowserProfileId,
   getBrowserProfileDir,
@@ -23,49 +24,27 @@ import {
   removeBrowserSessionRecord,
   upsertBrowserSessionRecord,
 } from '../browser-state'
-
-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)
+import {
+  buildBrowserConnectionOptions,
+  buildBrowserStdioServerParams,
+  formatWebSearchResults,
+  inferWebActionFromArgs,
+  normalizeBrowserActionParams,
+  parseJsonArrayValue,
+  pickBrowserTargetFromParams,
+  pickNonEmptyBrowserString,
+  resolveBrowserNavigationTarget,
+  sanitizePlaywrightMcpEnv,
+} from './web-utils'
+
+export {
+  buildBrowserConnectionOptions,
+  buildBrowserStdioServerParams,
+  formatWebSearchResults,
+  inferWebActionFromArgs,
+  normalizeBrowserActionParams,
+  resolveBrowserNavigationTarget,
+  sanitizePlaywrightMcpEnv,
 }
 
 type BrowserRuntimeEntry = {
@@ -77,74 +56,25 @@ type BrowserRuntimeEntry = {
   refCount: number
 }
 
-export const activeBrowsers = new Map<string, BrowserRuntimeEntry>()
-const pendingBrowserInitializations = new Map<string, Promise<BrowserRuntimeEntry>>()
-
-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'],
-    // Keep browser state isolated per session/profile. The upstream shared
-    // context mode is process-global and causes unrelated agent sessions to
-    // contend with each other.
-    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,
-  }
-}
+// Stored on globalThis to survive HMR reloads in dev mode —
+// prevents orphaned Chromium processes when web.ts is edited.
+export const activeBrowsers: Map<string, BrowserRuntimeEntry> =
+  hmrSingleton('__swarmclaw_active_browsers__', () => new Map<string, BrowserRuntimeEntry>())
+const pendingBrowserInitializations: Map<string, Promise<BrowserRuntimeEntry>> =
+  hmrSingleton('__swarmclaw_pending_browser_inits__', () => new Map<string, Promise<BrowserRuntimeEntry>>())
+
+// Kill all browsers on process exit to prevent orphaned Chromium processes
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const _shutdownRegistered = hmrSingleton('__swarmclaw_browser_shutdown_registered__', () => {
+  process.on('exit', () => {
+    for (const [, entry] of activeBrowsers) {
+      try { entry.client?.close?.() } catch { /* ignore */ }
+      try { entry.server?.close?.() } catch { /* ignore */ }
+    }
+  })
+  return true
+})
 
-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 sweepOrphanedBrowsers(maxAgeMs = 30 * 60 * 1000): number {
   const now = Date.now(); let cleaned = 0
   for (const [key, entry] of activeBrowsers) {
@@ -171,213 +101,10 @@ export function cleanupSessionBrowser(sessionId: string): void {
 export function getActiveBrowserCount(): number { return activeBrowsers.size }
 export function hasActiveBrowser(sessionId: string): boolean { return activeBrowsers.has(sessionId) }
 
-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
-}
-
-function parseJsonArrayValue(value: unknown): unknown[] | null {
-  const parsed = parseStructuredJsonValue(value)
-  return Array.isArray(parsed) ? parsed : null
-}
-
-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
-}
-
-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:/, '')
-}
-
 /**
  * Unified Web Execution Logic
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ 
 async function executeWebAction(args: Record<string, unknown>) {
   const normalized = normalizeToolInputArgs(args)
   const { query, url, maxResults } = normalized as { query?: string; url?: string; maxResults?: number }
@@ -414,7 +141,7 @@ async function executeWebAction(args: Record<string, unknown>) {
           const result = await pdfParse(Buffer.from(arrayBuffer))
           return truncate(result.text, MAX_OUTPUT)
         } catch (err: unknown) {
-          return `Error parsing PDF: ${err instanceof Error ? err.message : String(err)}`
+          return `Error parsing PDF: ${errorMessage(err)}`
         }
       }
       const html = await res.text()
@@ -426,7 +153,7 @@ async function executeWebAction(args: Record<string, unknown>) {
     }
     return `Error: Unknown action "${action}"`
   } catch (err: unknown) {
-    return `Error: ${err instanceof Error ? err.message : String(err)}`
+    return `Error: ${errorMessage(err)}`
   }
 }
 
@@ -557,7 +284,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
                 inheritedFromSessionId: profileInfo.inheritedFromSessionId,
                 status: 'error',
                 lastAction: 'browser_restore',
-                lastError: err instanceof Error ? err.message : String(err),
+                lastError: errorMessage(err),
               })
             }
           }
@@ -877,7 +604,14 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
                 const fileMatch = text.match(/\]\((\.\.\/[^\s)]+|\/[^\s)]+\.(pdf|png|jpg|jpeg|gif|webp|html|mp4|webm))\)/)
                 if (fileMatch) {
                   const rawPath = fileMatch[1]
-                  const srcPath = rawPath.startsWith('/') ? rawPath : path.resolve(process.cwd(), rawPath)
+                  let srcPath = rawPath
+                  if (!rawPath.startsWith('/')) {
+                    try {
+                      srcPath = resolvePathWithinBaseDir(cwd, rawPath)
+                    } catch {
+                      continue
+                    }
+                  }
                   if (fs.existsSync(srcPath)) {
                     const ext = path.extname(srcPath).slice(1).toLowerCase()
                     const IMAGE_EXTS = ['png', 'jpg', 'jpeg', 'gif', 'webp']
@@ -913,7 +647,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
             }
             if (isScreenshotTool) parts = dedupeScreenshotMarkdownLines(parts)
             if (savedPaths.length > 0) {
-              const unique = Array.from(new Set(savedPaths))
+              const unique = dedup(savedPaths)
               parts.push(`Saved to: ${unique.map((p) => path.relative(cwd, p) || '.').join(', ')}`)
             }
             upsertBrowserSessionRecord({
@@ -938,7 +672,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
           })
           return fallback
         } catch (err: unknown) {
-          const message = err instanceof Error ? err.message : String(err)
+          const message = errorMessage(err)
           upsertBrowserSessionRecord({
             sessionId: sessionKey,
             profileId: profileInfo.profileId,
@@ -981,7 +715,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
     }
 
     const dismissCookieBanners = async (mcpCall: (toolName: string, args: Record<string, unknown>) => Promise<string>) => {
-      await new Promise((r) => setTimeout(r, 1200))
+      await sleep(1200)
       const js = `() => {
         const docs = [document];
         const roots = [document];
@@ -1250,7 +984,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
       try {
         await callBrowserEvaluate(`async () => { await new Promise(resolve => setTimeout(resolve, ${Math.min(waitMs, 5000)})); }`)
       } catch {
-        await new Promise((resolve) => setTimeout(resolve, waitMs))
+        await sleep(waitMs)
       }
 
       return {
@@ -1654,7 +1388,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
                     }
                   }); }`)
               } catch {
-                await new Promise((r) => setTimeout(r, 1200))
+                await sleep(1200)
               }
               try { await dismissCookieBanners(callMcpTool) } catch { /* ignore */ }
             }
@@ -1669,7 +1403,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
 
             let result = await callMcpTool(mcpTool, args, { saveTo: typeof params.saveTo === 'string' ? params.saveTo : undefined })
             if (action === 'navigate' && result.includes('ERR_ABORTED')) {
-              await new Promise((r) => setTimeout(r, 1000))
+              await sleep(1000)
               result = await callMcpTool('browser_snapshot', {})
             }
             if (action === 'navigate') {
@@ -1686,7 +1420,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
 
             return result
           } catch (err: unknown) {
-            return `Error: ${err instanceof Error ? err.message : String(err)}`
+            return `Error: ${errorMessage(err)}`
           }
         },
         {
@@ -1775,7 +1509,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
             const result = runBrowserCommand(command, parsedArgs)
             if (result.status !== 0) return `Error (exit ${result.status}): ${result.stderr || result.stdout || 'unknown'}`
             return truncate(result.stdout || '(no output)', MAX_OUTPUT)
-          } catch (err: unknown) { return `Error: ${err instanceof Error ? err.message : String(err)}` }
+          } catch (err: unknown) { return `Error: ${errorMessage(err)}` }
         },
         {
           name: 'openclaw_browser',

package/src/lib/server/skill-prompt-budget.test.ts

@@ -4,7 +4,7 @@ import { budgetSkillsForPrompt, buildSkillPromptText, MAX_SKILLS_IN_PROMPT, MAX_
 import type { Skill } from '@/types'
 
 function makeSkill(id: string, overrides: Partial<Skill> = {}): Skill {
-  return {
+  return { id: "test-skill-1",
     name: id,
     filename: `${id}.md`,
     content: overrides.content ?? `Instructions for ${id} skill.`,

package/src/lib/server/skills-normalize.ts

@@ -1,5 +1,6 @@
 import path from 'path'
 import type { SkillInstallOption, SkillRequirements, SkillSecuritySummary } from '@/types'
+import { dedup } from '@/lib/shared-utils'
 
 export type SkillSourceFormat = 'openclaw' | 'plain'
 
@@ -292,7 +293,7 @@ function pickRuntimeMetadata(frontmatter: Record<string, unknown>): Record<strin
 }
 
 function uniqueStrings(values: string[]): string[] {
-  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)))
+  return dedup(values.map((value) => value.trim()).filter(Boolean))
 }
 
 function extractDetectedEnvVars(rawContent: string): string[] {