@castlekit/castle 0.0.1 → 0.1.0

package/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/src/lib/config.ts

@@ -0,0 +1,195 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import JSON5 from "json5";
+
+export interface CastleConfig {
+  openclaw: {
+    gateway_port: number;
+    gateway_token?: string;
+    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 });
+  }
+  const dataDir = join(dir, "data");
+  if (!existsSync(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+}
+
+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");
+}
+
+/**
+ * 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.
+ * Supports OPENCLAW_GATEWAY_URL env var, falls back to config port.
+ */
+export function getGatewayUrl(): string {
+  if (process.env.OPENCLAW_GATEWAY_URL) {
+    return process.env.OPENCLAW_GATEWAY_URL;
+  }
+  const config = readConfig();
+  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/src/lib/gateway-connection.ts

@@ -0,0 +1,391 @@
+import WebSocket from "ws";
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+import { getGatewayUrl, readOpenClawToken, readConfig, configExists } from "./config";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface RequestFrame {
+  type: "req";
+  id: string;
+  method: string;
+  params?: unknown;
+}
+
+interface ResponseFrame {
+  type: "res";
+  id: string;
+  ok: boolean;
+  payload?: unknown;
+  error?: {
+    code: string;
+    message: string;
+    details?: unknown;
+    retryable?: boolean;
+    retryAfterMs?: number;
+  };
+}
+
+interface EventFrame {
+  type: "event";
+  event: string;
+  payload?: unknown;
+  seq?: number;
+  stateVersion?: { version: number };
+}
+
+type GatewayFrame = ResponseFrame | EventFrame | { type: string; [key: string]: unknown };
+
+interface PendingRequest {
+  resolve: (payload: unknown) => void;
+  reject: (error: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export type ConnectionState = "disconnected" | "connecting" | "connected" | "error";
+
+export interface GatewayEvent {
+  event: string;
+  payload?: unknown;
+  seq?: number;
+}
+
+// ============================================================================
+// Singleton Gateway Connection
+// ============================================================================
+
+class GatewayConnection extends EventEmitter {
+  private ws: WebSocket | null = null;
+  private pending = new Map<string, PendingRequest>();
+  private _state: ConnectionState = "disconnected";
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private reconnectAttempts = 0;
+  private maxReconnectDelay = 30000; // 30s max
+  private baseReconnectDelay = 1000; // 1s base
+  private requestTimeout = 15000; // 15s per request
+  private connectTimeout = 10000; // 10s for connect handshake
+  private _serverInfo: { version?: string; connId?: string } = {};
+  private _features: { methods?: string[]; events?: string[] } = {};
+  private shouldReconnect = true;
+
+  get state(): ConnectionState {
+    return this._state;
+  }
+
+  get serverInfo() {
+    return this._serverInfo;
+  }
+
+  get isConnected(): boolean {
+    return this._state === "connected";
+  }
+
+  get isConfigured(): boolean {
+    // Check if we can find a token from any source
+    return !!this.resolveToken();
+  }
+
+  // --------------------------------------------------------------------------
+  // Connection lifecycle
+  // --------------------------------------------------------------------------
+
+  start(): void {
+    if (this._state === "connecting" || this._state === "connected") return;
+    this.shouldReconnect = true;
+    this.connect();
+  }
+
+  stop(): void {
+    this.shouldReconnect = false;
+    this.clearReconnectTimer();
+    this.cleanup();
+  }
+
+  private connect(): void {
+    const token = this.resolveToken();
+    if (!token) {
+      this._state = "error";
+      this.emit("stateChange", this._state);
+      console.error("[Gateway] No token available. Run 'castle setup' to configure.");
+      return;
+    }
+
+    const url = getGatewayUrl();
+    this._state = "connecting";
+    this.emit("stateChange", this._state);
+
+    try {
+      this.ws = new WebSocket(url);
+    } catch (err) {
+      console.error("[Gateway] Failed to create WebSocket:", err);
+      this._state = "error";
+      this.emit("stateChange", this._state);
+      this.scheduleReconnect();
+      return;
+    }
+
+    const connectTimer = setTimeout(() => {
+      console.error("[Gateway] Connect timeout");
+      this.cleanup();
+      this.scheduleReconnect();
+    }, this.connectTimeout);
+
+    this.ws.on("open", () => {
+      // Build connect handshake
+      const connectId = randomUUID();
+      const connectFrame: RequestFrame = {
+        type: "req",
+        id: connectId,
+        method: "connect",
+        params: {
+          minProtocol: 3,
+          maxProtocol: 3,
+          client: {
+            id: "gateway-client",
+            displayName: "Castle",
+            version: "0.0.1",
+            platform: process.platform,
+            mode: "backend",
+          },
+          auth: { token },
+          role: "operator",
+          scopes: ["operator.admin"],
+          caps: [],
+        },
+      };
+
+      // Handle handshake messages (may include connect.challenge events)
+      const onHandshakeMessage = (data: WebSocket.RawData) => {
+        try {
+          const msg = JSON.parse(data.toString());
+
+          // Handle connect.challenge event -- re-send connect with nonce
+          if (msg.type === "event" && msg.event === "connect.challenge") {
+            // For now we don't support device-signed nonce challenges
+            // Just proceed with the connect
+            return;
+          }
+
+          // Standard response frame to our connect request
+          if (msg.type === "res" && msg.id === connectId) {
+            clearTimeout(connectTimer);
+
+            if (msg.ok) {
+              // hello-ok is embedded in the payload
+              const helloOk = msg.payload || {};
+              this._state = "connected";
+              this._serverInfo = helloOk.server || {};
+              this._features = helloOk.features || {};
+              this.reconnectAttempts = 0;
+              this.emit("stateChange", this._state);
+              this.emit("connected", helloOk);
+              console.log(`[Gateway] Connected to OpenClaw v${helloOk.server?.version || "unknown"}`);
+              // Switch to normal message handler
+              this.ws?.off("message", onHandshakeMessage);
+              this.ws?.on("message", this.onMessage.bind(this));
+            } else {
+              const errMsg = msg.error?.message || "Connect rejected";
+              console.error(`[Gateway] Connect failed: ${errMsg}`);
+              this.ws?.off("message", onHandshakeMessage);
+              this.cleanup();
+              // Don't reconnect on auth errors
+              if (msg.error?.code === "auth_failed") {
+                this._state = "error";
+                this.emit("stateChange", this._state);
+                this.emit("authError", msg.error);
+              } else {
+                this.scheduleReconnect();
+              }
+            }
+            return;
+          }
+
+          // Forward any events that arrive during handshake
+          if (msg.type === "event") {
+            this.emit("gatewayEvent", {
+              event: msg.event,
+              payload: msg.payload,
+              seq: msg.seq,
+            } as GatewayEvent);
+          }
+        } catch (err) {
+          console.error("[Gateway] Failed to parse handshake message:", err);
+        }
+      };
+
+      this.ws!.on("message", onHandshakeMessage);
+      this.ws!.send(JSON.stringify(connectFrame));
+    });
+
+    this.ws.on("error", (err) => {
+      clearTimeout(connectTimer);
+      console.error("[Gateway] WebSocket error:", err.message);
+      this.cleanup();
+      this.scheduleReconnect();
+    });
+
+    this.ws.on("close", (code, reason) => {
+      clearTimeout(connectTimer);
+      const wasConnected = this._state === "connected";
+      this.cleanup();
+      if (wasConnected) {
+        console.log(`[Gateway] Disconnected (code: ${code}, reason: ${reason?.toString() || "none"})`);
+      }
+      this.scheduleReconnect();
+    });
+  }
+
+  private onMessage(data: WebSocket.RawData): void {
+    let msg: GatewayFrame;
+    try {
+      msg = JSON.parse(data.toString());
+    } catch {
+      return;
+    }
+
+    if (msg.type === "res") {
+      const res = msg as ResponseFrame;
+      const pending = this.pending.get(res.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(res.id);
+        if (res.ok) {
+          pending.resolve(res.payload);
+        } else {
+          pending.reject(
+            new Error(res.error?.message || "Request failed")
+          );
+        }
+      }
+    } else if (msg.type === "event") {
+      const evt = msg as EventFrame;
+      this.emit("gatewayEvent", {
+        event: evt.event,
+        payload: evt.payload,
+        seq: evt.seq,
+      } as GatewayEvent);
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // RPC
+  // --------------------------------------------------------------------------
+
+  async request<T = unknown>(method: string, params: unknown = {}): Promise<T> {
+    if (!this.ws || this._state !== "connected") {
+      throw new Error("Gateway not connected");
+    }
+
+    const id = randomUUID();
+    const frame: RequestFrame = { type: "req", id, method, params };
+
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Request timeout: ${method}`));
+      }, this.requestTimeout);
+
+      this.pending.set(id, {
+        resolve: resolve as (payload: unknown) => void,
+        reject,
+        timer,
+      });
+
+      this.ws!.send(JSON.stringify(frame), (err) => {
+        if (err) {
+          clearTimeout(timer);
+          this.pending.delete(id);
+          reject(new Error(`Send failed: ${err.message}`));
+        }
+      });
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Helpers
+  // --------------------------------------------------------------------------
+
+  private resolveToken(): string | null {
+    // 1. Castle config token
+    if (configExists()) {
+      const config = readConfig();
+      if (config.openclaw.gateway_token) {
+        return config.openclaw.gateway_token;
+      }
+    }
+    // 2. Auto-detect from OpenClaw config
+    return readOpenClawToken();
+  }
+
+  private cleanup(): void {
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        try { this.ws.close(); } catch { /* ignore */ }
+      }
+      this.ws = null;
+    }
+
+    // Reject all pending requests
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Connection closed"));
+      this.pending.delete(id);
+    }
+
+    if (this._state !== "error") {
+      this._state = "disconnected";
+      this.emit("stateChange", this._state);
+    }
+  }
+
+  private scheduleReconnect(): void {
+    if (!this.shouldReconnect) return;
+    this.clearReconnectTimer();
+
+    const delay = Math.min(
+      this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts),
+      this.maxReconnectDelay
+    );
+    this.reconnectAttempts++;
+
+    console.log(`[Gateway] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, delay);
+  }
+
+  private clearReconnectTimer(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+}
+
+// ============================================================================
+// Singleton export
+// ============================================================================
+
+let _gateway: GatewayConnection | null = null;
+
+export function getGateway(): GatewayConnection {
+  if (!_gateway) {
+    _gateway = new GatewayConnection();
+  }
+  return _gateway;
+}
+
+/**
+ * Ensure the gateway is started and return the instance.
+ * Safe to call multiple times -- only connects once.
+ */
+export function ensureGateway(): GatewayConnection {
+  const gw = getGateway();
+  if (gw.state === "disconnected") {
+    gw.start();
+  }
+  return gw;
+}