@swarmclawai/swarmclaw 0.4.0 → 0.5.0

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

@@ -0,0 +1,109 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+import { mergeHistoryMessages, isValidSessionKey } from '@/lib/server/openclaw-history-merge'
+import { loadSessions, saveSessions } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import type { GatewaySessionPreview } from '@/types'
+
+/**
+ * Extract a single session preview from the gateway response.
+ * The gateway may return:
+ *  - A map: { [sessionKey]: preview }
+ *  - An array: [preview, ...]
+ *  - A single object with sessionKey field
+ */
+function extractPreview(
+  raw: unknown,
+  sessionKey: string,
+): GatewaySessionPreview | undefined {
+  if (!raw || typeof raw !== 'object') return undefined
+
+  // Direct object with messages array
+  if ('messages' in (raw as Record<string, unknown>)) {
+    return raw as GatewaySessionPreview
+  }
+
+  // Map keyed by session key
+  const asMap = raw as Record<string, unknown>
+  if (asMap[sessionKey] && typeof asMap[sessionKey] === 'object') {
+    return asMap[sessionKey] as GatewaySessionPreview
+  }
+
+  // Array — find matching session
+  if (Array.isArray(raw)) {
+    return raw.find(
+      (p: unknown) =>
+        p && typeof p === 'object' && (p as GatewaySessionPreview).sessionKey === sessionKey,
+    ) as GatewaySessionPreview | undefined
+  }
+
+  return undefined
+}
+
+/** GET ?sessionKey=X — preview gateway session history */
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const sessionKey = searchParams.get('sessionKey')
+  if (!sessionKey || !isValidSessionKey(sessionKey)) {
+    return NextResponse.json({ error: 'Missing or invalid sessionKey' }, { status: 400 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    const raw = await gw.rpc('sessions.preview', { keys: [sessionKey], limit: 100 })
+    const preview = extractPreview(raw, sessionKey)
+    return NextResponse.json(preview ?? { sessionKey, epoch: 0, messages: [] })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}
+
+/** POST { sessionKey, epoch, localSessionId } — merge gateway history into local session */
+export async function POST(req: Request) {
+  const body = await req.json()
+  const { sessionKey, localSessionId } = body as {
+    sessionKey?: string
+    epoch?: number
+    localSessionId?: string
+  }
+  if (!sessionKey || !localSessionId) {
+    return NextResponse.json({ error: 'Missing sessionKey or localSessionId' }, { status: 400 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    const raw = await gw.rpc('sessions.preview', { keys: [sessionKey], limit: 100 })
+    const preview = extractPreview(raw, sessionKey)
+    if (!preview?.messages?.length) {
+      return NextResponse.json({ ok: true, merged: 0 })
+    }
+
+    const sessions = loadSessions()
+    const session = sessions[localSessionId]
+    if (!session) {
+      return NextResponse.json({ error: 'Local session not found' }, { status: 404 })
+    }
+
+    const merged = mergeHistoryMessages(session.messages, preview)
+    const newCount = merged.length - session.messages.length
+    session.messages = merged
+    session.lastActiveAt = Date.now()
+    sessions[localSessionId] = session
+    saveSessions(sessions)
+    notify('sessions')
+
+    return NextResponse.json({ ok: true, merged: newCount })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}

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

@@ -0,0 +1,53 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+import { lookup } from 'mime-types'
+
+const MAX_SIZE = 25 * 1024 * 1024 // 25MB
+
+/** GET ?path=... — proxy agent files (images etc.) from gateway */
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const filePath = searchParams.get('path')
+  if (!filePath) {
+    return NextResponse.json({ error: 'Missing path' }, { status: 400 })
+  }
+
+  // Security: path must be under ~/.openclaw/
+  if (!filePath.includes('.openclaw') && !filePath.includes('.clawdbot')) {
+    return NextResponse.json({ error: 'Path not allowed' }, { status: 403 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    const result = await gw.rpc('files.read', { path: filePath }) as { content?: string; encoding?: string } | undefined
+    if (!result?.content) {
+      return NextResponse.json({ error: 'File not found' }, { status: 404 })
+    }
+
+    const isBase64 = result.encoding === 'base64'
+    const buf = isBase64
+      ? Buffer.from(result.content, 'base64')
+      : Buffer.from(result.content, 'utf-8')
+
+    if (buf.length > MAX_SIZE) {
+      return NextResponse.json({ error: 'File too large' }, { status: 413 })
+    }
+
+    const mimeType = lookup(filePath) || 'application/octet-stream'
+
+    return new NextResponse(buf, {
+      headers: {
+        'Content-Type': mimeType,
+        'Content-Length': String(buf.length),
+        'Cache-Control': 'public, max-age=300',
+      },
+    })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}

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

@@ -0,0 +1,12 @@
+import { NextResponse } from 'next/server'
+import { fetchGatewayModelPolicy, buildAllowedModelKeys } from '@/lib/server/openclaw-models'
+
+/** GET — fetch allowed models for OpenClaw agents from gateway policy */
+export async function GET() {
+  const policy = await fetchGatewayModelPolicy()
+  const models = buildAllowedModelKeys(policy)
+  return NextResponse.json({
+    models: models ?? ['default'],
+    defaultModel: policy?.defaultModel ?? 'default',
+  })
+}

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

@@ -0,0 +1,39 @@
+import { NextResponse } from 'next/server'
+import type { PermissionPreset } from '@/types'
+import { getExecConfig } from '@/lib/server/openclaw-exec-config'
+import { resolvePresetFromConfig, applyPreset } from '@/lib/server/openclaw-permission-presets'
+
+/** GET ?agentId=X — resolve current permission preset */
+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 snap = await getExecConfig(agentId)
+    const preset = resolvePresetFromConfig(snap.file)
+    return NextResponse.json({ preset, config: snap.file })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}
+
+/** PUT { agentId, preset } — apply a permission preset */
+export async function PUT(req: Request) {
+  const body = await req.json()
+  const { agentId, preset } = body as { agentId?: string; preset?: PermissionPreset }
+  if (!agentId || !preset) {
+    return NextResponse.json({ error: 'Missing agentId or preset' }, { status: 400 })
+  }
+
+  try {
+    await applyPreset(agentId, preset)
+    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/sandbox-env/route.ts

@@ -0,0 +1,69 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+
+/** GET — list available and allowed env keys for sandbox */
+export async function GET() {
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    // Get available keys from dotenv
+    const available = await gw.rpc('env.keys') as string[] | undefined
+
+    // Get current config to find allowed keys
+    const config = await gw.rpc('config.get') as Record<string, unknown> | undefined
+    const agents = (config as Record<string, unknown>)?.agents as Record<string, unknown> | undefined
+    const defaults = agents?.defaults as Record<string, unknown> | undefined
+    const sandbox = defaults?.sandbox as Record<string, unknown> | undefined
+    const docker = sandbox?.docker as Record<string, unknown> | undefined
+    const envList = docker?.env as string[] | undefined
+
+    // Parse allowed keys from ${KEY} format
+    const allowed = (envList ?? [])
+      .map((entry) => {
+        const m = entry.match(/^\$\{(.+)\}$/)
+        return m ? m[1] : entry
+      })
+
+    return NextResponse.json({ available: available ?? [], allowed })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}
+
+/** PUT { allowed: string[] } — update sandbox env allowlist */
+export async function PUT(req: Request) {
+  const body = await req.json()
+  const { allowed } = body as { allowed?: string[] }
+  if (!allowed || !Array.isArray(allowed)) {
+    return NextResponse.json({ error: 'Missing allowed array' }, { status: 400 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    // Format as ${KEY} for gateway config
+    const envEntries = allowed.map((key) => `\${${key}}`)
+
+    // Fetch current config hash for conflict detection
+    const config = await gw.rpc('config.get') as Record<string, unknown> | undefined
+    const configHash = (config as Record<string, unknown>)?._hash as string | undefined
+
+    await gw.rpc('config.set', {
+      key: 'agents.defaults.sandbox.docker.env',
+      value: envEntries,
+      baseHash: configHash,
+    })
+
+    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/skills/install/route.ts

@@ -0,0 +1,32 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+
+/** POST { name, installId, timeoutMs? } — install a skill via gateway */
+export async function POST(req: Request) {
+  const body = await req.json()
+  const { name, installId, timeoutMs } = body as {
+    name?: string
+    installId?: string
+    timeoutMs?: number
+  }
+  if (!name) {
+    return NextResponse.json({ error: 'Missing skill name' }, { status: 400 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    const result = await gw.rpc('skills.install', {
+      name,
+      installId,
+      timeoutMs: timeoutMs ?? 120_000,
+    }, (timeoutMs ?? 120_000) + 5_000)
+    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 })
+  }
+}

package/src/app/api/openclaw/skills/remove/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+
+/** POST { skillKey, source } — remove a skill via gateway */
+export async function POST(req: Request) {
+  const body = await req.json()
+  const { skillKey, source } = body as { skillKey?: string; source?: string }
+  if (!skillKey) {
+    return NextResponse.json({ error: 'Missing skillKey' }, { status: 400 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    await gw.rpc('skills.remove', { skillKey, source })
+    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/skills/route.ts

@@ -0,0 +1,82 @@
+import { NextResponse } from 'next/server'
+import { ensureGatewayConnected } from '@/lib/server/openclaw-gateway'
+import { loadAgents, saveAgents } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import type { OpenClawSkillEntry, SkillAllowlistMode } from '@/types'
+
+/** GET ?agentId=X — fetch skills from gateway with eligibility */
+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 })
+  }
+
+  try {
+    const result = await gw.rpc('skills.status', { agentId }) as OpenClawSkillEntry[] | undefined
+    return NextResponse.json(result ?? [])
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}
+
+/** PATCH { skillKey, enabled?, apiKey? } — update a skill's config on gateway */
+export async function PATCH(req: Request) {
+  const body = await req.json()
+  const { skillKey, enabled, apiKey } = body as {
+    skillKey?: string
+    enabled?: boolean
+    apiKey?: string
+  }
+  if (!skillKey) {
+    return NextResponse.json({ error: 'Missing skillKey' }, { status: 400 })
+  }
+
+  const gw = await ensureGatewayConnected()
+  if (!gw) {
+    return NextResponse.json({ error: 'Gateway not connected' }, { status: 503 })
+  }
+
+  try {
+    await gw.rpc('skills.update', { skillKey, enabled, apiKey })
+    return NextResponse.json({ ok: true })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}
+
+/** PUT { agentId, mode, allowedSkills } — save skill allowlist config to agent */
+export async function PUT(req: Request) {
+  const body = await req.json()
+  const { agentId, mode, allowedSkills } = body as {
+    agentId?: string
+    mode?: SkillAllowlistMode
+    allowedSkills?: string[]
+  }
+
+  if (!agentId || !mode) {
+    return NextResponse.json({ error: 'Missing agentId or mode' }, { status: 400 })
+  }
+
+  const agents = loadAgents({ includeTrashed: true })
+  const agent = agents[agentId]
+  if (!agent) {
+    return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
+  }
+
+  agent.openclawSkillMode = mode
+  agent.openclawAllowedSkills = mode === 'selected' ? (allowedSkills ?? []) : undefined
+  agent.updatedAt = Date.now()
+  agents[agentId] = agent
+  saveAgents(agents)
+  notify('agents')
+
+  return NextResponse.json({ ok: true })
+}

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

@@ -0,0 +1,31 @@
+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: unknown) {
+    const message = err instanceof Error ? err.message : 'Sync failed'
+    return NextResponse.json({ error: message }, { 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, Record<string, unknown>>, save: (d: Record<string, Record<string, unknown>>) => 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() {
+  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',