claudeboard 1.1.0 → 1.5.0

package/dashboard/server.js

@@ -6,192 +6,310 @@ import { createClient } from "@supabase/supabase-js";
 import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs";
+import { spawn } from "child_process";
+import { createRequire } from "module";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
 
 const app = express();
 const server = createServer(app);
-const wss = new WebSocketServer({ server });
+
+// Two WS servers: one for board events, one for terminal
+const boardWss = new WebSocketServer({ noServer: true });
+const termWss  = new WebSocketServer({ noServer: true });
+
+// Route upgrade requests
+server.on("upgrade", (req, socket, head) => {
+  if (req.url === "/terminal") {
+    termWss.handleUpgrade(req, socket, head, (ws) => termWss.emit("connection", ws, req));
+  } else {
+    boardWss.handleUpgrade(req, socket, head, (ws) => boardWss.emit("connection", ws, req));
+  }
+});
 
 app.use(cors());
 app.use(express.json());
 
-const PORT = process.env.PORT || 3131;
-const PROJECT = process.env.PROJECT_NAME || "default";
+const PORT        = process.env.PORT         || 3131;
+const PROJECT     = process.env.PROJECT_NAME || "default";
+const PROJECT_DIR = process.env.PROJECT_DIR  || process.cwd();
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
 
-const supabase = createClient(
-  process.env.SUPABASE_URL,
-  process.env.SUPABASE_KEY
-);
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
-// Broadcast to all WS clients
+// ── STATE ─────────────────────────────────────────────────────────────────────
+let expoProcess  = null;
+let expoStatus   = "stopped"; // stopped | installing | starting | running | error
+let expoQR       = null;
+let expoUrl      = null;
+
+// ── BOARD BROADCAST ───────────────────────────────────────────────────────────
 function broadcast(event, data) {
   const msg = JSON.stringify({ event, data, ts: Date.now() });
-  wss.clients.forEach((client) => {
-    if (client.readyState === 1) client.send(msg);
-  });
+  boardWss.clients.forEach((c) => { if (c.readyState === 1) c.send(msg); });
 }
 
-// Subscribe to Supabase realtime
+function broadcastExpoStatus() {
+  broadcast("expo_status", { status: expoStatus, qr: expoQR, url: expoUrl });
+}
+
+// ── SUPABASE REALTIME ─────────────────────────────────────────────────────────
 supabase
   .channel("cb_changes")
-  .on("postgres_changes", { event: "*", schema: "public", table: "cb_tasks" }, (payload) => {
-    broadcast("task_update", payload);
-  })
-  .on("postgres_changes", { event: "*", schema: "public", table: "cb_logs" }, (payload) => {
-    broadcast("log", payload.new);
-  })
+  .on("postgres_changes", { event: "*", schema: "public", table: "cb_tasks" }, (p) => broadcast("task_update", p))
+  .on("postgres_changes", { event: "*", schema: "public", table: "cb_logs"  }, (p) => broadcast("log", p.new))
   .subscribe();
 
-// ─── API ROUTES ───────────────────────────────────────────────────────────────
+// ── TERMINAL (xterm.js via WebSocket + node-pty) ──────────────────────────────
+termWss.on("connection", (ws) => {
+  let pty = null;
+
+  try {
+    // Try node-pty for full PTY support
+    const nodePty = require("node-pty");
+    pty = nodePty.spawn(process.env.SHELL || "bash", [], {
+      name: "xterm-256color",
+      cols: 120,
+      rows: 40,
+      cwd: PROJECT_DIR,
+      env: {
+        ...process.env,
+        SUPABASE_URL,
+        SUPABASE_ACCESS_TOKEN: process.env.SUPABASE_ACCESS_TOKEN || "",
+        TERM: "xterm-256color",
+      },
+    });
+
+    pty.onData((data) => { if (ws.readyState === 1) ws.send(JSON.stringify({ type: "output", data })); });
+    pty.onExit(() => { if (ws.readyState === 1) ws.send(JSON.stringify({ type: "exit" })); });
+
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw);
+        if (msg.type === "input") pty.write(msg.data);
+        if (msg.type === "resize") pty.resize(msg.cols, msg.rows);
+      } catch {}
+    });
+
+    ws.on("close", () => { try { pty.kill(); } catch {} });
+
+  } catch {
+    // Fallback: simple shell without PTY (no colors but functional)
+    const shell = spawn(process.env.SHELL || "bash", [], {
+      cwd: PROJECT_DIR,
+      env: { ...process.env, SUPABASE_URL, TERM: "dumb" },
+    });
+
+    shell.stdout.on("data", (d) => ws.send(JSON.stringify({ type: "output", data: d.toString() })));
+    shell.stderr.on("data", (d) => ws.send(JSON.stringify({ type: "output", data: d.toString() })));
+    shell.on("close", () => ws.send(JSON.stringify({ type: "exit" })));
+
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw);
+        if (msg.type === "input") shell.stdin.write(msg.data);
+      } catch {}
+    });
+
+    ws.on("close", () => shell.kill());
+
+    // Send welcome message
+    ws.send(JSON.stringify({
+      type: "output",
+      data: `\r\n\x1b[33m[ClaudeBoard Terminal]\x1b[0m — Project: ${PROJECT_DIR}\r\n` +
+            `\x1b[2mTip: Run 'npx supabase ...' for Supabase CLI commands\x1b[0m\r\n\r\n`,
+    }));
+  }
+});
+
+// ── EXPO MANAGEMENT ───────────────────────────────────────────────────────────
+
+// GET expo status
+app.get("/api/expo/status", (req, res) => {
+  res.json({ status: expoStatus, qr: expoQR, url: expoUrl });
+});
+
+// POST expo/start — install deps + start Expo tunnel
+app.post("/api/expo/start", async (req, res) => {
+  if (expoProcess) return res.json({ ok: false, error: "Expo already running" });
+
+  res.json({ ok: true, message: "Starting Expo..." });
+  _startExpo(PROJECT_DIR);
+});
+
+// POST expo/stop
+app.post("/api/expo/stop", (req, res) => {
+  if (expoProcess) {
+    try { expoProcess.kill("SIGTERM"); } catch {}
+    expoProcess = null;
+  }
+  expoStatus = "stopped";
+  expoQR = null;
+  expoUrl = null;
+  broadcastExpoStatus();
+  res.json({ ok: true });
+});
+
+async function _startExpo(projectDir) {
+  // Step 1: npm install
+  expoStatus = "installing";
+  broadcastExpoStatus();
+  broadcast("expo_log", { message: "Installing dependencies..." });
+
+  await new Promise((resolve) => {
+    const install = spawn("npm", ["install"], { cwd: projectDir, stdio: "pipe" });
+    install.stdout.on("data", (d) => broadcast("expo_log", { message: d.toString().trim() }));
+    install.stderr.on("data", (d) => broadcast("expo_log", { message: d.toString().trim() }));
+    install.on("close", resolve);
+  });
+
+  broadcast("expo_log", { message: "Dependencies installed. Starting Expo..." });
+
+  // Step 2: expo start with tunnel
+  expoStatus = "starting";
+  broadcastExpoStatus();
+
+  const expo = spawn("npx", ["expo", "start", "--tunnel"], {
+    cwd: projectDir,
+    env: { ...process.env, CI: "false", EXPO_NO_DOTENV: "0" },
+    stdio: "pipe",
+  });
+
+  expoProcess = expo;
+
+  expo.stdout.on("data", (d) => {
+    const text = d.toString();
+    broadcast("expo_log", { message: text.trim() });
+
+    // Detect QR code URL (exp:// or https://expo.dev)
+    const expUrl = text.match(/exp:\/\/[^\s]+/);
+    if (expUrl) {
+      expoUrl = expUrl[0];
+      expoStatus = "running";
+      broadcastExpoStatus();
+    }
+
+    // Detect tunnel URL
+    const tunnel = text.match(/https:\/\/[a-z0-9-]+\.exp\.direct[^\s]*/);
+    if (tunnel) {
+      expoUrl = tunnel[0];
+      expoStatus = "running";
+      broadcastExpoStatus();
+    }
+
+    // Detect QR data from expo output
+    if (text.includes("QR")) {
+      broadcast("expo_log", { message: "📱 QR code ready — scan with Expo Go" });
+    }
+  });
+
+  expo.stderr.on("data", (d) => {
+    const text = d.toString().trim();
+    if (text) broadcast("expo_log", { message: text });
+  });
+
+  expo.on("close", (code) => {
+    expoProcess = null;
+    expoStatus = code === 0 ? "stopped" : "error";
+    expoQR = null;
+    broadcastExpoStatus();
+    broadcast("expo_log", { message: `Expo process exited (code ${code})` });
+  });
+}
+
+// ── SUPABASE QUERY API ────────────────────────────────────────────────────────
+app.post("/api/supabase/query", async (req, res) => {
+  const { sql } = req.body;
+  if (!sql) return res.status(400).json({ error: "No SQL provided" });
+
+  try {
+    const { data, error } = await supabase.rpc("execute_sql", { query: sql });
+    if (error) return res.status(400).json({ error: error.message });
+    res.json({ data });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── BOARD API ROUTES (unchanged) ──────────────────────────────────────────────
 
-// GET all tasks grouped by epic
 app.get("/api/board", async (req, res) => {
   const { data: epics } = await supabase
-    .from("cb_epics")
-    .select("*, cb_tasks(*)")
-    .eq("project", PROJECT)
-    .order("created_at");
-
+    .from("cb_epics").select("*, cb_tasks(*)").eq("project", PROJECT).order("created_at");
   const { data: logs } = await supabase
-    .from("cb_logs")
-    .select("*")
-    .eq("project", PROJECT)
-    .order("created_at", { ascending: false })
-    .limit(50);
-
+    .from("cb_logs").select("*").eq("project", PROJECT)
+    .order("created_at", { ascending: false }).limit(50);
   res.json({ epics: epics || [], logs: logs || [], project: PROJECT });
 });
 
-// GET next pending task
 app.get("/api/tasks/next", async (req, res) => {
-  const { data } = await supabase
-    .from("cb_tasks")
-    .select("*")
-    .eq("project", PROJECT)
-    .eq("status", "todo")
-    .order("priority_order", { ascending: true })
-    .limit(1)
-    .single();
-
+  const { data } = await supabase.from("cb_tasks").select("*")
+    .eq("project", PROJECT).eq("status", "todo")
+    .order("priority_order", { ascending: true }).limit(1).single();
   if (!data) return res.json({ task: null, message: "All tasks complete! 🎉" });
   res.json({ task: data });
 });
 
-// POST start task
 app.post("/api/tasks/:id/start", async (req, res) => {
   const { id } = req.params;
-  const { log } = req.body;
-
-  await supabase
-    .from("cb_tasks")
-    .update({ status: "in_progress", started_at: new Date().toISOString() })
-    .eq("id", id);
-
-  if (log) await addLog(id, log, "start");
+  await supabase.from("cb_tasks").update({ status: "in_progress", started_at: new Date().toISOString() }).eq("id", id);
+  if (req.body.log) await addLog(id, req.body.log, "start");
   broadcast("task_started", { id });
   res.json({ ok: true });
 });
 
-// POST log progress
 app.post("/api/tasks/:id/log", async (req, res) => {
-  const { id } = req.params;
-  const { message } = req.body;
-  await addLog(id, message, "progress");
+  await addLog(req.params.id, req.body.message, "progress");
   res.json({ ok: true });
 });
 
-// POST complete task
 app.post("/api/tasks/:id/complete", async (req, res) => {
   const { id } = req.params;
-  const { log } = req.body;
-
-  await supabase
-    .from("cb_tasks")
-    .update({ status: "done", completed_at: new Date().toISOString() })
-    .eq("id", id);
-
-  if (log) await addLog(id, log, "complete");
+  await supabase.from("cb_tasks").update({ status: "done", completed_at: new Date().toISOString() }).eq("id", id);
+  if (req.body.log) await addLog(id, req.body.log, "complete");
   broadcast("task_complete", { id });
   res.json({ ok: true });
 });
 
-// POST fail task
 app.post("/api/tasks/:id/fail", async (req, res) => {
   const { id } = req.params;
-  const { log } = req.body;
-
-  await supabase
-    .from("cb_tasks")
-    .update({ status: "error" })
-    .eq("id", id);
-
-  if (log) await addLog(id, log, "error");
+  await supabase.from("cb_tasks").update({ status: "error" }).eq("id", id);
+  if (req.body.log) await addLog(id, req.body.log, "error");
   broadcast("task_failed", { id });
   res.json({ ok: true });
 });
 
-// POST add new task manually (from dashboard or agent)
 app.post("/api/tasks", async (req, res) => {
   const { title, description, priority, type, epic_id } = req.body;
-
   const priorityOrder = { high: 1, medium: 2, low: 3 };
-
-  const { data, error } = await supabase
-    .from("cb_tasks")
-    .insert({
-      project: PROJECT,
-      epic_id: epic_id || null,
-      title,
-      description,
-      priority: priority || "medium",
-      priority_order: priorityOrder[priority] || 2,
-      type: type || "feature",
-      status: "todo",
-    })
-    .select()
-    .single();
-
+  const { data, error } = await supabase.from("cb_tasks").insert({
+    project: PROJECT, epic_id: epic_id || null, title, description,
+    priority: priority || "medium", priority_order: priorityOrder[priority] || 2,
+    type: type || "feature", status: "todo",
+  }).select().single();
   if (error) return res.status(400).json({ error: error.message });
   broadcast("task_added", data);
   res.json({ task: data });
 });
 
-// PATCH update task status manually
 app.patch("/api/tasks/:id", async (req, res) => {
-  const { id } = req.params;
-  const updates = req.body;
-
-  await supabase.from("cb_tasks").update(updates).eq("id", id);
-  broadcast("task_update", { id, ...updates });
+  await supabase.from("cb_tasks").update(req.body).eq("id", req.params.id);
+  broadcast("task_update", { id: req.params.id, ...req.body });
   res.json({ ok: true });
 });
 
-// GET logs for a specific task
 app.get("/api/tasks/:id/logs", async (req, res) => {
-  const { data } = await supabase
-    .from("cb_logs")
-    .select("*")
-    .eq("task_id", req.params.id)
-    .order("created_at");
+  const { data } = await supabase.from("cb_logs").select("*")
+    .eq("task_id", req.params.id).order("created_at");
   res.json({ logs: data || [] });
 });
 
-// Serve dashboard HTML
-app.get("*", (req, res) => {
-  res.sendFile(path.join(__dirname, "index.html"));
-});
+app.get("*", (req, res) => res.sendFile(path.join(__dirname, "index.html")));
 
-// ─── HELPERS ─────────────────────────────────────────────────────────────────
 async function addLog(taskId, message, type = "info") {
-  await supabase.from("cb_logs").insert({
-    project: PROJECT,
-    task_id: taskId,
-    message,
-    type,
-  });
+  await supabase.from("cb_logs").insert({ project: PROJECT, task_id: taskId, message, type });
 }
 
-server.listen(PORT, () => {
-  console.log(`READY on port ${PORT}`);
-});
+server.listen(PORT, () => console.log(`READY on port ${PORT}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeboard",
-  "version": "1.1.0",
+  "version": "1.5.0",
   "description": "AI engineering team — from PRD to working mobile app, autonomously",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "express": "^4.18.3",
+    "node-pty": "^1.0.0",
     "open": "^10.1.0",
     "ora": "^8.0.1",
     "puppeteer": "^22.8.0",