@swarmclawai/swarmclaw 0.6.4 → 0.6.7

package/src/app/api/wallets/[id]/route.ts

@@ -0,0 +1,118 @@
+import { NextResponse } from 'next/server'
+import { loadWallets, upsertWallet, deleteWallet as deleteWalletFromStore, loadAgents, saveAgents } from '@/lib/server/storage'
+import { getBalance, lamportsToSol } from '@/lib/server/solana'
+import { notify } from '@/lib/server/ws-hub'
+import type { AgentWallet } from '@/types'
+export const dynamic = 'force-dynamic'
+
+function stripPrivateKey(wallet: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(wallet).filter(([k]) => k !== 'encryptedPrivateKey'))
+}
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const wallets = loadWallets() as Record<string, AgentWallet>
+  const wallet = wallets[id]
+  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+
+  // Fetch live on-chain balance
+  let balanceLamports = 0
+  let balanceSol = 0
+  try {
+    balanceLamports = await getBalance(wallet.publicKey)
+    balanceSol = lamportsToSol(balanceLamports)
+  } catch {
+    // RPC failure — return 0
+  }
+
+  return NextResponse.json({
+    ...stripPrivateKey(wallet as unknown as Record<string, unknown>),
+    balanceLamports,
+    balanceSol,
+  })
+}
+
+export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const wallets = loadWallets() as Record<string, AgentWallet>
+  const wallet = wallets[id]
+  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+
+  const body = await req.json()
+
+  // Reassign wallet to a different agent
+  if (typeof body.agentId === 'string' && body.agentId !== wallet.agentId) {
+    const agents = loadAgents()
+    const newAgent = agents[body.agentId]
+    if (!newAgent) return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
+
+    // Check new agent doesn't already have a wallet
+    const allWallets = loadWallets() as Record<string, AgentWallet>
+    const conflict = Object.values(allWallets).find((w) => w.agentId === body.agentId && w.id !== id)
+    if (conflict) return NextResponse.json({ error: 'Target agent already has a wallet' }, { status: 409 })
+
+    // Unlink old agent
+    const oldAgent = agents[wallet.agentId]
+    if (oldAgent) {
+      oldAgent.walletId = null
+      oldAgent.updatedAt = Date.now()
+      agents[wallet.agentId] = oldAgent
+    }
+
+    // Link new agent
+    newAgent.walletId = id
+    newAgent.updatedAt = Date.now()
+    agents[body.agentId] = newAgent
+    saveAgents(agents)
+    notify('agents')
+
+    wallet.agentId = body.agentId
+  }
+
+  if (body.label !== undefined) wallet.label = body.label
+  if (typeof body.spendingLimitLamports === 'number') wallet.spendingLimitLamports = body.spendingLimitLamports
+  if (typeof body.dailyLimitLamports === 'number') wallet.dailyLimitLamports = body.dailyLimitLamports
+  if (typeof body.requireApproval === 'boolean') wallet.requireApproval = body.requireApproval
+  wallet.updatedAt = Date.now()
+
+  upsertWallet(id, wallet)
+  notify('wallets')
+
+  return NextResponse.json(stripPrivateKey(wallet as unknown as Record<string, unknown>))
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const wallets = loadWallets() as Record<string, AgentWallet>
+  const wallet = wallets[id]
+  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+
+  // Check if balance > 0 and warn
+  let balanceLamports = 0
+  try {
+    balanceLamports = await getBalance(wallet.publicKey)
+  } catch { /* ignore */ }
+
+  if (balanceLamports > 0) {
+    // Still delete, but include warning
+  }
+
+  // Unlink from agent
+  const agents = loadAgents()
+  const agent = agents[wallet.agentId]
+  if (agent) {
+    agent.walletId = null
+    agent.updatedAt = Date.now()
+    agents[wallet.agentId] = agent
+    saveAgents(agents)
+    notify('agents')
+  }
+
+  deleteWalletFromStore(id)
+  notify('wallets')
+
+  return NextResponse.json({
+    ok: true,
+    warning: balanceLamports > 0 ? `Wallet had ${lamportsToSol(balanceLamports)} SOL remaining` : undefined,
+  })
+}

package/src/app/api/wallets/[id]/send/route.ts

@@ -0,0 +1,118 @@
+import { NextResponse } from 'next/server'
+import { genId } from '@/lib/id'
+import { loadWallets, loadWalletTransactions, upsertWalletTransaction } from '@/lib/server/storage'
+import { sendSol, isValidSolanaAddress, lamportsToSol } from '@/lib/server/solana'
+import { notify } from '@/lib/server/ws-hub'
+import type { AgentWallet, WalletTransaction } from '@/types'
+export const dynamic = 'force-dynamic'
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const wallets = loadWallets() as Record<string, AgentWallet>
+  const wallet = wallets[id]
+  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+
+  const body = await req.json()
+  const toAddress = typeof body.toAddress === 'string' ? body.toAddress.trim() : ''
+  const amountLamports = typeof body.amountLamports === 'number' ? Math.floor(body.amountLamports) : 0
+  const memo = typeof body.memo === 'string' ? body.memo.slice(0, 500) : undefined
+
+  if (!toAddress || !isValidSolanaAddress(toAddress)) {
+    return NextResponse.json({ error: 'Invalid recipient address' }, { status: 400 })
+  }
+  if (amountLamports <= 0) {
+    return NextResponse.json({ error: 'Amount must be positive' }, { status: 400 })
+  }
+
+  // Per-tx spending limit
+  const perTxLimit = wallet.spendingLimitLamports ?? 100_000_000
+  if (amountLamports > perTxLimit) {
+    return NextResponse.json({
+      error: `Amount ${lamportsToSol(amountLamports)} SOL exceeds per-transaction limit of ${lamportsToSol(perTxLimit)} SOL`,
+    }, { status: 403 })
+  }
+
+  // 24h rolling daily limit
+  const dailyLimit = wallet.dailyLimitLamports ?? 1_000_000_000
+  const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000
+  const allTxs = loadWalletTransactions() as Record<string, WalletTransaction>
+  const recentSends = Object.values(allTxs).filter(
+    (tx) => tx.walletId === id && tx.type === 'send' && tx.status === 'confirmed' && tx.timestamp > oneDayAgo,
+  )
+  const dailySpent = recentSends.reduce((sum, tx) => sum + tx.amountLamports, 0)
+  if (dailySpent + amountLamports > dailyLimit) {
+    return NextResponse.json({
+      error: `Daily limit exceeded. Spent ${lamportsToSol(dailySpent)} SOL in last 24h, limit is ${lamportsToSol(dailyLimit)} SOL`,
+    }, { status: 403 })
+  }
+
+  const txId = genId(8)
+  const now = Date.now()
+
+  // If requireApproval, create pending tx and return it
+  if (wallet.requireApproval) {
+    const pendingTx: WalletTransaction = {
+      id: txId,
+      walletId: id,
+      agentId: wallet.agentId,
+      chain: wallet.chain,
+      type: 'send',
+      signature: '',
+      fromAddress: wallet.publicKey,
+      toAddress,
+      amountLamports,
+      status: 'pending_approval',
+      memo,
+      timestamp: now,
+    }
+    upsertWalletTransaction(txId, pendingTx)
+    notify('wallets')
+    return NextResponse.json({ status: 'pending_approval', transactionId: txId, message: 'Transaction requires user approval' })
+  }
+
+  // Auto-approved — sign and submit
+  try {
+    const { signature, fee } = await sendSol(wallet.encryptedPrivateKey, toAddress, amountLamports)
+    const confirmedTx: WalletTransaction = {
+      id: txId,
+      walletId: id,
+      agentId: wallet.agentId,
+      chain: wallet.chain,
+      type: 'send',
+      signature,
+      fromAddress: wallet.publicKey,
+      toAddress,
+      amountLamports,
+      feeLamports: fee,
+      status: 'confirmed',
+      memo,
+      approvedBy: 'auto',
+      timestamp: now,
+    }
+    upsertWalletTransaction(txId, confirmedTx)
+    notify('wallets')
+    return NextResponse.json({ status: 'confirmed', transactionId: txId, signature })
+  } catch (err: unknown) {
+    const failedTx: WalletTransaction = {
+      id: txId,
+      walletId: id,
+      agentId: wallet.agentId,
+      chain: wallet.chain,
+      type: 'send',
+      signature: '',
+      fromAddress: wallet.publicKey,
+      toAddress,
+      amountLamports,
+      status: 'failed',
+      memo,
+      timestamp: now,
+    }
+    upsertWalletTransaction(txId, failedTx)
+    notify('wallets')
+    return NextResponse.json({
+      error: err instanceof Error ? err.message : String(err),
+      transactionId: txId,
+      status: 'failed',
+    }, { status: 500 })
+  }
+}

package/src/app/api/wallets/[id]/transactions/route.ts

@@ -0,0 +1,18 @@
+import { NextResponse } from 'next/server'
+import { loadWallets, loadWalletTransactions } from '@/lib/server/storage'
+import type { AgentWallet, WalletTransaction } from '@/types'
+export const dynamic = 'force-dynamic'
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const wallets = loadWallets() as Record<string, AgentWallet>
+  const wallet = wallets[id]
+  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+
+  const allTxs = loadWalletTransactions() as Record<string, WalletTransaction>
+  const walletTxs = Object.values(allTxs)
+    .filter((tx) => tx.walletId === id)
+    .sort((a, b) => b.timestamp - a.timestamp)
+
+  return NextResponse.json(walletTxs)
+}

package/src/app/api/wallets/route.ts

@@ -0,0 +1,74 @@
+import { NextResponse } from 'next/server'
+import { genId } from '@/lib/id'
+import { loadWallets, upsertWallet, loadAgents, saveAgents } from '@/lib/server/storage'
+import { generateSolanaKeypair } from '@/lib/server/solana'
+import { notify } from '@/lib/server/ws-hub'
+import type { AgentWallet, WalletChain } from '@/types'
+export const dynamic = 'force-dynamic'
+
+/** Strip encryptedPrivateKey from wallet for safe API responses */
+function stripPrivateKey(wallet: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(wallet).filter(([k]) => k !== 'encryptedPrivateKey'))
+}
+
+export async function GET() {
+  const wallets = loadWallets() as Record<string, AgentWallet>
+  const safe = Object.fromEntries(
+    Object.entries(wallets).map(([id, w]) => [id, stripPrivateKey(w as unknown as Record<string, unknown>)]),
+  )
+  return NextResponse.json(safe)
+}
+
+export async function POST(req: Request) {
+  const body = await req.json()
+  const agentId = typeof body.agentId === 'string' ? body.agentId.trim() : ''
+  if (!agentId) {
+    return NextResponse.json({ error: 'agentId is required' }, { status: 400 })
+  }
+
+  const agents = loadAgents()
+  if (!agents[agentId]) {
+    return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
+  }
+
+  // Check agent doesn't already have a wallet
+  const existing = loadWallets() as Record<string, AgentWallet>
+  const hasWallet = Object.values(existing).some((w) => w.agentId === agentId)
+  if (hasWallet) {
+    return NextResponse.json({ error: 'Agent already has a wallet' }, { status: 409 })
+  }
+
+  const chain: WalletChain = body.chain === 'solana' ? 'solana' : 'solana' // extensible later
+  const { publicKey, encryptedPrivateKey } = generateSolanaKeypair()
+
+  const id = genId()
+  const now = Date.now()
+
+  const wallet: AgentWallet = {
+    id,
+    agentId,
+    chain,
+    publicKey,
+    encryptedPrivateKey,
+    label: typeof body.label === 'string' ? body.label : undefined,
+    spendingLimitLamports: typeof body.spendingLimitLamports === 'number' ? body.spendingLimitLamports : 100_000_000,
+    dailyLimitLamports: typeof body.dailyLimitLamports === 'number' ? body.dailyLimitLamports : 1_000_000_000,
+    requireApproval: body.requireApproval !== false,
+    createdAt: now,
+    updatedAt: now,
+  }
+
+  upsertWallet(id, wallet)
+
+  // Link wallet to agent
+  const agent = agents[agentId]
+  agent.walletId = id
+  agent.updatedAt = now
+  agents[agentId] = agent
+  saveAgents(agents)
+
+  notify('wallets')
+  notify('agents')
+
+  return NextResponse.json(stripPrivateKey(wallet as unknown as Record<string, unknown>))
+}

package/src/app/globals.css

@@ -215,6 +215,14 @@ textarea:hover::-webkit-scrollbar { width: 6px; }
   to { opacity: 1; transform: translateY(0); }
 }
 @keyframes spin { to { transform: rotate(360deg); } }
+@keyframes pulse-glow {
+  0%, 100% { transform: scale(1); opacity: 0.45; }
+  50% { transform: scale(1.2); opacity: 0.85; }
+}
+@keyframes avatar-pulse {
+  0%, 100% { transform: scale(1); }
+  50% { transform: scale(1.1); }
+}
 @keyframes slide-in-left {
   from { transform: translateX(-100%); }
   to { transform: translateX(0); }

package/src/cli/index.js

@@ -21,6 +21,7 @@ const COMMAND_GROUPS = [
       cmd('restore', 'POST', '/agents/trash', 'Restore a trashed agent', { expectsJsonBody: true }),
       cmd('purge', 'DELETE', '/agents/trash', 'Permanently delete a trashed agent', { expectsJsonBody: true }),
       cmd('thread', 'POST', '/agents/:id/thread', 'Get or create agent thread session'),
+      cmd('clone', 'POST', '/agents/:id/clone', 'Clone an agent'),
     ],
   },
   {
@@ -77,6 +78,7 @@ const COMMAND_GROUPS = [
       cmd('pin', 'POST', '/chatrooms/:id/pins', 'Toggle pin on a chatroom message', {
         expectsJsonBody: true,
       }),
+      cmd('moderate', 'POST', '/chatrooms/:id/moderate', 'Run moderation action on a chatroom', { expectsJsonBody: true }),
     ],
   },
   {
@@ -109,6 +111,7 @@ const COMMAND_GROUPS = [
         expectsJsonBody: true,
         defaultBody: { action: 'repair' },
       }),
+      cmd('health', 'GET', '/connectors/:id/health', 'Get connector health status'),
     ],
   },
   {
@@ -289,6 +292,8 @@ const COMMAND_GROUPS = [
       cmd('skills-install', 'POST', '/openclaw/skills/install', 'Install OpenClaw skill dependencies', { expectsJsonBody: true }),
       cmd('skills-remove', 'POST', '/openclaw/skills/remove', 'Remove OpenClaw skill', { expectsJsonBody: true }),
       cmd('sync', 'POST', '/openclaw/sync', 'Run OpenClaw sync action', { expectsJsonBody: true }),
+      cmd('doctor', 'GET', '/openclaw/doctor', 'Run OpenClaw doctor check (read-only)'),
+      cmd('doctor-fix', 'POST', '/openclaw/doctor', 'Run OpenClaw doctor with auto-fix', { expectsJsonBody: true }),
     ],
   },
   {
@@ -485,6 +490,21 @@ const COMMAND_GROUPS = [
       }),
     ],
   },
+  {
+    name: 'wallets',
+    description: 'Manage agent wallets and wallet transactions',
+    commands: [
+      cmd('list', 'GET', '/wallets', 'List wallets'),
+      cmd('get', 'GET', '/wallets/:id', 'Get wallet by id'),
+      cmd('create', 'POST', '/wallets', 'Create wallet', { expectsJsonBody: true }),
+      cmd('update', 'PATCH', '/wallets/:id', 'Update wallet settings', { expectsJsonBody: true }),
+      cmd('delete', 'DELETE', '/wallets/:id', 'Delete wallet'),
+      cmd('send', 'POST', '/wallets/:id/send', 'Send funds from wallet', { expectsJsonBody: true }),
+      cmd('approve', 'POST', '/wallets/:id/approve', 'Approve or deny a pending wallet transaction', { expectsJsonBody: true }),
+      cmd('transactions', 'GET', '/wallets/:id/transactions', 'List wallet transactions'),
+      cmd('balance-history', 'GET', '/wallets/:id/balance-history', 'Get wallet balance history'),
+    ],
+  },
   {
     name: 'upload',
     description: 'Upload raw file/blob',