@swarmclawai/swarmclaw 1.2.8 → 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/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)
-  })
-})