@swarmclawai/swarmclaw 0.4.0 → 0.4.5

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/directory/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server'
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  try {
+    const { listRunningConnectors, getRunningInstance } = 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: any) {
+    return NextResponse.json({ error: err.message || 'Directory listing failed' }, { status: 500 })
+  }
+}

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

@@ -0,0 +1,61 @@
+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: any) {
+    return NextResponse.json({ error: err.message || 'Discovery failed' }, { status: 500 })
+  }
+}

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

@@ -0,0 +1,30 @@
+import { NextResponse } from 'next/server'
+import { runSync, type SyncType } from '@/lib/server/openclaw-sync'
+export const dynamic = 'force-dynamic'
+
+const VALID_ACTIONS = new Set(['push', 'pull', 'both'])
+const VALID_TYPES: SyncType[] = ['memory', 'workspace', 'schedules', 'credentials', 'plugins']
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json()
+    const action = body.action
+    const types = body.types
+
+    if (!action || !VALID_ACTIONS.has(action)) {
+      return NextResponse.json({ error: 'Invalid action. Use push, pull, or both.' }, { status: 400 })
+    }
+    if (!Array.isArray(types) || types.length === 0) {
+      return NextResponse.json({ error: 'types must be a non-empty array.' }, { status: 400 })
+    }
+    const validTypes = types.filter((t: string) => VALID_TYPES.includes(t as SyncType)) as SyncType[]
+    if (validTypes.length === 0) {
+      return NextResponse.json({ error: `No valid types. Use: ${VALID_TYPES.join(', ')}` }, { status: 400 })
+    }
+
+    const results = await runSync({ action, types: validTypes })
+    return NextResponse.json({ ok: true, results })
+  } catch (err: any) {
+    return NextResponse.json({ error: err.message || 'Sync failed' }, { status: 500 })
+  }
+}

package/src/app/api/orchestrator/run/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { loadAgents, loadTasks, saveTasks } from '@/lib/server/storage'
 import { enqueueTask } from '@/lib/server/queue'
 
@@ -16,7 +16,7 @@ export async function POST(req: Request) {
   }
 
   // Create a board task and enqueue it
-  const taskId = crypto.randomBytes(4).toString('hex')
+  const taskId = genId()
   const now = Date.now()
   const tasks = loadTasks()
   tasks[taskId] = {

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

@@ -0,0 +1,55 @@
+import { NextResponse } from 'next/server'
+import { loadProjects, saveProjects, deleteProject, loadAgents, saveAgents, loadTasks, saveTasks, loadSchedules, saveSchedules, loadSkills, saveSkills } from '@/lib/server/storage'
+import { mutateItem, deleteItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
+import { notify } from '@/lib/server/ws-hub'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const ops: CollectionOps<any> = { load: loadProjects, save: saveProjects, deleteFn: deleteProject, topic: 'projects' }
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const projects = loadProjects()
+  if (!projects[id]) return notFound()
+  return NextResponse.json(projects[id])
+}
+
+export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+  const result = mutateItem(ops, id, (project) => {
+    Object.assign(project, body, { updatedAt: Date.now() })
+    delete (project as Record<string, unknown>).id
+    project.id = id
+    return project
+  })
+  if (!result) return notFound()
+  return NextResponse.json(result)
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  if (!deleteItem(ops, id)) return notFound()
+
+  // Clear projectId from referencing entities
+  const clearProjectId = (load: () => Record<string, any>, save: (d: Record<string, any>) => void, topic: string) => {
+    const items = load()
+    let changed = false
+    for (const item of Object.values(items)) {
+      if (item.projectId === id) {
+        item.projectId = undefined
+        changed = true
+      }
+    }
+    if (changed) {
+      save(items)
+      notify(topic)
+    }
+  }
+
+  clearProjectId(loadAgents, saveAgents, 'agents')
+  clearProjectId(loadTasks, saveTasks, 'tasks')
+  clearProjectId(loadSchedules, saveSchedules, 'schedules')
+  clearProjectId(loadSkills, saveSkills, 'skills')
+
+  return NextResponse.json({ ok: true })
+}

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

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server'
+import { genId } from '@/lib/id'
+import { loadProjects, saveProjects } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+export const dynamic = 'force-dynamic'
+
+export async function GET(_req: Request) {
+  return NextResponse.json(loadProjects())
+}
+
+export async function POST(req: Request) {
+  const body = await req.json()
+  const id = genId()
+  const now = Date.now()
+  const projects = loadProjects()
+  projects[id] = {
+    id,
+    name: body.name || 'Unnamed Project',
+    description: body.description || '',
+    color: body.color || undefined,
+    createdAt: now,
+    updatedAt: now,
+  }
+  saveProjects(projects)
+  notify('projects')
+  return NextResponse.json(projects[id])
+}

package/src/app/api/providers/[id]/models/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse } from 'next/server'
 import { loadModelOverrides, saveModelOverrides } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
 import { getProviderList } from '@/lib/providers'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -7,7 +8,7 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   const overrides = loadModelOverrides()
   const providers = getProviderList()
   const provider = providers.find((p) => p.id === id)
-  if (!provider) return new NextResponse(null, { status: 404 })
+  if (!provider) return notFound()
   return NextResponse.json({ models: provider.models, hasOverride: !!overrides[id] })
 }
 

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

@@ -1,37 +1,35 @@
 import { NextResponse } from 'next/server'
 import { loadProviderConfigs, saveProviderConfigs } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
+import { mutateItem, deleteItem, notFound, badRequest, type CollectionOps } from '@/lib/server/collection-helpers'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const ops: CollectionOps<any> = { load: loadProviderConfigs, save: saveProviderConfigs, topic: 'providers' }
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const configs = loadProviderConfigs()
   const config = configs[id]
-  if (!config) return new NextResponse(null, { status: 404 })
+  if (!config) return notFound()
   return NextResponse.json(config)
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json()
-  const configs = loadProviderConfigs()
-  const existing = configs[id]
-  if (!existing) return new NextResponse(null, { status: 404 })
-  configs[id] = { ...existing, ...body, id, updatedAt: Date.now() }
-  saveProviderConfigs(configs)
-  notify('providers')
-  return NextResponse.json(configs[id])
+  const result = mutateItem(ops, id, (existing) => ({
+    ...existing, ...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 configs = loadProviderConfigs()
-  if (!configs[id]) return new NextResponse(null, { status: 404 })
-  // Only allow deleting custom providers
+  if (!configs[id]) return notFound()
   if (configs[id].type === 'builtin') {
-    return NextResponse.json({ error: 'Cannot delete built-in providers' }, { status: 400 })
+    return badRequest('Cannot delete built-in providers')
   }
-  delete configs[id]
-  saveProviderConfigs(configs)
-  notify('providers')
+  if (!deleteItem(ops, id)) return notFound()
   return NextResponse.json({ ok: true })
 }

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

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { getProviderList } from '@/lib/providers'
 import { loadProviderConfigs, saveProviderConfigs } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
@@ -13,7 +13,7 @@ export async function GET(_req: Request) {
 export async function POST(req: Request) {
   const body = await req.json()
   const configs = loadProviderConfigs()
-  const id = body.id || `custom-${crypto.randomBytes(4).toString('hex')}`
+  const id = body.id || `custom-${genId()}`
   configs[id] = {
     id,
     name: body.name || 'Custom Provider',

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

@@ -1,31 +1,29 @@
 import { NextResponse } from 'next/server'
 import { loadSchedules, saveSchedules, deleteSchedule } from '@/lib/server/storage'
 import { resolveScheduleName } from '@/lib/schedule-name'
-import { notify } from '@/lib/server/ws-hub'
+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: loadSchedules, save: saveSchedules, deleteFn: deleteSchedule, topic: 'schedules' }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json()
-  const schedules = loadSchedules()
-  if (!schedules[id]) return new NextResponse(null, { status: 404 })
-
-  const origId = id
-  Object.assign(schedules[id], body)
-  schedules[id].id = origId
-  schedules[id].name = resolveScheduleName({
-    name: schedules[id].name,
-    taskPrompt: schedules[id].taskPrompt,
+  const result = mutateItem(ops, id, (schedule) => {
+    Object.assign(schedule, body)
+    schedule.id = id
+    schedule.name = resolveScheduleName({
+      name: schedule.name,
+      taskPrompt: schedule.taskPrompt,
+    })
+    return schedule
   })
-  saveSchedules(schedules)
-  notify('schedules')
-  return NextResponse.json(schedules[id])
+  if (!result) return notFound()
+  return NextResponse.json(result)
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const schedules = loadSchedules()
-  if (!schedules[id]) return new NextResponse(null, { status: 404 })
-  deleteSchedule(id)
-  notify('schedules')
-  return NextResponse.json('ok')
+  if (!deleteItem(ops, id)) return notFound()
+  return NextResponse.json({ ok: true })
 }

package/src/app/api/schedules/[id]/run/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse } from 'next/server'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
+import { notFound } from '@/lib/server/collection-helpers'
 import { loadSchedules, saveSchedules, loadAgents, loadTasks, saveTasks } from '@/lib/server/storage'
 import { enqueueTask } from '@/lib/server/queue'
 import { pushMainLoopEventToMainSessions } from '@/lib/server/main-agent-loop'
@@ -14,7 +15,7 @@ export async function POST(_req: Request, { params }: { params: Promise<{ id: st
   const { id } = await params
   const schedules = loadSchedules()
   const schedule = schedules[id]
-  if (!schedule) return new NextResponse(null, { status: 404 })
+  if (!schedule) return notFound()
 
   const agents = loadAgents()
   const agent = agents[schedule.agentId]
@@ -64,7 +65,7 @@ export async function POST(_req: Request, { params }: { params: Promise<{ id: st
     existingTask.validation = null
     prev.runNumber = schedule.runNumber
   } else {
-    taskId = crypto.randomBytes(4).toString('hex')
+    taskId = genId()
     tasks[taskId] = {
       id: taskId,
       title: `[Sched] ${schedule.name} (run #${schedule.runNumber})`,

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

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { loadSchedules, saveSchedules } from '@/lib/server/storage'
 import { resolveScheduleName } from '@/lib/schedule-name'
 import { findDuplicateSchedule } from '@/lib/schedule-dedupe'
@@ -51,7 +51,7 @@ export async function POST(req: Request) {
     return NextResponse.json(duplicate)
   }
 
-  const id = crypto.randomBytes(4).toString('hex')
+  const id = genId()
 
   let nextRunAt: number | undefined
   if (scheduleType === 'once' && body.runAt) {

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

@@ -1,29 +1,28 @@
 import { NextResponse } from 'next/server'
 import { loadSecrets, saveSecrets } 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: loadSecrets, save: saveSecrets }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const secrets = loadSecrets()
-  if (!secrets[id]) return new NextResponse(null, { status: 404 })
-  delete secrets[id]
-  saveSecrets(secrets)
-  return NextResponse.json('ok')
+  if (!deleteItem(ops, id)) return notFound()
+  return NextResponse.json({ ok: true })
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json()
-  const secrets = loadSecrets()
-  if (!secrets[id]) return new NextResponse(null, { status: 404 })
-
-  // Update metadata only (not the encrypted value unless a new value is provided)
-  if (body.name !== undefined) secrets[id].name = body.name
-  if (body.service !== undefined) secrets[id].service = body.service
-  if (body.scope !== undefined) secrets[id].scope = body.scope
-  if (body.agentIds !== undefined) secrets[id].agentIds = body.agentIds
-  secrets[id].updatedAt = Date.now()
-  saveSecrets(secrets)
-
-  const { encryptedValue, ...safe } = secrets[id]
+  const result = mutateItem(ops, id, (secret) => {
+    if (body.name !== undefined) secret.name = body.name
+    if (body.service !== undefined) secret.service = body.service
+    if (body.scope !== undefined) secret.scope = body.scope
+    if (body.agentIds !== undefined) secret.agentIds = body.agentIds
+    secret.updatedAt = Date.now()
+    return secret
+  })
+  if (!result) return notFound()
+  const { encryptedValue, ...safe } = result as Record<string, any>
   return NextResponse.json(safe)
 }

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

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { loadSecrets, saveSecrets, encryptKey } from '@/lib/server/storage'
 export const dynamic = 'force-dynamic'
 
@@ -18,7 +18,7 @@ export async function GET(_req: Request) {
 
 export async function POST(req: Request) {
   const body = await req.json()
-  const id = crypto.randomBytes(4).toString('hex')
+  const id = genId()
   const now = Date.now()
   const secrets = loadSecrets()
 

package/src/app/api/sessions/[id]/clear/route.ts

@@ -1,10 +1,11 @@
 import { NextResponse } from 'next/server'
 import { loadSessions, saveSessions } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const sessions = loadSessions()
-  if (!sessions[id]) return new NextResponse(null, { status: 404 })
+  if (!sessions[id]) return notFound()
   sessions[id].messages = []
   sessions[id].claudeSessionId = null
   sessions[id].codexThreadId = null

package/src/app/api/sessions/[id]/deploy/route.ts

@@ -1,12 +1,13 @@
 import { NextResponse } from 'next/server'
 import { execSync } from 'child_process'
 import { loadSessions } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const sessions = loadSessions()
   const session = sessions[id]
-  if (!session) return new NextResponse(null, { status: 404 })
+  if (!session) return notFound()
 
   const body = await req.json()
   const msg = body.message || 'Deploy from SwarmClaw'

package/src/app/api/sessions/[id]/devserver/route.ts

@@ -1,12 +1,13 @@
 import { NextResponse } from 'next/server'
 import { spawn } from 'child_process'
 import { loadSessions, devServers, localIP } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const sessions = loadSessions()
   const session = sessions[id]
-  if (!session) return new NextResponse(null, { status: 404 })
+  if (!session) return notFound()
 
   const { action } = await req.json()
 

package/src/app/api/sessions/[id]/messages/route.ts

@@ -1,9 +1,10 @@
 import { NextResponse } from 'next/server'
 import { loadSessions } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const sessions = loadSessions()
-  if (!sessions[id]) return new NextResponse(null, { status: 404 })
+  if (!sessions[id]) return notFound()
   return NextResponse.json(sessions[id].messages)
 }

package/src/app/api/sessions/[id]/retry/route.ts

@@ -1,11 +1,12 @@
 import { NextResponse } from 'next/server'
 import { loadSessions, saveSessions } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const sessions = loadSessions()
   const session = sessions[id]
-  if (!session) return new NextResponse(null, { status: 404 })
+  if (!session) return notFound()
 
   const msgs = session.messages
   // Pop trailing assistant messages to find the last user message

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

@@ -1,5 +1,6 @@
 import { NextResponse } from 'next/server'
 import { loadSessions, saveSessions, deleteSession, active, loadAgents } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
 import { enqueueSessionRun } from '@/lib/server/session-run-manager'
 import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
 
@@ -20,7 +21,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   const { id } = await params
   const updates = await req.json()
   const sessions = loadSessions()
-  if (!sessions[id]) return new NextResponse(null, { status: 404 })
+  if (!sessions[id]) return notFound()
   const hadMessagesBefore = Array.isArray(sessions[id].messages) && sessions[id].messages.length > 0
 
   const agentIdUpdateProvided = updates.agentId !== undefined

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

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import os from 'os'
 import path from 'path'
 import { loadSessions, saveSessions, deleteSession, active, loadAgents } from '@/lib/server/storage'
@@ -46,7 +46,7 @@ export async function POST(req: Request) {
   else if (cwd === '~') cwd = os.homedir()
   else if (!cwd) cwd = WORKSPACE_DIR
 
-  const id = body.id || crypto.randomBytes(4).toString('hex')
+  const id = body.id || genId()
   const sessions = loadSessions()
   const agent = body.agentId ? loadAgents()[body.agentId] : null
   const requestedTools = Array.isArray(body.tools) ? body.tools : null