@castlekit/castle 0.1.5 → 0.3.0

package/src/lib/config.ts

@@ -1,12 +1,15 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import { platform } from "os";
 import JSON5 from "json5";
 
 export interface CastleConfig {
   openclaw: {
     gateway_port: number;
     gateway_token?: string;
+    gateway_url?: string;   // Full WebSocket URL for remote Gateways (e.g. ws://192.168.1.50:18789)
+    is_remote?: boolean;    // True when connecting to a non-local Gateway
     primary_agent?: string;
   };
   server: {
@@ -34,11 +37,28 @@ export function getConfigPath(): string {
 export function ensureCastleDir(): void {
   const dir = getCastleDir();
   if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+  // Tighten existing directories that may have been created with default perms
+  if (platform() !== "win32") {
+    try { chmodSync(dir, 0o700); } catch { /* ignore */ }
   }
   const dataDir = join(dir, "data");
   if (!existsSync(dataDir)) {
-    mkdirSync(dataDir, { recursive: true });
+    mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+  }
+  const logsDir = join(dir, "logs");
+  if (!existsSync(logsDir)) {
+    mkdirSync(logsDir, { recursive: true, mode: 0o700 });
+  }
+  // Tighten log file permissions — LaunchAgent creates them with default umask
+  if (platform() !== "win32") {
+    for (const logFile of ["server.log", "server.err"]) {
+      const logPath = join(logsDir, logFile);
+      if (existsSync(logPath)) {
+        try { chmodSync(logPath, 0o600); } catch { /* ignore */ }
+      }
+    }
   }
 }
 
@@ -70,6 +90,14 @@ export function writeConfig(config: CastleConfig): void {
   const configPath = getConfigPath();
   const content = JSON5.stringify(config, null, 2);
   writeFileSync(configPath, content, "utf-8");
+  // Restrict permissions — castle.json may contain gateway_token
+  if (platform() !== "win32") {
+    try {
+      chmodSync(configPath, 0o600);
+    } catch {
+      // May fail on some filesystems
+    }
+  }
 }
 
 /**
@@ -177,13 +205,17 @@ export function readOpenClawPort(): number | null {
 
 /**
  * Get the Gateway WebSocket URL.
- * Supports OPENCLAW_GATEWAY_URL env var, falls back to config port.
+ * Priority: env var > config gateway_url > config port on localhost.
  */
 export function getGatewayUrl(): string {
   if (process.env.OPENCLAW_GATEWAY_URL) {
     return process.env.OPENCLAW_GATEWAY_URL;
   }
   const config = readConfig();
+  // Explicit URL takes priority (remote Gateways, Tailscale, etc.)
+  if (config.openclaw.gateway_url) {
+    return config.openclaw.gateway_url;
+  }
   return `ws://127.0.0.1:${config.openclaw.gateway_port}`;
 }
 

package/src/lib/date-utils.ts

@@ -0,0 +1,79 @@
+// ============================================================================
+// Shared date formatting — consistent across the app
+// ============================================================================
+//
+// Formats:
+//   formatDate(ts)        → "9 February 2026"
+//   formatDateTime(ts)    → "9 February 2026 at 2:24 am"
+//   formatTime(ts)        → "2:24 am"
+//   formatTimeAgo(ts)     → "3 hours ago", "2 days ago", etc.
+//   formatDateShort(ts)   → "9 Feb" (for compact UI like search results)
+
+/**
+ * "9 February 2026"
+ */
+export function formatDate(timestamp: number): string {
+  return new Date(timestamp).toLocaleDateString("en-GB", {
+    day: "numeric",
+    month: "long",
+    year: "numeric",
+  });
+}
+
+/**
+ * "9 February 2026 at 2:24 am"
+ */
+export function formatDateTime(timestamp: number): string {
+  const date = new Date(timestamp);
+  const datePart = date.toLocaleDateString("en-GB", {
+    day: "numeric",
+    month: "long",
+    year: "numeric",
+  });
+  const timePart = date.toLocaleTimeString("en-GB", {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+  });
+  return `${datePart} at ${timePart}`;
+}
+
+/**
+ * "2:24 am"
+ */
+export function formatTime(timestamp: number): string {
+  return new Date(timestamp).toLocaleTimeString("en-GB", {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+  });
+}
+
+/**
+ * "3 hours ago", "2 days ago", "just now", etc.
+ */
+export function formatTimeAgo(timestamp: number): string {
+  const now = Date.now();
+  const diff = now - timestamp;
+
+  const seconds = Math.floor(diff / 1000);
+  if (seconds < 60) return "just now";
+
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+
+  const days = Math.floor(hours / 24);
+  if (days < 7) return `${days}d ago`;
+
+  const weeks = Math.floor(days / 7);
+  if (weeks < 5) return `${weeks}w ago`;
+
+  const months = Math.floor(days / 30);
+  if (months < 12) return `${months}mo ago`;
+
+  const years = Math.floor(days / 365);
+  return `${years}y ago`;
+}

package/src/lib/db/__tests__/queries.test.ts

@@ -0,0 +1,318 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import * as schema from "../schema";
+
+// ============================================================================
+// Test-specific DB setup (in-memory or temp file)
+// ============================================================================
+
+let tmpDir: string;
+
+const TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS channels (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    default_agent_id TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER
+  );
+  CREATE TABLE IF NOT EXISTS channel_agents (
+    channel_id TEXT NOT NULL REFERENCES channels(id) ON DELETE CASCADE,
+    agent_id TEXT NOT NULL,
+    PRIMARY KEY (channel_id, agent_id)
+  );
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    channel_id TEXT NOT NULL REFERENCES channels(id) ON DELETE CASCADE,
+    session_key TEXT,
+    started_at INTEGER NOT NULL,
+    ended_at INTEGER,
+    summary TEXT,
+    total_input_tokens INTEGER DEFAULT 0,
+    total_output_tokens INTEGER DEFAULT 0
+  );
+  CREATE TABLE IF NOT EXISTS messages (
+    id TEXT PRIMARY KEY,
+    channel_id TEXT NOT NULL REFERENCES channels(id) ON DELETE CASCADE,
+    session_id TEXT REFERENCES sessions(id),
+    sender_type TEXT NOT NULL,
+    sender_id TEXT NOT NULL,
+    sender_name TEXT,
+    content TEXT NOT NULL DEFAULT '',
+    status TEXT NOT NULL DEFAULT 'complete',
+    mentioned_agent_id TEXT,
+    run_id TEXT,
+    session_key TEXT,
+    input_tokens INTEGER,
+    output_tokens INTEGER,
+    created_at INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_messages_channel ON messages(channel_id, created_at);
+  CREATE INDEX IF NOT EXISTS idx_messages_run_id ON messages(run_id);
+  CREATE TABLE IF NOT EXISTS message_attachments (
+    id TEXT PRIMARY KEY,
+    message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+    attachment_type TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    mime_type TEXT,
+    file_size INTEGER,
+    original_name TEXT,
+    created_at INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS message_reactions (
+    id TEXT PRIMARY KEY,
+    message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+    agent_id TEXT,
+    emoji TEXT NOT NULL,
+    emoji_char TEXT NOT NULL,
+    created_at INTEGER NOT NULL
+  );
+`;
+
+const FTS5_SQL = `
+  CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts
+  USING fts5(content, tokenize='unicode61');
+
+  CREATE TRIGGER IF NOT EXISTS messages_fts_insert AFTER INSERT ON messages BEGIN
+    INSERT INTO messages_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+  END;
+  CREATE TRIGGER IF NOT EXISTS messages_fts_delete AFTER DELETE ON messages BEGIN
+    INSERT INTO messages_fts(messages_fts, rowid, content) VALUES ('delete', OLD.rowid, OLD.content);
+  END;
+  CREATE TRIGGER IF NOT EXISTS messages_fts_update AFTER UPDATE OF content ON messages BEGIN
+    INSERT INTO messages_fts(messages_fts, rowid, content) VALUES ('delete', OLD.rowid, OLD.content);
+    INSERT INTO messages_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+  END;
+`;
+
+function createTestDb() {
+  tmpDir = mkdtempSync(join(tmpdir(), "castle-test-"));
+  const dbPath = join(tmpDir, "test.db");
+  const sqlite = new Database(dbPath);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+  sqlite.exec(TABLE_SQL);
+  sqlite.exec(FTS5_SQL);
+  return { db: drizzle(sqlite, { schema }), sqlite, dbPath };
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe("Database Queries", () => {
+  let db: ReturnType<typeof drizzle>;
+  let sqlite: Database.Database;
+
+  beforeAll(() => {
+    const setup = createTestDb();
+    db = setup.db;
+    sqlite = setup.sqlite;
+
+    // Override the global DB for our query functions
+    const DB_KEY = "__castle_db__";
+    (globalThis as Record<string, unknown>)[DB_KEY] = db;
+  });
+
+  afterAll(() => {
+    sqlite.close();
+    try { rmSync(tmpDir, { recursive: true }); } catch { /* ignore */ }
+  });
+
+  // ---- Channels ----
+
+  describe("Channels", () => {
+    it("should create and retrieve a channel", async () => {
+      const { createChannel, getChannel, getChannels } = await import("../queries");
+
+      const channel = createChannel("Test Channel", "agent-1", ["agent-1", "agent-2"]);
+      expect(channel.name).toBe("Test Channel");
+      expect(channel.defaultAgentId).toBe("agent-1");
+      expect(channel.agents).toContain("agent-1");
+      expect(channel.agents).toContain("agent-2");
+
+      const fetched = getChannel(channel.id);
+      expect(fetched).not.toBeNull();
+      expect(fetched!.name).toBe("Test Channel");
+
+      const all = getChannels();
+      expect(all.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it("should update a channel name", async () => {
+      const { createChannel, updateChannel, getChannel } = await import("../queries");
+
+      const channel = createChannel("Original", "agent-1");
+      updateChannel(channel.id, { name: "Updated" });
+
+      const fetched = getChannel(channel.id);
+      expect(fetched!.name).toBe("Updated");
+    });
+
+    it("should delete a channel", async () => {
+      const { createChannel, deleteChannel, getChannel } = await import("../queries");
+
+      const channel = createChannel("To Delete", "agent-1");
+      const deleted = deleteChannel(channel.id);
+      expect(deleted).toBe(true);
+
+      const fetched = getChannel(channel.id);
+      expect(fetched).toBeNull();
+    });
+  });
+
+  // ---- Messages ----
+
+  describe("Messages", () => {
+    it("should create and retrieve messages", async () => {
+      const { createChannel, createMessage, getMessagesByChannel } = await import("../queries");
+
+      const channel = createChannel("Msg Test", "agent-1");
+
+      createMessage({
+        channelId: channel.id,
+        senderType: "user",
+        senderId: "local-user",
+        senderName: "You",
+        content: "Hello there",
+      });
+
+      createMessage({
+        channelId: channel.id,
+        senderType: "agent",
+        senderId: "agent-1",
+        senderName: "Agent",
+        content: "Hi! How can I help?",
+      });
+
+      const messages = getMessagesByChannel(channel.id);
+      expect(messages.length).toBe(2);
+      expect(messages[0].content).toBe("Hello there");
+      expect(messages[1].content).toBe("Hi! How can I help?");
+    });
+
+    it("should support pagination with before cursor", async () => {
+      const { createChannel, createMessage, getMessagesByChannel } = await import("../queries");
+
+      const channel = createChannel("Pagination Test", "agent-1");
+
+      // Create 5 messages with slight time gaps
+      const ids: string[] = [];
+      for (let i = 0; i < 5; i++) {
+        const msg = createMessage({
+          channelId: channel.id,
+          senderType: "user",
+          senderId: "local-user",
+          content: `Message ${i}`,
+        });
+        ids.push(msg.id);
+        // Small delay to ensure different timestamps
+        await new Promise((r) => setTimeout(r, 10));
+      }
+
+      // Get latest 3
+      const latest = getMessagesByChannel(channel.id, 3);
+      expect(latest.length).toBe(3);
+
+      // Get messages before the oldest of the latest
+      const older = getMessagesByChannel(channel.id, 3, latest[0].id);
+      expect(older.length).toBe(2);
+    });
+
+    it("should update message status", async () => {
+      const { createChannel, createMessage, updateMessage, getMessagesByChannel } = await import("../queries");
+
+      const channel = createChannel("Status Test", "agent-1");
+      const msg = createMessage({
+        channelId: channel.id,
+        senderType: "agent",
+        senderId: "agent-1",
+        content: "Partial response...",
+        status: "complete",
+      });
+
+      updateMessage(msg.id, { status: "interrupted" });
+
+      const messages = getMessagesByChannel(channel.id);
+      expect(messages[0].status).toBe("interrupted");
+    });
+  });
+
+  // ---- Search (FTS5) ----
+
+  describe("Search (FTS5)", () => {
+    it("should find messages by content", async () => {
+      const { createChannel, createMessage, searchMessages } = await import("../queries");
+
+      const channel = createChannel("Search Test", "agent-1");
+
+      createMessage({
+        channelId: channel.id,
+        senderType: "user",
+        senderId: "local-user",
+        content: "The quick brown fox jumps over the lazy dog",
+      });
+
+      createMessage({
+        channelId: channel.id,
+        senderType: "agent",
+        senderId: "agent-1",
+        content: "Here is some completely different text about cats",
+      });
+
+      const results = searchMessages("brown fox");
+      expect(results.length).toBeGreaterThanOrEqual(1);
+      expect(results[0].content).toContain("brown fox");
+
+      const noResults = searchMessages("nonexistent_xyz_term");
+      expect(noResults.length).toBe(0);
+    });
+
+    it("should reject overly long queries", async () => {
+      const { searchMessages } = await import("../queries");
+      const longQuery = "a".repeat(501);
+      const results = searchMessages(longQuery);
+      expect(results).toEqual([]);
+    });
+  });
+
+  // ---- Sessions ----
+
+  describe("Sessions", () => {
+    it("should create and retrieve sessions", async () => {
+      const { createChannel, createSession, getSessionsByChannel, getLatestSessionKey } = await import("../queries");
+
+      const channel = createChannel("Session Test", "agent-1");
+
+      const session = createSession({
+        channelId: channel.id,
+        sessionKey: "sk_test_123",
+      });
+
+      expect(session.sessionKey).toBe("sk_test_123");
+
+      const sessions = getSessionsByChannel(channel.id);
+      expect(sessions.length).toBe(1);
+
+      const key = getLatestSessionKey(channel.id);
+      expect(key).toBe("sk_test_123");
+    });
+  });
+
+  // ---- Storage Stats ----
+
+  describe("Storage Stats", () => {
+    it("should return correct counts", async () => {
+      const { getStorageStats } = await import("../queries");
+
+      const stats = getStorageStats();
+      expect(stats.messages).toBeGreaterThan(0);
+      expect(stats.channels).toBeGreaterThan(0);
+      expect(typeof stats.totalAttachmentBytes).toBe("number");
+    });
+  });
+});