beads-ui 0.11.3 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beads-ui",
-  "version": "0.11.3",
+  "version": "0.12.1",
   "description": "Local UI for Beads — Collaborate on issues with your coding agent.",
   "keywords": [
     "agent",

package/server/app.js

@@ -4,7 +4,10 @@
 import express from 'express';
 import fs from 'node:fs';
 import path from 'node:path';
-import { registerWorkspace } from './registry-watcher.js';
+import {
+  getAvailableWorkspaces,
+  registerWorkspace
+} from './registry-watcher.js';
 
 /**
  * Create and configure the Express application.
@@ -51,6 +54,12 @@ export function createApp(config) {
     res.status(200).json({ ok: true, registered: workspace_path });
   });
 
+  // List all known workspaces (file-based registry + in-memory)
+  app.get('/api/workspaces', (_req, res) => {
+    const workspaces = getAvailableWorkspaces();
+    res.status(200).json({ ok: true, workspaces });
+  });
+
   if (
     !fs.statSync(path.resolve(config.app_dir, 'main.bundle.js'), {
       throwIfNoEntry: false

package/server/cli/commands.js

@@ -1,6 +1,8 @@
 import { getConfig } from '../config.js';
 import { resolveWorkspaceDatabase } from '../db.js';
 import {
+  detectListeningPort,
+  findAvailablePort,
   isProcessRunning,
   printServerUrl,
   readPidFile,
@@ -8,7 +10,14 @@ import {
   startDaemon,
   terminateProcess
 } from './daemon.js';
-import { openUrl, registerWorkspaceWithServer, waitForServer } from './open.js';
+import {
+  fetchWorkspacesFromServer,
+  openUrl,
+  registerWorkspaceWithServer,
+  waitForServer
+} from './open.js';
+
+const RESTART_SERVER_READY_MS = 400;
 
 const STARTUP_SETTLE_MS = 200;
 const REGISTER_RETRY_ATTEMPTS = 5;
@@ -45,6 +54,7 @@ export async function handleStart(options) {
       console.log('Workspace registered: %s', cwd);
     }
     console.warn('Server is already running.');
+    console.log('beads ui   listening on %s', url);
     if (should_open) {
       await openUrl(url);
     }
@@ -55,12 +65,51 @@ export async function handleStart(options) {
     removePidFile();
   }
 
+  const { port: config_port, host: config_host } = getConfig();
+
+  // When the user did not pass an explicit --port, check whether the default
+  // port is already in use. If something is already listening, try to register
+  // with it first — it may be an existing bdui instance we can reuse.
+  // Only auto-increment to the next port if registration fails.
+  let effective_port = options?.port;
+  if (!effective_port) {
+    const available = await findAvailablePort(config_port, config_host);
+    if (available === null) {
+      console.error(
+        'No available port found (tried %d–%d).',
+        config_port,
+        config_port + 9
+      );
+      return 1;
+    }
+    if (available !== config_port) {
+      // Default port is busy — try to register with whatever is there.
+      const existing_url = `http://${config_host}:${config_port}`;
+      const registered = await registerCurrentWorkspace(existing_url, cwd);
+      if (registered) {
+        console.log('Workspace registered with existing server: %s', cwd);
+        console.log('beads ui   listening on %s', existing_url);
+        if (should_open) {
+          await openUrl(existing_url);
+        }
+        return 0;
+      }
+      // Not a bdui instance — auto-increment to the next available port.
+      console.log('Port %d in use, using %d instead.', config_port, available);
+      effective_port = available;
+    }
+  }
+
+  // Set PORT env so getConfig() returns the correct URL for registration
+  if (effective_port) {
+    process.env.PORT = String(effective_port);
+  }
   const { url } = getConfig();
 
   const started = startDaemon({
     is_debug: options?.is_debug,
     host: options?.host,
-    port: options?.port
+    port: effective_port
   });
   if (started && started.pid > 0) {
     // Give the spawned daemon a brief moment to fail fast (for example EADDRINUSE).
@@ -77,6 +126,7 @@ export async function handleStart(options) {
           'Daemon exited early; registered workspace with existing server: %s',
           cwd
         );
+        console.log('beads ui   listening on %s', url);
         return 0;
       }
       return 1;
@@ -179,25 +229,60 @@ export async function handleStop() {
   return 1;
 }
 
-/**
- * Handle `restart` command: stop (ignore not-running) then start.
- *
- * @returns {Promise<number>} Exit code (0 on success)
- */
 /**
  * Handle `restart` command: stop (ignore not-running) then start.
  * Accepts the same options as `handleStart` and passes them through,
  * so restart only opens a browser when `open` is explicitly true.
  *
- * @param {{ open?: boolean }} [options]
+ * When the user does not pass explicit `--port`, the restart detects the
+ * port the running daemon is listening on and reuses it.
+ *
+ * @param {{ open?: boolean, host?: string, port?: number }} [options]
  * @returns {Promise<number>}
  */
 export async function handleRestart(options) {
+  // Capture state from the running server before stopping it.
+  let detected_port = null;
+  /** @type {Array<{ path: string, database: string }>} */
+  let saved_workspaces = [];
+  const existing_pid = readPidFile();
+  if (existing_pid && isProcessRunning(existing_pid)) {
+    detected_port = detectListeningPort(existing_pid);
+
+    const { url } = getConfig();
+    saved_workspaces = await fetchWorkspacesFromServer(url);
+  }
+
   const stop_code = await handleStop();
   // 0 = stopped, 2 = not running; both are acceptable to proceed
   if (stop_code !== 0 && stop_code !== 2) {
     return 1;
   }
-  const start_code = await handleStart(options);
-  return start_code === 0 ? 0 : 1;
+
+  // Reuse detected port unless the user explicitly passed one.
+  const merged_options = { ...options };
+  if (!merged_options.port && detected_port) {
+    merged_options.port = detected_port;
+  }
+
+  const start_code = await handleStart(merged_options);
+  if (start_code !== 0) {
+    return 1;
+  }
+
+  // Re-register workspaces from the previous server.
+  if (saved_workspaces.length > 0) {
+    const { url } = getConfig();
+    await waitForServer(url, RESTART_SERVER_READY_MS);
+    for (const ws of saved_workspaces) {
+      if (ws.path && ws.database) {
+        await registerWorkspaceWithServer(url, {
+          path: ws.path,
+          database: ws.database
+        });
+      }
+    }
+  }
+
+  return 0;
 }

package/server/cli/daemon.js

@@ -1,8 +1,9 @@
 /**
  * @import { SpawnOptions } from 'node:child_process'
  */
-import { spawn } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import fs from 'node:fs';
+import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -256,6 +257,74 @@ function sleep(ms) {
   });
 }
 
+/**
+ * Detect the TCP port a process is listening on by inspecting OS state.
+ * Returns the first LISTEN port found for the given PID, or null.
+ *
+ * @param {number} pid
+ * @returns {number | null}
+ */
+export function detectListeningPort(pid) {
+  try {
+    const output = execFileSync(
+      'lsof',
+      ['-iTCP', '-sTCP:LISTEN', '-a', '-p', String(pid), '-Fn', '-P'],
+      { encoding: 'utf8', timeout: 3000 }
+    );
+
+    // lsof -Fn outputs lines like "n*:3000" or "n127.0.0.1:4000"
+    for (const line of output.split('\n')) {
+      if (line.startsWith('n')) {
+        const colon_index = line.lastIndexOf(':');
+        if (colon_index >= 0) {
+          const port_value = Number.parseInt(line.slice(colon_index + 1), 10);
+          if (Number.isFinite(port_value) && port_value > 0) {
+            return port_value;
+          }
+        }
+      }
+    }
+  } catch {
+    // lsof not available or process gone — fall through
+  }
+  return null;
+}
+
+/**
+ * Check whether a TCP port is available on the given host.
+ *
+ * @param {number} port
+ * @param {string} host
+ * @returns {Promise<boolean>}
+ */
+export function isPortAvailable(port, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.listen(port, host, () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+/**
+ * Starting from `port`, find the first available port on `host`.
+ * Tries up to `max_attempts` consecutive ports.
+ *
+ * @param {number} port
+ * @param {string} host
+ * @param {number} [max_attempts]
+ * @returns {Promise<number | null>}
+ */
+export async function findAvailablePort(port, host, max_attempts = 10) {
+  for (let i = 0; i < max_attempts; i++) {
+    if (await isPortAvailable(port + i, host)) {
+      return port + i;
+    }
+  }
+  return null;
+}
+
 /**
  * Print the server URL derived from current config.
  */

package/server/cli/open.js

@@ -98,6 +98,45 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/**
+ * Fetch the list of workspaces from the running server.
+ *
+ * @param {string} base_url - Server base URL (e.g., "http://127.0.0.1:3000")
+ * @returns {Promise<Array<{ path: string, database: string }>>}
+ */
+export async function fetchWorkspacesFromServer(base_url) {
+  return new Promise((resolve) => {
+    const url = new URL('/api/workspaces', base_url);
+    const req = http.get(url, (res) => {
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.ok && Array.isArray(parsed.workspaces)) {
+            resolve(parsed.workspaces);
+          } else {
+            resolve([]);
+          }
+        } catch {
+          resolve([]);
+        }
+      });
+    });
+    req.on('error', () => resolve([]));
+    req.setTimeout(2000, () => {
+      try {
+        req.destroy();
+      } catch {
+        void 0;
+      }
+      resolve([]);
+    });
+  });
+}
+
 /**
  * Register a workspace with the running server.
  * Makes a POST request to /api/register-workspace.