@swarmclawai/swarmclaw 0.4.0 → 0.5.0

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

@@ -1,4 +1,5 @@
 import { NextResponse } from 'next/server'
+import { notFound } from '@/lib/server/collection-helpers'
 import { getMemoryDb } from '@/lib/server/memory-db'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -6,7 +7,7 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   const db = getMemoryDb()
   const entry = db.get(id)
   if (!entry || entry.category !== 'knowledge') {
-    return new NextResponse(null, { status: 404 })
+    return notFound()
   }
   return NextResponse.json(entry)
 }
@@ -16,7 +17,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   const db = getMemoryDb()
   const existing = db.get(id)
   if (!existing || existing.category !== 'knowledge') {
-    return new NextResponse(null, { status: 404 })
+    return notFound()
   }
 
   const body = await req.json().catch(() => null)
@@ -44,7 +45,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
 
   const updated = db.update(id, updates)
   if (!updated) {
-    return new NextResponse(null, { status: 404 })
+    return notFound()
   }
   return NextResponse.json(updated)
 }
@@ -54,7 +55,7 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   const db = getMemoryDb()
   const existing = db.get(id)
   if (!existing || existing.category !== 'knowledge') {
-    return new NextResponse(null, { status: 404 })
+    return notFound()
   }
   db.delete(id)
   return NextResponse.json({ deleted: id })

package/src/app/api/knowledge/upload/route.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from 'next/server'
 import fs from 'fs'
 import path from 'path'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { UPLOAD_DIR } from '@/lib/server/storage'
 
 const TEXT_EXTS = new Set([
@@ -40,7 +40,7 @@ export async function POST(req: Request) {
 
   // Save file to uploads
   if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })
-  const safeName = crypto.randomBytes(4).toString('hex') + '-' + filename.replace(/[^a-zA-Z0-9._-]/g, '_')
+  const safeName = genId() + '-' + filename.replace(/[^a-zA-Z0-9._-]/g, '_')
   const filePath = path.join(UPLOAD_DIR, safeName)
   fs.writeFileSync(filePath, buf)
 

package/src/app/api/mcp-servers/[id]/route.ts

@@ -1,32 +1,29 @@
 import { NextResponse } from 'next/server'
 import { loadMcpServers, saveMcpServers, deleteMcpServer } from '@/lib/server/storage'
+import { mutateItem, deleteItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const ops: CollectionOps<any> = { load: loadMcpServers, save: saveMcpServers, deleteFn: deleteMcpServer }
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const servers = loadMcpServers()
-  if (!servers[id]) return new NextResponse(null, { status: 404 })
+  if (!servers[id]) return notFound()
   return NextResponse.json(servers[id])
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json()
-  const servers = loadMcpServers()
-  if (!servers[id]) return new NextResponse(null, { status: 404 })
-  servers[id] = {
-    ...servers[id],
-    ...body,
-    id,
-    updatedAt: Date.now(),
-  }
-  saveMcpServers(servers)
-  return NextResponse.json(servers[id])
+  const result = mutateItem(ops, id, (server) => ({
+    ...server, ...body, id, updatedAt: Date.now(),
+  }))
+  if (!result) return notFound()
+  return NextResponse.json(result)
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const servers = loadMcpServers()
-  if (!servers[id]) return new NextResponse(null, { status: 404 })
-  deleteMcpServer(id)
+  if (!deleteItem(ops, id)) return notFound()
   return NextResponse.json({ deleted: id })
 }

package/src/app/api/mcp-servers/[id]/test/route.ts

@@ -1,12 +1,13 @@
 import { NextResponse } from 'next/server'
 import { loadMcpServers } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
 import { connectMcpServer, mcpToolsToLangChain, disconnectMcpServer } from '@/lib/server/mcp-client'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const servers = loadMcpServers()
   const server = servers[id]
-  if (!server) return new NextResponse(null, { status: 404 })
+  if (!server) return notFound()
 
   try {
     const { client, transport } = await connectMcpServer(server)

package/src/app/api/mcp-servers/[id]/tools/route.ts

@@ -1,12 +1,13 @@
 import { NextResponse } from 'next/server'
 import { loadMcpServers } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
 import { connectMcpServer, disconnectMcpServer } from '@/lib/server/mcp-client'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const servers = loadMcpServers()
   const config = servers[id]
-  if (!config) return new NextResponse(null, { status: 404 })
+  if (!config) return notFound()
 
   let client: any
   let transport: any

package/src/app/api/mcp-servers/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { loadMcpServers, saveMcpServers } from '@/lib/server/storage'
 export const dynamic = 'force-dynamic'
 
@@ -11,7 +11,7 @@ export async function GET(_req: Request) {
 export async function POST(req: Request) {
   const body = await req.json()
   const servers = loadMcpServers()
-  const id = crypto.randomBytes(4).toString('hex')
+  const id = genId()
   servers[id] = {
     id,
     name: body.name,

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

@@ -1,6 +1,7 @@
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import fs from 'fs'
 import { NextResponse } from 'next/server'
+import { notFound } from '@/lib/server/collection-helpers'
 import { getMemoryDb, getMemoryLookupLimits, storeMemoryImageAsset, storeMemoryImageFromDataUrl } from '@/lib/server/memory-db'
 import { resolveLookupRequest } from '@/lib/server/memory-graph'
 import type { MemoryImage } from '@/types'
@@ -42,7 +43,7 @@ export async function GET(req: Request, { params }: { params: Promise<{ id: stri
 
   if (limits.maxDepth <= 0) {
     const entry = db.get(id)
-    if (!entry) return new NextResponse(null, { status: 404 })
+    if (!entry) return notFound()
     if (envelope) {
       return NextResponse.json({
         entries: [entry],
@@ -55,7 +56,7 @@ export async function GET(req: Request, { params }: { params: Promise<{ id: stri
   }
 
   const result = db.getWithLinked(id, limits.maxDepth, limits.maxPerLookup, limits.maxLinkedExpansion)
-  if (!result) return new NextResponse(null, { status: 404 })
+  if (!result) return notFound()
   if (envelope) return NextResponse.json(result)
   return NextResponse.json(result.entries)
 }
@@ -78,7 +79,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     const updated = linkAction === 'link'
       ? db.link(id, targetIds, true)
       : db.unlink(id, targetIds, true)
-    if (!updated) return new NextResponse(null, { status: 404 })
+    if (!updated) return notFound()
     return NextResponse.json(updated)
   }
 
@@ -90,7 +91,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     image = null
   } else if (inputImageDataUrl) {
     try {
-      image = await storeMemoryImageFromDataUrl(inputImageDataUrl, `${id}-${crypto.randomBytes(2).toString('hex')}`)
+      image = await storeMemoryImageFromDataUrl(inputImageDataUrl, `${id}-${genId(2)}`)
     } catch (err) {
       return NextResponse.json({ error: err instanceof Error ? err.message : 'Invalid image data URL' }, { status: 400 })
     }
@@ -99,7 +100,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
       return NextResponse.json({ error: `Image file not found: ${inputImagePath}` }, { status: 400 })
     }
     try {
-      image = await storeMemoryImageAsset(inputImagePath, `${id}-${crypto.randomBytes(2).toString('hex')}`)
+      image = await storeMemoryImageAsset(inputImagePath, `${id}-${genId(2)}`)
     } catch (err) {
       return NextResponse.json({ error: err instanceof Error ? err.message : 'Failed to store memory image' }, { status: 400 })
     }
@@ -114,7 +115,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
         ? String((image as { path: string }).path)
         : (typeof body.imagePath === 'string' ? body.imagePath : undefined),
   })
-  if (!entry) return new NextResponse(null, { status: 404 })
+  if (!entry) return notFound()
   return NextResponse.json(entry)
 }
 
@@ -122,5 +123,5 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   const { id } = await params
   const db = getMemoryDb()
   db.delete(id)
-  return NextResponse.json('ok')
+  return NextResponse.json({ ok: true })
 }

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

@@ -1,4 +1,4 @@
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import fs from 'fs'
 import { NextResponse } from 'next/server'
 import { getMemoryDb, getMemoryLookupLimits, storeMemoryImageAsset, storeMemoryImageFromDataUrl } from '@/lib/server/memory-db'
@@ -72,7 +72,7 @@ export async function POST(req: Request) {
   }
 
   const db = getMemoryDb()
-  const draftId = crypto.randomBytes(6).toString('hex')
+  const draftId = genId(6)
 
   let image = body.image
   const inputImagePath = typeof body.imagePath === 'string' ? body.imagePath.trim() : ''

package/src/app/api/memory-images/[filename]/route.ts

@@ -1,4 +1,5 @@
 import { NextResponse } from 'next/server'
+import { notFound } from '@/lib/server/collection-helpers'
 import fs from 'fs'
 import path from 'path'
 
@@ -20,7 +21,7 @@ export async function GET(_req: Request, { params }: { params: Promise<{ filenam
   const filePath = path.join(IMAGES_DIR, safeName)
 
   if (!fs.existsSync(filePath)) {
-    return new NextResponse(null, { status: 404 })
+    return notFound()
   }
 
   const ext = path.extname(safeName).toLowerCase()

package/src/app/api/openclaw/agent-files/route.ts

@@ -0,0 +1,57 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+
+const AGENT_FILES = ['SOUL.md', 'IDENTITY.md', 'USER.md', 'TOOLS.md', 'HEARTBEAT.md', 'MEMORY.md', 'AGENTS.md'] as const
+
+/** GET ?agentId=X — fetch all agent files from gateway */
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const agentId = searchParams.get('agentId')
+  if (!agentId) {
+    return NextResponse.json({ error: 'Missing agentId' }, { status: 400 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'OpenClaw gateway not connected' }, { status: 503 })
+  }
+
+  const files: Record<string, { content: string; error?: string }> = {}
+  await Promise.all(
+    AGENT_FILES.map(async (filename) => {
+      try {
+        const result = await gw.rpc('agents.files.get', { agentId, filename }) as { content?: string } | undefined
+        files[filename] = { content: result?.content ?? '' }
+      } catch (err: unknown) {
+        files[filename] = { content: '', error: err instanceof Error ? err.message : String(err) }
+      }
+    }),
+  )
+
+  return NextResponse.json(files)
+}
+
+/** PUT { agentId, filename, content } — save an agent file */
+export async function PUT(req: Request) {
+  const body = await req.json()
+  const { agentId, filename, content } = body as { agentId?: string; filename?: string; content?: string }
+  if (!agentId || !filename) {
+    return NextResponse.json({ error: 'Missing agentId or filename' }, { status: 400 })
+  }
+  if (!AGENT_FILES.includes(filename as typeof AGENT_FILES[number])) {
+    return NextResponse.json({ error: `Invalid filename: ${filename}` }, { status: 400 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'OpenClaw gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    await gw.rpc('agents.files.set', { agentId, filename, content: content ?? '' })
+    return NextResponse.json({ ok: true })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}

package/src/app/api/openclaw/approvals/route.ts

@@ -0,0 +1,46 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+import type { PendingExecApproval, ExecApprovalDecision } from '@/types'
+
+/** GET — fetch pending execution approvals from gateway */
+export async function GET() {
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json([], { status: 200 })
+  }
+
+  try {
+    const result = await gw.rpc('exec.approvals.get') as PendingExecApproval[] | undefined
+    return NextResponse.json(result ?? [])
+  } catch {
+    return NextResponse.json([])
+  }
+}
+
+/** POST { id, decision } — resolve an execution approval */
+export async function POST(req: Request) {
+  const body = await req.json()
+  const { id, decision } = body as { id?: string; decision?: ExecApprovalDecision }
+
+  if (!id || !decision) {
+    return NextResponse.json({ error: 'Missing id or decision' }, { status: 400 })
+  }
+
+  const validDecisions: ExecApprovalDecision[] = ['allow-once', 'allow-always', 'deny']
+  if (!validDecisions.includes(decision)) {
+    return NextResponse.json({ error: 'Invalid decision' }, { status: 400 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'OpenClaw gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    await gw.rpc('exec.approvals.resolve', { id, decision })
+    return NextResponse.json({ ok: true })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}

package/src/app/api/openclaw/config-sync/route.ts

@@ -0,0 +1,33 @@
+import { NextResponse } from 'next/server'
+import { detectConfigIssues, repairConfigIssue } from '@/lib/server/openclaw-config-sync'
+
+/** GET — detect configuration issues */
+export async function GET() {
+  try {
+    const issues = await detectConfigIssues()
+    return NextResponse.json({ issues })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}
+
+/** POST { issueId } — repair a specific issue */
+export async function POST(req: Request) {
+  const body = await req.json()
+  const { issueId } = body as { issueId?: string }
+  if (!issueId) {
+    return NextResponse.json({ error: 'Missing issueId' }, { status: 400 })
+  }
+
+  try {
+    const result = await repairConfigIssue(issueId)
+    if (!result.ok) {
+      return NextResponse.json({ error: result.error }, { status: 502 })
+    }
+    return NextResponse.json({ ok: true })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}

package/src/app/api/openclaw/cron/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+import type { GatewayCronJob } from '@/types'
+
+/** GET — list all cron jobs from gateway */
+export async function GET() {
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    const result = await gw.rpc('cron.list', { includeDisabled: true }) as GatewayCronJob[] | undefined
+    return NextResponse.json(result ?? [])
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}
+
+/** POST { action, ...params } — add/run/remove cron jobs */
+export async function POST(req: Request) {
+  const body = await req.json()
+  const { action, ...params } = body as { action: string; [key: string]: unknown }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    switch (action) {
+      case 'add': {
+        const result = await gw.rpc('cron.add', params.job)
+        return NextResponse.json({ ok: true, result })
+      }
+      case 'run': {
+        const result = await gw.rpc('cron.run', { id: params.id, mode: 'force' })
+        return NextResponse.json({ ok: true, result })
+      }
+      case 'remove': {
+        await gw.rpc('cron.remove', { id: params.id })
+        return NextResponse.json({ ok: true })
+      }
+      default:
+        return NextResponse.json({ error: `Unknown action: ${action}` }, { status: 400 })
+    }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}

package/src/app/api/openclaw/directory/route.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server'
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  try {
+    const { listRunningConnectors } = await import('@/lib/server/connectors/manager')
+    const openclawConnectors = listRunningConnectors('openclaw')
+
+    if (!openclawConnectors.length) {
+      return NextResponse.json({ devices: [], note: 'No running OpenClaw connector.' })
+    }
+
+    // The directory.list RPC requires gateway support — degrade gracefully
+    return NextResponse.json({
+      devices: [],
+      connectors: openclawConnectors.map((c) => ({
+        id: c.id,
+        name: c.name,
+        platform: c.platform,
+      })),
+      note: 'Directory listing requires OpenClaw gateway directory.list RPC support.',
+    })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Directory listing failed'
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}

package/src/app/api/openclaw/discover/route.ts

@@ -0,0 +1,62 @@
+import { NextResponse } from 'next/server'
+import os from 'node:os'
+import { probeOpenClawHealth } from '@/lib/server/openclaw-health'
+export const dynamic = 'force-dynamic'
+
+const DEFAULT_PORTS = [18789, 18790]
+const PROBE_TIMEOUT_MS = 4000
+
+function getLanIps(): string[] {
+  const interfaces = os.networkInterfaces()
+  const ips: string[] = []
+  for (const iface of Object.values(interfaces)) {
+    if (!iface) continue
+    for (const info of iface) {
+      if (info.family === 'IPv4' && !info.internal) {
+        ips.push(info.address)
+      }
+    }
+  }
+  return ips
+}
+
+export async function GET() {
+  try {
+    const hosts = ['127.0.0.1', ...getLanIps()]
+    const probes: Array<Promise<{
+      host: string
+      port: number
+      healthy: boolean
+      models?: string[]
+      error?: string
+    }>> = []
+
+    for (const host of hosts) {
+      for (const port of DEFAULT_PORTS) {
+        probes.push(
+          probeOpenClawHealth({
+            endpoint: `http://${host}:${port}`,
+            timeoutMs: PROBE_TIMEOUT_MS,
+          }).then((result) => ({
+            host,
+            port,
+            healthy: result.ok,
+            models: result.models.length > 0 ? result.models : undefined,
+            error: result.error || undefined,
+          })).catch(() => ({
+            host,
+            port,
+            healthy: false,
+            error: 'unreachable',
+          })),
+        )
+      }
+    }
+
+    const results = await Promise.all(probes)
+    return NextResponse.json({ gateways: results })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Discovery failed'
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}

package/src/app/api/openclaw/dotenv-keys/route.ts

@@ -0,0 +1,18 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+
+/** GET — list env var keys from gateway .env */
+export async function GET() {
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'OpenClaw gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    const result = await gw.rpc('env.keys') as string[] | undefined
+    return NextResponse.json(result ?? [])
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}

package/src/app/api/openclaw/exec-config/route.ts

@@ -0,0 +1,41 @@
+import { NextResponse } from 'next/server'
+import { getExecConfig, setExecConfig } from '@/lib/server/openclaw-exec-config'
+import type { ExecApprovalConfig } from '@/types'
+
+/** GET ?agentId=X — fetch exec approval config */
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const agentId = searchParams.get('agentId')
+  if (!agentId) {
+    return NextResponse.json({ error: 'Missing agentId' }, { status: 400 })
+  }
+
+  try {
+    const snapshot = await getExecConfig(agentId)
+    return NextResponse.json(snapshot)
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}
+
+/** PUT { agentId, config, baseHash } — save exec approval config */
+export async function PUT(req: Request) {
+  const body = await req.json()
+  const { agentId, config, baseHash } = body as {
+    agentId?: string
+    config?: ExecApprovalConfig
+    baseHash?: string
+  }
+  if (!agentId || !config) {
+    return NextResponse.json({ error: 'Missing agentId or config' }, { status: 400 })
+  }
+
+  try {
+    const result = await setExecConfig(agentId, config, baseHash ?? '')
+    return NextResponse.json(result)
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}

package/src/app/api/openclaw/gateway/route.ts

@@ -0,0 +1,72 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected, getGateway, disconnectGateway, manualConnect } from '@/lib/server/openclaw-gateway'
+
+/** POST — proxy an RPC call or perform gateway actions */
+export async function POST(req: Request) {
+  const body = await req.json()
+  const { method, params } = body as { method?: string; params?: Record<string, unknown> }
+  if (!method || typeof method !== 'string') {
+    return NextResponse.json({ error: 'Missing RPC method' }, { status: 400 })
+  }
+
+  // Gateway control actions
+  if (method === 'gateway.connect') {
+    try {
+      const url = (params?.url as string) || undefined
+      const token = (params?.token as string) || undefined
+      const ok = await manualConnect(url, token)
+      return NextResponse.json({ ok })
+    } catch (err: unknown) {
+      return NextResponse.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, { status: 502 })
+    }
+  }
+
+  if (method === 'gateway.disconnect') {
+    disconnectGateway()
+    return NextResponse.json({ ok: true })
+  }
+
+  // Reload mode get/set
+  if (method === 'gateway.reload-mode.get') {
+    const gw = await ensureGatewayConnected()
+    if (!gw) return NextResponse.json({ error: 'Not connected' }, { status: 503 })
+    try {
+      const config = await gw.rpc('config.get') as Record<string, unknown> | undefined
+      const mode = (config as Record<string, unknown>)?.reloadMode ?? 'hot'
+      return NextResponse.json({ ok: true, result: mode })
+    } catch (err: unknown) {
+      return NextResponse.json({ error: err instanceof Error ? err.message : String(err) }, { status: 502 })
+    }
+  }
+
+  if (method === 'gateway.reload-mode.set') {
+    const gw = await ensureGatewayConnected()
+    if (!gw) return NextResponse.json({ error: 'Not connected' }, { status: 503 })
+    try {
+      await gw.rpc('config.set', { reloadMode: params?.mode })
+      return NextResponse.json({ ok: true })
+    } catch (err: unknown) {
+      return NextResponse.json({ error: err instanceof Error ? err.message : String(err) }, { status: 502 })
+    }
+  }
+
+  // General RPC proxy
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'OpenClaw gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    const result = await gw.rpc(method, params)
+    return NextResponse.json({ ok: true, result })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}
+
+/** GET — check gateway connection status */
+export async function GET() {
+  const gw = getGateway()
+  return NextResponse.json({ connected: !!gw?.connected })
+}