@swarmclawai/swarmclaw 1.2.0 → 1.2.2

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

@@ -3,6 +3,9 @@ import { execSync } from 'child_process'
 import { loadSessions } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'api-deploy'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
@@ -21,16 +24,18 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     try {
       execSync(`git commit -m "${msg.replace(/"/g, '\\"')}"`, opts)
       committed = true
-    } catch (ce: any) {
-      if (!(ce.stdout || ce.stderr || '').includes('nothing to commit')) throw ce
+    } catch (ce: unknown) {
+      const ex = ce as { stdout?: string; stderr?: string }
+      if (!(ex.stdout || ex.stderr || '').includes('nothing to commit')) throw ce
     }
     execSync('git push 2>&1', opts)
-    console.log(`[${id}] deployed: ${msg}`)
+    log.info(TAG, `deployed: ${msg}`)
     return NextResponse.json({ ok: true, output: committed ? 'Committed and pushed!' : 'Already committed — pushed to remote!' })
-  } catch (e: any) {
-    console.error(`[${id}] deploy error:`, e.message)
+  } catch (e: unknown) {
+    const ex = e as { stderr?: string; stdout?: string; message?: string }
+    log.error(TAG, `deploy error:`, ex.message)
     return NextResponse.json(
-      { ok: false, error: (e.stderr || e.stdout || e.message).toString().slice(0, 300) },
+      { ok: false, error: (ex.stderr || ex.stdout || ex.message || 'Unknown error').toString().slice(0, 300) },
       { status: 500 },
     )
   }

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

@@ -1,11 +1,16 @@
 import { NextResponse } from 'next/server'
 import { spawn } from 'child_process'
-import { loadSessions, devServers, localIP } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 import { resolveDevServerLaunchDir } from '@/lib/server/runtime/devserver-launch'
+import { clearDevServer, getDevServer, hasDevServer, registerDevServer, stopDevServer, updateDevServerUrl } from '@/lib/server/runtime/runtime-state'
+import { localIP } from '@/lib/server/runtime/network'
+import { listSessions } from '@/lib/server/sessions/session-repository'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { sleep } from '@/lib/shared-utils'
 import net from 'net'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'api-devserver'
 
 interface DevServerStartResult {
   status?: number
@@ -53,22 +58,21 @@ async function startDevServer(id: string, session: { cwd: string }): Promise<Dev
       if (match) {
         const detectedPort = match[1]
         detectedUrl = `http://${localIP()}:${detectedPort}`
-        const ds = devServers.get(id)
-        if (ds) ds.url = detectedUrl
+        updateDevServerUrl(id, detectedUrl)
       }
     }
   }
 
   proc.stdout!.on('data', onData)
   proc.stderr!.on('data', onData)
-  proc.on('close', () => { devServers.delete(id); console.log(`[${id}] dev server stopped`) })
-  proc.on('error', () => devServers.delete(id))
+  proc.on('close', () => { clearDevServer(id); log.info(TAG, `dev server stopped for ${id}`) })
+  proc.on('error', () => clearDevServer(id))
 
-  devServers.set(id, { proc, url: `http://${localIP()}:${port}` })
-  console.log(`[${id}] starting dev server in ${launch.launchDir} (session cwd=${session.cwd})`)
+  registerDevServer(id, { proc, url: `http://${localIP()}:${port}` })
+  log.info(TAG, `starting dev server in ${launch.launchDir} (session cwd=${session.cwd})`)
 
   await sleep(4000)
-  const ds = devServers.get(id)
+  const ds = getDevServer(id)
   if (!ds) {
     return {
       status: 502,
@@ -96,7 +100,7 @@ async function startDevServer(id: string, session: { cwd: string }): Promise<Dev
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const sessions = loadSessions()
+  const sessions = listSessions()
   const session = sessions[id]
   if (!session) return notFound()
 
@@ -105,8 +109,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const { action } = body
 
   if (action === 'start') {
-    if (devServers.has(id)) {
-      const ds = devServers.get(id)!
+    if (hasDevServer(id)) {
+      const ds = getDevServer(id)!
       return NextResponse.json({ running: true, url: ds.url })
     }
 
@@ -123,18 +127,11 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     return NextResponse.json(result.body, result.status ? { status: result.status } : undefined)
 
   } else if (action === 'stop') {
-    if (devServers.has(id)) {
-      const ds = devServers.get(id)!
-      try { ds.proc.kill('SIGTERM') } catch {}
-      if (typeof ds.proc.pid === 'number') {
-        try { process.kill(-ds.proc.pid, 'SIGTERM') } catch {}
-      }
-      devServers.delete(id)
-    }
+    stopDevServer(id)
     return NextResponse.json({ running: false })
 
   } else if (action === 'status') {
-    return NextResponse.json({ running: devServers.has(id), url: devServers.get(id)?.url })
+    return NextResponse.json({ running: hasDevServer(id), url: getDevServer(id)?.url })
   }
 
   return NextResponse.json({ running: false })

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

@@ -1,21 +1,25 @@
 import { NextResponse } from 'next/server'
-import { loadStoredItem, upsertStoredItem } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 import { materializeStreamingAssistantArtifacts } from '@/lib/chat/chat-streaming-state'
 import { appendSessionNote } from '@/lib/server/session-note'
-import type { Message, Session } from '@/types'
+import { getSessionRunState } from '@/lib/server/runtime/session-run-manager'
+import { getSession, saveSession } from '@/lib/server/sessions/session-repository'
+import type { Message } from '@/types'
 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 = loadStoredItem('sessions', id) as Session | null
+  const session = getSession(id)
   if (!session) return notFound()
   session.messages = Array.isArray(session.messages) ? session.messages : []
 
+  // Use persisted fields plus the run ledger. Process-local execution state is
+  // intentionally excluded here so stale registry entries do not block cleanup.
   const sessionClaimsActive = session.active === true
     || (typeof session.currentRunId === 'string' && session.currentRunId.trim().length > 0)
+    || !!getSessionRunState(id).runningRunId
   if (!sessionClaimsActive && materializeStreamingAssistantArtifacts(session.messages)) {
-    upsertStoredItem('sessions', id, session)
+    saveSession(id, session)
   }
 
   const url = new URL(req.url)
@@ -57,7 +61,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   if (error) return error
 
   if (body.kind === 'context-clear') {
-    const session = loadStoredItem('sessions', id) as Session | null
+    const session = getSession(id)
     if (!session) return notFound()
 
     session.messages.push({
@@ -66,7 +70,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
       kind: 'context-clear',
       time: Date.now(),
     })
-    upsertStoredItem('sessions', id, session)
+    saveSession(id, session)
     return NextResponse.json({ ok: true })
   }
 
@@ -78,7 +82,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
       kind: body.messageKind || 'system',
     })
     if (!inserted) {
-      const session = loadStoredItem('sessions', id) as Session | null
+      const session = getSession(id)
       if (!session) return notFound()
       return NextResponse.json({ error: 'Note text is required' }, { status: 400 })
     }
@@ -92,7 +96,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   const { id } = await params
   const { data: body, error } = await safeParseBody<{ messageIndex: number; bookmarked: boolean }>(req)
   if (error) return error
-  const session = loadStoredItem('sessions', id) as Session | null
+  const session = getSession(id)
   if (!session) return notFound()
 
   const { messageIndex, bookmarked } = body
@@ -101,7 +105,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   }
 
   session.messages[messageIndex].bookmarked = bookmarked
-  upsertStoredItem('sessions', id, session)
+  saveSession(id, session)
   return NextResponse.json(session.messages[messageIndex])
 }
 
@@ -109,7 +113,7 @@ export async function DELETE(req: Request, { params }: { params: Promise<{ id: s
   const { id } = await params
   const { data: body, error } = await safeParseBody<{ messageIndex: number }>(req)
   if (error) return error
-  const session = loadStoredItem('sessions', id) as Session | null
+  const session = getSession(id)
   if (!session) return notFound()
 
   const { messageIndex } = body
@@ -123,6 +127,6 @@ export async function DELETE(req: Request, { params }: { params: Promise<{ id: s
   }
 
   session.messages.splice(messageIndex, 1)
-  upsertStoredItem('sessions', id, session)
+  saveSession(id, session)
   return NextResponse.json({ ok: true })
 }

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

@@ -1,10 +1,12 @@
 import { NextResponse } from 'next/server'
-import { loadSession, upsertSession, deleteSession, active, loadAgents } from '@/lib/server/storage'
+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'
@@ -12,12 +14,12 @@ 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 = loadSession(id)
+  const session = getSession(id)
   if (!session) return notFound()
 
   const run = getSessionRunState(id)
   const queue = getSessionQueueSnapshot(id)
-  session.active = active.has(id) || !!run.runningRunId
+  session.active = !!run.runningRunId
   session.queuedCount = queue.queueLength
   session.currentRunId = run.runningRunId || null
 
@@ -28,7 +30,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   const { id } = await params
   const { data: updates, error } = await safeParseBody(req)
   if (error) return error
-  const session = loadSession(id) as Record<string, unknown> | null
+  const session = getSession(id) as Record<string, unknown> | null
   if (!session) return notFound()
 
   if (updates.resetMainLoopState === true) {
@@ -142,17 +144,14 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   if (updates.delegateResumeIds !== undefined) session.delegateResumeIds = updates.delegateResumeIds
   if (!Array.isArray(session.messages)) session.messages = []
 
-  upsertSession(id, session)
+  saveSession(id, session)
   return NextResponse.json(enrichSessionWithMissionSummary(session as never))
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  if (!loadSession(id)) return notFound()
-  if (active.has(id)) {
-    try { active.get(id)?.kill() } catch {}
-    active.delete(id)
-  }
+  if (!getSession(id)) return notFound()
+  stopActiveSessionProcess(id)
   cleanupSessionProcesses(id)
   deleteSession(id)
   return new NextResponse('OK')

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

@@ -1,19 +1,17 @@
 import { NextResponse } from 'next/server'
 import { materializeStreamingAssistantArtifacts } from '@/lib/chat/chat-streaming-state'
-import { active, loadStoredItem, upsertStoredItem } from '@/lib/server/storage'
 import { cancelSessionRuns } from '@/lib/server/runtime/session-run-manager'
+import { stopActiveSessionProcess } from '@/lib/server/runtime/runtime-state'
+import { getSession, saveSession } from '@/lib/server/sessions/session-repository'
 import type { Session } from '@/types'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const cancel = cancelSessionRuns(id, 'Stopped by user')
-  const session = loadStoredItem('sessions', id) as Session | null
+  const session = getSession(id) as Session | null
   if (session && Array.isArray(session.messages) && materializeStreamingAssistantArtifacts(session.messages)) {
-    upsertStoredItem('sessions', id, session)
-  }
-  if (active.has(id)) {
-    try { active.get(id)?.kill() } catch {}
-    active.delete(id)
+    saveSession(id, session)
   }
+  stopActiveSessionProcess(id)
   return NextResponse.json({ ok: true, ...cancel })
 }

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

@@ -10,11 +10,13 @@ test('chat messages route materializes stale streaming artifacts even if runtime
     returnedText: string | null
     persistedStreaming: boolean | null
     persistedText: string | null
-  }>(`
-    const storageMod = await import('./src/lib/server/storage')
-    const routeMod = await import('./src/app/api/chats/[id]/messages/route')
-    const storage = storageMod.default || storageMod
-    const route = routeMod.default || routeMod
+	  }>(`
+	    const storageMod = await import('./src/lib/server/storage')
+	    const routeMod = await import('./src/app/api/chats/[id]/messages/route')
+	    const runtimeStateMod = await import('./src/lib/server/runtime/runtime-state')
+	    const storage = storageMod.default || storageMod
+	    const route = routeMod.default || routeMod
+	    const runtimeState = runtimeStateMod.default || runtimeStateMod
 
     storage.upsertStoredItem('sessions', 'session-stale', {
       id: 'session-stale',
@@ -37,7 +39,7 @@ test('chat messages route materializes stale streaming artifacts even if runtime
       ],
     })
 
-    storage.active.set('session-stale', { kill() {} })
+	    runtimeState.registerActiveSessionProcess('session-stale', { kill() {} })
 
     const response = await route.GET(
       new Request('http://local/api/chats/session-stale/messages'),

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

@@ -3,9 +3,11 @@ import { genId } from '@/lib/id'
 import os from 'os'
 import path from 'path'
 import { perf } from '@/lib/server/runtime/perf'
-import { loadSessions, saveSessions, deleteSession, active, loadAgents } from '@/lib/server/storage'
+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'
@@ -25,11 +27,11 @@ 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 = loadSessions()
+  const sessions = listSessions()
   for (const id of Object.keys(sessions)) {
     const run = getSessionRunState(id)
     const queue = getSessionQueueSnapshot(id)
-    sessions[id].active = active.has(id) || !!run.runningRunId
+    sessions[id].active = !!run.runningRunId
     sessions[id].queuedCount = queue.queueLength
     sessions[id].currentRunId = run.runningRunId || null
   }
@@ -59,14 +61,11 @@ export async function DELETE(req: Request) {
   if (!Array.isArray(ids) || !ids.length) {
     return new NextResponse('Missing ids', { status: 400 })
   }
-  const sessions = loadSessions()
+  const sessions = listSessions()
   let deleted = 0
   for (const id of ids) {
     if (!sessions[id]) continue
-    if (active.has(id)) {
-      try { active.get(id)?.kill() } catch {}
-      active.delete(id)
-    }
+    stopActiveSessionProcess(id)
     deleteSession(id)
     deleted += 1
   }
@@ -83,7 +82,7 @@ export async function POST(req: Request) {
   else if (!cwd) cwd = WORKSPACE_DIR
 
   const id = body.id || genId()
-  const sessions = loadSessions()
+  const sessions = listSessions()
   const agent = body.agentId ? loadAgents()[body.agentId] : null
   if (isAgentDisabled(agent)) {
     return NextResponse.json({ error: buildAgentDisabledMessage(agent, 'start chats') }, { status: 409 })
@@ -162,7 +161,7 @@ export async function POST(req: Request) {
   sessions[id] = (body.provider || body.model || body.credentialId || body.apiEndpoint)
     ? nextSession
     : applyResolvedRoute(nextSession, resolvedRoute)
-  saveSessions(sessions)
+  replaceSessions(sessions)
   notify('sessions')
   return NextResponse.json(sessions[id])
 }

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

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

package/src/app/api/extensions/marketplace/route.ts

@@ -3,6 +3,9 @@ import { inferExtensionPublisherSourceFromUrl } from '@/lib/extension-sources'
 import { searchClawHub } from '@/lib/server/skills/clawhub-client'
 import type { ExtensionCatalogSource } from '@/types'
 import { errorMessage } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'api-extensions-marketplace'
 
 export const dynamic = 'force-dynamic'
 
@@ -71,7 +74,7 @@ export async function GET(req: Request) {
         })
       }
     } catch (err: unknown) {
-      console.warn('[extensions-marketplace] Registry failed:', {
+      log.warn(TAG, 'Registry failed:', {
         registryUrl: registry.url,
         error: errorMessage(err),
       })
@@ -93,7 +96,7 @@ export async function GET(req: Request) {
       catalogSource: 'clawhub',
     })))
   } catch (err: unknown) {
-    console.warn('[extensions-marketplace] ClawHub failed:', errorMessage(err))
+    log.warn(TAG, 'ClawHub failed:', errorMessage(err))
   }
 
   allExtensions.sort((a, b) => {

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

@@ -1,8 +1,8 @@
 import { NextResponse } from 'next/server'
-import { localIP } from '@/lib/server/storage'
+import { localIP } from '@/lib/server/runtime/network'
 export const dynamic = 'force-dynamic'
 
 
-export async function GET(_req: Request) {
+export async function GET() {
   return NextResponse.json({ ip: localIP(), port: parseInt(process.env.PORT || '3000') })
 }

package/src/app/api/memory/maintenance/route.ts

@@ -4,6 +4,9 @@ import { getMemoryDb } from '@/lib/server/memory/memory-db'
 import { loadSettings } from '@/lib/server/storage'
 import { syncAllSessionArchiveMemories } from '@/lib/server/memory/session-archive-memory'
 import { DATA_DIR } from '@/lib/server/data-dir'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'api-memory-maintenance'
 
 function parseBool(value: unknown, fallback: boolean): boolean {
   if (typeof value === 'boolean') return value
@@ -46,7 +49,7 @@ export async function GET(req: Request) {
       archiveExportDir: path.join(DATA_DIR, 'session-archives'),
     })
   } catch (err: unknown) {
-    console.error('[memory/maintenance] GET failed:', err)
+    log.error(TAG, 'GET failed:', err)
     return NextResponse.json({ ok: false, error: String((err as Error)?.message || err) }, { status: 500 })
   }
 }
@@ -77,7 +80,7 @@ export async function POST(req: Request) {
       ...result,
     })
   } catch (err: unknown) {
-    console.error('[memory/maintenance] POST failed:', err)
+    log.error(TAG, 'POST failed:', err)
     return NextResponse.json({ ok: false, error: String((err as Error)?.message || err) }, { status: 500 })
   }
 }

package/src/app/api/preview-server/route.ts

@@ -3,11 +3,14 @@ import { spawn, type ChildProcess } from 'child_process'
 import http from 'http'
 import fs from 'fs'
 import path from 'path'
-import { localIP } from '@/lib/server/storage'
+import { localIP } from '@/lib/server/runtime/network'
 import { resolveDevServerLaunchDir } from '@/lib/server/runtime/devserver-launch'
 import { resolvePathWithinBaseDir } from '@/lib/server/path-utils'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { hmrSingleton, sleep } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'api-preview-server'
 
 // ---------------------------------------------------------------------------
 // MIME types for static server
@@ -181,7 +184,7 @@ function createStaticServer(dir: string): http.Server {
 async function startNpmServer(dir: string, command: string[], port: number, framework?: string): Promise<PreviewServer> {
   // Install deps if node_modules missing
   if (!fs.existsSync(path.join(dir, 'node_modules'))) {
-    console.log(`[preview] Installing dependencies in ${dir}`)
+    log.info(TAG, `Installing dependencies in ${dir}`)
     await new Promise<void>((resolve, reject) => {
       const install = spawn('npm', ['install'], { cwd: dir, stdio: 'pipe' })
       install.on('close', (code) => code === 0 ? resolve() : reject(new Error(`npm install exited ${code}`)))
@@ -206,14 +209,14 @@ async function startNpmServer(dir: string, command: string[], port: number, fram
     env,
   })
 
-  let log = ''
+  let processOutput = ''
   let detectedPort = port
   const urlRe = /https?:\/\/(?:localhost|0\.0\.0\.0|127\.0\.0\.1|[\d.]+):(\d+)/
 
   const onData = (chunk: Buffer) => {
     const text = chunk.toString()
-    log += text
-    if (log.length > 10000) log = log.slice(-5000)
+    processOutput += text
+    if (processOutput.length > 10000) processOutput = processOutput.slice(-5000)
     const match = text.match(urlRe)
     if (match) {
       detectedPort = parseInt(match[1], 10)
@@ -236,7 +239,7 @@ async function startNpmServer(dir: string, command: string[], port: number, fram
 
   proc.on('close', () => {
     servers.delete(dirKey(dir))
-    console.log(`[preview] npm server stopped for ${dir}`)
+    log.info(TAG, `npm server stopped for ${dir}`)
   })
   proc.on('error', () => servers.delete(dirKey(dir)))
 
@@ -246,10 +249,10 @@ async function startNpmServer(dir: string, command: string[], port: number, fram
   await sleep(5000)
   if (proc.exitCode !== null) {
     servers.delete(dirKey(dir))
-    throw new Error(`npm dev server exited early with code ${proc.exitCode}\n${log.slice(-4000)}`)
+    throw new Error(`npm dev server exited early with code ${proc.exitCode}\n${processOutput.slice(-4000)}`)
   }
   entry.port = detectedPort
-  entry.log = log
+  entry.log = processOutput
 
   return entry
 }
@@ -295,7 +298,7 @@ export async function POST(req: Request) {
     const port = await findFreePort()
 
     if (project.type === 'npm' && project.devCommand) {
-      console.log(`[preview] Detected ${project.framework} project in ${launch.launchDir}, running: ${project.devCommand.join(' ')}`)
+      log.info(TAG, `Detected ${project.framework} project in ${launch.launchDir}, running: ${project.devCommand.join(' ')}`)
       try {
         const entry = await startNpmServer(launch.launchDir, project.devCommand, port, project.framework)
         return NextResponse.json({
@@ -305,7 +308,7 @@ export async function POST(req: Request) {
           launchDir: launch.launchDir,
         })
       } catch (err: unknown) {
-        console.error(`[preview] npm server failed, falling back to static:`, err)
+        log.error(TAG, 'npm server failed, falling back to static:', err)
         // Fall through to static server
       }
     }
@@ -319,7 +322,7 @@ export async function POST(req: Request) {
 
     const entry: PreviewServer = { type: 'static', server, port, dir, startedAt: Date.now(), log: '' }
     servers.set(key, entry)
-    console.log(`[preview] Started static server for ${dir} on port ${port}`)
+    log.info(TAG, `Started static server for ${dir} on port ${port}`)
 
     return NextResponse.json(buildResponse(entry))
 
@@ -332,7 +335,7 @@ export async function POST(req: Request) {
       }
       if (srv.server) srv.server.close()
       servers.delete(key)
-      console.log(`[preview] Stopped server for ${launch.launchDir}`)
+      log.info(TAG, `Stopped server for ${launch.launchDir}`)
     }
     return NextResponse.json({ running: false, dir: launch.launchDir })
 

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

@@ -1,65 +1,26 @@
 import { NextResponse } from 'next/server'
-import { loadProjects, saveProjects, deleteProject, loadAgents, saveAgents, loadTasks, saveTasks, loadSchedules, saveSchedules, loadSkills, saveSkills, loadSecrets, saveSecrets } from '@/lib/server/storage'
-import { mutateItem, deleteItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
-import { ensureProjectWorkspace, normalizeProjectPatchInput } from '@/lib/server/project-utils'
-import { notify } from '@/lib/server/ws-hub'
+import { notFound } from '@/lib/server/collection-helpers'
+import { deleteProjectAndDetachReferences, getProject, updateProject } from '@/lib/server/projects/project-service'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 
-// 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])
+  const project = getProject(id)
+  if (!project) return notFound()
+  return NextResponse.json(project)
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
   if (error) return error
-  const result = mutateItem(ops, id, (project) => {
-    const patch = normalizeProjectPatchInput(body && typeof body === 'object' ? body as Record<string, unknown> : {})
-    Object.assign(project, patch, { updatedAt: Date.now() })
-    delete (project as Record<string, unknown>).id
-    project.id = id
-    return project
-  })
+  const result = updateProject(id, body && typeof body === 'object' ? body : {})
   if (!result) return notFound()
-  ensureProjectWorkspace(id, result.name)
   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 as unknown as () => Record<string, Record<string, unknown>>,
-    saveAgents as unknown as (data: Record<string, Record<string, unknown>>) => void,
-    'agents',
-  )
-  clearProjectId(loadTasks as unknown as () => Record<string, Record<string, unknown>>, saveTasks as unknown as (data: Record<string, Record<string, unknown>>) => void, 'tasks')
-  clearProjectId(loadSchedules as unknown as () => Record<string, Record<string, unknown>>, saveSchedules as unknown as (data: Record<string, Record<string, unknown>>) => void, 'schedules')
-  clearProjectId(loadSkills as unknown as () => Record<string, Record<string, unknown>>, saveSkills as unknown as (data: Record<string, Record<string, unknown>>) => void, 'skills')
-  clearProjectId(loadSecrets as unknown as () => Record<string, Record<string, unknown>>, saveSecrets as unknown as (data: Record<string, Record<string, unknown>>) => void, 'secrets')
-
+  if (!deleteProjectAndDetachReferences(id)) return notFound()
   return NextResponse.json({ ok: true })
 }