@swarmclawai/swarmclaw 1.2.4 → 1.2.6

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

@@ -1,28 +1,10 @@
 import { NextResponse } from 'next/server'
-import { loadSession, upsertSession } from '@/lib/server/storage'
+import { retryChatTurn } from '@/lib/server/chats/chat-session-service'
 import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const session = loadSession(id)
-  if (!session) return notFound()
-
-  const msgs = session.messages
-  // Pop trailing assistant messages to find the last user message
-  while (msgs.length && msgs[msgs.length - 1].role === 'assistant') {
-    msgs.pop()
-  }
-  if (!msgs.length) {
-    return NextResponse.json({ message: '', imagePath: null }, { status: 200 })
-  }
-
-  const lastUser = msgs[msgs.length - 1]
-  const message = lastUser.text
-  const imagePath = lastUser.imagePath || null
-
-  // Remove the last user message too — it will be re-sent by the client
-  msgs.pop()
-  upsertSession(id, session)
-
-  return NextResponse.json({ message, imagePath })
+  const result = retryChatTurn(id)
+  if (!result.ok) return notFound()
+  return NextResponse.json(result.payload)
 }

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

@@ -1,158 +1,30 @@
 import { NextResponse } from 'next/server'
-import { loadAgents } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
-import { normalizeProviderEndpoint } from '@/lib/openclaw/openclaw-endpoint'
-import { resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
-import { clearMainLoopStateForSession } from '@/lib/server/agents/main-agent-loop'
-import { cleanupSessionProcesses } from '@/lib/server/runtime/process-manager'
-import { deleteSession, getSession, saveSession } from '@/lib/server/sessions/session-repository'
-import { stopActiveSessionProcess } from '@/lib/server/runtime/runtime-state'
-import { getSessionQueueSnapshot, getSessionRunState } from '@/lib/server/runtime/session-run-manager'
-import { normalizeCapabilitySelection } from '@/lib/capability-selection'
-import { enrichSessionWithMissionSummary } from '@/lib/server/missions/mission-service'
+import {
+  deleteChatSession,
+  getChatSessionForApi,
+  updateChatSession,
+} from '@/lib/server/chats/chat-session-service'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const session = getSession(id)
+  const session = getChatSessionForApi(id)
   if (!session) return notFound()
-
-  const run = getSessionRunState(id)
-  const queue = getSessionQueueSnapshot(id)
-  session.active = !!run.runningRunId
-  session.queuedCount = queue.queueLength
-  session.currentRunId = run.runningRunId || null
-
-  return NextResponse.json(enrichSessionWithMissionSummary(session))
+  return NextResponse.json(session)
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const { data: updates, error } = await safeParseBody(req)
   if (error) return error
-  const session = getSession(id) as Record<string, unknown> | null
+  const session = updateChatSession(id, updates as Record<string, unknown>)
   if (!session) return notFound()
-
-  if (updates.resetMainLoopState === true) {
-    clearMainLoopStateForSession(id)
-  }
-
-  const agentIdUpdateProvided = updates.agentId !== undefined
-  let nextAgentId = session.agentId
-  if (agentIdUpdateProvided) {
-    session.agentId = updates.agentId
-    nextAgentId = updates.agentId
-  }
-
-  const linkedAgent = nextAgentId ? loadAgents()[nextAgentId as string] : null
-  const routePreferredGatewayTags = updates.routePreferredGatewayTags !== undefined
-    ? (Array.isArray(updates.routePreferredGatewayTags)
-      ? updates.routePreferredGatewayTags.filter((tag: unknown): tag is string => typeof tag === 'string' && tag.trim().length > 0)
-      : [])
-    : ((session.routePreferredGatewayTags as string[]) || [])
-  const routePreferredGatewayUseCase = updates.routePreferredGatewayUseCase !== undefined
-    ? (typeof updates.routePreferredGatewayUseCase === 'string' && updates.routePreferredGatewayUseCase.trim()
-      ? updates.routePreferredGatewayUseCase.trim()
-      : null)
-    : ((session.routePreferredGatewayUseCase as string | null) || null)
-  const linkedRoute = linkedAgent ? resolvePrimaryAgentRoute(linkedAgent, undefined, {
-    preferredGatewayTags: routePreferredGatewayTags,
-    preferredGatewayUseCase: routePreferredGatewayUseCase,
-  }) : null
-
-  if (updates.name !== undefined) session.name = updates.name
-  if (updates.cwd !== undefined) session.cwd = updates.cwd
-  if (updates.provider !== undefined) session.provider = updates.provider
-  else if (agentIdUpdateProvided && linkedAgent?.provider) session.provider = linkedAgent.provider
-
-  if (updates.model !== undefined) session.model = updates.model
-  else if (agentIdUpdateProvided && linkedRoute?.model) session.model = linkedRoute.model
-  else if (agentIdUpdateProvided && linkedAgent?.model !== undefined) session.model = linkedAgent.model
-
-  if (updates.ollamaMode !== undefined) session.ollamaMode = updates.ollamaMode
-  else if (updates.provider !== undefined && updates.provider !== 'ollama') session.ollamaMode = null
-  else if (agentIdUpdateProvided && linkedRoute) session.ollamaMode = linkedRoute.ollamaMode ?? null
-  else if (agentIdUpdateProvided && linkedAgent) session.ollamaMode = linkedAgent.ollamaMode ?? null
-
-  if (updates.credentialId !== undefined) session.credentialId = updates.credentialId
-  else if (agentIdUpdateProvided && linkedRoute) session.credentialId = linkedRoute.credentialId ?? null
-  else if (agentIdUpdateProvided && linkedAgent) session.credentialId = linkedAgent.credentialId ?? null
-
-  if (updates.fallbackCredentialIds !== undefined) session.fallbackCredentialIds = updates.fallbackCredentialIds
-  else if (agentIdUpdateProvided && linkedRoute) session.fallbackCredentialIds = [...linkedRoute.fallbackCredentialIds]
-
-  if (updates.gatewayProfileId !== undefined) session.gatewayProfileId = updates.gatewayProfileId
-  else if (agentIdUpdateProvided && linkedRoute) session.gatewayProfileId = linkedRoute.gatewayProfileId ?? null
-
-  if (updates.routePreferredGatewayTags !== undefined) {
-    session.routePreferredGatewayTags = routePreferredGatewayTags
-  }
-  if (updates.routePreferredGatewayUseCase !== undefined) {
-    session.routePreferredGatewayUseCase = routePreferredGatewayUseCase
-  }
-
-  if (updates.tools !== undefined || updates.extensions !== undefined || (agentIdUpdateProvided && linkedAgent)) {
-    const nextSelection = normalizeCapabilitySelection({
-      tools: Array.isArray(updates.tools)
-        ? updates.tools
-        : (agentIdUpdateProvided && linkedAgent ? linkedAgent.tools : session.tools as string[] | undefined),
-      extensions: Array.isArray(updates.extensions)
-        ? updates.extensions
-        : (agentIdUpdateProvided && linkedAgent ? linkedAgent.extensions : session.extensions as string[] | undefined),
-    })
-    session.tools = nextSelection.tools
-    session.extensions = nextSelection.extensions
-  }
-
-  if (updates.apiEndpoint !== undefined) {
-    session.apiEndpoint = normalizeProviderEndpoint(
-      (updates.provider || session.provider) as string,
-      updates.apiEndpoint as string | null | undefined,
-    )
-  } else if (agentIdUpdateProvided && linkedRoute) {
-    session.apiEndpoint = linkedRoute.apiEndpoint ?? null
-  } else if (agentIdUpdateProvided && linkedAgent) {
-    session.apiEndpoint = normalizeProviderEndpoint(
-      linkedAgent.provider,
-      linkedAgent.apiEndpoint ?? null,
-    )
-  }
-  if (updates.heartbeatEnabled !== undefined) session.heartbeatEnabled = updates.heartbeatEnabled
-  if (updates.heartbeatIntervalSec !== undefined) session.heartbeatIntervalSec = updates.heartbeatIntervalSec
-  if (updates.sessionResetMode !== undefined) session.sessionResetMode = updates.sessionResetMode
-  if (updates.sessionIdleTimeoutSec !== undefined) session.sessionIdleTimeoutSec = updates.sessionIdleTimeoutSec
-  if (updates.sessionMaxAgeSec !== undefined) session.sessionMaxAgeSec = updates.sessionMaxAgeSec
-  if (updates.sessionDailyResetAt !== undefined) session.sessionDailyResetAt = updates.sessionDailyResetAt
-  if (updates.sessionResetTimezone !== undefined) session.sessionResetTimezone = updates.sessionResetTimezone
-  if (updates.thinkingLevel !== undefined) session.thinkingLevel = updates.thinkingLevel
-  if (updates.connectorThinkLevel !== undefined) session.connectorThinkLevel = updates.connectorThinkLevel
-  if (updates.connectorSessionScope !== undefined) session.connectorSessionScope = updates.connectorSessionScope
-  if (updates.connectorReplyMode !== undefined) session.connectorReplyMode = updates.connectorReplyMode
-  if (updates.connectorThreadBinding !== undefined) session.connectorThreadBinding = updates.connectorThreadBinding
-  if (updates.connectorGroupPolicy !== undefined) session.connectorGroupPolicy = updates.connectorGroupPolicy
-  if (updates.connectorIdleTimeoutSec !== undefined) session.connectorIdleTimeoutSec = updates.connectorIdleTimeoutSec
-  if (updates.connectorMaxAgeSec !== undefined) session.connectorMaxAgeSec = updates.connectorMaxAgeSec
-  if (updates.connectorContext !== undefined) session.connectorContext = updates.connectorContext
-  if (updates.identityState !== undefined) session.identityState = updates.identityState
-  if (updates.sessionArchiveState !== undefined) session.sessionArchiveState = updates.sessionArchiveState
-  if (updates.lastSessionResetAt !== undefined) session.lastSessionResetAt = updates.lastSessionResetAt
-  if (updates.lastSessionResetReason !== undefined) session.lastSessionResetReason = updates.lastSessionResetReason
-  if (updates.pinned !== undefined) session.pinned = !!updates.pinned
-  if (updates.claudeSessionId !== undefined) session.claudeSessionId = updates.claudeSessionId
-  if (updates.codexThreadId !== undefined) session.codexThreadId = updates.codexThreadId
-  if (updates.opencodeSessionId !== undefined) session.opencodeSessionId = updates.opencodeSessionId
-  if (updates.delegateResumeIds !== undefined) session.delegateResumeIds = updates.delegateResumeIds
-  if (!Array.isArray(session.messages)) session.messages = []
-
-  saveSession(id, session)
-  return NextResponse.json(enrichSessionWithMissionSummary(session as never))
+  return NextResponse.json(session)
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  if (!getSession(id)) return notFound()
-  stopActiveSessionProcess(id)
-  cleanupSessionProcesses(id)
-  deleteSession(id)
+  if (!deleteChatSession(id)) return notFound()
   return new NextResponse('OK')
 }

package/src/app/api/chats/heartbeat/route.ts

@@ -1,7 +1,8 @@
 import { NextResponse } from 'next/server'
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/runtime/heartbeat-defaults'
-import { disableAllSessionHeartbeats, loadSettings, saveSettings } from '@/lib/server/storage'
 import { cancelAllHeartbeatRuns } from '@/lib/server/runtime/session-run-manager'
+import { disableAllSessionHeartbeats } from '@/lib/server/sessions/session-repository'
+import { loadSettings, saveSettings } from '@/lib/server/settings/settings-repository'
 
 export async function POST(req: Request) {
   const body = await req.json().catch(() => ({}))

package/src/app/api/chats/migrate-messages/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from 'next/server'
+import { migrateAllSessions } from '@/lib/server/messages/message-repository'
+
+export async function POST() {
+  const result = migrateAllSessions()
+  return NextResponse.json(result)
+}

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

@@ -1,44 +1,17 @@
 import { NextResponse } from 'next/server'
-import { genId } from '@/lib/id'
-import os from 'os'
-import path from 'path'
 import { perf } from '@/lib/server/runtime/perf'
-import { loadAgents } from '@/lib/server/storage'
-import { WORKSPACE_DIR } from '@/lib/server/data-dir'
-import { notify } from '@/lib/server/ws-hub'
-import { deleteSession, listSessions, replaceSessions } from '@/lib/server/sessions/session-repository'
-import { stopActiveSessionProcess } from '@/lib/server/runtime/runtime-state'
-import { getSessionQueueSnapshot, getSessionRunState } from '@/lib/server/runtime/session-run-manager'
-import { normalizeProviderEndpoint } from '@/lib/openclaw/openclaw-endpoint'
-import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
-import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agents/agent-availability'
-import { buildSessionListSummary } from '@/lib/chat/session-summary'
-import { normalizeCapabilitySelection } from '@/lib/capability-selection'
-import { enrichSessionWithMissionSummary } from '@/lib/server/missions/mission-service'
+import {
+  createChatSession,
+  deleteChats,
+  listChatsForApi,
+} from '@/lib/server/chats/chat-session-service'
+import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
 export const dynamic = 'force-dynamic'
 
-async function ensureDaemonIfNeeded(source: string) {
-  const { ensureDaemonStarted } = await import('@/lib/server/runtime/daemon-state')
-  ensureDaemonStarted(source)
-}
-
 
 export async function GET(req: Request) {
   const endPerf = perf.start('api', 'GET /api/chats')
-  // Note: pruneThreadConnectorMirrors and materializeStreamingAssistantArtifacts
-  // are handled by the daemon periodic health check, not on every list fetch.
-  const sessions = listSessions()
-  for (const id of Object.keys(sessions)) {
-    const run = getSessionRunState(id)
-    const queue = getSessionQueueSnapshot(id)
-    sessions[id].active = !!run.runningRunId
-    sessions[id].queuedCount = queue.queueLength
-    sessions[id].currentRunId = run.runningRunId || null
-  }
-
-  const summarized = Object.fromEntries(
-    Object.entries(sessions).map(([id, session]) => [id, buildSessionListSummary(enrichSessionWithMissionSummary(session))]),
-  )
+  const summarized = listChatsForApi()
 
   const { searchParams } = new URL(req.url)
   const limitParam = searchParams.get('limit')
@@ -56,112 +29,18 @@ export async function GET(req: Request) {
 }
 
 export async function DELETE(req: Request) {
-  await ensureDaemonIfNeeded('api/chats:delete')
+  await ensureDaemonProcessRunning('api/chats:delete')
   const { ids } = await req.json().catch(() => ({ ids: [] })) as { ids: string[] }
   if (!Array.isArray(ids) || !ids.length) {
     return new NextResponse('Missing ids', { status: 400 })
   }
-  const sessions = listSessions()
-  let deleted = 0
-  for (const id of ids) {
-    if (!sessions[id]) continue
-    stopActiveSessionProcess(id)
-    deleteSession(id)
-    deleted += 1
-  }
-  notify('sessions')
-  return NextResponse.json({ deleted, requested: ids.length })
+  return NextResponse.json(deleteChats(ids))
 }
 
 export async function POST(req: Request) {
-  await ensureDaemonIfNeeded('api/chats:post')
+  await ensureDaemonProcessRunning('api/chats:post')
   const body = await req.json().catch(() => ({}))
-  let cwd = (body.cwd || '').trim()
-  if (cwd.startsWith('~/')) cwd = path.join(os.homedir(), cwd.slice(2))
-  else if (cwd === '~') cwd = os.homedir()
-  else if (!cwd) cwd = WORKSPACE_DIR
-
-  const id = body.id || genId()
-  const sessions = listSessions()
-  const agent = body.agentId ? loadAgents()[body.agentId] : null
-  if (isAgentDisabled(agent)) {
-    return NextResponse.json({ error: buildAgentDisabledMessage(agent, 'start chats') }, { status: 409 })
-  }
-  const routePreferredGatewayTags = Array.isArray(body.routePreferredGatewayTags)
-    ? body.routePreferredGatewayTags.filter((tag: unknown): tag is string => typeof tag === 'string' && tag.trim().length > 0)
-    : []
-  const routePreferredGatewayUseCase = typeof body.routePreferredGatewayUseCase === 'string' && body.routePreferredGatewayUseCase.trim()
-    ? body.routePreferredGatewayUseCase.trim()
-    : null
-  const resolvedRoute = agent ? resolvePrimaryAgentRoute(agent, undefined, {
-    preferredGatewayTags: routePreferredGatewayTags,
-    preferredGatewayUseCase: routePreferredGatewayUseCase,
-  }) : null
-  const resolvedCapabilities = normalizeCapabilitySelection({
-    tools: Array.isArray(body.tools) ? body.tools : agent?.tools,
-    extensions: Array.isArray(body.extensions) ? body.extensions : agent?.extensions,
-  })
-
-  // If session with this ID already exists, return it as-is
-  if (body.id && sessions[id]) {
-    return NextResponse.json(sessions[id])
-  }
-
-  const sessionName = body.name || 'New Chat'
-
-  const nextSession = {
-    id, name: sessionName, cwd,
-    user: body.user || 'user',
-    provider: body.provider || agent?.provider || 'claude-cli',
-    model: body.model || agent?.model || '',
-    ollamaMode: body.ollamaMode ?? agent?.ollamaMode ?? ((body.provider || agent?.provider) === 'ollama' ? 'local' : null),
-    credentialId: body.credentialId || agent?.credentialId || null,
-    fallbackCredentialIds: body.fallbackCredentialIds || agent?.fallbackCredentialIds || [],
-    apiEndpoint: normalizeProviderEndpoint(
-      body.provider || agent?.provider || 'claude-cli',
-      body.apiEndpoint || agent?.apiEndpoint || null,
-    ),
-    routePreferredGatewayTags,
-    routePreferredGatewayUseCase,
-    claudeSessionId: null,
-    codexThreadId: null,
-    opencodeSessionId: null,
-    delegateResumeIds: {
-      claudeCode: null,
-      codex: null,
-      opencode: null,
-      gemini: null,
-    },
-    messages: Array.isArray(body.messages) ? body.messages : [],
-    createdAt: Date.now(), lastActiveAt: Date.now(),
-    sessionType: body.sessionType || 'human',
-    agentId: body.agentId || null,
-    parentSessionId: body.parentSessionId || null,
-    tools: resolvedCapabilities.tools,
-    extensions: resolvedCapabilities.extensions,
-    heartbeatEnabled: body.heartbeatEnabled ?? null,
-    heartbeatIntervalSec: body.heartbeatIntervalSec ?? null,
-    sessionResetMode: body.sessionResetMode ?? agent?.sessionResetMode ?? null,
-    sessionIdleTimeoutSec: body.sessionIdleTimeoutSec ?? agent?.sessionIdleTimeoutSec ?? null,
-    sessionMaxAgeSec: body.sessionMaxAgeSec ?? agent?.sessionMaxAgeSec ?? null,
-    sessionDailyResetAt: body.sessionDailyResetAt ?? agent?.sessionDailyResetAt ?? null,
-    sessionResetTimezone: body.sessionResetTimezone ?? agent?.sessionResetTimezone ?? null,
-    thinkingLevel: body.thinkingLevel ?? null,
-    connectorThinkLevel: body.connectorThinkLevel ?? null,
-    connectorSessionScope: body.connectorSessionScope ?? null,
-    connectorReplyMode: body.connectorReplyMode ?? null,
-    connectorThreadBinding: body.connectorThreadBinding ?? null,
-    connectorGroupPolicy: body.connectorGroupPolicy ?? null,
-    connectorIdleTimeoutSec: body.connectorIdleTimeoutSec ?? null,
-    connectorMaxAgeSec: body.connectorMaxAgeSec ?? null,
-    connectorContext: body.connectorContext ?? null,
-    identityState: body.identityState ?? agent?.identityState ?? null,
-    sessionArchiveState: body.sessionArchiveState ?? null,
-  }
-  sessions[id] = (body.provider || body.model || body.credentialId || body.apiEndpoint)
-    ? nextSession
-    : applyResolvedRoute(nextSession, resolvedRoute)
-  replaceSessions(sessions)
-  notify('sessions')
-  return NextResponse.json(sessions[id])
+  const result = createChatSession(body as Record<string, unknown>)
+  if (!result.ok) return NextResponse.json(result.payload, { status: result.status })
+  return NextResponse.json(result.payload)
 }

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

@@ -1,77 +1,15 @@
 import { NextResponse } from 'next/server'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import type { Connector, ConnectorAccessMutationAction, ConnectorAccessMutationResponse } from '@/types'
 import { notFound } from '@/lib/server/collection-helpers'
-import {
-  loadConnectors,
-  logActivity,
-  upsertStoredItem,
-} from '@/lib/server/storage'
-import { ensureDaemonStarted } from '@/lib/server/runtime/daemon-state'
-import { notify } from '@/lib/server/ws-hub'
-import { errorMessage } from '@/lib/shared-utils'
 import {
   buildConnectorAccessSnapshot,
-  resolveConnectorOwnerSenderId,
 } from '@/lib/server/connectors/access'
-import {
-  addAllowedSender,
-  approvePairingCode,
-  approvePendingSender,
-  clearSenderAddressingOverride,
-  normalizeSenderId,
-  parseAllowFromCsv,
-  parseDmAddressingMode,
-  parsePairingPolicy,
-  removeAllowedSender,
-  rejectPendingSender,
-  setSenderAddressingOverride,
-  senderMatchesAnyEntry,
-} from '@/lib/server/connectors/pairing'
-
-function setConnectorSenderList(connector: Connector, key: string, values: string[]): void {
-  if (!connector.config) connector.config = {}
-  if (values.length === 0) {
-    delete connector.config[key]
-    return
-  }
-  connector.config[key] = values.join(',')
-}
-
-function addConnectorSenderListEntry(connector: Connector, key: string, senderId: string): boolean {
-  const normalized = normalizeSenderId(senderId)
-  if (!normalized) return false
-  const current = parseAllowFromCsv(connector.config?.[key])
-  if (senderMatchesAnyEntry(normalized, current)) return false
-  setConnectorSenderList(connector, key, [...current, normalized])
-  return true
-}
-
-function removeConnectorSenderListEntry(connector: Connector, key: string, senderId: string): boolean {
-  const normalized = normalizeSenderId(senderId)
-  if (!normalized) return false
-  const current = parseAllowFromCsv(connector.config?.[key])
-  const next = current.filter((entry) => !senderMatchesAnyEntry(normalized, [entry]))
-  if (next.length === current.length) return false
-  setConnectorSenderList(connector, key, next)
-  return true
-}
-
-function persistConnector(connector: Connector): void {
-  connector.updatedAt = Date.now()
-  upsertStoredItem('connectors', connector.id, connector)
-}
-
-function requireSenderId(body: Record<string, unknown>): string {
-  const senderId = typeof body.senderId === 'string' ? body.senderId.trim() : ''
-  if (!senderId) {
-    throw new Error('senderId is required for this action')
-  }
-  return senderId
-}
+import { loadConnectors } from '@/lib/server/connectors/connector-repository'
+import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
+import { updateConnectorAccess } from '@/lib/server/connectors/connector-service'
 
 export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  ensureDaemonStarted('api/connectors/[id]/access:get')
+  await ensureDaemonProcessRunning('api/connectors/[id]/access:get')
   const { id } = await params
   const connectors = loadConnectors()
   const connector = connectors[id]
@@ -88,169 +26,14 @@ export async function GET(req: Request, { params }: { params: Promise<{ id: stri
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  ensureDaemonStarted('api/connectors/[id]/access:put')
   const { id } = await params
-  const connectors = loadConnectors()
-  const connector = connectors[id]
+  const connector = loadConnectors()[id]
   if (!connector) return notFound()
-
-  try {
-    const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
-    if (error) return error
-    const action = typeof body.action === 'string' ? body.action.trim().toLowerCase() as ConnectorAccessMutationAction : null
-    if (!action) {
-      return NextResponse.json({ error: 'Missing access action' }, { status: 400 })
-    }
-
-    let connectorChanged = false
-    let responseSenderId = typeof body.senderId === 'string' ? body.senderId.trim() : ''
-    const responseSenderIdAlt = typeof body.senderIdAlt === 'string' ? body.senderIdAlt.trim() : ''
-    let summary = `Updated access controls for "${connector.name}".`
-
-    switch (action) {
-      case 'set_policy': {
-        const rawPolicy = typeof body.dmPolicy === 'string' ? body.dmPolicy.trim() : ''
-        if (!rawPolicy) {
-          delete connector.config.dmPolicy
-        } else {
-          connector.config.dmPolicy = parsePairingPolicy(rawPolicy, 'open')
-        }
-        connectorChanged = true
-        summary = `Updated DM policy for "${connector.name}".`
-        break
-      }
-      case 'set_dm_addressing_mode': {
-        const rawMode = typeof body.dmAddressingMode === 'string' ? body.dmAddressingMode.trim() : ''
-        const nextMode = parseDmAddressingMode(rawMode || 'open', 'open')
-        if (nextMode === 'open') delete connector.config.dmAddressingMode
-        else connector.config.dmAddressingMode = nextMode
-        connectorChanged = true
-        summary = `Updated DM addressing mode for "${connector.name}" to ${nextMode}.`
-        break
-      }
-      case 'allow_sender': {
-        const senderId = requireSenderId(body)
-        addAllowedSender(connector.id, senderId)
-        connectorChanged = removeConnectorSenderListEntry(connector, 'denyFrom', senderId) || connectorChanged
-        summary = `Allowed sender ${normalizeSenderId(senderId)} on "${connector.name}".`
-        break
-      }
-      case 'remove_allowed_sender': {
-        const senderId = requireSenderId(body)
-        removeAllowedSender(connector.id, senderId)
-        connectorChanged = removeConnectorSenderListEntry(connector, 'allowFrom', senderId) || connectorChanged
-        summary = `Removed connector-managed access for ${normalizeSenderId(senderId)} on "${connector.name}".`
-        break
-      }
-      case 'block_sender': {
-        const senderId = requireSenderId(body)
-        connectorChanged = addConnectorSenderListEntry(connector, 'denyFrom', senderId) || connectorChanged
-        connectorChanged = removeConnectorSenderListEntry(connector, 'allowFrom', senderId) || connectorChanged
-        removeAllowedSender(connector.id, senderId)
-        rejectPendingSender(connector.id, senderId)
-        const ownerSenderId = resolveConnectorOwnerSenderId(connector)
-        if (ownerSenderId && senderMatchesAnyEntry(senderId, [ownerSenderId])) {
-          delete connector.config.ownerSenderId
-          connectorChanged = true
-        }
-        summary = `Blocked sender ${normalizeSenderId(senderId)} on "${connector.name}".`
-        break
-      }
-      case 'unblock_sender': {
-        const senderId = requireSenderId(body)
-        connectorChanged = removeConnectorSenderListEntry(connector, 'denyFrom', senderId) || connectorChanged
-        summary = `Removed sender ${normalizeSenderId(senderId)} from the deny list on "${connector.name}".`
-        break
-      }
-      case 'approve_pairing': {
-        if (typeof body.code === 'string' && body.code.trim()) {
-          const approved = approvePairingCode(connector.id, body.code)
-          if (!approved.ok) {
-            return NextResponse.json({ error: approved.reason || 'Pairing approval failed.' }, { status: 400 })
-          }
-          if (approved.senderId) {
-            responseSenderId = approved.senderId
-            connectorChanged = removeConnectorSenderListEntry(connector, 'denyFrom', approved.senderId) || connectorChanged
-          }
-          summary = `Approved pairing on "${connector.name}".`
-        } else {
-          const senderId = requireSenderId(body)
-          const approved = approvePendingSender(connector.id, senderId)
-          if (!approved.ok) {
-            return NextResponse.json({ error: approved.reason || 'Pairing approval failed.' }, { status: 400 })
-          }
-          connectorChanged = removeConnectorSenderListEntry(connector, 'denyFrom', senderId) || connectorChanged
-          summary = `Approved pairing for ${normalizeSenderId(senderId)} on "${connector.name}".`
-        }
-        break
-      }
-      case 'reject_pairing': {
-        const senderId = requireSenderId(body)
-        rejectPendingSender(connector.id, senderId)
-        summary = `Rejected pairing for ${normalizeSenderId(senderId)} on "${connector.name}".`
-        break
-      }
-      case 'set_owner': {
-        const senderId = requireSenderId(body)
-        const normalized = normalizeSenderId(senderId)
-        if (!normalized) {
-          return NextResponse.json({ error: 'Could not normalize owner sender ID' }, { status: 400 })
-        }
-        connector.config.ownerSenderId = normalized
-        connectorChanged = true
-        connectorChanged = removeConnectorSenderListEntry(connector, 'denyFrom', normalized) || connectorChanged
-        summary = `Set connector owner for "${connector.name}" to ${normalized}.`
-        break
-      }
-      case 'clear_owner': {
-        if (connector.config?.ownerSenderId) {
-          delete connector.config.ownerSenderId
-          connectorChanged = true
-        }
-        summary = `Cleared connector owner override for "${connector.name}".`
-        break
-      }
-      case 'set_sender_dm_addressing': {
-        const senderId = requireSenderId(body)
-        const rawMode = typeof body.dmAddressingMode === 'string' ? body.dmAddressingMode.trim() : ''
-        const nextMode = parseDmAddressingMode(rawMode || 'open', 'open')
-        setSenderAddressingOverride(connector.id, senderId, nextMode)
-        summary = `Updated DM addressing override for ${normalizeSenderId(senderId)} on "${connector.name}" to ${nextMode}.`
-        break
-      }
-      case 'clear_sender_dm_addressing': {
-        const senderId = requireSenderId(body)
-        clearSenderAddressingOverride(connector.id, senderId)
-        summary = `Cleared DM addressing override for ${normalizeSenderId(senderId)} on "${connector.name}".`
-        break
-      }
-      default:
-        return NextResponse.json({ error: `Unsupported access action: ${action}` }, { status: 400 })
-    }
-
-    if (connectorChanged) {
-      persistConnector(connector)
-    }
-
-    logActivity({
-      entityType: 'connector',
-      entityId: connector.id,
-      action: 'access-updated',
-      actor: 'user',
-      summary,
-      detail: { action },
-    })
-    notify('connectors')
-
-    return NextResponse.json<ConnectorAccessMutationResponse>({
-      ok: true,
-      snapshot: buildConnectorAccessSnapshot({
-        connector,
-        senderId: responseSenderId || null,
-        senderIdAlt: responseSenderIdAlt || null,
-      }),
-    })
-  } catch (err: unknown) {
-    return NextResponse.json({ error: errorMessage(err) }, { status: 400 })
-  }
+  const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
+  if (error) return error
+  const result = await updateConnectorAccess(id, body)
+  if (!result.ok && result.status === 404) return notFound()
+  return result.ok
+    ? NextResponse.json(result.payload)
+    : NextResponse.json(result.payload, { status: result.status })
 }

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

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