@swarmclawai/swarmclaw 1.2.3 → 1.2.5

package/src/app/api/connectors/[id]/health/route.ts

@@ -1,64 +1,37 @@
 import { NextResponse } from 'next/server'
-import { loadConnectors, loadConnectorHealth } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
+import { getConnectorHealthForApi } from '@/lib/server/connectors/connector-service'
 import type { ConnectorHealthEvent } from '@/types'
 
 export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const connectors = loadConnectors()
-  if (!connectors[id]) return notFound()
-
+  const result = getConnectorHealthForApi(id)
+  if (!result) return notFound()
   const url = new URL(req.url)
   const since = url.searchParams.get('since')
-
-  const allHealth = loadConnectorHealth()
-  const events: ConnectorHealthEvent[] = []
-
-  for (const raw of Object.values(allHealth)) {
-    const entry = raw as ConnectorHealthEvent
-    if (entry.connectorId !== id) continue
-    if (since && entry.timestamp < since) continue
-    events.push(entry)
-  }
-
-  // Sort by timestamp ascending
-  events.sort((a, b) => a.timestamp.localeCompare(b.timestamp))
-
-  // Compute uptime percentage
-  const uptimePercent = computeUptime(events)
-
-  return NextResponse.json({ events, uptimePercent })
+  const events = since ? result.events.filter((entry) => entry.timestamp >= since) : result.events
+  return NextResponse.json({ events, uptimePercent: computeUptime(events) })
 }
 
 function computeUptime(events: ConnectorHealthEvent[]): number {
   if (events.length === 0) return 0
-
   const firstTime = new Date(events[0].timestamp).getTime()
   const now = Date.now()
   const totalMs = now - firstTime
   if (totalMs <= 0) return 100
-
   let uptimeMs = 0
   let lastUpAt: number | null = null
-
-  for (const ev of events) {
-    const t = new Date(ev.timestamp).getTime()
-    if (ev.event === 'started' || ev.event === 'reconnected') {
-      if (lastUpAt === null) {
-        lastUpAt = t
-      }
-    } else if (ev.event === 'stopped' || ev.event === 'error' || ev.event === 'disconnected') {
+  for (const event of events) {
+    const time = new Date(event.timestamp).getTime()
+    if (event.event === 'started' || event.event === 'reconnected') {
+      if (lastUpAt === null) lastUpAt = time
+    } else if (event.event === 'stopped' || event.event === 'error' || event.event === 'disconnected') {
       if (lastUpAt !== null) {
-        uptimeMs += t - lastUpAt
+        uptimeMs += time - lastUpAt
         lastUpAt = null
       }
     }
   }
-
-  // If still up, count time until now
-  if (lastUpAt !== null) {
-    uptimeMs += now - lastUpAt
-  }
-
+  if (lastUpAt !== null) uptimeMs += now - lastUpAt
   return Math.round((uptimeMs / totalMs) * 10000) / 100
 }

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

@@ -1,141 +1,33 @@
 import { NextResponse } from 'next/server'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { loadConnectors, logActivity, upsertStoredItem, deleteStoredItem } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
 import { notFound } from '@/lib/server/collection-helpers'
-import { ensureDaemonStarted } from '@/lib/server/runtime/daemon-state'
-import { errorMessage } from '@/lib/shared-utils'
+import {
+  deleteConnectorFromRoute,
+  getConnectorWithRuntime,
+  updateConnectorFromRoute,
+} from '@/lib/server/connectors/connector-service'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
-  ensureDaemonStarted('api/connectors/[id]:get')
   const { id } = await params
-  const connectors = loadConnectors()
-  const connector = connectors[id]
+  const connector = await getConnectorWithRuntime(id)
   if (!connector) return notFound()
-
-  // Merge runtime status, QR code, and presence
-  try {
-    const { getConnectorStatus, getConnectorQR, isConnectorAuthenticated, hasConnectorCredentials, getConnectorPresence, getReconnectState } = await import('@/lib/server/connectors/manager')
-    const runtimeStatus = getConnectorStatus(id)
-    connector.status = runtimeStatus === 'running'
-      ? 'running'
-      : connector.lastError
-        ? 'error'
-        : 'stopped'
-    const rState = getReconnectState(id)
-    if (rState) {
-      const ext = connector as unknown as Record<string, unknown>
-      ext.reconnectAttempts = rState.attempts
-      ext.nextRetryAt = rState.nextRetryAt
-      ext.reconnectError = rState.error
-      ext.reconnectExhausted = rState.exhausted
-    }
-    const qr = getConnectorQR(id)
-    if (qr) connector.qrDataUrl = qr
-    connector.authenticated = isConnectorAuthenticated(id)
-    connector.hasCredentials = hasConnectorCredentials(id)
-    if (connector.status === 'running') {
-      connector.presence = getConnectorPresence(id)
-    }
-  } catch { /* ignore */ }
-
   return NextResponse.json(connector)
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  ensureDaemonStarted('api/connectors/[id]:put')
   const { id } = await params
   const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
   if (error) return error
-  const connectors = loadConnectors()
-  const connector = connectors[id]
-  if (!connector) return notFound()
-
-  // Handle start/stop/repair actions — these modify connector state internally,
-  // so re-read from storage after to avoid overwriting with stale data
-  if (body.action === 'start' || body.action === 'stop' || body.action === 'repair') {
-    try {
-      const manager = await import('@/lib/server/connectors/manager')
-      if (body.action === 'start') {
-        manager.clearReconnectState(id)
-        await manager.startConnector(id)
-        logActivity({ entityType: 'connector', entityId: id, action: 'started', actor: 'user', summary: `Connector started: "${connector.name}"` })
-      } else if (body.action === 'stop') {
-        await manager.stopConnector(id)
-        logActivity({ entityType: 'connector', entityId: id, action: 'stopped', actor: 'user', summary: `Connector stopped: "${connector.name}"` })
-      } else {
-        manager.clearReconnectState(id)
-        await manager.repairConnector(id)
-        logActivity({ entityType: 'connector', entityId: id, action: 'started', actor: 'user', summary: `Connector repaired: "${connector.name}"` })
-      }
-    } catch (err: unknown) {
-      // Re-read to get the error state saved by startConnector
-      const fresh = loadConnectors()
-      return NextResponse.json(fresh[id] || { error: errorMessage(err) }, { status: 500 })
-    }
-    // Re-read the connector after manager modified it
-    const fresh = loadConnectors()
-    notify('connectors')
-    return NextResponse.json(fresh[id])
-  }
-
-  // Regular update — guard types at the boundary
-  if (body.name !== undefined) connector.name = typeof body.name === 'string' ? body.name : connector.name
-  if (body.agentId !== undefined) connector.agentId = typeof body.agentId === 'string' || body.agentId === null ? body.agentId : connector.agentId
-  if (body.chatroomId !== undefined) connector.chatroomId = typeof body.chatroomId === 'string' || body.chatroomId === null ? body.chatroomId : connector.chatroomId
-  if (body.credentialId !== undefined) connector.credentialId = typeof body.credentialId === 'string' || body.credentialId === null ? body.credentialId : connector.credentialId
-  if (body.config !== undefined) connector.config = body.config && typeof body.config === 'object' && !Array.isArray(body.config) ? body.config as Record<string, string> : connector.config
-  if (body.isEnabled !== undefined) connector.isEnabled = typeof body.isEnabled === 'boolean' ? body.isEnabled : connector.isEnabled
-  connector.updatedAt = Date.now()
-
-  upsertStoredItem('connectors', id, connector)
-
-  try {
-    const manager = await import('@/lib/server/connectors/manager')
-    const wasRunning = manager.getConnectorStatus(id) === 'running'
-    const shouldStop = body.isEnabled === false
-    const shouldReload = wasRunning && (
-      body.name !== undefined
-      || body.agentId !== undefined
-      || body.chatroomId !== undefined
-      || body.credentialId !== undefined
-      || body.config !== undefined
-      || body.isEnabled !== undefined
-    )
-    const shouldStart = body.isEnabled === true && !wasRunning
-
-    if (shouldStop) {
-      await manager.stopConnector(id)
-    } else if (shouldReload || shouldStart) {
-      manager.clearReconnectState(id)
-      await manager.startConnector(id)
-    }
-  } catch {
-    // Keep the saved connector update even if the runtime reload fails.
-  }
-
-  notify('connectors')
-  return NextResponse.json(loadConnectors()[id] || connector)
+  const result = await updateConnectorFromRoute(id, body)
+  if (!result.ok && result.status === 404) return notFound()
+  return result.ok
+    ? NextResponse.json(result.payload)
+    : NextResponse.json(result.payload, { status: result.status })
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const connectors = loadConnectors()
-  if (!connectors[id]) return notFound()
-
-  // Stop if running
-  try {
-    const { stopConnector } = await import('@/lib/server/connectors/manager')
-    await stopConnector(id)
-  } catch { /* ignore */ }
-
-  // Clear persisted pairing state when connector is deleted.
-  try {
-    const { clearConnectorPairingState } = await import('@/lib/server/connectors/pairing')
-    clearConnectorPairingState(id)
-  } catch { /* ignore */ }
-
-  deleteStoredItem('connectors', id)
-  notify('connectors')
-  return NextResponse.json({ ok: true })
+  const result = await deleteConnectorFromRoute(id)
+  if (!result.ok) return notFound()
+  return NextResponse.json(result.payload)
 }

package/src/app/api/connectors/[id]/webhook/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import { loadConnectors } from '@/lib/server/storage'
+import { loadConnectors } from '@/lib/server/connectors/connector-repository'
 
 export const dynamic = 'force-dynamic'
 

package/src/app/api/connectors/doctor/route.ts

@@ -1,6 +1,6 @@
 import { NextResponse } from 'next/server'
 import { buildConnectorDoctorPreview, buildConnectorDoctorReport, type ConnectorDoctorPreviewInput } from '@/lib/server/connectors/doctor'
-import { loadConnectors } from '@/lib/server/storage'
+import { loadConnectors } from '@/lib/server/connectors/connector-repository'
 
 export const dynamic = 'force-dynamic'
 

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

@@ -1,91 +1,33 @@
 import { NextResponse } from 'next/server'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { genId } from '@/lib/id'
 import { perf } from '@/lib/server/runtime/perf'
-import { loadConnectors, upsertStoredItem } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
-import { ensureDaemonStarted } from '@/lib/server/runtime/daemon-state'
 import { ConnectorCreateSchema, formatZodError } from '@/lib/validation/schemas'
 import { z } from 'zod'
-import type { Connector } from '@/types'
+import {
+  autoStartConnectorIfNeeded,
+  createConnector,
+  listConnectorsWithRuntime,
+} from '@/lib/server/connectors/connector-service'
+import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
+import { loadConnector } from '@/lib/server/connectors/connector-repository'
 export const dynamic = 'force-dynamic'
 
-
 export async function GET() {
   const endPerf = perf.start('api', 'GET /api/connectors')
-  ensureDaemonStarted('api/connectors:get')
-  const connectors = loadConnectors()
-  // Merge runtime status from manager
-  try {
-    const { getConnectorStatus, isConnectorAuthenticated, hasConnectorCredentials, getConnectorQR, getReconnectState } = await import('@/lib/server/connectors/manager')
-    for (const c of Object.values(connectors) as Connector[]) {
-      const runtimeStatus = getConnectorStatus(c.id)
-      c.status = runtimeStatus === 'running'
-        ? 'running'
-        : c.lastError
-          ? 'error'
-          : 'stopped'
-      if (c.platform === 'whatsapp') {
-        c.authenticated = isConnectorAuthenticated(c.id)
-        c.hasCredentials = hasConnectorCredentials(c.id)
-        const qr = getConnectorQR(c.id)
-        if (qr) c.qrDataUrl = qr
-      }
-      // Surface reconnect state if connector is in a recovery cycle
-      const rState = getReconnectState(c.id)
-      if (rState) {
-        const ext = c as unknown as Record<string, unknown>
-        ext.reconnectAttempts = rState.attempts
-        ext.nextRetryAt = rState.nextRetryAt
-        ext.reconnectError = rState.error
-        ext.reconnectExhausted = rState.exhausted
-      }
-    }
-  } catch { /* manager not loaded yet */ }
+  const connectors = await listConnectorsWithRuntime()
   endPerf({ count: Object.keys(connectors).length })
   return NextResponse.json(connectors)
 }
 
 export async function POST(req: Request) {
-  ensureDaemonStarted('api/connectors:post')
+  await ensureDaemonProcessRunning('api/connectors:post')
   const { data: raw, error } = await safeParseBody<Record<string, unknown>>(req)
   if (error) return error
   const parsed = ConnectorCreateSchema.safeParse(raw)
   if (!parsed.success) {
     return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
   }
-  const body = parsed.data
-  const id = genId()
-
-  const connector: Connector = {
-    id,
-    name: body.name || `${body.platform} Connector`,
-    platform: body.platform,
-    agentId: body.agentId || null,
-    chatroomId: body.chatroomId || null,
-    credentialId: body.credentialId || null,
-    config: body.config || {},
-    isEnabled: false,
-    status: 'stopped',
-    lastError: null,
-    createdAt: Date.now(),
-    updatedAt: Date.now(),
-  }
-
-  upsertStoredItem('connectors', id, connector)
-  notify('connectors')
-
-  // Auto-start if connector has credentials (or is WhatsApp which uses QR)
-  const hasCredentials = connector.platform === 'whatsapp'
-    || connector.platform === 'openclaw'
-    || (connector.platform === 'bluebubbles' && (!!connector.credentialId || !!connector.config.password))
-    || !!connector.credentialId
-  if (hasCredentials && body.autoStart !== false) {
-    try {
-      const { startConnector } = await import('@/lib/server/connectors/manager')
-      await startConnector(id)
-    } catch { /* auto-start is best-effort */ }
-  }
-
-  return NextResponse.json(loadConnectors()[id] || connector)
+  const connector = createConnector(parsed.data as unknown as Record<string, unknown>)
+  await autoStartConnectorIfNeeded(connector, parsed.data as unknown as Record<string, unknown>)
+  return NextResponse.json(loadConnector(connector.id) || connector)
 }

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

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import { loadCredentials, deleteCredential } from '@/lib/server/storage'
+import { deleteCredentialRecord } from '@/lib/server/credentials/credential-service'
 import { notFound } from '@/lib/server/collection-helpers'
 import { log } from '@/lib/server/logger'
 
@@ -7,11 +7,9 @@ const TAG = 'api-credentials'
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id: credId } = await params
-  const creds = loadCredentials()
-  if (!creds[credId]) {
+  if (!deleteCredentialRecord(credId)) {
     return notFound()
   }
-  deleteCredential(credId)
   log.info(TAG, `deleted ${credId}`)
   return new NextResponse('OK')
 }

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

@@ -1,17 +1,11 @@
 import { NextResponse } from 'next/server'
-import { genId } from '@/lib/id'
-import { loadCredentials, saveCredentials, encryptKey } from '@/lib/server/storage'
+import { createCredentialRecord, listCredentialSummaries } from '@/lib/server/credentials/credential-service'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 export const dynamic = 'force-dynamic'
 
 
-export async function GET(_req: Request) {
-  const creds = loadCredentials()
-  const safe: Record<string, Record<string, unknown>> = {}
-  for (const [id, c] of Object.entries(creds) as [string, Record<string, unknown>][]) {
-    safe[id] = { id: c.id, provider: c.provider, name: c.name, createdAt: c.createdAt }
-  }
-  return NextResponse.json(safe)
+export async function GET() {
+  return NextResponse.json(listCredentialSummaries())
 }
 
 export async function POST(req: Request) {
@@ -21,15 +15,12 @@ export async function POST(req: Request) {
   if (!provider || !apiKey) {
     return NextResponse.json({ error: 'provider and apiKey are required' }, { status: 400 })
   }
-  const id = 'cred_' + genId(6)
-  const creds = loadCredentials()
-  creds[id] = {
-    id,
-    provider,
-    name: name || `${provider} key`,
-    encryptedKey: encryptKey(apiKey),
-    createdAt: Date.now(),
+  try {
+    return NextResponse.json(createCredentialRecord({ provider, name, apiKey }))
+  } catch (err: unknown) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Failed to create credential' },
+      { status: 500 },
+    )
   }
-  saveCredentials(creds)
-  return NextResponse.json({ id, provider, name: creds[id].name, createdAt: creds[id].createdAt })
 }

package/src/app/api/daemon/health-check/route.ts

@@ -1,11 +1,10 @@
 import { NextResponse } from 'next/server'
-import { ensureDaemonStarted, getDaemonStatus, runDaemonHealthCheckNow } from '@/lib/server/runtime/daemon-state'
+import { runDaemonHealthCheckViaAdmin } from '@/lib/server/daemon/controller'
 
 export async function POST() {
-  ensureDaemonStarted('api/daemon/health-check:post')
-  await runDaemonHealthCheckNow()
+  const snapshot = await runDaemonHealthCheckViaAdmin('api/daemon/health-check:post')
   return NextResponse.json({
     ok: true,
-    status: getDaemonStatus(),
+    status: snapshot.status,
   })
 }

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

@@ -1,11 +1,15 @@
 import { NextResponse } from 'next/server'
+import {
+  ensureDaemonProcessRunning,
+  getDaemonStatusSnapshot,
+  stopDaemonProcess,
+} from '@/lib/server/daemon/controller'
 import { notify } from '@/lib/server/ws-hub'
 export const dynamic = 'force-dynamic'
 
 
 export async function GET() {
-  const { getDaemonStatus } = await import('@/lib/server/runtime/daemon-state')
-  return NextResponse.json(getDaemonStatus())
+  return NextResponse.json(await getDaemonStatusSnapshot())
 }
 
 export async function POST(req: Request) {
@@ -13,15 +17,13 @@ export async function POST(req: Request) {
   const action = body.action
 
   if (action === 'start') {
-    const { startDaemon } = await import('@/lib/server/runtime/daemon-state')
-    startDaemon({ source: 'api/daemon:post:start', manualStart: true })
+    await ensureDaemonProcessRunning('api/daemon:post:start', { manualStart: true })
     notify('daemon')
-    return NextResponse.json({ ok: true, status: 'running' })
+    return NextResponse.json(await getDaemonStatusSnapshot())
   } else if (action === 'stop') {
-    const { stopDaemon } = await import('@/lib/server/runtime/daemon-state')
-    await stopDaemon({ source: 'api/daemon:post:stop', manualStop: true })
+    await stopDaemonProcess({ source: 'api/daemon:post:stop', manualStop: true })
     notify('daemon')
-    return NextResponse.json({ ok: true, status: 'stopped' })
+    return NextResponse.json(await getDaemonStatusSnapshot())
   }
 
   return NextResponse.json({ error: 'Invalid action. Use "start" or "stop".' }, { status: 400 })

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

@@ -26,9 +26,10 @@ export async function GET(req: Request) {
   const terms = q.split(/\s+/).filter(Boolean)
   const limit = normalizeLimit(searchParams.get('limit'), 10, 100)
   const rows = Object.values(docs)
-    .map((doc: any) => {
-      const title = String(doc.title || '')
-      const content = String(doc.content || '')
+    .map((doc) => {
+      const d = doc as Record<string, unknown>
+      const title = String(d.title || '')
+      const content = String(d.content || '')
       const hay = `${title}\n${content}`.toLowerCase()
       if (!terms.every((term) => hay.includes(term))) return null
 
@@ -48,18 +49,18 @@ export async function GET(req: Request) {
       const snippet = content.slice(snippetStart, snippetEnd).replace(/\s+/g, ' ').trim()
 
       return {
-        id: doc.id,
-        title: doc.title,
-        fileName: doc.fileName,
-        sourcePath: doc.sourcePath,
-        textLength: doc.textLength || content.length,
-        updatedAt: doc.updatedAt,
+        id: d.id,
+        title: d.title,
+        fileName: d.fileName,
+        sourcePath: d.sourcePath,
+        textLength: (d.textLength as number) || content.length,
+        updatedAt: d.updatedAt,
         score,
         snippet,
       }
     })
     .filter(Boolean)
-    .sort((a: any, b: any) => b.score - a.score)
+    .sort((a, b) => (b as { score: number }).score - (a as { score: number }).score)
     .slice(0, limit)
 
   return NextResponse.json(rows)

package/src/app/api/external-agents/route.ts

@@ -3,7 +3,7 @@ import { genId } from '@/lib/id'
 import { formatZodError, ExternalAgentRegisterSchema } from '@/lib/validation/schemas'
 import { loadExternalAgents, loadGatewayProfiles, saveExternalAgents } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
-import type { ExternalAgentRuntime } from '@/types'
+import type { ExternalAgentRuntime, GatewayProfile } from '@/types'
 import { z } from 'zod'
 export const dynamic = 'force-dynamic'
 
@@ -14,9 +14,9 @@ function withDerivedStatus(record: ExternalAgentRuntime): ExternalAgentRuntime {
   if (!lastSeenAt) return { ...record, status: record.status || 'offline' }
   if (record.status === 'offline') return record
   const gateways = loadGatewayProfiles()
-  const gateway = record.gatewayProfileId ? gateways[record.gatewayProfileId] as any : undefined
+  const gateway = record.gatewayProfileId ? gateways[record.gatewayProfileId] as GatewayProfile | undefined : undefined
   const gatewayTags = Array.isArray(gateway?.tags)
-    ? (gateway as any)?.tags?.filter((tag: any): tag is string => typeof tag === 'string' && tag.trim().length > 0)
+    ? gateway.tags.filter((tag): tag is string => typeof tag === 'string' && tag.trim().length > 0)
     : []
   const gatewayUseCase = gateway?.deployment && typeof gateway.deployment === 'object' && typeof (gateway.deployment as Record<string, unknown>).useCase === 'string'
     ? (gateway.deployment as Record<string, unknown>).useCase as string

package/src/app/api/gateways/[id]/health/route.ts

@@ -1,13 +1,12 @@
 import { NextResponse } from 'next/server'
 import { probeOpenClawHealth, persistGatewayHealthResult } from '@/lib/server/openclaw/health'
-import { loadGatewayProfiles } from '@/lib/server/storage'
+import { loadGatewayProfile } from '@/lib/server/gateways/gateway-profile-repository'
 import { notFound } from '@/lib/server/collection-helpers'
 export const dynamic = 'force-dynamic'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const gateways = loadGatewayProfiles()
-  const gateway = gateways[id]
+  const gateway = loadGatewayProfile(id)
   if (!gateway) return notFound()
 
   const result = await probeOpenClawHealth({