claudeboard 2.16.0 → 3.1.0

package/dashboard/server.js

@@ -1,412 +0,0 @@
-import express from "express";
-import cors from "cors";
-import { createServer } from "http";
-import { WebSocketServer } from "ws";
-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";
-import { createConnection } from "net";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-
-const app = express();
-const server = createServer(app);
-
-// 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 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(SUPABASE_URL, SUPABASE_KEY);
-
-// ── 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() });
-  boardWss.clients.forEach((c) => { if (c.readyState === 1) c.send(msg); });
-}
-
-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" }, (p) => {
-    if (p.eventType === "UPDATE" && p.new) broadcast("task_update", p.new);
-    else if (p.eventType === "INSERT" && p.new) broadcast("task_added", p.new);
-    else if (p.eventType === "DELETE") broadcast("task_deleted", { id: p.old?.id });
-  })
-  .on("postgres_changes", { event: "*", schema: "public", table: "cb_logs"  }, (p) => broadcast("log", p.new))
-  .subscribe();
-
-// ── 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 ───────────────────────────────────────────────────────────
-
-// On server start, check if Expo is already running on the port
-// (e.g. started by claudeboard run) and mark it as running
-async function detectExistingExpo() {
-  const port = parseInt(process.env.EXPO_PORT || "8081");
-  const running = await isPortOpen(port);
-  if (running) {
-    expoStatus = "running";
-    expoUrl = `exp://localhost:${port}`;
-    broadcast("expo_log", { message: `✓ Detected existing Expo on port ${port} — ready to scan` });
-    broadcastExpoStatus();
-    console.log(`  Expo already running on port ${port} — attached`);
-  }
-}
-
-function isPortOpen(port) {
-  return new Promise(resolve => {
-    const sock = createConnection({ port, host: "127.0.0.1" });
-    sock.setTimeout(600);
-    sock.once("connect", () => { sock.destroy(); resolve(true); });
-    sock.once("error", () => resolve(false));
-    sock.once("timeout", () => resolve(false));
-  });
-}
-
-// GET expo status
-app.get("/api/expo/status", (req, res) => {
-  res.json({ status: expoStatus, qr: expoQR, url: expoUrl });
-});
-
-// POST expo/start — smart start: attach if already running, otherwise install + start
-app.post("/api/expo/start", async (req, res) => {
-  const port = parseInt(process.env.EXPO_PORT || "8081");
-
-  // Already managed by this server
-  if (expoProcess) {
-    return res.json({ ok: true, message: "Already running", status: expoStatus, url: expoUrl });
-  }
-
-  // Check if something is already listening on the port (e.g. started by claudeboard run)
-  const alreadyRunning = await isPortOpen(port);
-  if (alreadyRunning) {
-    expoStatus = "running";
-    expoUrl = `exp://localhost:${port}`;
-    broadcastExpoStatus();
-    broadcast("expo_log", { message: `✓ Attached to existing Expo on port ${port}` });
-    return res.json({ ok: true, message: "Attached to existing Expo", url: expoUrl });
-  }
-
-  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: install deps with --legacy-peer-deps
-  // Expo projects almost always have peer dep conflicts — this is expected
-  expoStatus = "installing";
-  broadcastExpoStatus();
-  broadcast("expo_log", { message: "Installing dependencies (--legacy-peer-deps)..." });
-
-  await new Promise((resolve) => {
-    const install = spawn("npm", ["install", "--legacy-peer-deps"], {
-      cwd: projectDir,
-      stdio: "pipe",
-      env: { ...process.env },
-    });
-    install.stdout.on("data", (d) => {
-      const msg = d.toString().trim();
-      if (msg && !msg.startsWith("npm warn")) broadcast("expo_log", { message: msg });
-    });
-    install.stderr.on("data", (d) => {
-      const msg = d.toString().trim();
-      // Only show real errors, not peer dep warnings
-      if (msg && msg.includes("npm error") && !msg.includes("ERESOLVE")) {
-        broadcast("expo_log", { message: msg });
-      }
-    });
-    install.on("close", resolve);
-  });
-
-  broadcast("expo_log", { message: "✓ Dependencies ready. Starting Expo tunnel..." });
-
-  // Step 2: expo start --tunnel, fully non-interactive
-  expoStatus = "starting";
-  broadcastExpoStatus();
-
-  const expo = spawn("npx", ["expo", "start", "--tunnel", "--non-interactive"], {
-    cwd: projectDir,
-    stdio: "pipe",
-    env: {
-      ...process.env,
-      CI: "1",                    // Prevents "use port X instead?" prompts
-      EXPO_NO_DOTENV: "0",
-      EXPO_NO_INTERACTIVE: "1",   // Belt + suspenders non-interactive
-      TERM: "dumb",               // No ANSI color codes in output
-    },
-  });
-
-  expoProcess = expo;
-
-  expo.stdout.on("data", (d) => {
-    const text = d.toString();
-    const clean = text.replace(/\x1b\[[0-9;]*m/g, "").trim(); // strip ANSI codes
-    if (clean) broadcast("expo_log", { message: clean });
-
-    // Detect URLs
-    const expUrl = text.match(/exp:\/\/[^\s\]]+/);
-    if (expUrl) { expoUrl = expUrl[0]; expoStatus = "running"; broadcastExpoStatus(); }
-
-    const tunnel = text.match(/https:\/\/[a-z0-9-]+\.exp\.direct[^\s\]]*/);
-    if (tunnel) { expoUrl = tunnel[0]; expoStatus = "running"; broadcastExpoStatus(); }
-
-    if (text.includes("scan") || text.includes("QR")) {
-      broadcast("expo_log", { message: "📱 QR ready — open Expo Go and scan" });
-    }
-  });
-
-  expo.stderr.on("data", (d) => {
-    const text = d.toString().replace(/\x1b\[[0-9;]*m/g, "").trim();
-    if (text) broadcast("expo_log", { message: text });
-  });
-
-  expo.on("close", (code) => {
-    expoProcess = null;
-    if (code !== 0 && expoStatus !== "running") expoStatus = "error";
-    broadcastExpoStatus();
-    broadcast("expo_log", { message: `Expo 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) ──────────────────────────────────────────────
-
-app.get("/api/board", async (req, res) => {
-  const { data: epics } = await supabase
-    .from("cb_epics").select("*, cb_tasks(*)")
-    .eq("project", PROJECT).order("created_at");
-
-  // Orphan tasks (manually created, no epic_id)
-  const { data: orphanTasks } = await supabase
-    .from("cb_tasks").select("*")
-    .eq("project", PROJECT).is("epic_id", null)
-    .order("priority_order", { ascending: true });
-
-  // Sort tasks within each epic by priority_order
-  const sortedEpics = (epics || []).map(epic => ({
-    ...epic,
-    cb_tasks: (epic.cb_tasks || []).sort((a, b) => (a.priority_order ?? 99) - (b.priority_order ?? 99)),
-  }));
-
-  // Orphan tasks appear as a virtual "Manual Tasks" epic
-  if (orphanTasks?.length) {
-    sortedEpics.push({ id: "manual", name: "— Manual Tasks", cb_tasks: orphanTasks });
-  }
-
-  const { data: logs } = await supabase
-    .from("cb_logs").select("*").eq("project", PROJECT)
-    .order("created_at", { ascending: false }).limit(50);
-  res.json({ epics: sortedEpics, logs: logs || [], project: PROJECT });
-});
-
-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();
-  if (!data) return res.json({ task: null, message: "All tasks complete! 🎉" });
-  res.json({ task: data });
-});
-
-app.post("/api/tasks/:id/start", async (req, res) => {
-  const { id } = req.params;
-  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 });
-});
-
-app.post("/api/tasks/:id/log", async (req, res) => {
-  await addLog(req.params.id, req.body.message, "progress");
-  res.json({ ok: true });
-});
-
-app.post("/api/tasks/:id/complete", async (req, res) => {
-  const { id } = req.params;
-  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 });
-});
-
-app.post("/api/tasks/:id/fail", async (req, res) => {
-  const { id } = req.params;
-  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 });
-});
-
-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();
-  if (error) return res.status(400).json({ error: error.message });
-  broadcast("task_added", data);
-  res.json({ task: data });
-});
-
-app.patch("/api/tasks/:id", async (req, res) => {
-  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 });
-});
-
-// DELETE a task
-app.delete("/api/tasks/:id", async (req, res) => {
-  await supabase.from("cb_logs").delete().eq("task_id", req.params.id);
-  await supabase.from("cb_tasks").delete().eq("id", req.params.id);
-  broadcast("task_deleted", { id: req.params.id });
-  res.json({ ok: true });
-});
-
-// POST reorder — receives ordered array of task ids for a column, renumbers them
-app.post("/api/tasks/reorder", async (req, res) => {
-  const { taskIds } = req.body; // array of ids in new order
-  for (let i = 0; i < taskIds.length; i++) {
-    await supabase.from("cb_tasks")
-      .update({ priority_order: i + 1 })
-      .eq("id", taskIds[i]);
-  }
-  broadcast("task_reordered", { taskIds });
-  res.json({ ok: true });
-});
-
-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");
-  res.json({ logs: data || [] });
-});
-
-app.get("*", (req, res) => res.sendFile(path.join(__dirname, "index.html")));
-
-async function addLog(taskId, message, type = "info") {
-  await supabase.from("cb_logs").insert({ project: PROJECT, task_id: taskId, message, type });
-}
-
-server.listen(PORT, () => {
-  console.log(`READY on port ${PORT}`);
-  // Check if Expo is already running (started by claudeboard run)
-  setTimeout(detectExistingExpo, 1000);
-});

package/sql/setup.sql

@@ -1,57 +0,0 @@
--- ClaudeBoard — Supabase Setup
--- Run this in your Supabase SQL Editor
-
--- Epics (grouping of tasks)
-create table if not exists cb_epics (
-  id uuid primary key default gen_random_uuid(),
-  project text not null,
-  name text not null,
-  created_at timestamptz default now()
-);
-
--- Tasks
-create table if not exists cb_tasks (
-  id uuid primary key default gen_random_uuid(),
-  project text not null,
-  epic_id uuid references cb_epics(id) on delete set null,
-  title text not null,
-  description text,
-  status text not null default 'todo', -- todo | in_progress | done | error | blocked
-  priority text default 'medium',      -- high | medium | low
-  priority_order int default 2,
-  type text default 'feature',         -- feature | bug | refactor | test | config
-  started_at timestamptz,
-  completed_at timestamptz,
-  created_at timestamptz default now()
-);
-
--- Logs (activity feed)
-create table if not exists cb_logs (
-  id uuid primary key default gen_random_uuid(),
-  project text not null,
-  task_id uuid references cb_tasks(id) on delete cascade,
-  message text not null,
-  type text default 'info',  -- start | progress | complete | error | info
-  created_at timestamptz default now()
-);
-
--- Indexes
-create index if not exists idx_tasks_project on cb_tasks(project);
-create index if not exists idx_tasks_status on cb_tasks(status);
-create index if not exists idx_tasks_priority on cb_tasks(priority_order);
-create index if not exists idx_logs_task on cb_logs(task_id);
-create index if not exists idx_logs_project on cb_logs(project);
-
--- Enable Realtime
-alter publication supabase_realtime add table cb_tasks;
-alter publication supabase_realtime add table cb_logs;
-alter publication supabase_realtime add table cb_epics;
-
--- RLS (Row Level Security) — permissive for local dev
-alter table cb_epics enable row level security;
-alter table cb_tasks enable row level security;
-alter table cb_logs enable row level security;
-
-create policy "allow_all_epics" on cb_epics for all using (true) with check (true);
-create policy "allow_all_tasks" on cb_tasks for all using (true) with check (true);
-create policy "allow_all_logs" on cb_logs for all using (true) with check (true);

package/tools/filesystem.js

@@ -1,95 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-/**
- * Read a file, return content string or null
- */
-export function readFile(filePath) {
-  try {
-    return fs.readFileSync(filePath, "utf8");
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Write a file (creates dirs if needed)
- */
-export function writeFile(filePath, content) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, content, "utf8");
-}
-
-/**
- * List files in a directory recursively (ignores node_modules, .git, etc)
- */
-export function listFiles(dir, extensions = null, maxDepth = 4) {
-  const results = [];
-  const IGNORE = new Set(["node_modules", ".git", ".expo", "dist", "build", ".next", "coverage"]);
-
-  function walk(current, depth) {
-    if (depth > maxDepth) return;
-    let entries;
-    try { entries = fs.readdirSync(current, { withFileTypes: true }); } catch { return; }
-
-    for (const entry of entries) {
-      if (IGNORE.has(entry.name)) continue;
-      const fullPath = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        walk(fullPath, depth + 1);
-      } else if (!extensions || extensions.some((ext) => entry.name.endsWith(ext))) {
-        results.push(fullPath);
-      }
-    }
-  }
-
-  walk(dir, 0);
-  return results;
-}
-
-/**
- * Get a compact project tree string (for LLM context)
- */
-export function projectTree(dir, maxDepth = 3) {
-  const IGNORE = new Set(["node_modules", ".git", ".expo", "dist", "build", ".next"]);
-  const lines = [];
-
-  function walk(current, depth, prefix) {
-    if (depth > maxDepth) return;
-    let entries;
-    try { entries = fs.readdirSync(current, { withFileTypes: true }); } catch { return; }
-
-    const filtered = entries.filter((e) => !IGNORE.has(e.name));
-    filtered.forEach((entry, i) => {
-      const isLast = i === filtered.length - 1;
-      const connector = isLast ? "└── " : "├── ";
-      lines.push(prefix + connector + entry.name);
-      if (entry.isDirectory()) {
-        walk(
-          path.join(current, entry.name),
-          depth + 1,
-          prefix + (isLast ? "    " : "│   ")
-        );
-      }
-    });
-  }
-
-  lines.push(path.basename(dir) + "/");
-  walk(dir, 0, "");
-  return lines.join("\n");
-}
-
-/**
- * Read multiple files and return as context string
- */
-export function readFilesAsContext(filePaths, projectRoot) {
-  return filePaths
-    .map((fp) => {
-      const content = readFile(fp);
-      if (!content) return null;
-      const rel = path.relative(projectRoot, fp);
-      return `### ${rel}\n\`\`\`\n${content.slice(0, 3000)}\n\`\`\``;
-    })
-    .filter(Boolean)
-    .join("\n\n");
-}

package/tools/screenshot.js

@@ -1,74 +0,0 @@
-import { runCommand, waitForPort } from "./terminal.js";
-import fs from "fs";
-import path from "path";
-
-let puppeteer = null;
-
-async function getPuppeteer() {
-  if (!puppeteer) {
-    try {
-      const mod = await import("puppeteer");
-      puppeteer = mod.default;
-    } catch {
-      return null;
-    }
-  }
-  return puppeteer;
-}
-
-/**
- * Take a screenshot of a running Expo Web app
- * Returns { success, imagePath, base64, error }
- */
-export async function screenshotExpoWeb(port = 8081, outputDir, pagePath = "/") {
-  const p = await getPuppeteer();
-  if (!p) {
-    return { success: false, error: "puppeteer not installed — run: npm install puppeteer" };
-  }
-
-  const url = `http://localhost:${port}${pagePath}`;
-  const filename = `screenshot-${Date.now()}.png`;
-  const imagePath = path.join(outputDir, filename);
-
-  fs.mkdirSync(outputDir, { recursive: true });
-
-  let browser;
-  try {
-    browser = await p.launch({
-      headless: "new",
-      args: ["--no-sandbox", "--disable-setuid-sandbox"],
-    });
-
-    const page = await browser.newPage();
-
-    // Mobile viewport — Expo apps are mobile-first
-    await page.setViewport({ width: 390, height: 844, deviceScaleFactor: 2 });
-
-    await page.goto(url, { waitUntil: "networkidle2", timeout: 30000 });
-
-    // Wait a bit for React to render
-    await new Promise((r) => setTimeout(r, 2000));
-
-    await page.screenshot({ path: imagePath, fullPage: false });
-
-    const base64 = fs.readFileSync(imagePath).toString("base64");
-
-    return { success: true, imagePath, base64, url };
-  } catch (err) {
-    return { success: false, error: err.message };
-  } finally {
-    if (browser) await browser.close();
-  }
-}
-
-/**
- * Take multiple screenshots navigating through routes
- */
-export async function screenshotRoutes(port = 8081, routes = ["/"], outputDir) {
-  const results = [];
-  for (const route of routes) {
-    const result = await screenshotExpoWeb(port, outputDir, route);
-    results.push({ route, ...result });
-  }
-  return results;
-}