@swarmclawai/swarmclaw 1.2.4 → 1.2.6

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

@@ -1,135 +1,20 @@
 import { NextResponse } from 'next/server'
-import { normalizeOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
-import { loadAgents, loadGatewayProfiles, saveGatewayProfiles, upsertAgent } from '@/lib/server/storage'
-import { mutateItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
-import type { Agent, AgentRoutingTarget, GatewayProfile, OpenClawDeploymentConfig, OpenClawGatewayStats } from '@/types'
-
-const ops: CollectionOps<GatewayProfile> = {
-  load: loadGatewayProfiles,
-  save: saveGatewayProfiles,
-  topic: 'gateways',
-}
-
-function normalizeTags(value: unknown): string[] {
-  if (!Array.isArray(value)) return []
-  return value
-    .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
-    .filter(Boolean)
-}
-
-function normalizeText(value: unknown): string | null {
-  return typeof value === 'string' && value.trim() ? value.trim() : null
-}
-
-function normalizeNullableNumber(value: unknown): number | null {
-  return typeof value === 'number' && Number.isFinite(value) ? value : null
-}
-
-function normalizeDeployment(value: unknown): OpenClawDeploymentConfig | null {
-  if (!value || typeof value !== 'object') return null
-  const deployment = value as Record<string, unknown>
-  return {
-    method: normalizeText(deployment.method) as OpenClawDeploymentConfig['method'],
-    provider: normalizeText(deployment.provider) as OpenClawDeploymentConfig['provider'],
-    remoteTarget: normalizeText(deployment.remoteTarget) as OpenClawDeploymentConfig['remoteTarget'],
-    useCase: normalizeText(deployment.useCase) as OpenClawDeploymentConfig['useCase'],
-    exposure: normalizeText(deployment.exposure) as OpenClawDeploymentConfig['exposure'],
-    managedBy: normalizeText(deployment.managedBy) as OpenClawDeploymentConfig['managedBy'],
-    localInstanceId: normalizeText(deployment.localInstanceId),
-    localPort: normalizeNullableNumber(deployment.localPort),
-    targetHost: normalizeText(deployment.targetHost),
-    sshHost: normalizeText(deployment.sshHost),
-    sshUser: normalizeText(deployment.sshUser),
-    sshPort: normalizeNullableNumber(deployment.sshPort),
-    sshKeyPath: normalizeText(deployment.sshKeyPath),
-    sshTargetDir: normalizeText(deployment.sshTargetDir),
-    image: normalizeText(deployment.image),
-    version: normalizeText(deployment.version),
-    lastDeployAt: normalizeNullableNumber(deployment.lastDeployAt),
-    lastDeployAction: normalizeText(deployment.lastDeployAction),
-    lastDeployProcessId: normalizeText(deployment.lastDeployProcessId),
-    lastDeploySummary: normalizeText(deployment.lastDeploySummary),
-    lastVerifiedAt: normalizeNullableNumber(deployment.lastVerifiedAt),
-    lastVerifiedOk: typeof deployment.lastVerifiedOk === 'boolean' ? deployment.lastVerifiedOk : null,
-    lastVerifiedMessage: normalizeText(deployment.lastVerifiedMessage),
-    lastBackupPath: normalizeText(deployment.lastBackupPath),
-  }
-}
-
-function normalizeStats(value: unknown): OpenClawGatewayStats | null {
-  if (!value || typeof value !== 'object') return null
-  const stats = value as Record<string, unknown>
-  return {
-    nodeCount: normalizeNullableNumber(stats.nodeCount) ?? undefined,
-    connectedNodeCount: normalizeNullableNumber(stats.connectedNodeCount) ?? undefined,
-    pendingNodePairings: normalizeNullableNumber(stats.pendingNodePairings) ?? undefined,
-    pairedDeviceCount: normalizeNullableNumber(stats.pairedDeviceCount) ?? undefined,
-    pendingDevicePairings: normalizeNullableNumber(stats.pendingDevicePairings) ?? undefined,
-    externalRuntimeCount: normalizeNullableNumber(stats.externalRuntimeCount) ?? undefined,
-  }
-}
+import { notFound } from '@/lib/server/collection-helpers'
+import {
+  deleteGatewayProfileAndDetachAgents,
+  updateGatewayProfile,
+} from '@/lib/server/gateways/gateway-profile-service'
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json().catch(() => ({}))
-  const result = mutateItem(ops, id, (gateway, all) => {
-    if (body.isDefault === true) {
-      for (const [candidateId, candidate] of Object.entries(all)) {
-        if (candidateId === id || !candidate || typeof candidate !== 'object') continue
-        candidate.isDefault = false
-      }
-    }
-    if (body.name !== undefined) gateway.name = String(body.name || '').trim() || gateway.name
-    if (body.endpoint !== undefined) gateway.endpoint = normalizeOpenClawEndpoint(body.endpoint || undefined)
-    if (body.wsUrl !== undefined) gateway.wsUrl = body.wsUrl || null
-    if (body.credentialId !== undefined) gateway.credentialId = body.credentialId || null
-    if (body.status !== undefined) gateway.status = body.status || 'unknown'
-    if (body.notes !== undefined) gateway.notes = body.notes || null
-    if (body.tags !== undefined) gateway.tags = normalizeTags(body.tags)
-    if (body.lastError !== undefined) gateway.lastError = body.lastError || null
-    if (body.lastCheckedAt !== undefined) gateway.lastCheckedAt = body.lastCheckedAt || null
-    if (body.lastModelCount !== undefined) gateway.lastModelCount = body.lastModelCount || null
-    if (body.discoveredHost !== undefined) gateway.discoveredHost = body.discoveredHost || null
-    if (body.discoveredPort !== undefined) gateway.discoveredPort = body.discoveredPort || null
-    if (body.deployment !== undefined) gateway.deployment = { ...(gateway.deployment || {}), ...(normalizeDeployment(body.deployment) || {}) }
-    if (body.stats !== undefined) gateway.stats = { ...(gateway.stats || {}), ...(normalizeStats(body.stats) || {}) }
-    if (body.isDefault !== undefined) gateway.isDefault = body.isDefault === true
-    gateway.updatedAt = Date.now()
-    return gateway
-  })
+  const result = updateGatewayProfile(id, body as Record<string, unknown>)
   if (!result) return notFound()
   return NextResponse.json(result)
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const gateways = loadGatewayProfiles()
-  if (!gateways[id]) return notFound()
-  delete gateways[id]
-  saveGatewayProfiles(gateways)
-
-  const agents = loadAgents({ includeTrashed: true })
-  const changedAgents: Agent[] = []
-  for (const agent of Object.values(agents) as Agent[]) {
-    let changed = false
-    if (agent.gatewayProfileId === id) {
-      agent.gatewayProfileId = null
-      changed = true
-    }
-    if (Array.isArray(agent.routingTargets)) {
-      const nextTargets = agent.routingTargets.map((target: AgentRoutingTarget) => (
-        target.gatewayProfileId === id
-          ? { ...target, gatewayProfileId: null }
-          : target
-      ))
-      if (JSON.stringify(nextTargets) !== JSON.stringify(agent.routingTargets)) {
-        agent.routingTargets = nextTargets
-        changed = true
-      }
-    }
-    if (changed) changedAgents.push(agent)
-  }
-  for (const agent of changedAgents) upsertAgent(agent.id, agent)
-
+  if (!deleteGatewayProfileAndDetachAgents(id)) return notFound()
   return NextResponse.json({ ok: true })
 }

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

@@ -1,112 +1,12 @@
 import { NextResponse } from 'next/server'
-import { genId } from '@/lib/id'
-import { normalizeOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
-import { getGatewayProfiles } from '@/lib/server/agents/agent-runtime-config'
-import { loadGatewayProfiles, saveGatewayProfiles } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
-import type { OpenClawDeploymentConfig, OpenClawGatewayStats } from '@/types'
+import { createGatewayProfile, listOpenClawGatewayProfiles } from '@/lib/server/gateways/gateway-profile-service'
 export const dynamic = 'force-dynamic'
 
-function normalizeTags(value: unknown): string[] {
-  if (!Array.isArray(value)) return []
-  return value
-    .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
-    .filter(Boolean)
-}
-
-function normalizeText(value: unknown): string | null {
-  return typeof value === 'string' && value.trim() ? value.trim() : null
-}
-
-function normalizeNullableNumber(value: unknown): number | null {
-  return typeof value === 'number' && Number.isFinite(value) ? value : null
-}
-
-function normalizeDeployment(value: unknown): OpenClawDeploymentConfig | null {
-  if (!value || typeof value !== 'object') return null
-  const deployment = value as Record<string, unknown>
-  return {
-    method: normalizeText(deployment.method) as OpenClawDeploymentConfig['method'],
-    provider: normalizeText(deployment.provider) as OpenClawDeploymentConfig['provider'],
-    remoteTarget: normalizeText(deployment.remoteTarget) as OpenClawDeploymentConfig['remoteTarget'],
-    useCase: normalizeText(deployment.useCase) as OpenClawDeploymentConfig['useCase'],
-    exposure: normalizeText(deployment.exposure) as OpenClawDeploymentConfig['exposure'],
-    managedBy: normalizeText(deployment.managedBy) as OpenClawDeploymentConfig['managedBy'],
-    localInstanceId: normalizeText(deployment.localInstanceId),
-    localPort: normalizeNullableNumber(deployment.localPort),
-    targetHost: normalizeText(deployment.targetHost),
-    sshHost: normalizeText(deployment.sshHost),
-    sshUser: normalizeText(deployment.sshUser),
-    sshPort: normalizeNullableNumber(deployment.sshPort),
-    sshKeyPath: normalizeText(deployment.sshKeyPath),
-    sshTargetDir: normalizeText(deployment.sshTargetDir),
-    image: normalizeText(deployment.image),
-    version: normalizeText(deployment.version),
-    lastDeployAt: normalizeNullableNumber(deployment.lastDeployAt),
-    lastDeployAction: normalizeText(deployment.lastDeployAction),
-    lastDeployProcessId: normalizeText(deployment.lastDeployProcessId),
-    lastDeploySummary: normalizeText(deployment.lastDeploySummary),
-    lastVerifiedAt: normalizeNullableNumber(deployment.lastVerifiedAt),
-    lastVerifiedOk: typeof deployment.lastVerifiedOk === 'boolean' ? deployment.lastVerifiedOk : null,
-    lastVerifiedMessage: normalizeText(deployment.lastVerifiedMessage),
-    lastBackupPath: normalizeText(deployment.lastBackupPath),
-  }
-}
-
-function normalizeStats(value: unknown): OpenClawGatewayStats | null {
-  if (!value || typeof value !== 'object') return null
-  const stats = value as Record<string, unknown>
-  return {
-    nodeCount: normalizeNullableNumber(stats.nodeCount) ?? undefined,
-    connectedNodeCount: normalizeNullableNumber(stats.connectedNodeCount) ?? undefined,
-    pendingNodePairings: normalizeNullableNumber(stats.pendingNodePairings) ?? undefined,
-    pairedDeviceCount: normalizeNullableNumber(stats.pairedDeviceCount) ?? undefined,
-    pendingDevicePairings: normalizeNullableNumber(stats.pendingDevicePairings) ?? undefined,
-    externalRuntimeCount: normalizeNullableNumber(stats.externalRuntimeCount) ?? undefined,
-  }
-}
-
 export async function GET() {
-  return NextResponse.json(getGatewayProfiles('openclaw'))
+  return NextResponse.json(listOpenClawGatewayProfiles())
 }
 
 export async function POST(req: Request) {
   const body = await req.json().catch(() => ({}))
-  const endpoint = normalizeOpenClawEndpoint(body.endpoint || undefined)
-  const now = Date.now()
-  const gateways = loadGatewayProfiles()
-  const id = body.id || `gateway-${genId()}`
-  const isDefault = body.isDefault === true
-
-  if (isDefault) {
-    for (const gateway of Object.values(gateways) as any[]) {
-      gateway.isDefault = false
-    }
-  }
-
-  gateways[id] = {
-    id,
-    name: typeof body.name === 'string' && body.name.trim() ? body.name.trim() : 'OpenClaw Gateway',
-    provider: 'openclaw',
-    endpoint,
-    wsUrl: body.wsUrl || null,
-    credentialId: body.credentialId || null,
-    status: body.status || 'unknown',
-    notes: typeof body.notes === 'string' ? body.notes : null,
-    tags: normalizeTags(body.tags),
-    lastError: null,
-    lastCheckedAt: null,
-    lastModelCount: null,
-    discoveredHost: typeof body.discoveredHost === 'string' ? body.discoveredHost : null,
-    discoveredPort: typeof body.discoveredPort === 'number' ? body.discoveredPort : null,
-    deployment: normalizeDeployment(body.deployment),
-    stats: normalizeStats(body.stats),
-    isDefault,
-    createdAt: now,
-    updatedAt: now,
-  }
-
-  saveGatewayProfiles(gateways)
-  notify('gateways')
-  return NextResponse.json(gateways[id])
+  return NextResponse.json(createGatewayProfile(body as Record<string, unknown>))
 }

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

@@ -9,22 +9,22 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   const config = servers[id]
   if (!config) return notFound()
 
-  let client: any
-  let transport: any
+  let client: Awaited<ReturnType<typeof connectMcpServer>>['client'] | null = null
+  let transport: Awaited<ReturnType<typeof connectMcpServer>>['transport'] | null = null
   try {
     const conn = await connectMcpServer(config)
     client = conn.client
     transport = conn.transport
     const { tools } = await client.listTools()
     return NextResponse.json(
-      tools.map((t: any) => ({
+      tools.map((t: { name: string; description?: string; inputSchema?: unknown }) => ({
         name: t.name,
         description: t.description ?? '',
         inputSchema: t.inputSchema ?? {},
       }))
     )
-  } catch (err: any) {
-    return NextResponse.json({ error: err.message }, { status: 502 })
+  } catch (err: unknown) {
+    return NextResponse.json({ error: err instanceof Error ? err.message : 'MCP connection failed' }, { status: 502 })
   } finally {
     if (client && transport) {
       await disconnectMcpServer(client, transport)

package/src/app/api/openclaw/dashboard-url/route.ts

@@ -1,5 +1,7 @@
 import { NextResponse } from 'next/server'
-import { loadAgents, loadGatewayProfiles, loadCredentials, decryptKey } from '@/lib/server/storage'
+import { getAgent } from '@/lib/server/agents/agent-repository'
+import { getGatewayProfile } from '@/lib/server/agents/agent-runtime-config'
+import { resolveCredentialSecret } from '@/lib/server/credentials/credential-service'
 
 /** GET ?agentId=X — resolve the tokenized dashboard URL for an OpenClaw agent's gateway */
 export async function GET(req: Request) {
@@ -9,8 +11,7 @@ export async function GET(req: Request) {
     return NextResponse.json({ error: 'Missing agentId' }, { status: 400 })
   }
 
-  const agents = loadAgents()
-  const agent = agents[agentId]
+  const agent = getAgent(agentId)
   if (!agent) {
     return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
   }
@@ -24,8 +25,7 @@ export async function GET(req: Request) {
 
   // If agent has a gatewayProfileId, prefer its endpoint and credential
   if (agent.gatewayProfileId) {
-    const gateways = loadGatewayProfiles()
-    const gw = gateways[agent.gatewayProfileId]
+    const gw = getGatewayProfile(agent.gatewayProfileId)
     if (gw) {
       endpoint = gw.endpoint || endpoint
       credentialId = gw.credentialId || credentialId
@@ -50,17 +50,9 @@ export async function GET(req: Request) {
 
   // Decrypt the token if we have a credential
   if (credentialId) {
-    try {
-      const creds = loadCredentials()
-      const cred = creds[credentialId]
-      if (cred?.encryptedKey) {
-        const token = decryptKey(cred.encryptedKey)
-        if (token) {
-          dashboardUrl = `${dashboardUrl}?token=${encodeURIComponent(token)}`
-        }
-      }
-    } catch {
-      // If decryption fails, return the URL without token
+    const token = resolveCredentialSecret(credentialId)
+    if (token) {
+      dashboardUrl = `${dashboardUrl}?token=${encodeURIComponent(token)}`
     }
   }
 

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

@@ -1,10 +1,10 @@
 import { NextResponse } from 'next/server'
+import { listDaemonRunningConnectors } from '@/lib/server/daemon/controller'
 export const dynamic = 'force-dynamic'
 
 export async function GET() {
   try {
-    const { listRunningConnectors } = await import('@/lib/server/connectors/manager')
-    const openclawConnectors = listRunningConnectors('openclaw')
+    const openclawConnectors = await listDaemonRunningConnectors('openclaw')
 
     if (!openclawConnectors.length) {
       return NextResponse.json({ devices: [], note: 'No running OpenClaw connector.' })

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

@@ -1,7 +1,7 @@
 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 { getSession, saveSession } from '@/lib/server/sessions/session-repository'
 import { notify } from '@/lib/server/ws-hub'
 import type { GatewaySessionPreview } from '@/types'
 import { errorMessage } from '@/lib/shared-utils'
@@ -90,8 +90,7 @@ export async function POST(req: Request) {
       return NextResponse.json({ ok: true, merged: 0 })
     }
 
-    const sessions = loadSessions()
-    const session = sessions[localSessionId]
+    const session = getSession(localSessionId)
     if (!session) {
       return NextResponse.json({ error: 'Local session not found' }, { status: 404 })
     }
@@ -100,8 +99,7 @@ export async function POST(req: Request) {
     const newCount = merged.length - session.messages.length
     session.messages = merged
     session.lastActiveAt = Date.now()
-    sessions[localSessionId] = session
-    saveSessions(sessions)
+    saveSession(localSessionId, session)
     notify('sessions')
 
     return NextResponse.json({ ok: true, merged: newCount })

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

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('provider route upserts builtin override records for enablement changes', () => {
+  const output = runWithTempDataDir<{
+    providerConfig: {
+      id: string
+      type: string
+      name: string
+      isEnabled: boolean
+      requiresApiKey: boolean
+    }
+    responsePayload: {
+      id: string
+      type: string
+      isEnabled: boolean
+    }
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const routeMod = await import('./src/app/api/providers/[id]/route')
+    const storage = storageMod.default || storageMod
+    const route = routeMod.default || routeMod
+
+    const response = await route.PUT(
+      new Request('http://local/api/providers/openai', {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ isEnabled: false }),
+      }),
+      { params: Promise.resolve({ id: 'openai' }) },
+    )
+
+    console.log(JSON.stringify({
+      providerConfig: storage.loadProviderConfigs().openai,
+      responsePayload: await response.json(),
+    }))
+  `, { prefix: 'swarmclaw-provider-route-test-' })
+
+  assert.equal(output.providerConfig.id, 'openai')
+  assert.equal(output.providerConfig.type, 'builtin')
+  assert.equal(output.providerConfig.name, 'OpenAI')
+  assert.equal(output.providerConfig.isEnabled, false)
+  assert.equal(output.providerConfig.requiresApiKey, true)
+  assert.equal(output.responsePayload.id, 'openai')
+  assert.equal(output.responsePayload.type, 'builtin')
+  assert.equal(output.responsePayload.isEnabled, false)
+})

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

@@ -13,18 +13,19 @@ export async function GET(req: Request) {
       return NextResponse.json({ models: [], error: `Ollama returned ${res.status}` })
     }
     const data = await res.json()
-    const models = (data.models || []).map((m: any) => ({
-      name: m.name?.replace(/:latest$/, '') || m.name,
+    const models = (data.models || []).map((m: Record<string, unknown>) => ({
+      name: typeof m.name === 'string' ? m.name.replace(/:latest$/, '') : m.name,
       size: m.size,
       modified: m.modified_at,
     }))
     return NextResponse.json({ models })
-  } catch (err: any) {
+  } catch (err: unknown) {
+    const e = err as Record<string, unknown>
     return NextResponse.json({
       models: [],
-      error: err.code === 'ECONNREFUSED'
+      error: e.code === 'ECONNREFUSED'
         ? 'Ollama is not running'
-        : err.message || 'Failed to connect',
+        : (err instanceof Error ? err.message : 'Failed to connect'),
     })
   }
 }

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

@@ -1,123 +1,29 @@
 import { NextResponse } from 'next/server'
-import { loadAgents, loadSchedules, loadSessions, logActivity, upsertSchedules } from '@/lib/server/storage'
-import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { notFound } from '@/lib/server/collection-helpers'
-import { prepareScheduleUpdate } from '@/lib/server/schedules/schedule-service'
-import {
-  archiveScheduleCluster,
-  purgeArchivedScheduleCluster,
-  restoreArchivedScheduleCluster,
-} from '@/lib/server/schedules/schedule-lifecycle'
-import { errorMessage } from '@/lib/shared-utils'
-import { notify } from '@/lib/server/ws-hub'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
+import {
+  deleteScheduleFromRoute,
+  updateScheduleFromRoute,
+} from '@/lib/server/schedules/schedule-route-service'
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const { data: body, error } = await safeParseBody(req)
   if (error) return error
-  const schedules = loadSchedules()
-  const current = schedules[id]
-  if (!current) return notFound()
-
-  if (body?.restore === true) {
-    const restored = restoreArchivedScheduleCluster(id, {
-      actor: { actor: 'user' },
-    })
-    if (!restored.ok || !restored.schedule) {
-      return NextResponse.json({ error: 'Schedule is not archived.' }, { status: 409 })
-    }
-    return NextResponse.json({
-      ...restored.schedule,
-      restoredIds: restored.restoredIds,
-    })
-  }
-
-  if (body?.status === 'archived') {
-    const archived = archiveScheduleCluster(id, {
-      actor: { actor: 'user' },
-    })
-    if (!archived.ok || !archived.schedule) {
-      return NextResponse.json({ error: 'Failed to archive schedule.' }, { status: 500 })
-    }
-    return NextResponse.json({
-      ...archived.schedule,
-      archivedIds: archived.archivedIds,
-      cancelledTaskIds: archived.cancelledTaskIds,
-      abortedRunSessionIds: archived.abortedRunSessionIds,
-    })
-  }
-
-  const sessions = loadSessions()
-  const agents = loadAgents()
-  const sessionCwd = typeof current.createdInSessionId === 'string'
-    ? sessions[current.createdInSessionId]?.cwd
-    : null
-  const prepared = prepareScheduleUpdate({
-    id,
-    current,
-    patch: body as Record<string, unknown>,
-    schedules,
-    now: Date.now(),
-    cwd: sessionCwd || WORKSPACE_DIR,
-    agentExists: (agentId) => Boolean(agents[agentId]),
-    propagateEquivalentStatuses: true,
-    propagationSource: current as unknown as Record<string, unknown>,
-  })
-  if (!prepared.ok) {
-    const message = errorMessage(prepared.error)
-    return NextResponse.json({ error: message }, { status: 400 })
-  }
-  upsertSchedules(prepared.entries)
-  logActivity({
-    entityType: 'schedule',
-    entityId: id,
-    action: 'updated',
-    actor: 'user',
-    summary: `Schedule updated: "${prepared.schedule.name}"`,
-    detail: prepared.affectedScheduleIds.length > 1 ? { affectedScheduleIds: prepared.affectedScheduleIds } : undefined,
-  })
-  notify('schedules')
-  return NextResponse.json(
-    prepared.affectedScheduleIds.length > 1
-      ? { ...prepared.schedule, affectedScheduleIds: prepared.affectedScheduleIds }
-      : prepared.schedule,
-  )
+  const result = updateScheduleFromRoute(id, (body || {}) as Record<string, unknown>)
+  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 schedules = loadSchedules()
-  const current = schedules[id]
-  if (!current) return notFound()
-
   const { searchParams } = new URL(req.url)
   const purge = searchParams.get('purge') === 'true'
-  if (purge) {
-    const purged = purgeArchivedScheduleCluster(id, {
-      actor: { actor: 'user' },
-    })
-    if (!purged.ok) {
-      return NextResponse.json({ error: 'Only archived schedules can be purged.' }, { status: 409 })
-    }
-    return NextResponse.json({
-      ok: true,
-      purgedIds: purged.purgedIds,
-    })
-  }
-
-  const archived = archiveScheduleCluster(id, {
-    actor: { actor: 'user' },
-  })
-  if (!archived.ok || !archived.schedule) {
-    return NextResponse.json({ error: 'Failed to archive schedule.' }, { status: 500 })
-  }
-  return NextResponse.json({
-    ok: true,
-    archivedIds: archived.archivedIds,
-    cancelledTaskIds: archived.cancelledTaskIds,
-    removedQueuedTaskIds: archived.removedQueuedTaskIds,
-    abortedRunSessionIds: archived.abortedRunSessionIds,
-    schedule: archived.schedule,
-  })
+  const result = deleteScheduleFromRoute(id, purge)
+  if (!result.ok && result.status === 404) return notFound()
+  return result.ok
+    ? NextResponse.json(result.payload)
+    : NextResponse.json(result.payload, { status: result.status })
 }