npm - @citadel-labs/beads-ui - Versions diffs - 2.4.0 → 2.5.0 - Mend

@citadel-labs/beads-ui 2.4.0 → 2.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (97) hide show

package/server/dist/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Beads Board</title>
-    <script type="module" crossorigin src="/assets/index-DOFQi_E1.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DeppoR8O.css">
+    <script type="module" crossorigin src="/assets/index-G6bcoKqz.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Dm1YZe0A.css">
   </head>
   <body>
     <div id="root"></div>

package/server/handlers.js CHANGED Viewed

@@ -6,6 +6,8 @@ const path = require('node:path');
 // MIME types
 // ---------------------------------------------------------------------------
+const FILES_IGNORED = new Set(['.git']);
 const MIME_TYPES = {
   '.html': 'text/html',
   '.js': 'application/javascript',
@@ -68,6 +70,16 @@ function normalizeIssue(issue) {
 // JSON response helpers
 // ---------------------------------------------------------------------------
+function readJsonBody(req) {
+  return new Promise((resolve) => {
+    let data = '';
+    req.on('data', chunk => { data += chunk; });
+    req.on('end', () => {
+      try { resolve(JSON.parse(data)); } catch { resolve(null); }
+    });
+  });
+}
 function jsonResponse(res, data, status = 200) {
   res.writeHead(status, {
     'Content-Type': 'application/json',
@@ -92,7 +104,7 @@ function createRequestHandler(projectDir, distDir) {
     if (req.method === 'OPTIONS') {
       res.writeHead(204, {
         'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Methods': 'GET, OPTIONS',
+        'Access-Control-Allow-Methods': 'GET, PATCH, OPTIONS',
         'Access-Control-Allow-Headers': 'Content-Type',
       });
       res.end();
@@ -109,6 +121,19 @@ function createRequestHandler(projectDir, distDir) {
       } else if (pathname === '/api/blocked') {
         const blocked = await execBd(['blocked'], projectDir);
         jsonResponse(res, Array.isArray(blocked) ? blocked.map(normalizeIssue) : blocked);
+      } else if (pathname.startsWith('/api/issue/') && req.method === 'PATCH') {
+        const id = pathname.split('/api/issue/')[1];
+        if (!id || !/^[\w.\-]+$/.test(id)) {
+          errorResponse(res, 'Invalid issue ID', 400);
+          return;
+        }
+        const body = await readJsonBody(req);
+        if (!body || typeof body.description !== 'string') {
+          errorResponse(res, 'Missing required field: description', 400);
+          return;
+        }
+        await execCmd('bd', ['update', id, '--description', body.description], projectDir);
+        jsonResponse(res, { ok: true });
       } else if (pathname.startsWith('/api/issue/')) {
         const id = pathname.split('/api/issue/')[1];
         if (!id || !/^[\w.\-]+$/.test(id)) {
@@ -181,32 +206,63 @@ function createRequestHandler(projectDir, distDir) {
           jsonResponse(res, []);
         }
       } else if (pathname === '/api/git-status') {
-        const stdout = await execGit(['status', '--porcelain'], projectDir);
-        const files = stdout.replace(/\n$/, '').split('\n').filter(Boolean).map(line => {
-          const match = line.match(/^(..)[ ](.+)$/);
-          if (!match) return { status: '?', path: line.trim() };
-          return { status: match[1].trim(), path: match[2] };
-        });
-        jsonResponse(res, files);
+        const branch = parsedUrl.searchParams.get('branch') || '';
+        if (branch && !/^[\w\/.@{}-]+$/.test(branch)) {
+          errorResponse(res, 'Invalid branch name', 400);
+          return;
+        }
+        if (branch) {
+          // Show what changed between the selected branch and the working tree
+          // (i.e. "what would change if you merged this branch into your working state")
+          const stdout = await execGit(['diff', '--name-status', branch], projectDir);
+          const files = stdout.replace(/\n$/, '').split('\n').filter(Boolean).map(line => {
+            const match = line.match(/^([A-Z])\t(.+)$/);
+            if (!match) return { status: '?', path: line.trim() };
+            return { status: match[1], path: match[2] };
+          });
+          jsonResponse(res, files);
+        } else {
+          const stdout = await execGit(['status', '--porcelain'], projectDir);
+          const files = stdout.replace(/\n$/, '').split('\n').filter(Boolean).map(line => {
+            const match = line.match(/^(..)[ ](.+)$/);
+            if (!match) return { status: '?', path: line.trim() };
+            return { status: match[1].trim(), path: match[2] };
+          });
+          jsonResponse(res, files);
+        }
       } else if (pathname === '/api/git-diff') {
         const file = parsedUrl.searchParams.get('file') || '';
+        const branch = parsedUrl.searchParams.get('branch') || '';
         if (!file || /[;&|`$]/.test(file)) {
           errorResponse(res, 'Invalid file path', 400);
           return;
         }
+        if (branch && !/^[\w\/.@{}-]+$/.test(branch)) {
+          errorResponse(res, 'Invalid branch name', 400);
+          return;
+        }
         try {
-          // Try staged + unstaged diff first, fall back to untracked file content
           let diff;
-          try {
-            diff = await execGit(['diff', 'HEAD', '--', file], projectDir);
-            if (!diff.trim()) {
-              diff = await execGit(['diff', '--', file], projectDir);
+          if (branch) {
+            // Diff working tree against the specified branch for this file
+            try {
+              diff = await execGit(['diff', branch, '--', file], projectDir);
+            } catch {
+              diff = '';
+            }
+          } else {
+            // Try staged + unstaged diff first, fall back to untracked file content
+            try {
+              diff = await execGit(['diff', 'HEAD', '--', file], projectDir);
+              if (!diff.trim()) {
+                diff = await execGit(['diff', '--', file], projectDir);
+              }
+            } catch {
+              diff = '';
             }
-          } catch {
-            diff = '';
           }
-          if (!diff.trim()) {
-            // Untracked file — show full content as addition
+          if (!diff.trim() && !branch) {
+            // Untracked file — show full content as addition (only for current branch)
             try {
               const content = fs.readFileSync(
                 path.join(projectDir, file), 'utf8'
@@ -223,14 +279,13 @@ function createRequestHandler(projectDir, distDir) {
         }
       } else if (pathname === '/api/file-content') {
         const relPath = parsedUrl.searchParams.get('path') || '';
+        const branch = parsedUrl.searchParams.get('branch') || '';
         if (!relPath || relPath.includes('..') || path.isAbsolute(relPath)) {
           errorResponse(res, 'Invalid path', 400);
           return;
         }
-        const targetFile = path.join(projectDir, relPath);
-        const resolved = path.resolve(targetFile);
-        if (!resolved.startsWith(path.resolve(projectDir))) {
-          errorResponse(res, 'Invalid path', 400);
+        if (branch && !/^[\w\/.@{}-]+$/.test(branch)) {
+          errorResponse(res, 'Invalid branch name', 400);
           return;
         }
         const EXT_TO_LANG = {
@@ -257,56 +312,111 @@ function createRequestHandler(projectDir, distDir) {
           '.mermaid': 'mermaid', '.mmd': 'mermaid',
           '.kusto': 'kusto', '.kql': 'kusto',
         };
-        try {
-          const content = fs.readFileSync(resolved, 'utf8');
-          const ext = path.extname(relPath).toLowerCase();
-          const language = EXT_TO_LANG[ext] || 'text';
-          jsonResponse(res, { path: relPath, content, language });
-        } catch (err) {
-          if (err.code === 'ENOENT' || err.code === 'EISDIR') {
-            errorResponse(res, 'File not found', 404);
-          } else {
+        const ext = path.extname(relPath).toLowerCase();
+        const language = EXT_TO_LANG[ext] || 'text';
+        if (branch) {
+          // git show sandboxes to the repo; relPath already validated against .. and absolute
+          try {
+            const content = await execGit(['show', `${branch}:${relPath}`], projectDir);
+            jsonResponse(res, { path: relPath, content, language });
+          } catch (err) {
             errorResponse(res, err.message);
           }
+        } else {
+          const targetFile = path.join(projectDir, relPath);
+          const resolved = path.resolve(targetFile);
+          if (!resolved.startsWith(path.resolve(projectDir))) {
+            errorResponse(res, 'Invalid path', 400);
+            return;
+          }
+          try {
+            const content = fs.readFileSync(resolved, 'utf8');
+            jsonResponse(res, { path: relPath, content, language });
+          } catch (err) {
+            if (err.code === 'ENOENT' || err.code === 'EISDIR') {
+              errorResponse(res, 'File not found', 404);
+            } else {
+              errorResponse(res, err.message);
+            }
+          }
         }
       } else if (pathname === '/api/files') {
         const relPath = parsedUrl.searchParams.get('path') || '';
+        const branch = parsedUrl.searchParams.get('branch') || '';
         // Block path traversal
         if (relPath.includes('..') || path.isAbsolute(relPath)) {
           errorResponse(res, 'Invalid path', 400);
           return;
         }
-        const targetDir = path.join(projectDir, relPath);
-        const resolved = path.resolve(targetDir);
-        if (!resolved.startsWith(path.resolve(projectDir))) {
-          errorResponse(res, 'Invalid path', 400);
+        if (branch && !/^[\w\/.@{}-]+$/.test(branch)) {
+          errorResponse(res, 'Invalid branch name', 400);
           return;
         }
-        const IGNORED = new Set(['.git', 'node_modules', '.beads', '.claude', '.playwright-mcp', 'coverage', '.vscode']);
-        try {
-          const entries = fs.readdirSync(targetDir, { withFileTypes: true });
-          const results = [];
-          for (const entry of entries) {
-            // Skip hidden files/dirs and common ignored directories
-            if (entry.name.startsWith('.') || IGNORED.has(entry.name)) continue;
-            const entryPath = relPath ? `${relPath}/${entry.name}` : entry.name;
-            results.push({
-              name: entry.name,
-              type: entry.isDirectory() ? 'directory' : 'file',
-              path: entryPath,
+        if (branch) {
+          // Use git ls-tree to list files from the specified branch
+          try {
+            const treeRef = relPath ? `${branch}:${relPath}` : branch;
+            const stdout = await execGit(['ls-tree', treeRef], projectDir);
+            const results = [];
+            for (const line of stdout.trim().split('\n').filter(Boolean)) {
+              // Format: <mode> <type> <hash>\t<name>
+              const match = line.match(/^\d+\s+(blob|tree)\s+[a-f0-9]+\t(.+)$/);
+              if (!match) continue;
+              const name = match[2];
+              if (FILES_IGNORED.has(name)) continue;
+              const entryPath = relPath ? `${relPath}/${name}` : name;
+              results.push({
+                name,
+                type: match[1] === 'tree' ? 'directory' : 'file',
+                path: entryPath,
+              });
+            }
+            results.sort((a, b) => {
+              if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
+              return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
             });
+            jsonResponse(res, results);
+          } catch (err) {
+            // git ls-tree fails when branch or path doesn't exist
+            const msg = err.message || '';
+            if (msg.includes('Not a valid object') || msg.includes('does not exist')) {
+              errorResponse(res, 'Directory not found', 404);
+            } else {
+              errorResponse(res, msg);
+            }
           }
-          // Sort: directories first, then alphabetically within each group
-          results.sort((a, b) => {
-            if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
-            return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
-          });
-          jsonResponse(res, results);
-        } catch (err) {
-          if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
-            errorResponse(res, 'Directory not found', 404);
-          } else {
-            errorResponse(res, err.message);
+        } else {
+          const targetDir = path.join(projectDir, relPath);
+          const resolved = path.resolve(targetDir);
+          if (!resolved.startsWith(path.resolve(projectDir))) {
+            errorResponse(res, 'Invalid path', 400);
+            return;
+          }
+          try {
+            const entries = fs.readdirSync(targetDir, { withFileTypes: true });
+            const results = [];
+            for (const entry of entries) {
+              // Skip ignored dirs (.git, node_modules, coverage)
+              if (FILES_IGNORED.has(entry.name)) continue;
+              const entryPath = relPath ? `${relPath}/${entry.name}` : entry.name;
+              results.push({
+                name: entry.name,
+                type: entry.isDirectory() ? 'directory' : 'file',
+                path: entryPath,
+              });
+            }
+            // Sort: directories first, then alphabetically within each group
+            results.sort((a, b) => {
+              if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
+              return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
+            });
+            jsonResponse(res, results);
+          } catch (err) {
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
+              errorResponse(res, 'Directory not found', 404);
+            } else {
+              errorResponse(res, err.message);
+            }
           }
         }
       } else if (pathname === '/api/branches') {

package/server/index.js CHANGED Viewed

@@ -1,8 +1,8 @@
 const http = require('node:http');
-const fs = require('node:fs');
 const path = require('node:path');
 const { attachTerminal, cleanupAllPtys } = require('./terminal.js');
 const { createRequestHandler } = require('./handlers.js');
+const { createPidfileManager } = require('./pidfile.js');
 const DEFAULT_PORT = 8377;
 const DIST_DIR = path.join(__dirname, 'dist');
@@ -14,27 +14,7 @@ const PROJECT_DIR = process.argv[2] || process.cwd();
 // Pidfile management
 // ---------------------------------------------------------------------------
-const PIDFILE = path.join(PROJECT_DIR, '.beads-board.pid');
-function writePidfile(port) {
-  fs.writeFileSync(PIDFILE, JSON.stringify({ pid: process.pid, port }));
-}
-function removePidfile() {
-  try { fs.unlinkSync(PIDFILE); } catch {}
-}
-function getRunningInstance() {
-  try {
-    const data = JSON.parse(fs.readFileSync(PIDFILE, 'utf8'));
-    // Check if process is still running
-    process.kill(data.pid, 0);
-    return data;
-  } catch {
-    removePidfile();
-    return null;
-  }
-}
+const pidfile = createPidfileManager(PROJECT_DIR);
 // ---------------------------------------------------------------------------
 // Port detection
@@ -69,7 +49,7 @@ if (terminalEnabled) {
 }
 async function start() {
-  const existing = getRunningInstance();
+  const existing = pidfile.getRunningInstance();
   if (existing) {
     console.log(`beads-board already running at http://localhost:${existing.port}`);
     process.exit(0);
@@ -77,12 +57,11 @@ async function start() {
   const port = await findAvailablePort(parseInt(process.env.PORT || DEFAULT_PORT, 10));
   server.listen(port, () => {
-    writePidfile(port);
+    pidfile.writePidfile(port);
     console.log(`beads-board server running at http://localhost:${port}`);
   });
 }
-process.on('SIGTERM', () => { cleanupAllPtys(); removePidfile(); process.exit(0); });
-process.on('SIGINT', () => { cleanupAllPtys(); removePidfile(); process.exit(0); });
+pidfile.registerCleanupHandlers(cleanupAllPtys);
 start();

package/server/pidfile.js ADDED Viewed

@@ -0,0 +1,71 @@
+const fs = require('node:fs');
+const path = require('node:path');
+/**
+ * Creates a pidfile manager for the given project directory.
+ * @param {string} projectDir - The project directory where .beads-board.pid lives.
+ * @returns {object} Pidfile management functions.
+ */
+function createPidfileManager(projectDir) {
+  const PIDFILE = path.join(projectDir, '.beads-board.pid');
+  function writePidfile(port) {
+    fs.writeFileSync(PIDFILE, JSON.stringify({ pid: process.pid, port }));
+  }
+  function removePidfile() {
+    try { fs.unlinkSync(PIDFILE); } catch {}
+  }
+  function getRunningInstance() {
+    try {
+      const data = JSON.parse(fs.readFileSync(PIDFILE, 'utf8'));
+      if (!data.pid) {
+        removePidfile();
+        return null;
+      }
+      // Check if process is still running (signal 0 throws if not running)
+      process.kill(data.pid, 0);
+      return data;
+    } catch {
+      removePidfile();
+      return null;
+    }
+  }
+  /**
+   * Registers process-level handlers to ensure the pidfile is removed on exit.
+   * Handles SIGTERM, SIGINT, uncaughtException, and unhandledRejection.
+   * @param {function} [onBeforeExit] - Optional callback to run before exiting (e.g., PTY cleanup).
+   */
+  function registerCleanupHandlers(onBeforeExit) {
+    function cleanup(exitCode) {
+      if (onBeforeExit) {
+        try { onBeforeExit(); } catch {}
+      }
+      removePidfile();
+      process.exit(exitCode || 0);
+    }
+    process.on('SIGTERM', () => cleanup(0));
+    process.on('SIGINT', () => cleanup(0));
+    process.on('uncaughtException', (err) => {
+      console.error('Uncaught exception:', err);
+      cleanup(1);
+    });
+    process.on('unhandledRejection', (reason) => {
+      console.error('Unhandled rejection:', reason);
+      cleanup(1);
+    });
+  }
+  return {
+    writePidfile,
+    removePidfile,
+    getRunningInstance,
+    registerCleanupHandlers,
+    get pidfilePath() { return PIDFILE; },
+  };
+}
+module.exports = { createPidfileManager };

package/server/terminal-sessions.js ADDED Viewed

@@ -0,0 +1,149 @@
+const { randomUUID } = require('node:crypto');
+const MAX_SCROLLBACK_CHARS = 100 * 1024; // ~100KB for ASCII terminal output
+const MAX_SESSIONS = 10;
+const DISCONNECT_TIMEOUT_MS = 60 * 1000; // 60 seconds
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/** @type {Map<string, Session>} */
+const sessions = new Map();
+/**
+ * @typedef {Object} Session
+ * @property {string} id
+ * @property {import('node-pty').IPty|null} pty
+ * @property {string[]} scrollback - ring buffer of output chunks
+ * @property {number} scrollbackChars - total character count
+ * @property {number} cols
+ * @property {number} rows
+ * @property {NodeJS.Timeout|null} disconnectTimer
+ * @property {WebSocket|null} ws
+ * @property {boolean} replaying
+ * @property {string[]} outputQueue
+ */
+/**
+ * Create a new terminal session.
+ * @param {{ cols: number, rows: number, evictIdle?: boolean }} opts
+ * @returns {Session}
+ */
+function createSession({ cols, rows, evictIdle = false }) {
+  if (sessions.size >= MAX_SESSIONS) {
+    if (evictIdle) {
+      // Find oldest idle session (no ws connection)
+      let oldestId = null;
+      for (const [id, s] of sessions) {
+        if (!s.ws) {
+          oldestId = id;
+          break; // first inserted = oldest (Map preserves insertion order)
+        }
+      }
+      if (oldestId) {
+        const old = sessions.get(oldestId);
+        if (old.disconnectTimer) clearTimeout(old.disconnectTimer);
+        if (old.pty) try { old.pty.kill(); } catch {}
+        sessions.delete(oldestId);
+      } else {
+        throw new Error('Session limit reached: all sessions are active');
+      }
+    } else {
+      throw new Error('Session limit reached');
+    }
+  }
+  const id = randomUUID();
+  /** @type {Session} */
+  const session = {
+    id,
+    pty: null,
+    scrollback: [],
+    scrollbackChars: 0,
+    cols,
+    rows,
+    disconnectTimer: null,
+    ws: null,
+    replaying: false,
+    outputQueue: [],
+  };
+  sessions.set(id, session);
+  return session;
+}
+/**
+ * Validate that a string is a UUID format.
+ * @param {string} id
+ * @returns {boolean}
+ */
+function isValidSessionId(id) {
+  return UUID_RE.test(id);
+}
+/**
+ * Get a session by ID.
+ * @param {string} id
+ * @returns {Session|undefined}
+ */
+function getSession(id) {
+  return sessions.get(id);
+}
+/**
+ * Delete a session by ID.
+ * @param {string} id
+ */
+function deleteSession(id) {
+  const session = sessions.get(id);
+  if (session) {
+    if (session.disconnectTimer) clearTimeout(session.disconnectTimer);
+    sessions.delete(id);
+  }
+}
+/**
+ * Append data to a session's scrollback ring buffer.
+ * Trims from front when exceeding MAX_SCROLLBACK_CHARS.
+ * @param {Session} session
+ * @param {string} data
+ */
+function appendScrollback(session, data) {
+  session.scrollback.push(data);
+  session.scrollbackChars += data.length;
+  // Trim from front if over limit
+  while (session.scrollbackChars > MAX_SCROLLBACK_CHARS && session.scrollback.length > 1) {
+    const removed = session.scrollback.shift();
+    session.scrollbackChars -= removed.length;
+  }
+}
+/**
+ * Get the count of active sessions.
+ * @returns {number}
+ */
+function getSessionCount() {
+  return sessions.size;
+}
+/**
+ * Clear all sessions (for testing/cleanup).
+ */
+function clearAllSessions() {
+  for (const [, session] of sessions) {
+    if (session.disconnectTimer) clearTimeout(session.disconnectTimer);
+    if (session.pty) try { session.pty.kill(); } catch {}
+  }
+  sessions.clear();
+}
+module.exports = {
+  createSession,
+  getSession,
+  deleteSession,
+  isValidSessionId,
+  appendScrollback,
+  getSessionCount,
+  clearAllSessions,
+  MAX_SCROLLBACK_CHARS,
+  MAX_SESSIONS,
+  DISCONNECT_TIMEOUT_MS,
+};