@castlekit/castle 0.1.6 → 0.3.1

package/src/lib/db/schema.ts

@@ -0,0 +1,164 @@
+import { sqliteTable, text, integer, primaryKey, index } from "drizzle-orm/sqlite-core";
+
+// ============================================================================
+// channels
+// ============================================================================
+
+export const channels = sqliteTable("channels", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  defaultAgentId: text("default_agent_id").notNull(),
+  createdAt: integer("created_at").notNull(), // unix ms
+  updatedAt: integer("updated_at"),           // unix ms
+  lastAccessedAt: integer("last_accessed_at"), // unix ms — last time user opened this channel
+  archivedAt: integer("archived_at"),           // unix ms — null if active, set when archived
+});
+
+// ============================================================================
+// settings (key-value store for user preferences)
+// ============================================================================
+
+export const settings = sqliteTable("settings", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull(),
+  updatedAt: integer("updated_at").notNull(), // unix ms
+});
+
+// ============================================================================
+// agent_statuses (live agent activity state)
+// ============================================================================
+
+export const agentStatuses = sqliteTable("agent_statuses", {
+  agentId: text("agent_id").primaryKey(),
+  status: text("status").notNull().default("idle"), // "idle" | "thinking" | "active"
+  updatedAt: integer("updated_at").notNull(), // unix ms
+});
+
+// ============================================================================
+// channel_agents (many-to-many junction)
+// ============================================================================
+
+export const channelAgents = sqliteTable(
+  "channel_agents",
+  {
+    channelId: text("channel_id")
+      .notNull()
+      .references(() => channels.id, { onDelete: "cascade" }),
+    agentId: text("agent_id").notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.channelId, table.agentId] }),
+  ]
+);
+
+// ============================================================================
+// sessions
+// ============================================================================
+
+export const sessions = sqliteTable(
+  "sessions",
+  {
+    id: text("id").primaryKey(),
+    channelId: text("channel_id")
+      .notNull()
+      .references(() => channels.id, { onDelete: "cascade" }),
+    sessionKey: text("session_key"),           // Gateway session key
+    startedAt: integer("started_at").notNull(), // unix ms
+    endedAt: integer("ended_at"),               // unix ms, nullable
+    summary: text("summary"),
+    totalInputTokens: integer("total_input_tokens").default(0),
+    totalOutputTokens: integer("total_output_tokens").default(0),
+    // Compaction tracking: ID of the oldest message still in the agent's context.
+    // Messages before this boundary have been compacted (summarized).
+    // Updated when compaction events are detected.
+    compactionBoundaryMessageId: text("compaction_boundary_message_id"),
+  },
+  (table) => [
+    index("idx_sessions_channel").on(table.channelId, table.startedAt),
+  ]
+);
+
+// ============================================================================
+// messages
+// ============================================================================
+
+export const messages = sqliteTable(
+  "messages",
+  {
+    id: text("id").primaryKey(),
+    channelId: text("channel_id")
+      .notNull()
+      .references(() => channels.id, { onDelete: "cascade" }),
+    sessionId: text("session_id").references(() => sessions.id),
+    senderType: text("sender_type").notNull(), // "user" | "agent"
+    senderId: text("sender_id").notNull(),
+    senderName: text("sender_name"),
+    content: text("content").notNull().default(""),
+    status: text("status").notNull().default("complete"), // "complete" | "interrupted" | "aborted"
+    mentionedAgentId: text("mentioned_agent_id"),
+    runId: text("run_id"),                     // Gateway run ID for streaming correlation
+    sessionKey: text("session_key"),           // Gateway session key
+    inputTokens: integer("input_tokens"),
+    outputTokens: integer("output_tokens"),
+    createdAt: integer("created_at").notNull(), // unix ms
+  },
+  (table) => [
+    index("idx_messages_channel").on(table.channelId, table.createdAt),
+    index("idx_messages_session").on(table.sessionId, table.createdAt),
+    index("idx_messages_run_id").on(table.runId),
+  ]
+);
+
+// ============================================================================
+// message_attachments
+// ============================================================================
+
+export const messageAttachments = sqliteTable(
+  "message_attachments",
+  {
+    id: text("id").primaryKey(),
+    messageId: text("message_id")
+      .notNull()
+      .references(() => messages.id, { onDelete: "cascade" }),
+    attachmentType: text("attachment_type").notNull(), // "image" | "audio"
+    filePath: text("file_path").notNull(),
+    mimeType: text("mime_type"),
+    fileSize: integer("file_size"),
+    originalName: text("original_name"),
+    createdAt: integer("created_at").notNull(), // unix ms
+  },
+  (table) => [
+    index("idx_attachments_message").on(table.messageId),
+  ]
+);
+
+// ============================================================================
+// recent_searches
+// ============================================================================
+
+export const recentSearches = sqliteTable("recent_searches", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  query: text("query").notNull(),
+  createdAt: integer("created_at").notNull(), // unix ms
+});
+
+// ============================================================================
+// message_reactions
+// ============================================================================
+
+export const messageReactions = sqliteTable(
+  "message_reactions",
+  {
+    id: text("id").primaryKey(),
+    messageId: text("message_id")
+      .notNull()
+      .references(() => messages.id, { onDelete: "cascade" }),
+    agentId: text("agent_id"),
+    emoji: text("emoji").notNull(),
+    emojiChar: text("emoji_char").notNull(),
+    createdAt: integer("created_at").notNull(), // unix ms
+  },
+  (table) => [
+    index("idx_reactions_message").on(table.messageId),
+  ]
+);

package/src/lib/gateway-connection.ts

@@ -463,7 +463,8 @@ class GatewayConnection extends EventEmitter {
     let msg: GatewayFrame;
     try {
       msg = JSON.parse(data.toString());
-    } catch {
+    } catch (err) {
+      console.warn("[Gateway] Failed to parse message:", (err as Error).message);
       return;
     }
 
@@ -502,16 +503,31 @@ class GatewayConnection extends EventEmitter {
 
     const id = randomUUID();
     const frame: RequestFrame = { type: "req", id, method, params };
+    const startTime = Date.now();
 
     return new Promise<T>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
+        const elapsed = Date.now() - startTime;
+        console.error(`[Gateway RPC] ${method} TIMEOUT after ${elapsed}ms`);
         reject(new Error(`Request timeout: ${method}`));
       }, this.requestTimeout);
 
       this.pending.set(id, {
-        resolve: resolve as (payload: unknown) => void,
-        reject,
+        resolve: (payload: unknown) => {
+          const elapsed = Date.now() - startTime;
+          if (elapsed > 2000) {
+            console.warn(`[Gateway RPC] ${method} OK (slow: ${elapsed}ms)`);
+          } else {
+            console.log(`[Gateway RPC] ${method} OK (${elapsed}ms)`);
+          }
+          resolve(payload as T);
+        },
+        reject: (error: Error) => {
+          const elapsed = Date.now() - startTime;
+          console.error(`[Gateway RPC] ${method} FAILED (${elapsed}ms): ${sanitize(error.message)}`);
+          reject(error);
+        },
         timer,
       });
 
@@ -519,6 +535,8 @@ class GatewayConnection extends EventEmitter {
         if (err) {
           clearTimeout(timer);
           this.pending.delete(id);
+          const elapsed = Date.now() - startTime;
+          console.error(`[Gateway RPC] ${method} SEND ERROR (${elapsed}ms): ${err.message}`);
           reject(new Error(`Send failed: ${err.message}`));
         }
       });
@@ -556,6 +574,9 @@ class GatewayConnection extends EventEmitter {
     }
 
     // Reject all pending requests
+    if (this.pending.size > 0) {
+      console.warn(`[Gateway] Rejecting ${this.pending.size} pending request(s) due to connection close`);
+    }
     for (const [id, pending] of this.pending) {
       clearTimeout(pending.timer);
       pending.reject(new Error("Connection closed"));

package/src/lib/hooks/use-agent-status.ts

@@ -0,0 +1,251 @@
+"use client";
+
+import { useCallback, useEffect } from "react";
+import useSWR, { mutate as globalMutate } from "swr";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type AgentStatus = "idle" | "thinking" | "active";
+
+interface AgentStatusRow {
+  agentId: string;
+  status: AgentStatus;
+  updatedAt: number;
+}
+
+type StatusMap = Record<string, AgentStatus>;
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const SWR_KEY = "/api/openclaw/agents/status";
+const CHANNEL_NAME = "agent-status";
+
+// ============================================================================
+// Fetcher
+// ============================================================================
+
+const statusFetcher = async (url: string): Promise<StatusMap> => {
+  const res = await fetch(url);
+  if (!res.ok) return {};
+  const data = await res.json();
+  const map: StatusMap = {};
+  for (const row of (data.statuses || []) as AgentStatusRow[]) {
+    map[row.agentId] = row.status;
+  }
+  return map;
+};
+
+// ============================================================================
+// BroadcastChannel: cross-tab real-time sync (no polling needed)
+// ============================================================================
+
+let broadcast: BroadcastChannel | null = null;
+
+function getBroadcast(): BroadcastChannel | null {
+  if (typeof window === "undefined") return null;
+  if (!broadcast) {
+    try {
+      broadcast = new BroadcastChannel(CHANNEL_NAME);
+    } catch {
+      // BroadcastChannel not supported (e.g. some older browsers)
+    }
+  }
+  return broadcast;
+}
+
+// ============================================================================
+// Client-side active → idle timers (mirrors the server-side 2 min expiry)
+// ============================================================================
+
+const ACTIVE_TIMEOUT_MS = 2 * 60 * 1000;
+const activeTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+function scheduleIdleTransition(agentId: string) {
+  // Clear any existing timer for this agent
+  const existing = activeTimers.get(agentId);
+  if (existing) clearTimeout(existing);
+
+  activeTimers.set(
+    agentId,
+    setTimeout(() => {
+      activeTimers.delete(agentId);
+      // Explicitly transition to idle — triggers SWR + BroadcastChannel
+      updateStatus(agentId, "idle");
+    }, ACTIVE_TIMEOUT_MS)
+  );
+}
+
+function clearIdleTimer(agentId: string) {
+  const existing = activeTimers.get(agentId);
+  if (existing) {
+    clearTimeout(existing);
+    activeTimers.delete(agentId);
+  }
+}
+
+// ============================================================================
+// Channel tracking: which channel each agent is currently thinking in
+// ============================================================================
+
+const thinkingChannels = new Map<string, string>();
+
+/** Returns the channelId the agent is currently thinking in, or undefined. */
+export function getThinkingChannel(agentId: string): string | undefined {
+  return thinkingChannels.get(agentId);
+}
+
+// ============================================================================
+// Exported setters (optimistic SWR + DB persist + cross-tab broadcast)
+// ============================================================================
+
+function updateStatus(agentId: string, status: AgentStatus) {
+  // 1. Optimistic: update SWR cache immediately (current tab)
+  globalMutate(
+    SWR_KEY,
+    (prev: StatusMap | undefined) => ({ ...prev, [agentId]: status }),
+    { revalidate: false }
+  );
+
+  // 2. Broadcast to other tabs (instant, no server round-trip)
+  getBroadcast()?.postMessage({ agentId, status });
+
+  // 3. Persist to DB via API (fire-and-forget)
+  fetch(SWR_KEY, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ agentId, status }),
+  }).catch(() => {
+    // Silent — DB will be stale but next page load corrects it
+  });
+}
+
+export function setAgentThinking(agentId: string, channelId?: string) {
+  clearIdleTimer(agentId);
+  if (channelId) thinkingChannels.set(agentId, channelId);
+  updateStatus(agentId, "thinking");
+}
+
+export function setAgentActive(agentId: string) {
+  thinkingChannels.delete(agentId);
+  updateStatus(agentId, "active");
+  // Schedule automatic idle transition after 2 minutes
+  scheduleIdleTransition(agentId);
+}
+
+export function setAgentIdle(agentId: string) {
+  thinkingChannels.delete(agentId);
+  clearIdleTimer(agentId);
+  updateStatus(agentId, "idle");
+}
+
+// ============================================================================
+// User presence constants
+// ============================================================================
+
+export const USER_STATUS_ID = "__user__";
+const USER_IDLE_TIMEOUT_MS = 2 * 60 * 1000; // 2 minutes of inactivity → idle
+
+// ============================================================================
+// Hook
+// ============================================================================
+
+/**
+ * Shared agent status hook backed by the database.
+ * Uses BroadcastChannel for instant cross-tab sync — no polling.
+ * On mount, fetches current state from DB (catches up after page load).
+ * The server auto-expires "active" statuses older than 2 minutes to "idle".
+ *
+ * Status lifecycle: idle → thinking → active (2 min server-side) → idle
+ */
+export function useAgentStatus() {
+  const { data: statuses } = useSWR<StatusMap>(SWR_KEY, statusFetcher, {
+    fallbackData: {},
+    revalidateOnFocus: true,
+    revalidateOnReconnect: true,
+    refreshInterval: 120_000, // Light background poll every 2 min just to catch expired "active" → "idle"
+    dedupingInterval: 5000,
+  });
+
+  // Listen for cross-tab broadcasts and update SWR cache instantly
+  useEffect(() => {
+    const bc = getBroadcast();
+    if (!bc) return;
+
+    const handler = (e: MessageEvent) => {
+      const { agentId, status } = e.data as { agentId: string; status: AgentStatus };
+      if (agentId && status) {
+        globalMutate(
+          SWR_KEY,
+          (prev: StatusMap | undefined) => ({ ...prev, [agentId]: status }),
+          { revalidate: false }
+        );
+      }
+    };
+
+    bc.addEventListener("message", handler);
+    return () => bc.removeEventListener("message", handler);
+  }, []);
+
+  const getStatus = useCallback(
+    (agentId: string): AgentStatus => {
+      return statuses?.[agentId] ?? "idle";
+    },
+    [statuses]
+  );
+
+  return {
+    statuses: statuses ?? {},
+    getStatus,
+    setThinking: setAgentThinking,
+    setActive: setAgentActive,
+    setIdle: setAgentIdle,
+  };
+}
+
+// ============================================================================
+// User Presence Hook
+// ============================================================================
+
+/**
+ * Tracks user activity and sets active/idle status.
+ * Call once at the app layout level — listens for mouse, keyboard,
+ * scroll, and touch events. After 2 minutes of inactivity, sets idle.
+ */
+export function useUserPresence() {
+  useEffect(() => {
+    let idleTimer: ReturnType<typeof setTimeout> | null = null;
+    let isActive = false;
+
+    const setActive = () => {
+      if (!isActive) {
+        isActive = true;
+        updateStatus(USER_STATUS_ID, "active");
+      }
+      // Reset idle timer on every interaction
+      if (idleTimer) clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        isActive = false;
+        updateStatus(USER_STATUS_ID, "idle");
+      }, USER_IDLE_TIMEOUT_MS);
+    };
+
+    // Set active immediately on mount
+    setActive();
+
+    const events = ["mousemove", "keydown", "scroll", "click", "touchstart"] as const;
+    for (const event of events) {
+      document.addEventListener(event, setActive, { passive: true });
+    }
+
+    return () => {
+      for (const event of events) {
+        document.removeEventListener(event, setActive);
+      }
+      if (idleTimer) clearTimeout(idleTimer);
+    };
+  }, []);
+}