@castlekit/castle 0.3.1 → 0.4.0

package/.next/standalone/src/components/ui/twemoji-text.tsx

@@ -0,0 +1,37 @@
+"use client";
+
+import { useRef, useEffect, memo } from "react";
+import twemoji from "@twemoji/api";
+
+interface TwemojiTextProps {
+  children: React.ReactNode;
+  className?: string;
+}
+
+/**
+ * Wraps children and replaces native Unicode emojis with Twemoji SVG images.
+ * Uses twemoji.parse() on the rendered DOM node after mount/update.
+ */
+export const TwemojiText = memo(function TwemojiText({
+  children,
+  className,
+}: TwemojiTextProps) {
+  const ref = useRef<HTMLSpanElement>(null);
+
+  useEffect(() => {
+    if (ref.current) {
+      twemoji.parse(ref.current, {
+        folder: "svg",
+        ext: ".svg",
+        // Use jsDelivr CDN for the SVG assets
+        base: "https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/",
+      });
+    }
+  });
+
+  return (
+    <span ref={ref} className={className}>
+      {children}
+    </span>
+  );
+});

package/.next/standalone/src/components/ui/uptime.tsx

@@ -0,0 +1,106 @@
+"use client";
+
+import { cn } from "@/lib/utils";
+
+export type UptimeStatus = "loading" | "operational" | "degraded" | "partial" | "major" | "maintenance";
+
+export interface UptimeProps {
+  title: string;
+  status: UptimeStatus;
+  uptimePercent?: number;
+  message?: string;
+  data?: number[];
+  labels?: string[];
+  barCount?: number;
+  className?: string;
+}
+
+const statusConfig: Record<UptimeStatus, { label: string; color: string; dot: string }> = {
+  loading: { label: "Checking...", color: "bg-foreground/5 text-foreground-secondary", dot: "bg-foreground/30" },
+  operational: { label: "Operational", color: "bg-success/10 text-success", dot: "bg-success" },
+  degraded: { label: "Degraded", color: "bg-warning/10 text-warning", dot: "bg-warning" },
+  partial: { label: "Partial Outage", color: "bg-warning/10 text-warning", dot: "bg-warning" },
+  major: { label: "Major Outage", color: "bg-error/10 text-error", dot: "bg-error" },
+  maintenance: { label: "Maintenance", color: "bg-info/10 text-info", dot: "bg-info" },
+};
+
+function getBarColor(value: number): string {
+  if (value < 0) return "bg-foreground/10";
+  if (value >= 99) return "bg-success";
+  if (value >= 95) return "bg-success/70";
+  if (value >= 90) return "bg-warning";
+  if (value >= 50) return "bg-warning/70";
+  return "bg-error";
+}
+
+function Uptime({
+  title,
+  status,
+  message,
+  data = [],
+  labels = [],
+  barCount = 45,
+  className,
+}: UptimeProps) {
+  const config = statusConfig[status];
+  
+  const bars = data === undefined
+    ? null
+    : data.length > 0 
+      ? data.slice(-barCount) 
+      : Array(barCount).fill(-1);
+
+  return (
+    <div className={cn("w-full", className)}>
+      <div className="flex items-center justify-between mb-6">
+        <h3 className="text-lg font-semibold text-foreground">{title}</h3>
+        {status === "loading" ? (
+          <span className="inline-flex items-center gap-2 px-3 py-1 text-sm text-foreground-secondary">
+            <svg className="animate-spin h-4 w-4" viewBox="0 0 24 24" fill="none">
+              <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
+              <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+            </svg>
+          </span>
+        ) : (
+          <span className={cn(
+            "inline-flex items-center gap-2 px-3 py-1 rounded-full text-sm font-medium transition-opacity duration-300",
+            config.color
+          )}>
+            <span className={cn("h-2 w-2 rounded-full", config.dot)} />
+            {config.label}
+          </span>
+        )}
+      </div>
+
+      <div className="flex items-center justify-between mb-3">
+        <span className="text-sm text-foreground-secondary">Uptime</span>
+        <span className="text-sm text-foreground-secondary" suppressHydrationWarning>
+          {message}
+        </span>
+      </div>
+
+      <div className="flex justify-between mb-2 h-8">
+        {bars?.map((value, i) => (
+          <div
+            key={i}
+            className={cn(
+              "h-8 w-1 rounded-full",
+              getBarColor(value)
+            )}
+            title={value < 0 ? "No data" : `${value}%`}
+          />
+        ))}
+      </div>
+
+      {labels.length > 0 && (
+        <div className="flex justify-between text-xs text-foreground-muted">
+          {labels.map((label, i) => (
+            <span key={i}>{label}</span>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+export { Uptime };

package/.next/standalone/src/lib/api-security.ts

@@ -0,0 +1,188 @@
+import { NextRequest, NextResponse } from "next/server";
+
+// ============================================================================
+// Localhost guard — reject requests from non-local IPs
+// ============================================================================
+
+const LOCALHOST_IPS = new Set([
+  "127.0.0.1",
+  "::1",
+  "::ffff:127.0.0.1",
+  "localhost",
+]);
+
+/**
+ * Reject requests that don't originate from localhost.
+ * Uses x-forwarded-for (if behind a proxy) or falls back to the host header.
+ * Returns a 403 response if the request is from a non-local IP, or null if OK.
+ */
+export function checkLocalhost(request: NextRequest): NextResponse | null {
+  // If running in development, skip the check
+  if (process.env.NODE_ENV === "development") return null;
+
+  const forwarded = request.headers.get("x-forwarded-for");
+  const host = request.headers.get("host") || "";
+
+  // Check x-forwarded-for first (proxy scenario)
+  if (forwarded) {
+    const clientIp = forwarded.split(",")[0].trim();
+    if (!LOCALHOST_IPS.has(clientIp)) {
+      return NextResponse.json(
+        { error: "Forbidden — Castle is only accessible from localhost" },
+        { status: 403 }
+      );
+    }
+  }
+
+  // Check host header — reject if it's not a localhost variant
+  const hostname = host.split(":")[0];
+  if (hostname && !LOCALHOST_IPS.has(hostname)) {
+    return NextResponse.json(
+      { error: "Forbidden — Castle is only accessible from localhost" },
+      { status: 403 }
+    );
+  }
+
+  return null;
+}
+
+// ============================================================================
+// Rate limiting — in-memory sliding window
+// ============================================================================
+
+interface RateLimitEntry {
+  timestamps: number[];
+}
+
+const rateLimitStore = new Map<string, RateLimitEntry>();
+
+// Clean up stale entries every 5 minutes
+let cleanupTimer: ReturnType<typeof setInterval> | null = null;
+function ensureCleanup() {
+  if (cleanupTimer) return;
+  cleanupTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of rateLimitStore.entries()) {
+      entry.timestamps = entry.timestamps.filter((t) => now - t < 60_000);
+      if (entry.timestamps.length === 0) rateLimitStore.delete(key);
+    }
+  }, 5 * 60_000);
+  // Don't prevent process exit
+  if (typeof cleanupTimer === "object" && "unref" in cleanupTimer) {
+    cleanupTimer.unref();
+  }
+}
+
+/**
+ * Simple in-memory rate limiter using a sliding window.
+ *
+ * @param key    — Unique key for the rate limit bucket (e.g. "chat:send" or IP-based)
+ * @param limit  — Max requests allowed within the window
+ * @param windowMs — Window duration in milliseconds (default: 60 seconds)
+ * @returns 429 response if rate limit exceeded, or null if OK
+ */
+export function checkRateLimit(
+  key: string,
+  limit: number,
+  windowMs = 60_000
+): NextResponse | null {
+  ensureCleanup();
+
+  const now = Date.now();
+  let entry = rateLimitStore.get(key);
+
+  if (!entry) {
+    entry = { timestamps: [] };
+    rateLimitStore.set(key, entry);
+  }
+
+  // Drop timestamps outside the window
+  entry.timestamps = entry.timestamps.filter((t) => now - t < windowMs);
+
+  if (entry.timestamps.length >= limit) {
+    return NextResponse.json(
+      { error: "Too many requests — please slow down" },
+      { status: 429 }
+    );
+  }
+
+  entry.timestamps.push(now);
+  return null;
+}
+
+/**
+ * Helper to build a rate-limit key from the request IP + route.
+ */
+export function rateLimitKey(request: NextRequest, route: string): string {
+  const ip =
+    request.headers.get("x-forwarded-for")?.split(",")[0].trim() ||
+    request.headers.get("x-real-ip") ||
+    "local";
+  return `${ip}:${route}`;
+}
+
+// ============================================================================
+// CSRF protection
+// ============================================================================
+
+/**
+ * Verify that a mutating API request originated from the Castle UI itself,
+ * not from a cross-origin attacker (CSRF protection).
+ *
+ * Checks the Origin or Referer header against allowed localhost origins.
+ * Returns a 403 response if the request fails the check, or null if it passes.
+ */
+export function checkCsrf(request: NextRequest): NextResponse | null {
+  const origin = request.headers.get("origin");
+  const referer = request.headers.get("referer");
+
+  // Build allowed origins from the request's own host
+  const host = request.headers.get("host") || "localhost:3333";
+  const allowed = new Set([
+    `http://${host}`,
+    `https://${host}`,
+    // Common localhost variants
+    "http://localhost:3333",
+    "http://127.0.0.1:3333",
+    "http://[::1]:3333",
+  ]);
+
+  // If Origin header is present, it must match
+  if (origin) {
+    if (allowed.has(origin)) return null;
+    return NextResponse.json(
+      { error: "Forbidden — cross-origin request rejected" },
+      { status: 403 }
+    );
+  }
+
+  // Fall back to Referer (browsers always send at least one for form submissions)
+  if (referer) {
+    try {
+      const refOrigin = new URL(referer).origin;
+      if (allowed.has(refOrigin)) return null;
+    } catch {
+      // Malformed referer
+    }
+    return NextResponse.json(
+      { error: "Forbidden — cross-origin request rejected" },
+      { status: 403 }
+    );
+  }
+
+  // No Origin or Referer — likely a direct curl/CLI call, allow it.
+  // Browsers ALWAYS send Origin on cross-origin requests,
+  // so a missing Origin means it's not a browser-based CSRF attack.
+  return null;
+}
+
+/**
+ * Sanitize a string by redacting token patterns and key material.
+ * Use this before returning any text content (logs, errors) via API.
+ */
+export function sanitizeForApi(str: string): string {
+  return str
+    .replace(/rew_[a-f0-9]+/gi, "rew_***")
+    .replace(/-----BEGIN [A-Z ]+-----[\s\S]*?-----END [A-Z ]+-----/g, "[REDACTED KEY]")
+    .replace(/\b[a-f0-9]{32,}\b/gi, (m) => m.slice(0, 8) + "***");
+}

package/.next/standalone/src/lib/config.ts

@@ -0,0 +1,227 @@
+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: {
+    port: number;
+  };
+}
+
+const DEFAULT_CONFIG: CastleConfig = {
+  openclaw: {
+    gateway_port: 18789,
+  },
+  server: {
+    port: 3333,
+  },
+};
+
+export function getCastleDir(): string {
+  return join(homedir(), ".castle");
+}
+
+export function getConfigPath(): string {
+  return join(getCastleDir(), "castle.json");
+}
+
+export function ensureCastleDir(): void {
+  const dir = getCastleDir();
+  if (!existsSync(dir)) {
+    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, 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 */ }
+      }
+    }
+  }
+}
+
+export function configExists(): boolean {
+  return existsSync(getConfigPath());
+}
+
+export function readConfig(): CastleConfig {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON5.parse(raw);
+    return {
+      ...DEFAULT_CONFIG,
+      ...parsed,
+      openclaw: { ...DEFAULT_CONFIG.openclaw, ...parsed.openclaw },
+      server: { ...DEFAULT_CONFIG.server, ...parsed.server },
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function writeConfig(config: CastleConfig): void {
+  ensureCastleDir();
+  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
+    }
+  }
+}
+
+/**
+ * Load a .env file and set values into process.env (does not override existing)
+ */
+function loadEnvFile(envPath: string): void {
+  if (!existsSync(envPath)) return;
+  try {
+    const raw = readFileSync(envPath, "utf-8");
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      const key = trimmed.slice(0, eqIdx).trim();
+      let value = trimmed.slice(eqIdx + 1).trim();
+      // Strip surrounding quotes
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+      if (!process.env[key]) {
+        process.env[key] = value;
+      }
+    }
+  } catch {
+    // Ignore errors loading .env
+  }
+}
+
+/**
+ * Resolve ${ENV_VAR} references in a string value.
+ * Users often have "token": "${OPENCLAW_GATEWAY_TOKEN}" in their config.
+ */
+function resolveEnvVar(value: string): string | null {
+  if (value.startsWith("${") && value.endsWith("}")) {
+    const envVar = value.slice(2, -1);
+    return process.env[envVar] || null;
+  }
+  return value;
+}
+
+/**
+ * Get the OpenClaw directory path
+ */
+export function getOpenClawDir(): string {
+  return join(homedir(), ".openclaw");
+}
+
+/**
+ * Try to read the OpenClaw gateway token from ~/.openclaw/openclaw.json
+ * Handles ${ENV_VAR} references and loads ~/.openclaw/.env
+ */
+export function readOpenClawToken(): string | null {
+  // Load ~/.openclaw/.env first so env var references can resolve
+  loadEnvFile(join(getOpenClawDir(), ".env"));
+
+  const paths = [
+    join(homedir(), ".openclaw", "openclaw.json"),
+    join(homedir(), ".openclaw", "openclaw.json5"),
+  ];
+
+  for (const p of paths) {
+    if (!existsSync(p)) continue;
+    try {
+      const raw = readFileSync(p, "utf-8");
+      const parsed = JSON5.parse(raw);
+      const token = parsed?.gateway?.auth?.token;
+      if (token && typeof token === "string") {
+        return resolveEnvVar(token);
+      }
+    } catch {
+      // Continue to next path
+    }
+  }
+
+  // Fallback: check env vars directly
+  return process.env.OPENCLAW_GATEWAY_TOKEN || null;
+}
+
+/**
+ * Try to read the OpenClaw gateway port from ~/.openclaw/openclaw.json
+ */
+export function readOpenClawPort(): number | null {
+  const paths = [
+    join(homedir(), ".openclaw", "openclaw.json"),
+    join(homedir(), ".openclaw", "openclaw.json5"),
+  ];
+
+  for (const p of paths) {
+    if (!existsSync(p)) continue;
+    try {
+      const raw = readFileSync(p, "utf-8");
+      const parsed = JSON5.parse(raw);
+      const port = parsed?.gateway?.port;
+      if (typeof port === "number" && port > 0 && port <= 65535) {
+        return port;
+      }
+    } catch {
+      // Continue
+    }
+  }
+  return null;
+}
+
+/**
+ * Get the Gateway WebSocket URL.
+ * 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}`;
+}
+
+/**
+ * Check if OpenClaw is installed by looking for the config directory
+ */
+export function isOpenClawInstalled(): boolean {
+  return existsSync(join(homedir(), ".openclaw"));
+}

package/.next/standalone/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`;
+}