@swarmclawai/swarmclaw 0.5.3 → 0.6.2

package/src/app/api/chatrooms/[id]/chat/route.ts

@@ -0,0 +1,284 @@
+import { NextResponse } from 'next/server'
+import { genId } from '@/lib/id'
+import { loadChatrooms, saveChatrooms, loadAgents } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import { notFound } from '@/lib/server/collection-helpers'
+import { streamAgentChat } from '@/lib/server/stream-agent-chat'
+import { getProvider } from '@/lib/providers'
+import {
+  resolveApiKey,
+  parseMentions,
+  buildChatroomSystemPrompt,
+  buildSyntheticSession,
+  buildAgentSystemPromptForChatroom,
+  buildHistoryForAgent,
+} from '@/lib/server/chatroom-helpers'
+import type { Chatroom, ChatroomMessage, Agent } from '@/types'
+
+export const dynamic = 'force-dynamic'
+export const maxDuration = 300
+
+const MAX_CHAIN_DEPTH = 5
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+
+  const chatrooms = loadChatrooms()
+  const chatroom = chatrooms[id] as Chatroom | undefined
+  if (!chatroom) return notFound()
+
+  const text = typeof body.text === 'string' ? body.text : ''
+  const senderId = typeof body.senderId === 'string' ? body.senderId : 'user'
+  const imagePath = typeof body.imagePath === 'string' ? body.imagePath : undefined
+  const attachedFiles = Array.isArray(body.attachedFiles)
+    ? (body.attachedFiles as unknown[]).filter((f): f is string => typeof f === 'string')
+    : undefined
+  const replyToId = typeof body.replyToId === 'string' ? body.replyToId : undefined
+
+  if (!text.trim() && !imagePath && !attachedFiles?.length) {
+    return NextResponse.json({ error: 'text or attachment is required' }, { status: 400 })
+  }
+
+  const agents = loadAgents() as Record<string, Agent>
+
+  // Persist incoming message
+  const senderName = senderId === 'user' ? 'You' : (agents[senderId]?.name || senderId)
+  let mentions = parseMentions(text, agents, chatroom.agentIds)
+  // Auto-address: if enabled and no explicit mentions, address all agents
+  if (chatroom.autoAddress && mentions.length === 0) {
+    mentions = [...chatroom.agentIds]
+  }
+  const userMessage: ChatroomMessage = {
+    id: genId(),
+    senderId,
+    senderName,
+    role: senderId === 'user' ? 'user' : 'assistant',
+    text,
+    mentions,
+    reactions: [],
+    time: Date.now(),
+    ...(imagePath ? { imagePath } : {}),
+    ...(attachedFiles ? { attachedFiles } : {}),
+    ...(replyToId ? { replyToId } : {}),
+  }
+  chatroom.messages.push(userMessage)
+  chatroom.updatedAt = Date.now()
+  chatrooms[id] = chatroom
+  saveChatrooms(chatrooms)
+  notify('chatrooms')
+  notify(`chatroom:${id}`)
+
+  // Build reply context if replying to a message
+  let replyContext = ''
+  if (replyToId) {
+    const replyMsg = chatroom.messages.find((m) => m.id === replyToId)
+    if (replyMsg) {
+      const truncated = replyMsg.text.length > 200 ? replyMsg.text.slice(0, 200) + '...' : replyMsg.text
+      replyContext = `> [${replyMsg.senderName}]: ${truncated}\n\n`
+    }
+  }
+
+  // SSE stream
+  const encoder = new TextEncoder()
+  const stream = new ReadableStream({
+    start(controller) {
+      let closed = false
+      const writeEvent = (event: Record<string, unknown>) => {
+        if (closed) return
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`))
+        } catch {
+          closed = true
+        }
+      }
+
+      const processAgents = async () => {
+        // Build agent queue: start with mentioned agents, then chain
+        const initialQueue: Array<{ agentId: string; depth: number; contextMessage?: string }> = mentions.map((aid) => ({ agentId: aid, depth: 0 }))
+        const processed = new Set<string>()
+        const agentQueue: Array<{ agentId: string; depth: number; contextMessage?: string }> = []
+
+        /** Process a single agent: stream response, persist message, return chained mentions */
+        const processOneAgent = async (item: { agentId: string; depth: number; contextMessage?: string }): Promise<string[]> => {
+          if (processed.has(item.agentId) || item.depth >= MAX_CHAIN_DEPTH) return []
+          processed.add(item.agentId)
+
+          const agent = agents[item.agentId]
+          if (!agent) return []
+
+          // Pre-flight: check if the agent's provider is usable before attempting to stream
+          const providerInfo = getProvider(agent.provider)
+          const apiKey = resolveApiKey(agent.credentialId)
+          if (providerInfo?.requiresApiKey && !apiKey) {
+            writeEvent({ t: 'cr_agent_start', agentId: agent.id, agentName: agent.name })
+            writeEvent({ t: 'err', text: `${agent.name} has no API credentials configured`, agentId: agent.id, agentName: agent.name })
+            writeEvent({ t: 'cr_agent_done', agentId: agent.id, agentName: agent.name })
+            return []
+          }
+          if (providerInfo?.requiresEndpoint && !agent.apiEndpoint) {
+            writeEvent({ t: 'cr_agent_start', agentId: agent.id, agentName: agent.name })
+            writeEvent({ t: 'err', text: `${agent.name} has no endpoint configured`, agentId: agent.id, agentName: agent.name })
+            writeEvent({ t: 'cr_agent_done', agentId: agent.id, agentName: agent.name })
+            return []
+          }
+
+          writeEvent({ t: 'cr_agent_start', agentId: agent.id, agentName: agent.name })
+
+          try {
+            const freshChatrooms = loadChatrooms()
+            const freshChatroom = freshChatrooms[id] as Chatroom
+
+            const syntheticSession = buildSyntheticSession(agent, id)
+            const agentSystemPrompt = buildAgentSystemPromptForChatroom(agent)
+            const chatroomContext = buildChatroomSystemPrompt(freshChatroom, agents, agent.id)
+            const fullSystemPrompt = [agentSystemPrompt, chatroomContext].filter(Boolean).join('\n\n')
+            const history = buildHistoryForAgent(freshChatroom, agent.id, imagePath, attachedFiles)
+
+            // Use enriched context message for chained agents, or reply context + original text
+            const messageForAgent = item.contextMessage || (replyContext + text)
+
+            let fullText = ''
+            let agentError = ''
+            const result = await streamAgentChat({
+              session: syntheticSession,
+              message: messageForAgent,
+              imagePath,
+              attachedFiles,
+              apiKey,
+              systemPrompt: fullSystemPrompt,
+              write: (raw: string) => {
+                const lines = raw.split('\n').filter(Boolean)
+                for (const line of lines) {
+                  if (!line.startsWith('data: ')) continue
+                  try {
+                    const parsed = JSON.parse(line.slice(6).trim())
+                    if (parsed.t === 'd' && parsed.text) {
+                      fullText += parsed.text
+                      writeEvent({ t: 'd', text: parsed.text, agentId: agent.id, agentName: agent.name })
+                    } else if (parsed.t === 'tool_call' || parsed.t === 'tool_result') {
+                      writeEvent({ ...parsed, agentId: agent.id, agentName: agent.name })
+                    } else if (parsed.t === 'err' && parsed.text) {
+                      agentError = parsed.text
+                      writeEvent({ t: 'err', text: parsed.text, agentId: agent.id, agentName: agent.name })
+                    }
+                  } catch {
+                    // skip malformed lines
+                  }
+                }
+              },
+              history,
+            })
+
+            const responseText = result.fullText || fullText
+
+            // Don't persist empty or error-only messages — they pollute chat history
+            if (!responseText.trim() && agentError) {
+              writeEvent({ t: 'cr_agent_done', agentId: agent.id, agentName: agent.name })
+              return []
+            }
+
+            if (responseText.trim()) {
+              const newMentions = parseMentions(responseText, agents, freshChatroom.agentIds)
+              const agentMessage: ChatroomMessage = {
+                id: genId(),
+                senderId: agent.id,
+                senderName: agent.name,
+                role: 'assistant',
+                text: responseText,
+                mentions: newMentions,
+                reactions: [],
+                time: Date.now(),
+              }
+              const latestChatrooms = loadChatrooms()
+              const latestChatroom = latestChatrooms[id] as Chatroom
+              latestChatroom.messages.push(agentMessage)
+              latestChatroom.updatedAt = Date.now()
+              latestChatrooms[id] = latestChatroom
+              saveChatrooms(latestChatrooms)
+              notify(`chatroom:${id}`)
+
+              writeEvent({ t: 'cr_agent_done', agentId: agent.id, agentName: agent.name })
+
+              // Return chained agent IDs — enriched context is built below when queuing
+              return newMentions.filter((mid) => !processed.has(mid) && freshChatroom.agentIds.includes(mid))
+            }
+
+            writeEvent({ t: 'cr_agent_done', agentId: agent.id, agentName: agent.name })
+            return []
+          } catch (err: unknown) {
+            const msg = err instanceof Error ? err.message : String(err)
+            writeEvent({ t: 'err', text: `Agent ${agent.name} error: ${msg}`, agentId: agent.id })
+            writeEvent({ t: 'cr_agent_done', agentId: agent.id, agentName: agent.name })
+            return []
+          }
+        }
+
+        if (chatroom.chatMode === 'parallel') {
+          // Process initial batch in parallel
+          const results = await Promise.all(initialQueue.map(processOneAgent))
+          // Chained agents from parallel responses queue sequentially
+          for (const chainedIds of results) {
+            for (const cid of chainedIds) {
+              agentQueue.push({ agentId: cid, depth: 1 })
+            }
+          }
+        } else {
+          // Sequential: push initial queue items
+          agentQueue.push(...initialQueue)
+        }
+
+        // Process remaining chained agents sequentially with enriched context
+        while (agentQueue.length > 0) {
+          const item = agentQueue.shift()!
+
+          // Build enriched context for chained agents by looking at the most recent message
+          if (item.depth > 0 && !item.contextMessage) {
+            const latestChatrooms = loadChatrooms()
+            const latestChatroom = latestChatrooms[id] as Chatroom
+            const lastAgentMsg = [...latestChatroom.messages].reverse().find(
+              (m) => m.role === 'assistant' && m.senderId !== item.agentId
+            )
+            if (lastAgentMsg) {
+              const truncated = lastAgentMsg.text.length > 500 ? lastAgentMsg.text.slice(0, 500) + '...' : lastAgentMsg.text
+              item.contextMessage = `${lastAgentMsg.senderName} said: "${truncated}" — They're requesting your help. Review the conversation and respond.`
+            }
+          }
+
+          const chainedIds = await processOneAgent(item)
+          for (const cid of chainedIds) {
+            agentQueue.push({ agentId: cid, depth: item.depth + 1 })
+          }
+        }
+
+        writeEvent({ t: 'done' })
+        if (!closed) {
+          try { controller.close() } catch { /* already closed */ }
+          closed = true
+        }
+      }
+
+      processAgents().catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err)
+        writeEvent({ t: 'err', text: msg })
+        writeEvent({ t: 'done' })
+        if (!closed) {
+          try { controller.close() } catch { /* already closed */ }
+          closed = true
+        }
+      })
+    },
+    cancel() {
+      // Client disconnected
+    },
+  })
+
+  return new NextResponse(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  })
+}

package/src/app/api/chatrooms/[id]/members/route.ts

@@ -0,0 +1,82 @@
+import { NextResponse } from 'next/server'
+import { loadChatrooms, saveChatrooms, loadAgents } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import { notFound } from '@/lib/server/collection-helpers'
+import { genId } from '@/lib/id'
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+  const chatrooms = loadChatrooms()
+  const chatroom = chatrooms[id]
+  if (!chatroom) return notFound()
+
+  const agentId = body.agentId as string
+  if (!agentId) return NextResponse.json({ error: 'agentId is required' }, { status: 400 })
+
+  if (!chatroom.agentIds.includes(agentId)) {
+    chatroom.agentIds.push(agentId)
+
+    // Inject a system event message
+    const agents = loadAgents()
+    const agentName = agents[agentId]?.name || 'Unknown agent'
+    if (!Array.isArray(chatroom.messages)) chatroom.messages = []
+    chatroom.messages.push({
+      id: genId(),
+      senderId: 'system',
+      senderName: 'System',
+      role: 'assistant',
+      text: `${agentName} has joined the chat`,
+      mentions: [],
+      reactions: [],
+      time: Date.now(),
+    })
+
+    chatroom.updatedAt = Date.now()
+    chatrooms[id] = chatroom
+    saveChatrooms(chatrooms)
+    notify('chatrooms')
+    notify(`chatroom:${id}`)
+  }
+
+  return NextResponse.json(chatroom)
+}
+
+export async function DELETE(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+  const chatrooms = loadChatrooms()
+  const chatroom = chatrooms[id]
+  if (!chatroom) return notFound()
+
+  const agentId = body.agentId as string
+  if (!agentId) return NextResponse.json({ error: 'agentId is required' }, { status: 400 })
+
+  const wasPresent = chatroom.agentIds.includes(agentId)
+  chatroom.agentIds = chatroom.agentIds.filter((aid: string) => aid !== agentId)
+
+  // Inject a system event message
+  if (wasPresent) {
+    const agents = loadAgents()
+    const agentName = agents[agentId]?.name || 'Unknown agent'
+    if (!Array.isArray(chatroom.messages)) chatroom.messages = []
+    chatroom.messages.push({
+      id: genId(),
+      senderId: 'system',
+      senderName: 'System',
+      role: 'assistant',
+      text: `${agentName} has left the chat`,
+      mentions: [],
+      reactions: [],
+      time: Date.now(),
+    })
+  }
+
+  chatroom.updatedAt = Date.now()
+  chatrooms[id] = chatroom
+  saveChatrooms(chatrooms)
+  notify('chatrooms')
+  notify(`chatroom:${id}`)
+
+  return NextResponse.json(chatroom)
+}

package/src/app/api/chatrooms/[id]/pins/route.ts

@@ -0,0 +1,39 @@
+import { NextResponse } from 'next/server'
+import { loadChatrooms, saveChatrooms } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import { notFound } from '@/lib/server/collection-helpers'
+import type { Chatroom } from '@/types'
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+  const chatrooms = loadChatrooms()
+  const chatroom = chatrooms[id] as Chatroom | undefined
+  if (!chatroom) return notFound()
+
+  const messageId = body.messageId as string
+  if (!messageId) {
+    return NextResponse.json({ error: 'messageId is required' }, { status: 400 })
+  }
+
+  const message = chatroom.messages.find((m) => m.id === messageId)
+  if (!message) {
+    return NextResponse.json({ error: 'Message not found' }, { status: 404 })
+  }
+
+  // Toggle: remove if pinned, add if not
+  if (!chatroom.pinnedMessageIds) chatroom.pinnedMessageIds = []
+  const idx = chatroom.pinnedMessageIds.indexOf(messageId)
+  if (idx >= 0) {
+    chatroom.pinnedMessageIds.splice(idx, 1)
+  } else {
+    chatroom.pinnedMessageIds.push(messageId)
+  }
+
+  chatroom.updatedAt = Date.now()
+  chatrooms[id] = chatroom
+  saveChatrooms(chatrooms)
+  notify(`chatroom:${id}`)
+
+  return NextResponse.json({ ok: true, pinnedMessageIds: chatroom.pinnedMessageIds })
+}

package/src/app/api/chatrooms/[id]/reactions/route.ts

@@ -0,0 +1,42 @@
+import { NextResponse } from 'next/server'
+import { loadChatrooms, saveChatrooms } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import { notFound } from '@/lib/server/collection-helpers'
+import type { Chatroom, ChatroomMessage, ChatroomReaction } from '@/types'
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+  const chatrooms = loadChatrooms()
+  const chatroom = chatrooms[id] as Chatroom | undefined
+  if (!chatroom) return notFound()
+
+  const messageId = body.messageId as string
+  const emoji = body.emoji as string
+  const reactorId = (body.reactorId as string) || 'user'
+  if (!messageId || !emoji) {
+    return NextResponse.json({ error: 'messageId and emoji are required' }, { status: 400 })
+  }
+
+  const message = chatroom.messages.find((m: ChatroomMessage) => m.id === messageId)
+  if (!message) {
+    return NextResponse.json({ error: 'Message not found' }, { status: 404 })
+  }
+
+  // Toggle: remove if already exists, add if not
+  const existingIdx = message.reactions.findIndex(
+    (r: ChatroomReaction) => r.emoji === emoji && r.reactorId === reactorId
+  )
+  if (existingIdx >= 0) {
+    message.reactions.splice(existingIdx, 1)
+  } else {
+    message.reactions.push({ emoji, reactorId, time: Date.now() })
+  }
+
+  chatroom.updatedAt = Date.now()
+  chatrooms[id] = chatroom
+  saveChatrooms(chatrooms)
+  notify(`chatroom:${id}`)
+
+  return NextResponse.json({ ok: true, reactions: message.reactions })
+}

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

@@ -0,0 +1,84 @@
+import { NextResponse } from 'next/server'
+import { loadChatrooms, saveChatrooms, loadAgents } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import { notFound } from '@/lib/server/collection-helpers'
+import { genId } from '@/lib/id'
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const chatrooms = loadChatrooms()
+  const chatroom = chatrooms[id]
+  if (!chatroom) return notFound()
+  return NextResponse.json(chatroom)
+}
+
+export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+  const chatrooms = loadChatrooms()
+  const chatroom = chatrooms[id]
+  if (!chatroom) return notFound()
+
+  if (body.name !== undefined) chatroom.name = body.name
+  if (body.description !== undefined) chatroom.description = body.description
+
+  // Diff agentIds and inject join/leave system messages
+  if (Array.isArray(body.agentIds)) {
+    const oldIds = new Set(chatroom.agentIds)
+    const newIds = new Set(body.agentIds as string[])
+    const added = (body.agentIds as string[]).filter((aid: string) => !oldIds.has(aid))
+    const removed = chatroom.agentIds.filter((aid: string) => !newIds.has(aid))
+
+    if (added.length > 0 || removed.length > 0) {
+      const agents = loadAgents()
+      if (!Array.isArray(chatroom.messages)) chatroom.messages = []
+      const now = Date.now()
+      let offset = 0
+      for (const aid of added) {
+        chatroom.messages.push({
+          id: genId(),
+          senderId: 'system',
+          senderName: 'System',
+          role: 'assistant',
+          text: `${agents[aid]?.name || 'Unknown agent'} has joined the chat`,
+          mentions: [],
+          reactions: [],
+          time: now + offset++,
+        })
+      }
+      for (const aid of removed) {
+        chatroom.messages.push({
+          id: genId(),
+          senderId: 'system',
+          senderName: 'System',
+          role: 'assistant',
+          text: `${agents[aid]?.name || 'Unknown agent'} has left the chat`,
+          mentions: [],
+          reactions: [],
+          time: now + offset++,
+        })
+      }
+    }
+
+    chatroom.agentIds = body.agentIds
+  }
+
+  chatroom.updatedAt = Date.now()
+
+  chatrooms[id] = chatroom
+  saveChatrooms(chatrooms)
+  notify('chatrooms')
+  notify(`chatroom:${id}`)
+  return NextResponse.json(chatroom)
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const chatrooms = loadChatrooms()
+  if (!chatrooms[id]) return notFound()
+
+  delete chatrooms[id]
+  saveChatrooms(chatrooms)
+  notify('chatrooms')
+  return NextResponse.json({ ok: true })
+}

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

@@ -0,0 +1,50 @@
+import { NextResponse } from 'next/server'
+import { genId } from '@/lib/id'
+import { loadChatrooms, saveChatrooms, loadAgents } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import type { Chatroom, ChatroomMessage } from '@/types'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const chatrooms = loadChatrooms()
+  return NextResponse.json(chatrooms)
+}
+
+export async function POST(req: Request) {
+  const body = await req.json()
+  const chatrooms = loadChatrooms()
+  const id = genId()
+
+  const agentIds: string[] = Array.isArray(body.agentIds) ? body.agentIds : []
+  const now = Date.now()
+
+  // Generate join messages for initial agents
+  const agents = agentIds.length > 0 ? loadAgents() : {}
+  const joinMessages: ChatroomMessage[] = agentIds.map((agentId: string, i: number) => ({
+    id: genId(),
+    senderId: 'system',
+    senderName: 'System',
+    role: 'assistant',
+    text: `${agents[agentId]?.name || 'Unknown agent'} has joined the chat`,
+    mentions: [],
+    reactions: [],
+    time: now + i, // offset by 1ms so they sort in order
+  }))
+
+  const chatroom: Chatroom = {
+    id,
+    name: body.name || 'New Chatroom',
+    description: body.description || '',
+    agentIds,
+    messages: joinMessages,
+    createdAt: now,
+    updatedAt: now,
+  }
+
+  chatrooms[id] = chatroom
+  saveChatrooms(chatrooms)
+  notify('chatrooms')
+
+  return NextResponse.json(chatroom)
+}

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

@@ -61,6 +61,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   // Regular update
   if (body.name !== undefined) connector.name = body.name
   if (body.agentId !== undefined) connector.agentId = body.agentId
+  if (body.chatroomId !== undefined) connector.chatroomId = body.chatroomId
   if (body.credentialId !== undefined) connector.credentialId = body.credentialId
   if (body.config !== undefined) connector.config = body.config
   if (body.isEnabled !== undefined) connector.isEnabled = body.isEnabled

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

@@ -33,7 +33,8 @@ export async function POST(req: Request) {
     id,
     name: body.name || `${body.platform} Connector`,
     platform: body.platform,
-    agentId: body.agentId,
+    agentId: body.agentId || null,
+    chatroomId: body.chatroomId || null,
     credentialId: body.credentialId || null,
     config: body.config || {},
     isEnabled: false,

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

@@ -6,8 +6,8 @@ export const dynamic = 'force-dynamic'
 
 export async function GET(_req: Request) {
   const creds = loadCredentials()
-  const safe: Record<string, any> = {}
-  for (const [id, c] of Object.entries(creds) as [string, any][]) {
+  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)
@@ -28,6 +28,5 @@ export async function POST(req: Request) {
     createdAt: Date.now(),
   }
   saveCredentials(creds)
-  console.log(`[credentials] stored ${id} for ${provider}`)
   return NextResponse.json({ id, provider, name: creds[id].name, createdAt: creds[id].createdAt })
 }

package/src/app/api/files/open/route.ts

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server'
+import { exec } from 'child_process'
+import fs from 'fs'
+import path from 'path'
+
+export async function POST(req: Request) {
+  const { path: targetPath } = await req.json() as { path?: string }
+  if (!targetPath || typeof targetPath !== 'string') {
+    return NextResponse.json({ error: 'path is required' }, { status: 400 })
+  }
+
+  const resolved = path.resolve(targetPath)
+
+  // Verify the path exists
+  if (!fs.existsSync(resolved)) {
+    return NextResponse.json({ error: 'Path does not exist' }, { status: 404 })
+  }
+
+  const isDir = fs.statSync(resolved).isDirectory()
+  const platform = process.platform
+
+  // Determine the command to reveal in the OS file manager
+  let cmd: string
+  if (platform === 'darwin') {
+    // macOS: -R reveals in Finder (selects the item), for dirs just open the dir
+    cmd = isDir ? `open "${resolved}"` : `open -R "${resolved}"`
+  } else if (platform === 'win32') {
+    cmd = isDir ? `explorer "${resolved}"` : `explorer /select,"${resolved}"`
+  } else {
+    // Linux: xdg-open on the directory containing the file
+    cmd = `xdg-open "${isDir ? resolved : path.dirname(resolved)}"`
+  }
+
+  return new Promise<NextResponse>((resolve) => {
+    exec(cmd, (err) => {
+      if (err) {
+        resolve(NextResponse.json({ error: err.message }, { status: 500 }))
+      } else {
+        resolve(NextResponse.json({ ok: true }))
+      }
+    })
+  })
+}