claudeboard 2.12.0 → 2.13.0

package/agents/expo-health.js

@@ -6,6 +6,7 @@ import fs from "fs";
 import path from "path";
 import { createRequire } from "module";
 import { createConnection } from "net";
+import { spawn as _spawn, execSync } from "child_process";
 
 const require = createRequire(import.meta.url);
 const MAX_FIX_ATTEMPTS = 5;
@@ -149,14 +150,13 @@ async function tryStartExpo(projectPath, port) {
       done(false, `Expo did not become ready within 60s.\n${output.slice(-800)}`), 60000);
 
     try {
-      const { spawn } = require("child_process");
       // Use iOS simulator if available, fallback to web
-      const useIOS = process.env.CLAUDEBOARD_IOS === "1" || await isSimulatorAvailable();
+      const useIOS = process.env.CLAUDEBOARD_IOS === "1" || isSimulatorAvailableSync();
       const expoArgs = useIOS
         ? ["expo", "start", "--ios", "--port", String(port)]
         : ["expo", "start", "--web", "--port", String(port)];
       
-      proc = spawn("npx", expoArgs, {
+      proc = _spawn("npx", expoArgs, {
         cwd: projectPath,
         env: (() => { const e = { ...process.env, CI: "1", EXPO_NO_INTERACTIVE: "1", EXPO_NO_DOTENV: "0" }; delete e.ANTHROPIC_API_KEY; return e; })(),
         stdio: "pipe",
@@ -320,13 +320,10 @@ function getFatalError(output) {
 }
 
 // ── iOS Simulator detection ───────────────────────────────────────────────────
-async function isSimulatorAvailable() {
+function isSimulatorAvailableSync() {
   try {
-    const { execSync } = await import("child_process");
     const output = execSync("xcrun simctl list devices booted 2>&1", { encoding: "utf8" });
-    // Check if any device is already booted
     if (output.includes("Booted")) return true;
-    // Check if any iOS runtime is available
     const runtimes = execSync("xcrun simctl list runtimes 2>&1", { encoding: "utf8" });
     return runtimes.includes("iOS") && !runtimes.includes("unavailable");
   } catch {
@@ -337,7 +334,6 @@ async function isSimulatorAvailable() {
 // Take a screenshot of the iOS simulator
 export async function screenshotSimulator(outputPath) {
   try {
-    const { execSync } = await import("child_process");
     execSync(`xcrun simctl io booted screenshot "${outputPath}"`, { stdio: "pipe" });
     const data = fs.readFileSync(outputPath);
     return { success: true, base64: data.toString("base64"), path: outputPath };
@@ -349,7 +345,6 @@ export async function screenshotSimulator(outputPath) {
 // Tap on the iOS simulator at given coordinates
 export async function tapSimulator(x, y) {
   try {
-    const { execSync } = await import("child_process");
     execSync(`xcrun simctl io booted tap ${x} ${y}`, { stdio: "pipe" });
     return true;
   } catch { return false; }

package/dashboard/index.html

@@ -1201,13 +1201,23 @@ function connectWS() {
   ws.onclose = () => { setWS(false); setTimeout(connectWS, 2000); };
   ws.onmessage = (e) => {
     const { event, data } = JSON.parse(e.data);
-    if (['task_update','task_added','task_started','task_complete','task_failed','task_deleted','task_reordered'].includes(event)) {
+
+    // Task state changes that require a board reload (status flipped, new task, deleted)
+    if (['task_added','task_started','task_complete','task_failed','task_deleted'].includes(event)) {
       loadBoard();
     }
+    // Reorder: just re-render from current board data — no network call needed
+    if (event === 'task_reordered') {
+      renderKanban();
+      updateStats();
+    }
+    // Single task field update: patch in-memory and re-render (no full reload)
+    if (event === 'task_update') {
+      patchTaskInMemory(data);
+    }
     if (event === 'log') {
       board.logs.unshift(data);
       if (activeTab === 'activity') renderLogs();
-      // If on detail tab, don't touch activityPane — it'll refresh next time they switch
     }
     if (event === 'expo_status') {
       setExpoStatus(data.status, data.url);
@@ -1221,6 +1231,12 @@ function connectWS() {
 function setWS(on) {
   document.getElementById('wsDot').className = 'ws-dot' + (on ? ' on' : '');
   document.getElementById('wsLabel').textContent = on ? t('live') : t('reconnecting');
+  // Poll only when disconnected
+  if (on) {
+    if (pollInterval) { clearInterval(pollInterval); pollInterval = null; }
+  } else {
+    if (!pollInterval) pollInterval = setInterval(loadBoard, 10000);
+  }
 }
 
 // ── DATA ─────────────────────────────────────────────────────────────────────
@@ -1328,9 +1344,37 @@ function cardHTML(task, position = null) {
     </div>`;
 }
 
-// ── DRAG & DROP ───────────────────────────────────────────────────────────────
+// ── IN-MEMORY PATCH (avoid full reload for minor updates) ─────────────────────
+function patchTaskInMemory(patch) {
+  if (!board.epics) return;
+  for (const epic of board.epics) {
+    const idx = (epic.cb_tasks || []).findIndex(t => t.id === patch.id);
+    if (idx !== -1) {
+      epic.cb_tasks[idx] = { ...epic.cb_tasks[idx], ...patch };
+      renderKanban();
+      updateStats();
+      return;
+    }
+  }
+  // Task not found in memory yet (new orphan etc), do full reload
+  loadBoard();
+}
+
+// ── DRAG STATE ────────────────────────────────────────────────────────────────
+// We track order in JS so we don't depend on DOM state during drag
+let dragColumnOrder = {}; // { status: [id, id, ...] } — snapshot at dragstart
 function onDragStart(e, id) {
   draggedId = id;
+
+  // Snapshot current order of all columns from memory (reliable — not DOM-dependent)
+  dragColumnOrder = {};
+  for (const status of ['todo', 'in_progress', 'done', 'error']) {
+    dragColumnOrder[status] = allTasks()
+      .filter(t => t.status === status)
+      .sort((a, b) => (a.priority_order ?? 99) - (b.priority_order ?? 99))
+      .map(t => t.id);
+  }
+
   setTimeout(() => {
     const el = document.querySelector(`.card[data-id="${id}"]`);
     if (el) el.classList.add('dragging');
@@ -1391,27 +1435,34 @@ async function onDrop(e, status) {
   const insertBeforeId = col.dataset.insertBefore || '';
   delete col.dataset.insertBefore;
 
-  // Build the new ordered list of ids for this column
-  // Start from the DOM — what's visually shown — plus insert dragged card
-  const otherIds = [...col.querySelectorAll('.card')]
-    .map(c => c.dataset.id)
-    .filter(id => id && id !== draggedId);
+  // Use the JS snapshot (taken at dragstart) — not DOM which has .dragging gaps
+  const sourceStatus = allTasks().find(t => t.id === draggedId)?.status || status;
+  const columnIds = (dragColumnOrder[status] || []).filter(id => id !== draggedId);
 
   let newOrderedIds;
   if (!insertBeforeId) {
-    newOrderedIds = [...otherIds, draggedId]; // dropped at end
+    newOrderedIds = [...columnIds, draggedId];
   } else {
-    const insertIdx = otherIds.indexOf(insertBeforeId);
+    const insertIdx = columnIds.indexOf(insertBeforeId);
     if (insertIdx === -1) {
-      newOrderedIds = [draggedId, ...otherIds];
+      newOrderedIds = [draggedId, ...columnIds];
     } else {
-      newOrderedIds = [...otherIds.slice(0, insertIdx), draggedId, ...otherIds.slice(insertIdx)];
+      newOrderedIds = [...columnIds.slice(0, insertIdx), draggedId, ...columnIds.slice(insertIdx)];
     }
   }
 
-  // Update status first if moving to different column
-  const draggedTask = allTasks().find(t => t.id === draggedId);
-  if (draggedTask?.status !== status) {
+  // Optimistic update in memory so re-render is instant
+  const task = allTasks().find(t => t.id === draggedId);
+  if (task) task.status = status;
+  newOrderedIds.forEach((id, i) => {
+    const t = allTasks().find(t => t.id === id);
+    if (t) t.priority_order = i + 1;
+  });
+  renderKanban();
+  updateStats();
+
+  // Update status if column changed
+  if (sourceStatus !== status) {
     await fetch(`/api/tasks/${draggedId}`, {
       method: 'PATCH',
       headers: { 'Content-Type': 'application/json' },
@@ -1419,7 +1470,7 @@ async function onDrop(e, status) {
     });
   }
 
-  // Persist the new order in one call
+  // Persist new order
   await fetch('/api/tasks/reorder', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -1427,7 +1478,6 @@ async function onDrop(e, status) {
   });
 
   draggedId = null;
-  loadBoard();
 }
 
 // ── CARD SELECT ───────────────────────────────────────────────────────────────
@@ -1901,8 +1951,9 @@ function applyTranslations() {
 
 // ── INIT ──────────────────────────────────────────────────────────────────────
 loadBoard();
-setInterval(loadBoard, 8000);
 connectWS();
+// Only poll when WS is disconnected (fallback)
+let pollInterval = null;
 
 // Load expo status
 fetch('/api/expo/status').then(r => r.json()).then(d => setExpoStatus(d.status, d.url));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeboard",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "AI engineering team — from PRD to working mobile app, autonomously",
   "type": "module",
   "bin": {