@swarmclawai/swarmclaw 0.6.4 → 0.6.6

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

@@ -187,7 +187,7 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
         },
         {
           name: 'memory_tool',
-          description: 'Store and retrieve long-term memories that persist across sessions. Memories can be shared or agent-scoped. Supports file references, image attachments, and linking memories together with depth traversal. Also supports a cross-agent knowledge base via "knowledge_store" and "knowledge_search". Use "store", "get", "search", "list", "delete", "link", "unlink", "knowledge_store", or "knowledge_search".',
+          description: 'My long-term memory — things I remember across conversations. I can store personal notes, recall past context, and build up knowledge over time. Memories can be private to me or shared with other agents. I can also attach files, link related memories, and contribute to a shared knowledge base. Actions: store, get, search, list, delete, link, unlink, knowledge_store, knowledge_search.',
           schema: z.object({
             action: z.enum(['store', 'get', 'search', 'list', 'delete', 'link', 'unlink', 'knowledge_store', 'knowledge_search']).describe('The action to perform'),
             key: z.string().describe('For store: memory title. For get/delete/link/unlink: memory ID. For search: optional query fallback.'),

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

@@ -49,7 +49,7 @@ export function buildShellTools(bctx: ToolBuildContext): StructuredToolInterface
         },
         {
           name: 'execute_command',
-          description: 'Execute a shell command in the session working directory. This is the PRIMARY tool for running servers, dev servers, installing packages, running scripts, git operations, and any command the user wants to run or test. Use background=true for long-running processes like servers. Supports timeout/yield controls.',
+          description: 'Run a shell command in my working directory. This is how I run servers, install packages, execute scripts, use git, and do anything hands-on. Use background=true for long-running processes like dev servers. Supports timeout/yield controls.',
           schema: z.object({
             command: z.string().describe('The shell command to execute'),
             background: z.boolean().optional().describe('If true, start command in background immediately'),

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

@@ -0,0 +1,124 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import type { ToolBuildContext } from './context'
+import { loadWallets, loadWalletTransactions } from '../storage'
+import type { AgentWallet, WalletTransaction } from '@/types'
+
+export function buildWalletTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('wallet')) return []
+
+  const agentId = bctx.ctx?.agentId
+
+  function getAgentWallet(): AgentWallet | null {
+    if (!agentId) return null
+    const wallets = loadWallets() as Record<string, AgentWallet>
+    return Object.values(wallets).find((w) => w.agentId === agentId) ?? null
+  }
+
+  return [
+    tool(
+      async ({ action, toAddress, amountSol, memo, limit }) => {
+        const wallet = getAgentWallet()
+        if (!wallet) {
+          return JSON.stringify({ error: 'No wallet linked to this agent. Ask the user to create one in the Wallets section.' })
+        }
+
+        switch (action) {
+          case 'balance': {
+            try {
+              const { getBalance, lamportsToSol } = await import('../solana')
+              const balanceLamports = await getBalance(wallet.publicKey)
+              return JSON.stringify({
+                address: wallet.publicKey,
+                chain: wallet.chain,
+                balanceLamports,
+                balanceSol: lamportsToSol(balanceLamports),
+              })
+            } catch (err: unknown) {
+              return JSON.stringify({ error: `Failed to fetch balance: ${err instanceof Error ? err.message : String(err)}` })
+            }
+          }
+
+          case 'address': {
+            return JSON.stringify({
+              address: wallet.publicKey,
+              chain: wallet.chain,
+            })
+          }
+
+          case 'send': {
+            if (!toAddress) return JSON.stringify({ error: 'toAddress is required for send action' })
+            if (!amountSol || amountSol <= 0) return JSON.stringify({ error: 'amountSol must be positive' })
+
+            const { isValidSolanaAddress, solToLamports, lamportsToSol } = await import('../solana')
+            if (!isValidSolanaAddress(toAddress)) {
+              return JSON.stringify({ error: 'Invalid Solana address' })
+            }
+
+            const amountLamports = solToLamports(amountSol)
+
+            // Check per-tx limit
+            const perTxLimit = wallet.spendingLimitLamports ?? 100_000_000
+            if (amountLamports > perTxLimit) {
+              return JSON.stringify({
+                error: `Amount ${amountSol} SOL exceeds per-transaction limit of ${lamportsToSol(perTxLimit)} SOL`,
+              })
+            }
+
+            // Send via API to enforce all limits and approval flow
+            try {
+              const baseUrl = process.env.NEXTAUTH_URL || `http://localhost:${process.env.PORT || 3456}`
+              const res = await fetch(`${baseUrl}/api/wallets/${wallet.id}/send`, {
+                method: 'POST',
+                headers: {
+                  'Content-Type': 'application/json',
+                  'X-Access-Key': process.env.ACCESS_KEY || '',
+                },
+                body: JSON.stringify({ toAddress, amountLamports, memo }),
+              })
+              const result = await res.json()
+              return JSON.stringify(result)
+            } catch (err: unknown) {
+              return JSON.stringify({ error: `Send failed: ${err instanceof Error ? err.message : String(err)}` })
+            }
+          }
+
+          case 'transactions': {
+            const allTxs = loadWalletTransactions() as Record<string, WalletTransaction>
+            const walletTxs = Object.values(allTxs)
+              .filter((tx) => tx.walletId === wallet.id)
+              .sort((a, b) => b.timestamp - a.timestamp)
+              .slice(0, limit ?? 10)
+              .map((tx) => ({
+                id: tx.id,
+                type: tx.type,
+                status: tx.status,
+                amountLamports: tx.amountLamports,
+                toAddress: tx.toAddress,
+                fromAddress: tx.fromAddress,
+                signature: tx.signature || undefined,
+                memo: tx.memo,
+                timestamp: tx.timestamp,
+              }))
+
+            return JSON.stringify({ transactions: walletTxs, count: walletTxs.length })
+          }
+
+          default:
+            return JSON.stringify({ error: `Unknown action: ${action}. Use balance, address, send, or transactions.` })
+        }
+      },
+      {
+        name: 'wallet_tool',
+        description: 'Manage your own crypto wallet. Actions: balance (check your SOL balance), address (get your wallet address), send (send SOL from your wallet — subject to your spending limits and user approval), transactions (view your recent transaction history).',
+        schema: z.object({
+          action: z.enum(['balance', 'address', 'send', 'transactions']).describe('Wallet action to perform'),
+          toAddress: z.string().optional().describe('Recipient Solana address (required for send)'),
+          amountSol: z.number().optional().describe('Amount in SOL to send (required for send)'),
+          memo: z.string().optional().describe('Reason or memo for the transaction'),
+          limit: z.number().optional().describe('Number of transactions to return (default 10, for transactions action)'),
+        }),
+      },
+    ),
+  ]
+}

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

@@ -141,7 +141,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
         },
         {
           name: 'web_search',
-          description: 'Search the web. Returns an array of results with title, url, and snippet.',
+          description: 'Search the web for information. Returns results with title, url, and snippet.',
           schema: z.object({
             query: z.string().describe('Search query'),
             maxResults: z.number().optional().describe('Maximum results to return (default 5, max 10)'),
@@ -179,7 +179,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
         },
         {
           name: 'web_fetch',
-          description: 'Fetch a URL and return its text content (HTML stripped). Useful for reading web pages.',
+          description: 'Fetch a URL and read its content (HTML stripped to text). How I read web pages and pull in external information.',
           schema: z.object({
             url: z.string().describe('The URL to fetch'),
           }),

package/src/lib/server/solana.ts

@@ -0,0 +1,122 @@
+import { Keypair, Connection, PublicKey, SystemProgram, Transaction, LAMPORTS_PER_SOL, sendAndConfirmTransaction } from '@solana/web3.js'
+import bs58 from 'bs58'
+import { encryptKey, decryptKey } from './storage'
+
+const DEFAULT_RPC_URL = process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com'
+
+// ---------------------------------------------------------------------------
+// Keypair generation & encryption
+// ---------------------------------------------------------------------------
+
+export function generateSolanaKeypair(): { publicKey: string; encryptedPrivateKey: string } {
+  const keypair = Keypair.generate()
+  const secretKeyBase58 = bs58.encode(keypair.secretKey)
+  return {
+    publicKey: keypair.publicKey.toBase58(),
+    encryptedPrivateKey: encryptKey(secretKeyBase58),
+  }
+}
+
+export function getKeypairFromEncrypted(encryptedPrivateKey: string): Keypair {
+  const secretKeyBase58 = decryptKey(encryptedPrivateKey)
+  const secretKey = bs58.decode(secretKeyBase58)
+  return Keypair.fromSecretKey(secretKey)
+}
+
+// ---------------------------------------------------------------------------
+// Connection
+// ---------------------------------------------------------------------------
+
+export function getConnection(rpcUrl?: string): Connection {
+  return new Connection(rpcUrl || DEFAULT_RPC_URL, 'confirmed')
+}
+
+// ---------------------------------------------------------------------------
+// Balance
+// ---------------------------------------------------------------------------
+
+export async function getBalance(publicKey: string, rpcUrl?: string): Promise<number> {
+  const connection = getConnection(rpcUrl)
+  const pk = new PublicKey(publicKey)
+  return connection.getBalance(pk)
+}
+
+// ---------------------------------------------------------------------------
+// Send SOL
+// ---------------------------------------------------------------------------
+
+export async function sendSol(
+  encryptedPrivateKey: string,
+  toAddress: string,
+  lamports: number,
+  rpcUrl?: string,
+): Promise<{ signature: string; fee: number }> {
+  const connection = getConnection(rpcUrl)
+  const fromKeypair = getKeypairFromEncrypted(encryptedPrivateKey)
+  const toPublicKey = new PublicKey(toAddress)
+
+  const transaction = new Transaction().add(
+    SystemProgram.transfer({
+      fromPubkey: fromKeypair.publicKey,
+      toPubkey: toPublicKey,
+      lamports,
+    }),
+  )
+
+  const signature = await sendAndConfirmTransaction(connection, transaction, [fromKeypair])
+
+  // Fetch fee from confirmed tx
+  let fee = 5000 // default fee estimate
+  try {
+    const txInfo = await connection.getTransaction(signature, { commitment: 'confirmed' })
+    if (txInfo?.meta?.fee) fee = txInfo.meta.fee
+  } catch {
+    // use default
+  }
+
+  return { signature, fee }
+}
+
+// ---------------------------------------------------------------------------
+// Recent transactions
+// ---------------------------------------------------------------------------
+
+export async function getRecentTransactions(
+  publicKey: string,
+  limit = 20,
+  rpcUrl?: string,
+): Promise<Array<{ signature: string; blockTime: number | null; err: unknown }>> {
+  const connection = getConnection(rpcUrl)
+  const pk = new PublicKey(publicKey)
+  const signatures = await connection.getSignaturesForAddress(pk, { limit })
+  return signatures.map((s) => ({
+    signature: s.signature,
+    blockTime: s.blockTime ?? null,
+    err: s.err,
+  }))
+}
+
+// ---------------------------------------------------------------------------
+// Validate address
+// ---------------------------------------------------------------------------
+
+export function isValidSolanaAddress(address: string): boolean {
+  try {
+    new PublicKey(address)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+export function lamportsToSol(lamports: number): number {
+  return lamports / LAMPORTS_PER_SOL
+}
+
+export function solToLamports(sol: number): number {
+  return Math.round(sol * LAMPORTS_PER_SOL)
+}

package/src/lib/server/storage.ts

@@ -54,6 +54,9 @@ const COLLECTIONS = [
   'webhook_retry_queue',
   'notifications',
   'chatrooms',
+  'wallets',
+  'wallet_transactions',
+  'wallet_balance_history',
 ] as const
 
 for (const table of COLLECTIONS) {
@@ -826,6 +829,41 @@ export function markNotificationRead(id: string) {
   }
 }
 
+// --- Wallets ---
+export function loadWallets(): Record<string, unknown> {
+  return loadCollection('wallets')
+}
+
+export function upsertWallet(id: string, wallet: unknown) {
+  upsertCollectionItem('wallets', id, wallet)
+}
+
+export function deleteWallet(id: string) {
+  deleteCollectionItem('wallets', id)
+}
+
+// --- Wallet Transactions ---
+export function loadWalletTransactions(): Record<string, unknown> {
+  return loadCollection('wallet_transactions')
+}
+
+export function upsertWalletTransaction(id: string, tx: unknown) {
+  upsertCollectionItem('wallet_transactions', id, tx)
+}
+
+export function deleteWalletTransaction(id: string) {
+  deleteCollectionItem('wallet_transactions', id)
+}
+
+// --- Wallet Balance History ---
+export function loadWalletBalanceHistory(): Record<string, unknown> {
+  return loadCollection('wallet_balance_history')
+}
+
+export function upsertWalletBalanceSnapshot(id: string, snapshot: unknown) {
+  upsertCollectionItem('wallet_balance_history', id, snapshot)
+}
+
 export function getSessionMessages(sessionId: string): Message[] {
   const stmt = db.prepare('SELECT data FROM sessions WHERE id = ?')
   const row = stmt.get(sessionId) as { data: string } | undefined