@castlekit/castle 0.0.1 → 0.1.0

package/next.config.ts

@@ -0,0 +1,7 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  devIndicators: false,
+};
+
+export default nextConfig;

package/package.json

@@ -1,17 +1,66 @@
 {
   "name": "@castlekit/castle",
-  "version": "0.0.1",
-  "description": "The extensible kit for AI agents",
-  "main": "index.js",
+  "version": "0.1.0",
+  "description": "The multi-agent workspace",
+  "type": "module",
+  "bin": {
+    "castle": "./bin/castle.js"
+  },
+  "scripts": {
+    "dev": "next dev -p 3333",
+    "build": "next build",
+    "start": "next start -p 3333",
+    "lint": "next lint"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/castlekit/castle.git"
   },
-  "keywords": ["ai", "agents", "openclaw", "multi-agent"],
+  "keywords": [
+    "ai",
+    "agents",
+    "openclaw",
+    "multi-agent",
+    "local-first"
+  ],
   "author": "Castle Kit Inc.",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/castlekit/castle/issues"
   },
-  "homepage": "https://github.com/castlekit/castle#readme"
+  "homepage": "https://castlekit.com",
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.0",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@radix-ui/react-slider": "^1.3.6",
+    "@tailwindcss/postcss": "^4.1.18",
+    "@types/node": "^25.2.1",
+    "@types/react": "^19.2.13",
+    "@types/react-dom": "^19.2.3",
+    "clsx": "^2.1.1",
+    "commander": "^14.0.3",
+    "json5": "^2.2.3",
+    "lucide-react": "^0.563.0",
+    "next": "^16.1.6",
+    "next-themes": "^0.4.6",
+    "open": "^11.0.0",
+    "picocolors": "^1.1.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "recharts": "^3.7.0",
+    "swr": "^2.4.0",
+    "tailwind-merge": "^3.4.0",
+    "tailwindcss": "^4.1.18",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1"
+  }
 }

package/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

package/src/app/api/avatars/[id]/route.ts

@@ -0,0 +1,75 @@
+import { NextRequest, NextResponse } from "next/server";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export const dynamic = "force-dynamic";
+
+const AVATAR_DIRS = [
+  join(homedir(), ".castle", "avatars"),
+  join(homedir(), ".openclaw", "avatars"),
+];
+
+const MIME_TYPES: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+};
+
+/**
+ * GET /api/avatars/[id]
+ * Serves avatar images from ~/.castle/avatars/ or ~/.openclaw/avatars/
+ * Supports IDs with or without extension (tries .png, .jpg, .webp)
+ */
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  // Sanitize -- prevent path traversal
+  const safeId = id.replace(/[^a-zA-Z0-9._-]/g, "");
+  if (!safeId || safeId.includes("..")) {
+    return new NextResponse("Not found", { status: 404 });
+  }
+
+  // Try each avatar directory
+  for (const dir of AVATAR_DIRS) {
+    if (!existsSync(dir)) continue;
+
+    // Try exact filename first (if it has an extension)
+    const hasExtension = /\.\w+$/.test(safeId);
+    if (hasExtension) {
+      const filePath = join(dir, safeId);
+      if (existsSync(filePath)) {
+        return serveFile(filePath);
+      }
+    }
+
+    // Try common extensions
+    for (const ext of [".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg"]) {
+      const filePath = join(dir, `${safeId}${ext}`);
+      if (existsSync(filePath)) {
+        return serveFile(filePath);
+      }
+    }
+  }
+
+  return new NextResponse("Not found", { status: 404 });
+}
+
+function serveFile(filePath: string): NextResponse {
+  const data = readFileSync(filePath);
+  const ext = filePath.substring(filePath.lastIndexOf(".")).toLowerCase();
+  const contentType = MIME_TYPES[ext] || "application/octet-stream";
+
+  return new NextResponse(data, {
+    headers: {
+      "Content-Type": contentType,
+      "Cache-Control": "public, max-age=86400, immutable",
+    },
+  });
+}

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

@@ -0,0 +1,107 @@
+import { NextResponse } from "next/server";
+import { ensureGateway } from "@/lib/gateway-connection";
+
+export const dynamic = "force-dynamic";
+
+interface AgentIdentity {
+  name?: string;
+  theme?: string;
+  emoji?: string;
+  avatar?: string;
+  avatarUrl?: string;
+}
+
+interface GatewayAgent {
+  id: string;
+  name?: string;
+  identity?: AgentIdentity;
+}
+
+interface AgentsListPayload {
+  defaultId?: string;
+  mainKey?: string;
+  scope?: string;
+  agents: GatewayAgent[];
+}
+
+/**
+ * Rewrite avatar URLs to local /api/avatars/ endpoint.
+ * Handles URLs like "http://localhost:8787/api/v1/avatars/HASH" -> "/api/avatars/HASH"
+ */
+function rewriteAvatarUrl(url: string | null): string | null {
+  if (!url) return null;
+
+  // Extract hash from known avatar URL patterns
+  const patterns = [
+    /\/api\/v\d+\/avatars\/([a-f0-9]+)/i,
+    /\/avatars\/([a-f0-9]+)/i,
+  ];
+
+  for (const pattern of patterns) {
+    const match = url.match(pattern);
+    if (match) {
+      return `/api/avatars/${match[1]}`;
+    }
+  }
+
+  // If it's already a relative path or data URI, pass through
+  if (url.startsWith("/") || url.startsWith("data:")) {
+    return url;
+  }
+
+  // Only allow http/https URLs through; reject file:, javascript:, etc.
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+
+  return null;
+}
+
+/**
+ * GET /api/openclaw/agents
+ * Discover agents from OpenClaw Gateway via agents.list
+ */
+export async function GET() {
+  const gw = ensureGateway();
+
+  if (!gw.isConnected) {
+    return NextResponse.json(
+      { error: "Gateway not connected", state: gw.state, agents: [] },
+      { status: 503 }
+    );
+  }
+
+  try {
+    const result = await gw.request<AgentsListPayload>("agents.list", {});
+
+    const agents = (result?.agents || []).map((agent: GatewayAgent) => {
+      const name =
+        agent.identity?.name || agent.name || agent.id;
+      const rawAvatar =
+        agent.identity?.avatarUrl || agent.identity?.avatar || null;
+      const emoji = agent.identity?.emoji || null;
+      const description = agent.identity?.theme || null;
+
+      // Rewrite external avatar URLs to our local /api/avatars/ endpoint
+      const avatar = rewriteAvatarUrl(rawAvatar);
+
+      return {
+        id: agent.id,
+        name,
+        description,
+        avatar,
+        emoji,
+      };
+    });
+
+    return NextResponse.json({
+      agents,
+      defaultId: result?.defaultId,
+    });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to list agents", agents: [] },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,94 @@
+import { NextRequest, NextResponse } from "next/server";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import JSON5 from "json5";
+import { getOpenClawDir } from "@/lib/config";
+import { ensureGateway } from "@/lib/gateway-connection";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/openclaw/config
+ * God mode: reads OpenClaw config from filesystem
+ */
+export async function GET() {
+  const configPath = join(getOpenClawDir(), "openclaw.json");
+
+  if (!existsSync(configPath)) {
+    // Try json5
+    const json5Path = join(getOpenClawDir(), "openclaw.json5");
+    if (!existsSync(json5Path)) {
+      return NextResponse.json(
+        { error: "OpenClaw config not found" },
+        { status: 404 }
+      );
+    }
+
+    try {
+      const raw = readFileSync(json5Path, "utf-8");
+      const config = JSON5.parse(raw);
+      return NextResponse.json({ config, format: "json5" });
+    } catch (err) {
+      return NextResponse.json(
+        { error: err instanceof Error ? err.message : "Failed to parse config" },
+        { status: 500 }
+      );
+    }
+  }
+
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const config = JSON5.parse(raw);
+    return NextResponse.json({ config, format: "json" });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to parse config" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * PATCH /api/openclaw/config
+ * Update OpenClaw config via Gateway's config.patch method.
+ * Body: { patch: { ... } } -- the patch to apply
+ */
+export async function PATCH(request: NextRequest) {
+  const gw = ensureGateway();
+
+  if (!gw.isConnected) {
+    return NextResponse.json(
+      { error: "Gateway not connected" },
+      { status: 503 }
+    );
+  }
+
+  try {
+    let body: unknown;
+    try {
+      body = await request.json();
+    } catch {
+      return NextResponse.json(
+        { error: "Invalid JSON in request body" },
+        { status: 400 }
+      );
+    }
+
+    const { patch } = body as { patch?: unknown };
+
+    if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+      return NextResponse.json(
+        { error: "Missing or invalid 'patch' field — must be a JSON object" },
+        { status: 400 }
+      );
+    }
+
+    await gw.request("config.patch", patch);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Config patch failed" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,96 @@
+import { ensureGateway, type GatewayEvent } from "@/lib/gateway-connection";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+/**
+ * GET /api/openclaw/events
+ * SSE endpoint -- streams OpenClaw Gateway events to the browser in real-time.
+ * Browser connects once via EventSource and receives push updates.
+ */
+export async function GET() {
+  const gw = ensureGateway();
+
+  const encoder = new TextEncoder();
+  let closed = false;
+
+  const stream = new ReadableStream({
+    start(controller) {
+      // Send initial state
+      const initial = {
+        event: "castle.state",
+        payload: {
+          state: gw.state,
+          isConnected: gw.isConnected,
+          server: gw.serverInfo,
+        },
+      };
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify(initial)}\n\n`));
+
+      // Forward gateway events
+      const onGatewayEvent = (evt: GatewayEvent) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(evt)}\n\n`));
+        } catch {
+          // Stream may have closed
+        }
+      };
+
+      // Forward state changes
+      const onStateChange = (state: string) => {
+        if (closed) return;
+        try {
+          const msg = {
+            event: "castle.state",
+            payload: {
+              state,
+              isConnected: gw.isConnected,
+              server: gw.serverInfo,
+            },
+          };
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(msg)}\n\n`));
+        } catch {
+          // Stream may have closed
+        }
+      };
+
+      // Heartbeat to keep connection alive
+      const heartbeat = setInterval(() => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(`: heartbeat\n\n`));
+        } catch {
+          // Stream may have closed
+        }
+      }, 30000);
+
+      gw.on("gatewayEvent", onGatewayEvent);
+      gw.on("stateChange", onStateChange);
+
+      // Cleanup when the client disconnects
+      const cleanup = () => {
+        closed = true;
+        clearInterval(heartbeat);
+        gw.off("gatewayEvent", onGatewayEvent);
+        gw.off("stateChange", onStateChange);
+      };
+
+      // The stream's cancel is called when the client disconnects
+      // We store cleanup for the cancel callback
+      (controller as unknown as { _cleanup: () => void })._cleanup = cleanup;
+    },
+    cancel(controller) {
+      const cleanup = (controller as unknown as { _cleanup: () => void })._cleanup;
+      if (cleanup) cleanup();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+    },
+  });
+}

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

@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from "next/server";
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { getOpenClawDir } from "@/lib/config";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/openclaw/logs?lines=100&file=gateway
+ * God mode: reads log files from ~/.openclaw/logs/
+ */
+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 logsDir = join(getOpenClawDir(), "logs");
+
+  if (!existsSync(logsDir)) {
+    return NextResponse.json({ logs: [], error: "No logs directory found" });
+  }
+
+  // List available log files
+  const availableFiles = existsSync(logsDir)
+    ? readdirSync(logsDir).filter((f) => f.endsWith(".log"))
+    : [];
+
+  // Find matching log file
+  const logFile = availableFiles.find((f) => f.startsWith(file));
+  if (!logFile) {
+    return NextResponse.json({
+      logs: [],
+      available: availableFiles,
+      error: `Log file '${file}' not found`,
+    });
+  }
+
+  try {
+    const logPath = join(logsDir, logFile);
+    const content = readFileSync(logPath, "utf-8");
+    const allLines = content.split("\n").filter(Boolean);
+
+    // Return last N lines
+    const tailLines = allLines.slice(-lines);
+
+    return NextResponse.json({
+      logs: tailLines,
+      file: logFile,
+      totalLines: allLines.length,
+      available: availableFiles,
+    });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to read logs" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,68 @@
+import { NextResponse } from "next/server";
+import { ensureGateway } from "@/lib/gateway-connection";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * POST /api/openclaw/ping
+ * Health check -- tests connection to OpenClaw Gateway
+ */
+export async function POST() {
+  const gw = ensureGateway();
+
+  if (!gw.isConfigured) {
+    return NextResponse.json({
+      ok: false,
+      configured: false,
+      error: "No OpenClaw token found. Run 'castle setup' or check ~/.openclaw/openclaw.json",
+    });
+  }
+
+  // If not connected yet, give it a moment to complete handshake
+  if (gw.state === "connecting") {
+    await new Promise<void>((resolve) => {
+      const timeout = setTimeout(resolve, 5000);
+      const onState = () => {
+        clearTimeout(timeout);
+        gw.off("stateChange", onState);
+        resolve();
+      };
+      gw.on("stateChange", onState);
+    });
+  }
+
+  if (!gw.isConnected) {
+    return NextResponse.json({
+      ok: false,
+      configured: true,
+      state: gw.state,
+      error: gw.state === "error"
+        ? "Failed to connect to OpenClaw Gateway. Is it running?"
+        : "Connecting to OpenClaw Gateway...",
+    });
+  }
+
+  try {
+    const start = Date.now();
+    await gw.request("health", {});
+    const latency = Date.now() - start;
+
+    return NextResponse.json({
+      ok: true,
+      configured: true,
+      latency_ms: latency,
+      server: gw.serverInfo,
+    });
+  } catch (err) {
+    return NextResponse.json({
+      ok: false,
+      configured: true,
+      error: err instanceof Error ? err.message : "Health check failed",
+    });
+  }
+}
+
+// Allow GET for easy status checks
+export async function GET() {
+  return POST();
+}

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

@@ -0,0 +1,65 @@
+import { NextResponse } from "next/server";
+import { execSync } from "child_process";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * POST /api/openclaw/restart
+ * God mode: restart the OpenClaw Gateway process.
+ * Tries common methods to restart the gateway.
+ */
+export async function POST() {
+  try {
+    // Try openclaw CLI restart first
+    try {
+      execSync("openclaw gateway restart", {
+        timeout: 10000,
+        stdio: "pipe",
+      });
+      return NextResponse.json({
+        ok: true,
+        method: "openclaw gateway restart",
+      });
+    } catch {
+      // openclaw CLI not available or restart command failed
+    }
+
+    // Try stopping and starting via process signal
+    try {
+      const pids = execSync("pgrep -f 'openclaw.*gateway'", {
+        timeout: 5000,
+        stdio: "pipe",
+      })
+        .toString()
+        .trim()
+        .split(/\s+/)
+        .filter((p) => /^\d+$/.test(p));
+
+      const pid = pids[0];
+      if (pid) {
+        execSync(`kill -HUP ${pid}`, { timeout: 5000, stdio: "pipe" });
+        return NextResponse.json({
+          ok: true,
+          method: "SIGHUP",
+          pid: parseInt(pid, 10),
+        });
+      }
+    } catch {
+      // pgrep not available or no process found
+    }
+
+    return NextResponse.json(
+      {
+        ok: false,
+        error:
+          "Could not restart gateway. Try manually: openclaw gateway restart",
+      },
+      { status: 500 }
+    );
+  } catch (err) {
+    return NextResponse.json(
+      { ok: false, error: err instanceof Error ? err.message : "Restart failed" },
+      { status: 500 }
+    );
+  }
+}