@castlekit/castle 0.1.6 → 0.3.0

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

@@ -0,0 +1,272 @@
+import { NextRequest, NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { checkCsrf, sanitizeForApi, checkRateLimit, rateLimitKey } from "@/lib/api-security";
+import { ensureGateway } from "@/lib/gateway-connection";
+import {
+  createMessage,
+  updateMessage,
+  deleteMessage,
+  getMessagesByChannel,
+  getMessagesAfter,
+  getMessagesAround,
+  getMessageByRunId,
+  getLatestSessionKey,
+  createSession,
+} from "@/lib/db/queries";
+import type { ChatSendRequest, ChatCompleteRequest } from "@/lib/types/chat";
+
+const MAX_MESSAGE_LENGTH = 32768; // 32KB
+
+// ============================================================================
+// POST /api/openclaw/chat — Send a message
+// ============================================================================
+
+export async function POST(request: NextRequest) {
+  const csrf = checkCsrf(request);
+  if (csrf) return csrf;
+
+  // Rate limit: 30 messages per minute
+  const rl = checkRateLimit(rateLimitKey(request, "chat:send"), 30);
+  if (rl) return rl;
+
+  let body: ChatSendRequest;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
+  }
+
+  // Validate
+  if (!body.channelId || typeof body.channelId !== "string") {
+    return NextResponse.json({ error: "channelId is required" }, { status: 400 });
+  }
+  if (!body.content || typeof body.content !== "string") {
+    return NextResponse.json({ error: "content is required" }, { status: 400 });
+  }
+  if (body.content.length > MAX_MESSAGE_LENGTH) {
+    return NextResponse.json(
+      { error: `Message too long (max ${MAX_MESSAGE_LENGTH} chars)` },
+      { status: 400 }
+    );
+  }
+
+  // Persist user message to DB
+  const userMsg = createMessage({
+    channelId: body.channelId,
+    senderType: "user",
+    senderId: "local-user",
+    senderName: "You",
+    content: body.content,
+    mentionedAgentId: body.agentId,
+  });
+
+  try {
+    const gateway = ensureGateway();
+
+    // Get existing session key for this channel (if any)
+    let sessionKey = getLatestSessionKey(body.channelId);
+
+    // If no existing session, create one with a proper structured key:
+    //   agent:<agentId>:castle:<channelId>
+    // This maps Castle channels to Gateway sessions 1:1, so the session
+    // is stable and traceable between Castle DB and Gateway transcripts.
+    if (!sessionKey) {
+      const agentId = body.agentId || "main";
+      sessionKey = `agent:${agentId}:castle:${body.channelId}`;
+
+      createSession({
+        channelId: body.channelId,
+        sessionKey,
+      });
+    }
+
+    // Build chat.send params per Gateway protocol
+    const rpcParams: Record<string, unknown> = {
+      message: body.content,
+      sessionKey,
+      idempotencyKey: randomUUID(),
+      timeoutMs: 120000,
+    };
+
+    const result = await gateway.request<{
+      runId: string;
+      status?: string;
+    }>("chat.send", rpcParams);
+
+    // Update user message with runId and sessionKey
+    const runId = result.runId;
+    updateMessage(userMsg.id, {
+      runId,
+      sessionKey,
+    });
+
+    return NextResponse.json({
+      runId,
+      messageId: userMsg.id,
+      sessionKey,
+    });
+  } catch (err) {
+    // RPC failed — try to remove the optimistic user message
+    try {
+      deleteMessage(userMsg.id);
+    } catch (delErr) {
+      console.error("[Chat API] Cleanup failed:", (delErr as Error).message);
+    }
+    console.error("[Chat API] Send failed:", (err as Error).message);
+    return NextResponse.json(
+      { error: sanitizeForApi((err as Error).message) },
+      { status: 502 }
+    );
+  }
+}
+
+// ============================================================================
+// PUT /api/openclaw/chat — Complete/update an agent message
+// ============================================================================
+
+export async function PUT(request: NextRequest) {
+  const csrf = checkCsrf(request);
+  if (csrf) return csrf;
+
+  let body: ChatCompleteRequest;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
+  }
+
+  if (!body.runId || !body.channelId || !body.content) {
+    return NextResponse.json(
+      { error: "runId, channelId, and content are required" },
+      { status: 400 }
+    );
+  }
+
+  try {
+    // Check if we already have a message for this runId (from a previous partial save)
+    const existing = getMessageByRunId(body.runId);
+
+    if (existing) {
+      // Already complete with same content — idempotent, skip update to avoid
+      // triggering FTS5 update trigger with identical content (causes SQL error)
+      if (existing.status === "complete" && existing.content === body.content) {
+        return NextResponse.json({ messageId: existing.id, updated: false });
+      }
+
+      // Update existing message (e.g. partial → complete, or content changed)
+      updateMessage(existing.id, {
+        content: body.content,
+        status: body.status,
+        sessionKey: body.sessionKey,
+        inputTokens: body.inputTokens,
+        outputTokens: body.outputTokens,
+      });
+      return NextResponse.json({ messageId: existing.id, updated: true });
+    }
+
+    // Create new agent message
+    const agentMsg = createMessage({
+      channelId: body.channelId,
+      senderType: "agent",
+      senderId: body.agentId,
+      senderName: body.agentName,
+      content: body.content,
+      status: body.status,
+      runId: body.runId,
+      sessionKey: body.sessionKey,
+      inputTokens: body.inputTokens,
+      outputTokens: body.outputTokens,
+    });
+
+    return NextResponse.json({ messageId: agentMsg.id, updated: false });
+  } catch (err) {
+    console.error("[Chat API] Complete failed:", (err as Error).message);
+    return NextResponse.json(
+      { error: sanitizeForApi((err as Error).message) },
+      { status: 500 }
+    );
+  }
+}
+
+// ============================================================================
+// DELETE /api/openclaw/chat — Abort streaming
+// ============================================================================
+
+export async function DELETE(request: NextRequest) {
+  const csrf = checkCsrf(request);
+  if (csrf) return csrf;
+
+  try {
+    const gateway = ensureGateway();
+    await gateway.request("chat.abort", {});
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    console.error("[Chat API] Abort failed:", (err as Error).message);
+    return NextResponse.json(
+      { error: sanitizeForApi((err as Error).message) },
+      { status: 502 }
+    );
+  }
+}
+
+// ============================================================================
+// GET /api/openclaw/chat?channelId=X&limit=50&before=Y — Load history
+//   ?around=msgId — Load a window centered on a specific message
+//   ?after=msgId  — Forward pagination (newer messages)
+//   ?before=msgId — Backward pagination (older messages, existing)
+// ============================================================================
+
+export async function GET(request: NextRequest) {
+  const { searchParams } = new URL(request.url);
+  const channelId = searchParams.get("channelId");
+  const limit = Math.min(parseInt(searchParams.get("limit") || "50", 10), 200);
+  const around = searchParams.get("around") || undefined;
+  const after = searchParams.get("after") || undefined;
+  const before = searchParams.get("before") || undefined;
+
+  if (!channelId) {
+    return NextResponse.json({ error: "channelId is required" }, { status: 400 });
+  }
+
+  try {
+    // Anchor mode: load a window of messages around a specific message
+    if (around) {
+      const result = getMessagesAround(channelId, around, limit);
+      if (!result) {
+        // Anchor message not found — fall back to latest messages
+        const msgs = getMessagesByChannel(channelId, limit);
+        return NextResponse.json({
+          messages: msgs,
+          hasMore: msgs.length === limit,
+        });
+      }
+      return NextResponse.json({
+        messages: result.messages,
+        hasMoreBefore: result.hasMoreBefore,
+        hasMoreAfter: result.hasMoreAfter,
+      });
+    }
+
+    // Forward pagination: load messages newer than cursor
+    if (after) {
+      const msgs = getMessagesAfter(channelId, after, limit);
+      return NextResponse.json({
+        messages: msgs,
+        hasMore: msgs.length === limit,
+      });
+    }
+
+    // Default / backward pagination
+    const msgs = getMessagesByChannel(channelId, limit, before);
+    return NextResponse.json({
+      messages: msgs,
+      hasMore: msgs.length === limit,
+    });
+  } catch (err) {
+    console.error("[Chat API] History failed:", (err as Error).message);
+    return NextResponse.json(
+      { error: sanitizeForApi((err as Error).message) },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/openclaw/chat/search/route.ts

@@ -0,0 +1,149 @@
+import { NextRequest, NextResponse } from "next/server";
+import { sanitizeForApi, checkRateLimit, rateLimitKey, checkCsrf } from "@/lib/api-security";
+import { searchMessages, getChannels, getRecentSearches, addRecentSearch, clearRecentSearches } from "@/lib/db/queries";
+import type { MessageSearchResult, SearchResult } from "@/lib/types/search";
+
+const MAX_QUERY_LENGTH = 500;
+
+// ============================================================================
+// GET /api/openclaw/chat/search?q=X — Universal full-text search
+// ============================================================================
+
+export async function GET(request: NextRequest) {
+  // Rate limit: 60 searches per minute
+  const rl = checkRateLimit(rateLimitKey(request, "chat:search"), 60);
+  if (rl) return rl;
+
+  const { searchParams } = new URL(request.url);
+
+  // GET /api/openclaw/chat/search?recent=1 — return recent searches
+  if (searchParams.get("recent") === "1") {
+    try {
+      const recent = getRecentSearches();
+      return NextResponse.json({ recent });
+    } catch (err) {
+      console.error("[Chat Search] Recent failed:", (err as Error).message);
+      return NextResponse.json({ recent: [] });
+    }
+  }
+
+  const q = searchParams.get("q");
+  const limit = Math.min(parseInt(searchParams.get("limit") || "30", 10), 100);
+
+  if (!q || !q.trim()) {
+    return NextResponse.json({ results: [] });
+  }
+
+  if (q.length > MAX_QUERY_LENGTH) {
+    return NextResponse.json(
+      { error: `Search query too long (max ${MAX_QUERY_LENGTH} chars)` },
+      { status: 400 }
+    );
+  }
+
+  try {
+    // Build channel name lookup — include archived channels so their
+    // names still resolve in search results.
+    const activeChannels = getChannels(false);
+    const archivedChannels = getChannels(true);
+    const channelMap = new Map<string, { name: string; archived: boolean }>();
+    for (const ch of activeChannels) {
+      channelMap.set(ch.id, { name: ch.name, archived: false });
+    }
+    for (const ch of archivedChannels) {
+      channelMap.set(ch.id, { name: ch.name, archived: true });
+    }
+
+    // Search messages across all channels
+    const rawMessages = searchMessages(q, undefined, limit);
+
+    // Map raw ChatMessage[] into typed MessageSearchResult[]
+    const results: SearchResult[] = rawMessages.map((msg): MessageSearchResult => {
+      const ch = channelMap.get(msg.channelId);
+      const channelName = ch?.name || "Unknown";
+      const archived = ch?.archived ?? false;
+      const senderName =
+        msg.senderType === "user"
+          ? "You"
+          : msg.senderName || msg.senderId;
+
+      // Truncate snippet to ~200 chars
+      const snippet =
+        msg.content.length > 200
+          ? msg.content.slice(0, 200) + "…"
+          : msg.content;
+
+      return {
+        id: msg.id,
+        type: "message",
+        title: `#${channelName}`,
+        subtitle: senderName,
+        snippet,
+        timestamp: msg.createdAt,
+        href: `/chat/${msg.channelId}?m=${msg.id}`,
+        channelId: msg.channelId,
+        channelName,
+        messageId: msg.id,
+        senderType: msg.senderType,
+        senderName,
+        archived,
+      };
+    });
+
+    // Future: merge results from searchTasks(), searchNotes(), etc.
+    // Sort by timestamp descending (already sorted by FTS query)
+
+    return NextResponse.json({ results });
+  } catch (err) {
+    console.error("[Chat Search] Failed:", (err as Error).message);
+    return NextResponse.json(
+      { error: sanitizeForApi((err as Error).message) },
+      { status: 500 }
+    );
+  }
+}
+
+// ============================================================================
+// POST /api/openclaw/chat/search — Save a recent search
+// ============================================================================
+
+export async function POST(request: NextRequest) {
+  const csrf = checkCsrf(request);
+  if (csrf) return csrf;
+
+  try {
+    const body = await request.json();
+    const q = body.query;
+    if (!q || typeof q !== "string" || !q.trim()) {
+      return NextResponse.json({ error: "query is required" }, { status: 400 });
+    }
+    addRecentSearch(q.trim());
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    console.error("[Chat Search] Save recent failed:", (err as Error).message);
+    return NextResponse.json(
+      { error: sanitizeForApi((err as Error).message) },
+      { status: 500 }
+    );
+  }
+}
+
+// ============================================================================
+// DELETE /api/openclaw/chat/search — Clear all recent searches
+// ============================================================================
+
+export async function DELETE(request: NextRequest) {
+  const csrf = checkCsrf(request);
+  if (csrf) return csrf;
+
+  try {
+    clearRecentSearches();
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    console.error("[Chat Search] Clear recent failed:", (err as Error).message);
+    return NextResponse.json(
+      { error: sanitizeForApi((err as Error).message) },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/openclaw/chat/storage/route.ts

@@ -0,0 +1,75 @@
+import { NextResponse } from "next/server";
+import { existsSync, statSync, readdirSync } from "fs";
+import { join } from "path";
+import { getCastleDir } from "@/lib/config";
+import { getStorageStats } from "@/lib/db/queries";
+import { getDbPath } from "@/lib/db/index";
+
+/**
+ * Recursively calculate total size of a directory.
+ */
+function getDirSize(dir: string): number {
+  if (!existsSync(dir)) return 0;
+
+  let total = 0;
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      total += getDirSize(fullPath);
+    } else {
+      try {
+        total += statSync(fullPath).size;
+      } catch {
+        // Skip files we can't stat
+      }
+    }
+  }
+  return total;
+}
+
+// ============================================================================
+// GET /api/openclaw/chat/storage — Storage stats
+// ============================================================================
+
+export async function GET() {
+  try {
+    const stats = getStorageStats();
+
+    // Get actual DB file size
+    const dbPath = getDbPath();
+    let dbSizeBytes = 0;
+    if (existsSync(dbPath)) {
+      dbSizeBytes = statSync(dbPath).size;
+    }
+
+    // Get actual attachments directory size
+    const attachmentsDir = join(getCastleDir(), "data", "attachments");
+    const attachmentsDirSize = getDirSize(attachmentsDir);
+
+    // Define warning thresholds
+    const WARN_DB_SIZE = 500 * 1024 * 1024;       // 500MB
+    const WARN_ATTACHMENTS = 2 * 1024 * 1024 * 1024; // 2GB
+    const warnings: string[] = [];
+
+    if (dbSizeBytes > WARN_DB_SIZE) {
+      warnings.push(`Database is ${(dbSizeBytes / 1024 / 1024).toFixed(0)}MB — consider archiving old messages`);
+    }
+    if (attachmentsDirSize > WARN_ATTACHMENTS) {
+      warnings.push(`Attachments using ${(attachmentsDirSize / 1024 / 1024 / 1024).toFixed(1)}GB of disk space`);
+    }
+
+    return NextResponse.json({
+      ...stats,
+      dbSizeBytes,
+      attachmentsDirBytes: attachmentsDirSize,
+      warnings,
+    });
+  } catch (err) {
+    console.error("[Storage] Stats failed:", (err as Error).message);
+    return NextResponse.json(
+      { error: "Failed to get storage stats" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { readFileSync, existsSync, readdirSync } from "fs";
-import { join } from "path";
+import { join, resolve } from "path";
 import { getOpenClawDir } from "@/lib/config";
 import { sanitizeForApi } from "@/lib/api-security";
 
@@ -14,7 +14,17 @@ export async function GET(request: NextRequest) {
   const { searchParams } = new URL(request.url);
   const rawLines = parseInt(searchParams.get("lines") || "100", 10);
   const lines = Math.min(Math.max(1, Number.isFinite(rawLines) ? rawLines : 100), 10000);
-  const file = searchParams.get("file")?.trim() || "gateway";
+  const rawFile = searchParams.get("file")?.trim() || "gateway";
+
+  // Sanitize file parameter: only allow alphanumeric, hyphens, underscores, dots
+  // Reject anything with path separators or traversal patterns
+  const file = rawFile.replace(/[^a-zA-Z0-9._-]/g, "");
+  if (!file || file.includes("..") || file !== rawFile) {
+    return NextResponse.json(
+      { error: "Invalid log file name" },
+      { status: 400 }
+    );
+  }
 
   const logsDir = join(getOpenClawDir(), "logs");
 
@@ -27,7 +37,7 @@ export async function GET(request: NextRequest) {
     ? readdirSync(logsDir).filter((f) => f.endsWith(".log"))
     : [];
 
-  // Find matching log file
+  // Find matching log file — must match prefix exactly within the logs directory
   const logFile = availableFiles.find((f) => f.startsWith(file));
   if (!logFile) {
     return NextResponse.json({
@@ -39,6 +49,10 @@ export async function GET(request: NextRequest) {
 
   try {
     const logPath = join(logsDir, logFile);
+    // Final safety check: resolved path must be inside the logs directory
+    if (!resolve(logPath).startsWith(resolve(logsDir))) {
+      return NextResponse.json({ error: "Invalid log file path" }, { status: 400 });
+    }
     const content = readFileSync(logPath, "utf-8");
     const allLines = content.split("\n").filter(Boolean);
 

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

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { execSync } from "child_process";
-import { checkCsrf } from "@/lib/api-security";
+import { checkCsrf, checkRateLimit, rateLimitKey } from "@/lib/api-security";
 
 export const dynamic = "force-dynamic";
 
@@ -12,6 +12,11 @@ export const dynamic = "force-dynamic";
 export async function POST(request: NextRequest) {
   const csrf = checkCsrf(request);
   if (csrf) return csrf;
+
+  // Rate limit: 5 restarts per minute
+  const rl = checkRateLimit(rateLimitKey(request, "restart"), 5);
+  if (rl) return rl;
+
   try {
     // Try openclaw CLI restart first
     try {

package/src/app/api/openclaw/session/status/route.ts

@@ -0,0 +1,42 @@
+import { NextRequest, NextResponse } from "next/server";
+import { ensureGateway } from "@/lib/gateway-connection";
+import { sanitizeForApi } from "@/lib/api-security";
+import type { SessionStatus } from "@/lib/types/chat";
+
+// ============================================================================
+// GET /api/openclaw/session/status?sessionKey=X — Session stats
+// ============================================================================
+
+export async function GET(request: NextRequest) {
+  const { searchParams } = new URL(request.url);
+  const sessionKey = searchParams.get("sessionKey");
+
+  if (!sessionKey) {
+    return NextResponse.json(
+      { error: "sessionKey is required" },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const gateway = ensureGateway();
+    const result = await gateway.request<SessionStatus>("session.status", {
+      sessionKey,
+    });
+
+    return NextResponse.json(result);
+  } catch (err) {
+    const message = (err as Error).message;
+
+    // Session not found is not an error — just return empty
+    if (message.includes("not found") || message.includes("unknown")) {
+      return new NextResponse(null, { status: 204 });
+    }
+
+    console.error("[Session Status] Failed:", message);
+    return NextResponse.json(
+      { error: sanitizeForApi(message) },
+      { status: 502 }
+    );
+  }
+}