clawport-ui 0.8.0 → 0.8.2

package/app/api/conversations/[agentId]/route.ts

@@ -0,0 +1,77 @@
+import { NextRequest } from 'next/server'
+import { getMessages, appendMessages, clearConversation, validateAgentId, StoredMessage } from '@/lib/conversation-store'
+import { apiErrorResponse } from '@/lib/api-error'
+
+function isValidMessage(m: unknown): m is StoredMessage {
+  if (!m || typeof m !== 'object') return false
+  const msg = m as Record<string, unknown>
+  return (
+    typeof msg.id === 'string' && msg.id.length > 0 &&
+    (msg.role === 'user' || msg.role === 'assistant') &&
+    typeof msg.content === 'string' &&
+    (typeof msg.timestamp === 'number' || msg.timestamp === undefined)
+  )
+}
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ agentId: string }> },
+) {
+  try {
+    const { agentId } = await params
+    validateAgentId(agentId)
+    const messages = getMessages(agentId)
+    return Response.json(messages)
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith('Invalid agent ID')) {
+      return Response.json({ error: err.message }, { status: 400 })
+    }
+    return apiErrorResponse(err, 'Failed to load conversation')
+  }
+}
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ agentId: string }> },
+) {
+  try {
+    const { agentId } = await params
+    validateAgentId(agentId)
+
+    const body = await req.json()
+    const messages: unknown[] = body.messages
+
+    if (!Array.isArray(messages) || messages.length === 0) {
+      return Response.json({ error: 'messages array required' }, { status: 400 })
+    }
+
+    if (!messages.every(isValidMessage)) {
+      return Response.json({ error: 'Invalid message format: each message needs id, role (user|assistant), and content' }, { status: 400 })
+    }
+
+    appendMessages(agentId, messages)
+    return Response.json({ ok: true })
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith('Invalid agent ID')) {
+      return Response.json({ error: err.message }, { status: 400 })
+    }
+    return apiErrorResponse(err, 'Failed to save conversation')
+  }
+}
+
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ agentId: string }> },
+) {
+  try {
+    const { agentId } = await params
+    validateAgentId(agentId)
+    clearConversation(agentId)
+    return Response.json({ ok: true })
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith('Invalid agent ID')) {
+      return Response.json({ error: err.message }, { status: 400 })
+    }
+    return apiErrorResponse(err, 'Failed to clear conversation')
+  }
+}

package/app/api/conversations/route.ts

@@ -0,0 +1,11 @@
+import { listAgentIds } from '@/lib/conversation-store'
+import { apiErrorResponse } from '@/lib/api-error'
+
+export async function GET() {
+  try {
+    const ids = listAgentIds()
+    return Response.json(ids)
+  } catch (err) {
+    return apiErrorResponse(err, 'Failed to list conversations')
+  }
+}

package/app/api/memory/reindex/route.ts

@@ -0,0 +1,36 @@
+import { NextResponse } from 'next/server'
+import { execSync } from 'child_process'
+import { requireEnv } from '@/lib/env'
+
+export async function POST() {
+  let bin: string
+  try {
+    bin = requireEnv('OPENCLAW_BIN')
+  } catch {
+    return NextResponse.json(
+      { status: 'unavailable', message: 'OPENCLAW_BIN not configured', timestamp: null },
+      { status: 503 }
+    )
+  }
+
+  try {
+    const output = execSync(`${bin} memory reindex`, {
+      timeout: 30000,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim()
+
+    return NextResponse.json({
+      status: 'success',
+      message: output || 'Reindex completed',
+      timestamp: new Date().toISOString(),
+    })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Reindex failed'
+    return NextResponse.json({
+      status: 'failed',
+      message,
+      timestamp: new Date().toISOString(),
+    })
+  }
+}

package/app/api/memory/route.ts

@@ -1,4 +1,6 @@
 import { getMemoryFiles, getMemoryConfig, getMemoryStatus, computeMemoryStats } from '@/lib/memory'
+import { computeMemoryHealth } from '@/lib/memory-health'
+import { writeMemoryFile, PathValidationError } from '@/lib/memory-write'
 import { apiErrorResponse } from '@/lib/api-error'
 import { NextResponse } from 'next/server'
 
@@ -8,8 +10,41 @@ export async function GET() {
     const config = getMemoryConfig()
     const status = getMemoryStatus()
     const stats = computeMemoryStats(files)
-    return NextResponse.json({ files, config, status, stats })
+    const health = computeMemoryHealth(files, config, status, stats)
+    return NextResponse.json({ files, config, status, stats, health })
   } catch (err) {
     return apiErrorResponse(err, 'Failed to load memory files')
   }
 }
+
+export async function PUT(req: Request) {
+  try {
+    const body = await req.json()
+    const { relativePath, content, expectedLastModified } = body
+
+    if (typeof content !== 'string') {
+      return NextResponse.json({ error: 'Content must be a string' }, { status: 400 })
+    }
+
+    const result = writeMemoryFile(relativePath, content, expectedLastModified)
+    return NextResponse.json({ ok: true, ...result })
+  } catch (err) {
+    if (err instanceof PathValidationError) {
+      return NextResponse.json({ error: err.message }, { status: 400 })
+    }
+    const code = (err as NodeJS.ErrnoException).code
+    if (code === 'ENOENT') {
+      return NextResponse.json({ error: 'File not found' }, { status: 404 })
+    }
+    if (code === 'E2BIG') {
+      return NextResponse.json({ error: (err as Error).message }, { status: 413 })
+    }
+    if (code === 'ECONFLICT') {
+      return NextResponse.json(
+        { error: 'File was modified by another process. Refresh or overwrite.' },
+        { status: 409 }
+      )
+    }
+    return apiErrorResponse(err, 'Failed to save memory file')
+  }
+}

package/app/api/onboarded/route.ts

@@ -0,0 +1,24 @@
+import { NextRequest } from 'next/server'
+import { isOnboarded, setOnboarded } from '@/lib/conversation-store'
+import { apiErrorResponse } from '@/lib/api-error'
+
+export async function GET() {
+  try {
+    return Response.json({ onboarded: isOnboarded() })
+  } catch (err) {
+    return apiErrorResponse(err, 'Failed to check onboarded status')
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json()
+    if (typeof body.onboarded !== 'boolean') {
+      return Response.json({ error: 'onboarded boolean required' }, { status: 400 })
+    }
+    setOnboarded(body.onboarded)
+    return Response.json({ ok: true })
+  } catch (err) {
+    return apiErrorResponse(err, 'Failed to update onboarded status')
+  }
+}

package/app/chat/page.tsx

@@ -1,12 +1,13 @@
 'use client'
-import { useEffect, useState, useCallback, Suspense } from 'react'
+import { useEffect, useState, useCallback, useRef, Suspense } from 'react'
 import { useSearchParams, useRouter } from 'next/navigation'
 import type { Agent } from '@/lib/types'
 import { AgentList, AgentListMobile } from '@/components/chat/AgentList'
 import { ConversationView } from '@/components/chat/ConversationView'
 import {
   loadConversations, saveConversations, getOrCreateConversation,
-  markRead, type ConversationStore
+  markRead, type ConversationStore, type Message,
+  fetchConversation, syncToServer, fromStoredMessage,
 } from '@/lib/conversations'
 
 function MessengerApp() {
@@ -31,13 +32,72 @@ function MessengerApp() {
     setConversations(loadConversations())
   }, [])
 
-  // Save conversations whenever they change
+  // Save conversations whenever they change (localStorage + server sync)
+  const prevConversationsRef = useRef<ConversationStore>({})
   useEffect(() => {
     if (Object.keys(conversations).length > 0) {
       saveConversations(conversations)
+
+      // Sync only new messages to server (fire-and-forget)
+      const prev = prevConversationsRef.current
+      for (const agentId of Object.keys(conversations)) {
+        const prevMsgs = prev[agentId]?.messages || []
+        const currMsgs = conversations[agentId]?.messages || []
+        if (currMsgs.length > prevMsgs.length) {
+          const prevIds = new Set(prevMsgs.map((m: Message) => m.id))
+          const newMsgs = currMsgs.filter((m: Message) => !prevIds.has(m.id))
+          if (newMsgs.length > 0) {
+            syncToServer(agentId, newMsgs)
+          }
+        }
+      }
+      prevConversationsRef.current = conversations
     }
   }, [conversations])
 
+  // Background merge: fetch server conversations and merge with localStorage
+  const mergedRef = useRef(false)
+  useEffect(() => {
+    if (loading || agents.length === 0 || mergedRef.current) return
+    mergedRef.current = true
+
+    Promise.all(
+      agents.map(async (agent) => {
+        const serverMsgs = await fetchConversation(agent.id)
+        return { agentId: agent.id, messages: serverMsgs }
+      })
+    ).then(results => {
+      setConversations(prev => {
+        let merged = { ...prev }
+        for (const { agentId, messages: serverMsgs } of results) {
+          if (serverMsgs.length === 0) continue
+          const existing = merged[agentId]
+          if (!existing) {
+            // Server has messages but localStorage doesn't — create conversation
+            merged[agentId] = {
+              agentId,
+              messages: serverMsgs.map(fromStoredMessage),
+              unread: 0,
+              lastActivity: serverMsgs[serverMsgs.length - 1].timestamp,
+            }
+          } else {
+            // Merge by message ID, sort by timestamp
+            const existingIds = new Set(existing.messages.map((m: Message) => m.id))
+            const newFromServer = serverMsgs
+              .filter(m => !existingIds.has(m.id))
+              .map(fromStoredMessage)
+            if (newFromServer.length > 0) {
+              const allMessages = [...existing.messages, ...newFromServer]
+                .sort((a, b) => a.timestamp - b.timestamp)
+              merged[agentId] = { ...existing, messages: allMessages }
+            }
+          }
+        }
+        return merged
+      })
+    })
+  }, [loading, agents])
+
   // Set default active agent on desktop only (don't auto-select on mobile)
   useEffect(() => {
     if (!loading && agents.length > 0 && !activeAgentId) {