kandown 0.13.1 → 0.14.1

package/bin/kandown.js

@@ -322,18 +322,43 @@ ${c.bold}Examples:${c.reset}
 `);
 }
 
-function copyRecursive(src, dest) {
-  if (!existsSync(src)) return;
-  mkdirSync(dest, { recursive: true });
-  for (const entry of readdirSync(src)) {
+/**
+ * 📖 Resilient recursive copy used by `kandown init` (t113).
+ * Returns the list of per-entry error messages; an empty array means a fully
+ * clean copy. A partially-failed init no longer leaves the user with no clue
+ * about what went wrong — the caller reports each failure.
+ */
+function copyRecursive(src, dest, errors = []) {
+  if (!existsSync(src)) return errors;
+  try {
+    mkdirSync(dest, { recursive: true });
+  } catch (e) {
+    errors.push(`Failed to create directory ${dest}: ${e.message}`);
+    return errors;
+  }
+  let entries;
+  try {
+    entries = readdirSync(src);
+  } catch (e) {
+    errors.push(`Failed to read ${src}: ${e.message}`);
+    return errors;
+  }
+  for (const entry of entries) {
     const srcPath = join(src, entry);
     const destPath = join(dest, entry);
-    if (statSync(srcPath).isDirectory()) {
-      copyRecursive(srcPath, destPath);
-    } else {
-      copyFileSync(srcPath, destPath);
+    try {
+      if (statSync(srcPath).isDirectory()) {
+        copyRecursive(srcPath, destPath, errors);
+      } else {
+        copyFileSync(srcPath, destPath);
+      }
+    } catch (e) {
+      // 📖 One unreadable / unwritable file shouldn't abort the whole init —
+      // record the error and keep copying the rest (t113).
+      errors.push(`Failed to copy ${srcPath}: ${e.message}`);
     }
   }
+  return errors;
 }
 
 function findAgentsFile(cwd) {
@@ -348,7 +373,15 @@ function findAgentsFile(cwd) {
 function appendAgentReference(cwd, agentsFile, kandownPath) {
   const filePath = join(cwd, agentsFile);
   const marker = '<!-- kandown:agent-ref -->';
-  const existing = readFileSync(filePath, 'utf8');
+  let existing;
+  try {
+    existing = readFileSync(filePath, 'utf8');
+  } catch (e) {
+    // 📖 TOCTOU: file existed at the check but vanished or became unreadable.
+    // Warn and skip rather than crashing init (t113).
+    warn(`Could not read ${agentsFile} (${e.message}); skipping agent reference.`);
+    return false;
+  }
 
   if (existing.includes(marker)) {
     info(`${agentsFile} already references the kandown (skipped)`);
@@ -368,8 +401,13 @@ This project uses a file-based kanban:
 - **Completion workflow:** set task frontmatter \`status: Done\` + write the completion report
 `;
 
-  writeFileSync(filePath, existing + ref, 'utf8');
-  return true;
+  try {
+    writeFileSync(filePath, existing + ref, 'utf8');
+    return true;
+  } catch (e) {
+    warn(`Could not append agent reference to ${agentsFile} (${e.message}).`);
+    return false;
+  }
 }
 
 function createAgentsFileIfMissing(cwd, kandownPath) {
@@ -586,7 +624,13 @@ function doInit(args, cwd, kandownPath, kandownDir) {
   const tasksDest = getTasksDir(kandownDir);
   if (!existsSync(tasksDest)) {
     mkdirSync(tasksDest, { recursive: true });
-    copyRecursive(tasksSrc, tasksDest);
+    // 📖 copyRecursive now returns an errors[] array — report any partial
+    // failures instead of letting them crash the whole init (t113).
+    const copyErrors = copyRecursive(tasksSrc, tasksDest);
+    if (copyErrors.length > 0) {
+      warn(`Some task template files could not be copied:`);
+      for (const msg of copyErrors) warn(`  - ${msg}`);
+    }
     success('./tasks/ (with welcome example)');
   } else {
     info('./tasks/ already exists (kept)');
@@ -1747,7 +1791,10 @@ function serveApp(res, kandownDir) {
     res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
     res.end(injected);
   } catch (e) {
-    writeText(res, 500, `Failed to serve kandown.html: ${e.message}`);
+    // 📖 Don't leak internal paths / error details to HTTP clients — log the
+    // full error server-side, send a generic message to the browser (t113).
+    console.error(`[serve] Error serving ${htmlPath}:`, e);
+    writeText(res, 500, 'Internal server error — check the terminal where kandown is running.');
   }
 }
 
@@ -1837,7 +1884,10 @@ async function listenOnAvailablePort(kandownDir, preferredPort) {
       await listen(server, p);
       return { server, port: p };
     } catch (e) {
-      if (e.code !== 'EADDRINUSE') throw e;
+      // 📖 EADDRINUSE → try the next port. EACCES (privileged port / blocked
+      // by OS) → also try the next port instead of crashing (t113). Anything
+      // else is unexpected and bubbles up.
+      if (e.code !== 'EADDRINUSE' && e.code !== 'EACCES') throw e;
     }
   }
 

package/bin/tui.js

@@ -53993,7 +53993,8 @@ var DEFAULT_CONFIG = {
   board: {
     columns: ["Backlog", "Todo", "In Progress", "Review", "Done"],
     defaultPriority: "P3",
-    defaultOwnerType: "human"
+    defaultOwnerType: "human",
+    stackDefaultState: "collapsed"
   },
   fields: {
     priority: false,
@@ -54016,24 +54017,37 @@ var DEFAULT_CONFIG = {
 function loadConfig(kandownDir) {
   const configPath = join(kandownDir, "kandown.json");
   if (!existsSync2(configPath)) return structuredClone(DEFAULT_CONFIG);
+  let raw;
   try {
-    const raw = JSON.parse(readFileSync2(configPath, "utf8"));
-    const merged = {
-      ui: { ...DEFAULT_CONFIG.ui, ...raw.ui },
-      agent: { ...DEFAULT_CONFIG.agent, ...raw.agent },
-      board: {
-        ...DEFAULT_CONFIG.board,
-        ...raw.board,
-        columns: Array.isArray(raw.board?.columns) && raw.board.columns.length > 0 ? raw.board.columns.filter((name) => typeof name === "string" && name.trim().length > 0) : DEFAULT_CONFIG.board.columns
-      },
-      fields: { ...DEFAULT_CONFIG.fields, ...raw.fields },
-      notifications: { ...DEFAULT_CONFIG.notifications, ...raw.notifications }
-    };
-    if (raw.agents) merged.agents = raw.agents;
-    return merged;
-  } catch {
+    raw = JSON.parse(readFileSync2(configPath, "utf8"));
+  } catch (e) {
+    const err = e;
+    if (err.code === "ENOENT") return structuredClone(DEFAULT_CONFIG);
+    console.warn(`[kandown] kandown.json is corrupted, using defaults: ${e.message}`);
+    return structuredClone(DEFAULT_CONFIG);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    console.warn("[kandown] kandown.json must be a JSON object, using defaults.");
     return structuredClone(DEFAULT_CONFIG);
   }
+  const obj = raw;
+  const safeObj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+  const boardRaw = safeObj(obj.board);
+  const merged = {
+    ui: { ...DEFAULT_CONFIG.ui, ...safeObj(obj.ui) },
+    agent: { ...DEFAULT_CONFIG.agent, ...safeObj(obj.agent) },
+    board: {
+      ...DEFAULT_CONFIG.board,
+      ...boardRaw,
+      columns: Array.isArray(boardRaw.columns) && boardRaw.columns.length > 0 ? boardRaw.columns.filter((name) => typeof name === "string" && name.trim().length > 0) : DEFAULT_CONFIG.board.columns
+    },
+    fields: { ...DEFAULT_CONFIG.fields, ...safeObj(obj.fields) },
+    notifications: { ...DEFAULT_CONFIG.notifications, ...safeObj(obj.notifications) }
+  };
+  if (obj.agents && typeof obj.agents === "object") {
+    merged.agents = obj.agents;
+  }
+  return merged;
 }
 function saveConfig(kandownDir, config) {
   const configPath = join(kandownDir, "kandown.json");
@@ -54107,6 +54121,13 @@ var SETTINGS = [
     max: 5
   },
   // Board
+  {
+    key: "board.stackDefaultState",
+    label: "Task groups",
+    section: "Board",
+    type: "select",
+    options: ["collapsed", "expanded"]
+  },
   {
     key: "board.defaultPriority",
     label: "Default priority",
@@ -54164,8 +54185,12 @@ function Settings({ kandownDir, version }) {
   const persistConfig = (0, import_react34.useCallback)(
     (newConfig) => {
       setConfig(newConfig);
-      saveConfig(kandownDir, newConfig);
-      setSavedAt(Date.now());
+      try {
+        saveConfig(kandownDir, newConfig);
+        setSavedAt(Date.now());
+      } catch (e) {
+        console.error("[kandown] Failed to save config:", e);
+      }
     },
     [kandownDir]
   );
@@ -54547,17 +54572,23 @@ function listTaskIds(kandownDir) {
 }
 function readBoard(kandownDir) {
   const config = loadConfig(kandownDir);
-  const tasks = listTaskIds(kandownDir).map((id) => {
-    const task = readTask(kandownDir, id);
-    return {
-      ...task,
-      frontmatter: {
-        ...task.frontmatter,
-        id: task.frontmatter.id || id,
-        status: task.frontmatter.status || "Backlog"
-      }
-    };
-  });
+  const ids = listTaskIds(kandownDir);
+  const tasks = [];
+  for (const id of ids) {
+    try {
+      const task = readTask(kandownDir, id);
+      tasks.push({
+        ...task,
+        frontmatter: {
+          ...task.frontmatter,
+          id: task.frontmatter.id || id,
+          status: task.frontmatter.status || "Backlog"
+        }
+      });
+    } catch (e) {
+      console.error(`[kandown] Failed to read task ${id}:`, e.message);
+    }
+  }
   return {
     frontmatter: null,
     title: "Project Kanban",
@@ -54590,8 +54621,11 @@ function readAgentDoc(kandownDir) {
     join2(kandownDir, "AGENT.md")
   ];
   for (const candidate of candidates) {
-    if (existsSync3(candidate)) {
+    if (!existsSync3(candidate)) continue;
+    try {
       return readFileSync3(candidate, "utf8");
+    } catch (e) {
+      console.warn(`[kandown] Could not read ${candidate}:`, e.message);
     }
   }
   return "";
@@ -54599,13 +54633,18 @@ function readAgentDoc(kandownDir) {
 function moveTaskToColumn(kandownDir, taskId, targetColumn) {
   const taskPath = join2(getTasksDir(kandownDir), `${taskId}.md`);
   if (!existsSync3(taskPath)) return false;
-  const parsed = readTask(kandownDir, taskId);
-  writeFileSync2(taskPath, serializeTaskFile({
-    ...parsed.frontmatter,
-    id: taskId,
-    status: targetColumn
-  }, parsed.body), "utf8");
-  return true;
+  try {
+    const parsed = readTask(kandownDir, taskId);
+    writeFileSync2(taskPath, serializeTaskFile({
+      ...parsed.frontmatter,
+      id: taskId,
+      status: targetColumn
+    }, parsed.body), "utf8");
+    return true;
+  } catch (e) {
+    console.error(`[kandown] Failed to move task ${taskId} to ${targetColumn}:`, e.message);
+    return false;
+  }
 }
 
 // src/cli/lib/daemon.ts
@@ -56787,7 +56826,13 @@ function launchAgent(opts) {
   if (!agentDef) {
     throw new Error(`Unknown agent: ${agentId}`);
   }
-  const task = readTask(kandownDir, taskId);
+  let task;
+  try {
+    task = readTask(kandownDir, taskId);
+  } catch (e) {
+    throw new Error(`Failed to read task ${taskId}: ${e.message}`);
+  }
+  const originalStatus = task.frontmatter.status || "Backlog";
   const agentDoc = readAgentDoc(kandownDir);
   const taskFileContent = [
     `---`,
@@ -56799,16 +56844,24 @@ function launchAgent(opts) {
     task.body.trim()
   ].join("\n");
   const { systemPrompt, taskPrompt } = buildPrompt(agentDoc, taskFileContent, taskId, kandownDir);
-  moveTaskToColumn(kandownDir, taskId, "In Progress");
+  const taskMoved = moveTaskToColumn(kandownDir, taskId, "In Progress");
+  if (!taskMoved) {
+    throw new Error(`Could not move task ${taskId} to In Progress \u2014 task file missing or unwritable.`);
+  }
   const contextFile = join7(tmpdir(), `kandown-${taskId}-context.md`);
-  writeFileSync3(contextFile, `${systemPrompt}
+  try {
+    writeFileSync3(contextFile, `${systemPrompt}
 
 ---
 
 ${taskPrompt}`, "utf8");
+  } catch (e) {
+    console.warn(`[kandown] Failed to write context file (${e.message}); launching anyway.`);
+  }
   const launchOpts = { systemPrompt, taskPrompt, kandownDir, taskId };
   const [binary, ...args] = agentDef.buildCommand(launchOpts);
   if (!binary) {
+    rollbackTaskStatus(kandownDir, taskId, originalStatus);
     throw new Error(`Agent ${agentId} returned an empty command`);
   }
   if (isInTmux()) {
@@ -56818,24 +56871,47 @@ ${taskPrompt}`, "utf8");
       `KANDOWN_TASK_ID=${shellescape(taskId)}`,
       `KANDOWN_DIR=${shellescape(kandownDir)}`
     ].join(" ");
-    execSync(`tmux split-window -h -p 50 ${shellescape(`env ${envPrefix} ${shellCmd}`)}`, {
-      stdio: "inherit"
-    });
+    try {
+      execSync(`tmux split-window -h -p 50 ${shellescape(`env ${envPrefix} ${shellCmd}`)}`, {
+        stdio: "inherit"
+      });
+    } catch (e) {
+      rollbackTaskStatus(kandownDir, taskId, originalStatus);
+      throw new Error(`Failed to open agent pane in tmux: ${e.message}. Is tmux installed and the session valid?`);
+    }
   } else {
-    onBeforeExec?.();
-    const child = spawn2(binary, args, {
-      stdio: "inherit",
-      env: {
-        ...process.env,
-        // 📖 Expose the context file path so agents that support env vars can use it
-        KANDOWN_CONTEXT_FILE: contextFile,
-        KANDOWN_TASK_ID: taskId,
-        KANDOWN_DIR: kandownDir
-      }
-    });
-    child.on("exit", (code) => {
-      process.exit(code ?? 0);
-    });
+    try {
+      onBeforeExec?.();
+      const child = spawn2(binary, args, {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          // 📖 Expose the context file path so agents that support env vars can use it
+          KANDOWN_CONTEXT_FILE: contextFile,
+          KANDOWN_TASK_ID: taskId,
+          KANDOWN_DIR: kandownDir
+        }
+      });
+      child.on("error", (e) => {
+        rollbackTaskStatus(kandownDir, taskId, originalStatus);
+        console.error(`[kandown] Failed to launch ${agentDef.name}: ${e.message}`);
+        process.exit(1);
+      });
+      child.on("exit", (code) => {
+        if (code === 0) process.exit(0);
+        if (code === null) return;
+        process.exit(code);
+      });
+    } catch (e) {
+      rollbackTaskStatus(kandownDir, taskId, originalStatus);
+      throw new Error(`Failed to launch ${agentDef.name}: ${e.message}`);
+    }
+  }
+}
+function rollbackTaskStatus(kandownDir, taskId, originalStatus) {
+  const ok = moveTaskToColumn(kandownDir, taskId, originalStatus);
+  if (!ok) {
+    console.warn(`[kandown] Could not roll back task ${taskId} to ${originalStatus} \u2014 update it manually.`);
   }
 }
 function buildShellCmd(binary, args) {
@@ -56895,6 +56971,7 @@ function AgentPicker({ agents, taskId, onSelect, onCancel }) {
             /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: "yellow", children: taskId })
           ] })
         ] }),
+        agents.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: "yellow", children: "No agents installed. Install claude, codex, or opencode." }),
         agents.map((agent, idx) => {
           const isFocused = idx === cursor;
           const numHint = idx < 9 ? `${idx + 1} ` : "  ";
@@ -57272,6 +57349,7 @@ function Board({ kandownDir, version }) {
   const [rowIndex, setRowIndex] = (0, import_react37.useState)(0);
   const [mode, setMode] = (0, import_react37.useState)("browse");
   const [statusMsg, setStatusMsg] = (0, import_react37.useState)("");
+  const [boardError, setBoardError] = (0, import_react37.useState)(null);
   const [detailTask, setDetailTask] = (0, import_react37.useState)(null);
   const [detailTaskId, setDetailTaskId] = (0, import_react37.useState)("");
   const [detailScroll, setDetailScroll] = (0, import_react37.useState)(0);
@@ -57320,43 +57398,49 @@ function Board({ kandownDir, version }) {
     if (!task) return null;
     return { taskId: task.id, colIndex: clickedCol, rowIndex: taskIdx, startX: x, startY: y };
   }, [board, columnAtX]);
+  const loadBoardInto = (0, import_react37.useCallback)(() => {
+    try {
+      const loaded = readBoard(kandownDir);
+      setBoard(loaded);
+      updateLayout(loaded);
+      setBoardError(null);
+      return loaded;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      setBoardError(`Failed to load board: ${msg}`);
+      setStatusMsg("");
+      return null;
+    }
+  }, [kandownDir, updateLayout]);
   (0, import_react37.useEffect)(() => {
-    const loaded = readBoard(kandownDir);
-    setBoard(loaded);
-    updateLayout(loaded);
+    loadBoardInto();
     setInstalledAgents(detectInstalledAgents());
-  }, [kandownDir, updateLayout]);
+  }, [kandownDir, loadBoardInto]);
   (0, import_react37.useEffect)(() => {
     const watcher = createWatcher();
     watcher.on("taskChanged", () => {
-      const loaded = readBoard(kandownDir);
-      setBoard(loaded);
-      updateLayout(loaded);
+      loadBoardInto();
     });
     watcher.on("newTaskDetected", (taskId) => {
-      const loaded = readBoard(kandownDir);
-      setBoard(loaded);
-      updateLayout(loaded);
+      loadBoardInto();
       setStatusMsg(`New task: ${taskId}`);
       setTimeout(() => setStatusMsg(""), 2e3);
     });
     watcher.on("configChanged", () => {
-      const loaded = readBoard(kandownDir);
-      setBoard(loaded);
-      updateLayout(loaded);
+      loadBoardInto();
     });
     watcher.start(kandownDir);
     return () => {
       watcher.stop();
     };
-  }, [kandownDir, updateLayout]);
+  }, [kandownDir, loadBoardInto]);
   const reloadBoard = (0, import_react37.useCallback)(() => {
-    const loaded = readBoard(kandownDir);
-    setBoard(loaded);
-    updateLayout(loaded);
-    setStatusMsg("Board reloaded");
-    setTimeout(() => setStatusMsg(""), 1500);
-  }, [kandownDir, updateLayout]);
+    const loaded = loadBoardInto();
+    if (loaded) {
+      setStatusMsg("Board reloaded");
+      setTimeout(() => setStatusMsg(""), 1500);
+    }
+  }, [loadBoardInto]);
   const refreshDaemonStatus = (0, import_react37.useCallback)(async () => {
     const next = await getDaemonStatus(kandownDir);
     setDaemonStatus(next);
@@ -57455,11 +57539,16 @@ function Board({ kandownDir, version }) {
     return col.tasks[Math.min(rowIndex, col.tasks.length - 1)] ?? null;
   }, [board, colIndex, rowIndex]);
   const openDetail = (0, import_react37.useCallback)((taskId) => {
-    const task = readTask(kandownDir, taskId);
-    setDetailTask(task);
-    setDetailTaskId(taskId);
-    setDetailScroll(0);
-    setMode("detail");
+    try {
+      const task = readTask(kandownDir, taskId);
+      setDetailTask(task);
+      setDetailTaskId(taskId);
+      setDetailScroll(0);
+      setMode("detail");
+    } catch (e) {
+      setStatusMsg(`Error opening task: ${e instanceof Error ? e.message : String(e)}`);
+      setTimeout(() => setStatusMsg(""), 4e3);
+    }
   }, [kandownDir]);
   const closeContextMenu = (0, import_react37.useCallback)(() => {
     setCtxMenuRow(-1);
@@ -57594,9 +57683,7 @@ function Board({ kandownDir, version }) {
             return;
           }
           moveTaskToColumn(kandownDir, moveTaskId, targetColName);
-          const loaded = readBoard(kandownDir);
-          setBoard(loaded);
-          updateLayout(loaded);
+          loadBoardInto();
           setStatusMsg(`Moved ${moveTaskId} \u2192 ${targetColName}`);
           setTimeout(() => setStatusMsg(""), 2e3);
         }
@@ -57608,7 +57695,7 @@ function Board({ kandownDir, version }) {
       setMode("browse");
       return;
     }
-  }, [board, mode, colIndex, rowIndex, ctxMenuRow, moveTaskId, kandownDir, updateLayout, openDetail, closeContextMenu]);
+  }, [board, mode, colIndex, rowIndex, ctxMenuRow, moveTaskId, kandownDir, updateLayout, openDetail, closeContextMenu, loadBoardInto]);
   const handleMouseEvent = (0, import_react37.useCallback)((mouse) => {
     if (!board) return;
     if (mode === "browse") {
@@ -57670,11 +57757,9 @@ function Board({ kandownDir, version }) {
               return;
             }
             moveTaskToColumn(kandownDir, taskDrag.taskId, targetColName);
-            const loaded = readBoard(kandownDir);
-            setBoard(loaded);
-            updateLayout(loaded);
+            const loaded = loadBoardInto();
             setColIndex(targetCol);
-            const movedRow = loaded.columns[targetCol]?.tasks.findIndex((task) => task.id === taskDrag.taskId) ?? 0;
+            const movedRow = loaded?.columns[targetCol]?.tasks.findIndex((task) => task.id === taskDrag.taskId) ?? 0;
             setRowIndex(Math.max(0, movedRow));
             setStatusMsg(`Dragged ${taskDrag.taskId} \u2192 ${targetColName}`);
             setTimeout(() => setStatusMsg(""), 2e3);
@@ -57836,9 +57921,7 @@ function Board({ kandownDir, version }) {
             return;
           }
           moveTaskToColumn(kandownDir, moveTaskId, name);
-          const loaded = readBoard(kandownDir);
-          setBoard(loaded);
-          updateLayout(loaded);
+          loadBoardInto();
           setStatusMsg(`Moved ${moveTaskId} \u2192 ${name}`);
           setTimeout(() => setStatusMsg(""), 2e3);
         }
@@ -57871,6 +57954,13 @@ function Board({ kandownDir, version }) {
       }
     }
   });
+  if (boardError) {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(Box_default, { flexDirection: "column", padding: 2, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Text, { color: "red", bold: true, children: "Error loading board" }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Text, { color: "red", children: boardError }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Text, { color: "gray", children: "Press 'r' to retry or 'q' to quit." })
+    ] });
+  }
   if (!board) {
     return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Box_default, { padding: 2, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Text, { color: "gray", children: "Loading board\u2026" }) });
   }