@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/lib/server/missions/mission-service.ts

@@ -1,6 +0,0 @@
-export * from './mission-service/queries'
-export * from './mission-service/recovery'
-export * from './mission-service/ticks'
-export * from './mission-service/bindings'
-export * from './mission-service/actions'
-export * from './mission-service/context'

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

@@ -1,105 +0,0 @@
-import { z } from 'zod'
-import { tool, type StructuredToolInterface } from '@langchain/core/tools'
-import { loadSessions, saveSessions } from '../storage'
-import { notify } from '../ws-hub'
-import type { ToolBuildContext } from './context'
-import type { Extension, ExtensionHooks } from '@/types'
-import { registerNativeCapability } from '../native-capabilities'
-import { normalizeToolInputArgs } from './normalize-tool-args'
-import { normalizeCanvasContent, summarizeCanvasContent } from '@/lib/canvas-content'
-import { errorMessage } from '@/lib/shared-utils'
-
-/**
- * Core Canvas Execution Logic
- */
-async function executeCanvasAction(args: Record<string, unknown>, context: { sessionId?: string }) {
-  const normalized = normalizeToolInputArgs(args)
-  const action = normalized.action as string
-  const content = normalized.content as string | undefined
-  const document = normalized.document
-  try {
-    const sessionId = context.sessionId
-    if (!sessionId) return 'Error: no active session for canvas.'
-
-    const sessions = loadSessions()
-    const session = sessions[sessionId]
-    if (!session) return 'Error: session not found.'
-
-    if (action === 'present') {
-      const nextContent = normalizeCanvasContent(document ?? content)
-      if (!nextContent) return 'Error: content or document is required for present action.'
-      ;(session as unknown as Record<string, unknown>).canvasContent = nextContent
-      session.lastActiveAt = Date.now()
-      sessions[sessionId] = session
-      saveSessions(sessions)
-      notify(`canvas:${sessionId}`)
-      return JSON.stringify({
-        ok: true,
-        action: 'present',
-        ...summarizeCanvasContent(nextContent),
-      })
-    }
-
-    if (action === 'hide') {
-      ;(session as unknown as Record<string, unknown>).canvasContent = null
-      session.lastActiveAt = Date.now()
-      sessions[sessionId] = session
-      saveSessions(sessions)
-      notify(`canvas:${sessionId}`)
-      return JSON.stringify({ ok: true, action: 'hide' })
-    }
-
-    if (action === 'snapshot') {
-      const current = normalizeCanvasContent((session as unknown as Record<string, unknown>).canvasContent)
-      return JSON.stringify({ ok: true, action: 'snapshot', ...summarizeCanvasContent(current) })
-    }
-
-    return `Unknown canvas action "${action}".`
-  } catch (err: unknown) {
-    return `Error: ${errorMessage(err)}`
-  }
-}
-
-/**
- * Register as a Built-in Extension
- */
-const CanvasExtension: Extension = {
-  name: 'Core Canvas',
-  description: 'Present live HTML/CSS/JS content to the user in an interactive canvas panel.',
-  hooks: {} as ExtensionHooks,
-  tools: [
-    {
-      name: 'canvas',
-      description: 'Interact with the live canvas panel.',
-      parameters: {
-        type: 'object',
-        properties: {
-          action: { type: 'string', enum: ['present', 'hide', 'snapshot'] },
-          content: { type: 'string' },
-          document: { type: 'object', additionalProperties: true },
-        },
-        required: ['action']
-      },
-      execute: async (args, context) => executeCanvasAction(args, { sessionId: context.session.id })
-    }
-  ]
-}
-
-registerNativeCapability('canvas', CanvasExtension)
-
-/**
- * Legacy Bridge
- */
-export function buildCanvasTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasExtension('canvas')) return []
-  return [
-    tool(
-      async (args) => executeCanvasAction(args, { sessionId: bctx.ctx?.sessionId || undefined }),
-      {
-        name: 'canvas',
-        description: CanvasExtension.tools![0].description,
-        schema: z.object({}).passthrough()
-      }
-    )
-  ]
-}

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

@@ -1,281 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { spawnSync } from 'child_process'
-import { UPLOAD_DIR } from '../storage'
-import { truncate, MAX_OUTPUT } from './context'
-import type { Session } from '@/types'
-import { normalizeToolInputArgs } from './normalize-tool-args'
-import { detectDocker } from '@/lib/server/sandbox/docker-detect'
-import {
-  ensureSessionSandbox,
-  resolveSandboxRuntimeStatus,
-  resolveSandboxWorkdir,
-  type AgentSandboxConfig,
-} from '@/lib/server/sandbox/session-runtime'
-import { buildDockerExecArgs } from '@/lib/server/runtime/process-manager'
-
-export type SandboxContext = {
-  sessionId?: string
-  cwd?: string
-  agentId?: string | null
-  config?: AgentSandboxConfig | null
-  resolveCurrentSession?: () => Session | null
-}
-
-const EXT_MAP: Record<string, string> = {
-  javascript: 'js',
-  typescript: 'ts',
-}
-
-function sandboxUnavailableError(reason: string): string {
-  return JSON.stringify({
-    error: reason,
-    guidance: [
-      'Install Docker Desktop to keep sandbox_exec inside a container.',
-      'Use http_request for straightforward API calls.',
-      'Use extension_creator plus manage_schedules for recurring automations.',
-    ],
-  })
-}
-
-function quoteShell(value: string): string {
-  return `'${value.replace(/'/g, `'\\''`)}'`
-}
-
-function createSandboxDir(baseCwd: string, sessionId: string): string {
-  const root = path.join(baseCwd, '.swarmclaw-sandbox')
-  fs.mkdirSync(root, { recursive: true })
-  return fs.mkdtempSync(path.join(root, `${sessionId}-`))
-}
-
-function collectArtifacts(params: {
-  sandboxDir: string
-  ignoredFiles: Set<string>
-}): Array<{ name: string; url: string }> {
-  const artifacts: { name: string; url: string }[] = []
-  try {
-    const files = fs.readdirSync(params.sandboxDir)
-    for (const file of files) {
-      if (params.ignoredFiles.has(file)) continue
-      const src = path.join(params.sandboxDir, file)
-      if (!fs.statSync(src).isFile()) continue
-      fs.mkdirSync(UPLOAD_DIR, { recursive: true })
-      const destName = `sandbox-${Date.now()}-${file}`
-      const dest = path.join(UPLOAD_DIR, destName)
-      fs.copyFileSync(src, dest)
-      artifacts.push({ name: file, url: `/api/uploads/${encodeURIComponent(destName)}` })
-    }
-  } catch {
-    // ignore artifact collection failures
-  }
-  return artifacts
-}
-
-function executeHostNode(params: {
-  sandboxDir: string
-  language: string
-  scriptFile: string
-  timeout: number
-}): {
-  runtime: 'host'
-  stdout: string
-  stderr: string
-  exitCode: number
-  timedOut: boolean
-} {
-  const tmpDir = path.join(params.sandboxDir, '.tmp')
-  fs.mkdirSync(tmpDir, { recursive: true })
-  const args = params.language === 'typescript'
-    ? ['--no-warnings=ExperimentalWarning', '--experimental-strip-types', params.scriptFile]
-    : [params.scriptFile]
-  const result = spawnSync(process.execPath, args, {
-    cwd: params.sandboxDir,
-    encoding: 'utf-8',
-    timeout: params.timeout,
-    maxBuffer: MAX_OUTPUT,
-    env: {
-      ...process.env,
-      HOME: params.sandboxDir,
-      TMPDIR: tmpDir,
-      WORKSPACE: params.sandboxDir,
-      SESSION_CWD: params.sandboxDir,
-      SWARMCLAW_SANDBOX_MODE: 'host',
-    },
-  })
-  return {
-    runtime: 'host',
-    stdout: truncate((result.stdout || '').toString(), MAX_OUTPUT),
-    stderr: truncate((result.stderr || '').toString(), MAX_OUTPUT),
-    exitCode: result.status ?? (result.error ? 1 : 0),
-    timedOut: !!(result.error?.message?.includes('ETIMEDOUT') || result.signal === 'SIGTERM'),
-  }
-}
-
-async function executeContainerNode(params: {
-  sandboxDir: string
-  language: string
-  scriptFile: string
-  timeout: number
-  context: SandboxContext
-}): Promise<{
-  runtime: 'container'
-  stdout: string
-  stderr: string
-  exitCode: number
-  timedOut: boolean
-}> {
-  const session = params.context.resolveCurrentSession?.() ?? null
-  const sandbox = await ensureSessionSandbox({
-    config: params.context.config,
-    session,
-    agentId: params.context.agentId ?? session?.agentId ?? null,
-    sessionId: params.context.sessionId ?? session?.id ?? null,
-    workspaceDir: params.context.cwd || process.cwd(),
-  })
-
-  if (!sandbox) {
-    throw new Error('Container sandbox is not active for this session.')
-  }
-
-  const tmpDir = path.join(params.sandboxDir, '.tmp')
-  fs.mkdirSync(tmpDir, { recursive: true })
-  const resolved = resolveSandboxWorkdir({
-    workspaceDir: sandbox.workspaceDir,
-    hostWorkdir: params.sandboxDir,
-    containerWorkdir: sandbox.containerWorkdir,
-  })
-  const containerCommand = params.language === 'typescript'
-    ? `node --no-warnings=ExperimentalWarning --experimental-strip-types ${quoteShell(params.scriptFile)}`
-    : `node ${quoteShell(params.scriptFile)}`
-  const result = spawnSync('docker', buildDockerExecArgs({
-    containerName: sandbox.containerName,
-    command: containerCommand,
-    workdir: resolved.containerWorkdir,
-    env: {
-      HOME: resolved.containerWorkdir,
-      TMPDIR: path.posix.join(resolved.containerWorkdir, '.tmp'),
-      WORKSPACE: sandbox.containerWorkdir,
-      SESSION_CWD: resolved.containerWorkdir,
-      SWARMCLAW_SANDBOX_MODE: 'container',
-    },
-  }), {
-    encoding: 'utf-8',
-    timeout: params.timeout,
-    maxBuffer: MAX_OUTPUT,
-  })
-
-  return {
-    runtime: 'container',
-    stdout: truncate((result.stdout || '').toString(), MAX_OUTPUT),
-    stderr: truncate((result.stderr || '').toString(), MAX_OUTPUT),
-    exitCode: result.status ?? (result.error ? 1 : 0),
-    timedOut: !!(result.error?.message?.includes('ETIMEDOUT') || result.signal === 'SIGTERM'),
-  }
-}
-
-export async function executeSandboxExec(args: unknown, context: SandboxContext) {
-  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
-  const language = normalized.language as string
-  const code = normalized.code as string
-  const timeoutSec = normalized.timeoutSec as number | undefined
-  const timeout = Math.min(Math.max(timeoutSec ?? 60, 5), 300) * 1000
-  const ext = EXT_MAP[language]
-  const sessionId = context.sessionId ?? 'unknown'
-  const cwd = context.cwd || process.cwd()
-
-  if (language !== 'javascript' && language !== 'typescript') {
-    return sandboxUnavailableError('sandbox_exec currently supports only JavaScript and TypeScript via Node.js.')
-  }
-
-  let sandboxDir: string | null = null
-  try {
-    sandboxDir = createSandboxDir(cwd, sessionId)
-    const sandboxRoot = sandboxDir
-    const scriptFile = `script.${ext}`
-    fs.writeFileSync(path.join(sandboxRoot, 'package.json'), JSON.stringify({ type: 'module' }), 'utf-8')
-    fs.writeFileSync(path.join(sandboxRoot, scriptFile), code, 'utf-8')
-
-    const warnings: string[] = []
-    const docker = detectDocker()
-    const runtimeResult = docker.available
-      ? await executeContainerNode({
-          sandboxDir: sandboxRoot,
-          language,
-          scriptFile,
-          timeout,
-          context,
-        }).catch((err: unknown) => {
-          warnings.push(err instanceof Error ? err.message : 'Container sandbox unavailable; used host Node fallback.')
-          return executeHostNode({
-            sandboxDir: sandboxRoot,
-            language,
-            scriptFile,
-            timeout,
-          })
-        })
-      : (() => {
-          warnings.push('Docker is not available; used host Node fallback.')
-          return executeHostNode({
-            sandboxDir: sandboxRoot,
-            language,
-            scriptFile,
-            timeout,
-          })
-        })()
-
-    const artifacts = collectArtifacts({
-      sandboxDir: sandboxRoot,
-      ignoredFiles: new Set([scriptFile, 'package.json']),
-    })
-
-    return JSON.stringify({
-      runtime: runtimeResult.runtime,
-      exitCode: runtimeResult.exitCode,
-      timedOut: runtimeResult.timedOut,
-      stdout: runtimeResult.stdout,
-      stderr: runtimeResult.stderr,
-      artifacts,
-      ...(warnings.length ? { warnings } : {}),
-    })
-  } catch (err: unknown) {
-    return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-  } finally {
-    if (sandboxDir) {
-      try { fs.rmSync(sandboxDir, { recursive: true, force: true }) } catch { /* ignore */ }
-    }
-  }
-}
-
-export async function executeListRuntimes(context: SandboxContext) {
-  const docker = detectDocker()
-  const session = context.resolveCurrentSession?.() ?? null
-  const status = resolveSandboxRuntimeStatus({
-    config: context.config,
-    session,
-    agentId: context.agentId ?? session?.agentId ?? null,
-    sessionId: context.sessionId ?? session?.id ?? null,
-  })
-
-  return JSON.stringify({
-    node: {
-      available: true,
-      version: process.version,
-      supportsTypeScript: true,
-    },
-    docker,
-    sandbox: {
-      enabledByConfig: Boolean(context.config?.enabled),
-      sandboxedForSession: status.sandboxed,
-      mode: status.mode,
-      scope: status.scope,
-      scopeKey: status.scopeKey,
-      executionMode: docker.available && status.sandboxed ? 'container' : 'host',
-      browserEnabledByConfig: context.config?.browser?.enabled === true,
-    },
-    guidance: docker.available
-      ? []
-      : ['Install Docker Desktop to keep shell, browser, and sandbox_exec inside containers.'],
-  })
-}
-
-// Execution functions (executeSandboxExec, executeListRuntimes) are kept for shell.ts to import.

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

@@ -1,150 +0,0 @@
-import assert from 'node:assert/strict'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { after, before, describe, it } from 'node:test'
-
-import type { Agent, Session } from '@/types'
-
-const originalEnv = {
-  DATA_DIR: process.env.DATA_DIR,
-  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
-  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
-  CREDENTIAL_SECRET: process.env.CREDENTIAL_SECRET,
-}
-
-let tempDir = ''
-let workspaceDir = ''
-let buildWalletTools: typeof import('./wallet').buildWalletTools
-let createAgentWallet: typeof import('@/lib/server/wallet/wallet-service').createAgentWallet
-let storage: typeof import('../storage')
-
-function makeAgent(): Agent {
-  const now = Date.now()
-  return {
-    id: 'agent_wallet',
-    name: 'Wallet Agent',
-    description: 'Tests wallet actions',
-    systemPrompt: 'test',
-    provider: 'ollama',
-    model: 'qwen3.5',
-    extensions: ['wallet'],
-    createdAt: now,
-    updatedAt: now,
-  }
-}
-
-function makeSession(): Session {
-  const now = Date.now()
-  return {
-    id: 'session_wallet',
-    name: 'Wallet Session',
-    cwd: workspaceDir,
-    user: 'tester',
-    provider: 'ollama',
-    model: 'qwen3.5',
-    claudeSessionId: null,
-    messages: [],
-    createdAt: now,
-    lastActiveAt: now,
-    extensions: ['wallet'],
-    agentId: 'agent_wallet',
-  }
-}
-
-function makeBuildContext(session: Session) {
-  return {
-    cwd: workspaceDir,
-    ctx: {
-      sessionId: session.id,
-      agentId: session.agentId || null,
-    },
-    hasExtension: (extensionId: string) => extensionId === 'wallet',
-    hasTool: () => true,
-    cleanupFns: [],
-    commandTimeoutMs: 5000,
-    claudeTimeoutMs: 5000,
-    cliProcessTimeoutMs: 5000,
-    persistDelegateResumeId: () => {},
-    readStoredDelegateResumeId: () => null,
-    resolveCurrentSession: () => session,
-    activeExtensions: ['wallet'],
-  }
-}
-
-before(async () => {
-  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-wallet-tool-'))
-  workspaceDir = path.join(tempDir, 'workspace')
-  process.env.DATA_DIR = path.join(tempDir, 'data')
-  process.env.WORKSPACE_DIR = workspaceDir
-  process.env.SWARMCLAW_BUILD_MODE = '1'
-  process.env.CREDENTIAL_SECRET = '22'.repeat(32)
-  fs.mkdirSync(process.env.DATA_DIR, { recursive: true })
-  fs.mkdirSync(workspaceDir, { recursive: true })
-
-  ;({ buildWalletTools } = await import('./wallet'))
-  ;({ createAgentWallet } = await import('@/lib/server/wallet/wallet-service'))
-  storage = await import('../storage')
-  storage.saveAgents({ agent_wallet: makeAgent() })
-  storage.saveSessions({ session_wallet: makeSession() })
-})
-
-after(() => {
-  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
-  else process.env.DATA_DIR = originalEnv.DATA_DIR
-  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
-  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
-  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
-  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
-  if (originalEnv.CREDENTIAL_SECRET === undefined) delete process.env.CREDENTIAL_SECRET
-  else process.env.CREDENTIAL_SECRET = originalEnv.CREDENTIAL_SECRET
-  fs.rmSync(tempDir, { recursive: true, force: true })
-})
-
-describe('wallet tool generic execution', () => {
-  it('signs messages directly without creating approval records', async () => {
-    createAgentWallet({ agentId: 'agent_wallet', chain: 'ethereum' })
-    const session = makeSession()
-    const [walletTool] = buildWalletTools(makeBuildContext(session))
-
-    const result = JSON.parse(String(await walletTool.invoke({
-      action: 'sign_message',
-      chain: 'ethereum',
-      message: 'sign me',
-    })))
-
-    assert.equal(result.status, 'signed')
-    assert.equal(result.chain, 'ethereum')
-    assert.equal(typeof result.signature, 'string')
-
-    const approvals = storage.loadApprovals()
-    const walletApprovals = Object.values(approvals).filter((approval: any) => approval.category === 'wallet_action')
-    assert.equal(walletApprovals.length, 0)
-  })
-
-  it('ignores legacy approval fields and still encodes contract calls', async () => {
-    const session = makeSession()
-    const [walletTool] = buildWalletTools(makeBuildContext(session))
-
-    const signResult = JSON.parse(String(await walletTool.invoke({
-      action: 'sign_message',
-      chain: 'ethereum',
-      message: 'signed',
-      approved: true,
-      approvalId: 'legacy-approval-id',
-    })))
-    assert.equal(signResult.status, 'signed')
-    assert.equal(signResult.chain, 'ethereum')
-    assert.equal(typeof signResult.signature, 'string')
-
-    const encoded = JSON.parse(String(await walletTool.invoke({
-      action: 'encode_contract_call',
-      chain: 'ethereum',
-      abi: JSON.stringify(['function approve(address spender,uint256 amount)']),
-      functionName: 'approve',
-      args: JSON.stringify(['0x000000000000000000000000000000000000dEaD', '5']),
-    })))
-    assert.equal(encoded.status, 'encoded')
-    assert.equal(encoded.data.startsWith('0x095ea7b3'), true)
-  })
-})