@rsktash/beads-ui 0.1.50 → 0.10.3

package/server/cli/usage.js

@@ -1,49 +0,0 @@
-/**
- * Print CLI usage to a stream-like target.
- *
- * @param {{ write: (chunk: string) => any }} out_stream
- */
-export function printUsage(out_stream) {
-  const lines = [
-    'Usage: bdui <command> [options]',
-    '',
-    'Commands:',
-    '  start       Start the UI server',
-    '  stop        Stop the UI server',
-    '  restart     Restart the UI server',
-    '',
-    'Options:',
-    '  -h, --help        Show this help message',
-    '  -v, --version     Show the CLI version',
-    '  -d, --debug       Enable debug logging',
-    '      --open        Open the browser after start/restart',
-    '      --host <addr> Bind to a specific host (default: 127.0.0.1)',
-    '      --port <num>  Bind to a specific port (default: 3000)',
-    '',
-    'Environment variables:',
-    '  PORT                          Server port (default: 3333)',
-    '  HOST                          Bind address (default: 127.0.0.1)',
-    '  BEADS_DOLT_PASSWORD            Password for remote Dolt server',
-    '  FILE_ATTACHMENT_BASE_URL  Base URL for attach:// URIs in markdown',
-    '',
-    'Dolt modes:',
-    '  Embedded (default): spawns a local dolt sql-server from .beads/embeddeddolt/',
-    '  Remote server: set dolt_mode: "server" in .beads/metadata.json with',
-    '    dolt_server_host, dolt_server_port, dolt_server_user, dolt_database.',
-    '    Password is read from BEADS_DOLT_PASSWORD env var.',
-    '',
-    'Attachments:',
-    '  Markdown content can use attach://<path> URIs for portable file references.',
-    '  Set FILE_ATTACHMENT_BASE_URL to resolve them at render time.',
-    '  Example: attach://bead-42/shot.png becomes',
-    '    ${FILE_ATTACHMENT_BASE_URL}/bead-42/shot.png',
-    '',
-    'Issue mentions:',
-    '  Use #issue-id to mention issues in markdown (e.g., #yuklar-985).',
-    '  These are auto-linked to the issue detail page.',
-    ''
-  ];
-  for (const line of lines) {
-    out_stream.write(line + '\n');
-  }
-}

package/server/config.js

@@ -1,36 +0,0 @@
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-/**
- * Resolve runtime configuration for the server.
- * Notes:
- * - `app_dir` is resolved relative to the installed package location.
- * - `root_dir` represents the directory where the process was invoked
- * (i.e., the current working directory) so DB resolution follows the
- * caller's context rather than the install location.
- *
- * @returns {{ host: string, port: number, app_dir: string, root_dir: string, url: string }}
- */
-export function getConfig() {
-  const this_file = fileURLToPath(new URL(import.meta.url));
-  const server_dir = path.dirname(this_file);
-  const package_root = path.resolve(server_dir, '..');
-  // Always reflect the directory from which the process was started
-  const root_dir = process.cwd();
-
-  let port_value = Number.parseInt(process.env.PORT || '', 10);
-  if (!Number.isFinite(port_value)) {
-    port_value = 3333;
-  }
-
-  const host_env = process.env.HOST;
-  const host_value = host_env && host_env.length > 0 ? host_env : '127.0.0.1';
-
-  return {
-    host: host_value,
-    port: port_value,
-    app_dir: path.resolve(package_root, 'app'),
-    root_dir,
-    url: `http://${host_value}:${port_value}`
-  };
-}

package/server/db.test.js

@@ -1,169 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import {
-  findNearestBeadsDb,
-  findNearestBeadsMetadata,
-  resolveDbPath,
-  resolveWorkspaceDatabase
-} from './db.js';
-
-/** @type {string[]} */
-const tmps = [];
-
-function mkdtemp() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'beads-ui-test-'));
-  tmps.push(dir);
-  return dir;
-}
-
-beforeEach(() => {
-  vi.resetModules();
-});
-
-afterEach(() => {
-  for (const d of tmps.splice(0)) {
-    try {
-      fs.rmSync(d, { recursive: true, force: true });
-    } catch {
-      // ignore cleanup errors
-    }
-  }
-});
-
-describe('resolveDbPath', () => {
-  test('uses explicit_db when provided', () => {
-    const res = resolveDbPath({ cwd: '/x', explicit_db: './my.db', env: {} });
-    expect(res.path.endsWith('/x/my.db')).toBe(true);
-    expect(res.source).toBe('flag');
-  });
-
-  test('uses BEADS_DB from env when set', () => {
-    const res = resolveDbPath({ cwd: '/x', env: { BEADS_DB: '/abs/env.db' } });
-    expect(res.path).toBe('/abs/env.db');
-    expect(res.source).toBe('env');
-  });
-
-  test('finds nearest .beads/ui.db walking up', () => {
-    const root = mkdtemp();
-    const nested = path.join(root, 'a', 'b', 'c');
-    fs.mkdirSync(nested, { recursive: true });
-    const beads = path.join(root, '.beads');
-    fs.mkdirSync(beads);
-    const ui_db = path.join(beads, 'ui.db');
-    fs.writeFileSync(ui_db, '');
-
-    const found = findNearestBeadsDb(nested);
-    expect(found).toBe(ui_db);
-
-    const res = resolveDbPath({ cwd: nested, env: {} });
-    expect(res.path).toBe(ui_db);
-    expect(res.source).toBe('nearest');
-  });
-
-  test('falls back to ~/.beads/default.db when none found', async () => {
-    // Mock os.homedir to a deterministic location using spy
-    const home = mkdtemp();
-    vi.spyOn(os, 'homedir').mockReturnValue(home);
-    const mod = await import('./db.js');
-    const res = mod.resolveDbPath({ cwd: '/no/db/here', env: {} });
-    expect(res.path).toBe(path.join(home, '.beads', 'default.db'));
-    expect(res.source).toBe('home-default');
-  });
-
-  test('treats ~/.beads/default.db as fallback, not nearest workspace db', async () => {
-    const home = mkdtemp();
-    const nested = path.join(home, 'projects', 'repo', 'deep');
-    fs.mkdirSync(nested, { recursive: true });
-    const home_beads = path.join(home, '.beads');
-    fs.mkdirSync(home_beads, { recursive: true });
-    fs.writeFileSync(path.join(home_beads, 'default.db'), '');
-    vi.spyOn(os, 'homedir').mockReturnValue(home);
-    const mod = await import('./db.js');
-
-    const res = mod.resolveDbPath({ cwd: nested, env: {} });
-
-    expect(res.path).toBe(path.join(home, '.beads', 'default.db'));
-    expect(res.source).toBe('home-default');
-  });
-});
-
-describe('findNearestBeadsMetadata', () => {
-  test('finds nearest metadata walking up', () => {
-    const root = mkdtemp();
-    const nested = path.join(root, 'a', 'b', 'c');
-    fs.mkdirSync(nested, { recursive: true });
-    const beads_dir = path.join(root, '.beads');
-    fs.mkdirSync(beads_dir, { recursive: true });
-    const metadata = path.join(beads_dir, 'metadata.json');
-    fs.writeFileSync(metadata, '{}');
-
-    const found = findNearestBeadsMetadata(nested);
-
-    expect(found).toBe(metadata);
-  });
-
-  test('returns null when metadata is missing', () => {
-    const root = mkdtemp();
-
-    const found = findNearestBeadsMetadata(root);
-
-    expect(found).toBeNull();
-  });
-});
-
-describe('resolveWorkspaceDatabase', () => {
-  test('uses metadata directory for non-SQLite workspace', () => {
-    const root = mkdtemp();
-    const nested = path.join(root, 'workspace', 'nested');
-    fs.mkdirSync(nested, { recursive: true });
-    const beads_dir = path.join(root, '.beads');
-    fs.mkdirSync(beads_dir, { recursive: true });
-    fs.writeFileSync(path.join(beads_dir, 'metadata.json'), '{}');
-
-    const found = resolveWorkspaceDatabase({ cwd: nested, env: {} });
-
-    expect(found.path).toBe(beads_dir);
-    expect(found.source).toBe('metadata');
-    expect(found.exists).toBe(true);
-  });
-
-  test('prefers metadata workspace when home default db exists', async () => {
-    const home = mkdtemp();
-    const root = path.join(home, 'project');
-    const nested = path.join(root, 'workspace', 'nested');
-    fs.mkdirSync(nested, { recursive: true });
-    const home_beads = path.join(home, '.beads');
-    fs.mkdirSync(home_beads, { recursive: true });
-    fs.writeFileSync(path.join(home_beads, 'default.db'), '');
-    const beads_dir = path.join(root, '.beads');
-    fs.mkdirSync(beads_dir, { recursive: true });
-    fs.writeFileSync(path.join(beads_dir, 'metadata.json'), '{}');
-    vi.spyOn(os, 'homedir').mockReturnValue(home);
-    const mod = await import('./db.js');
-
-    const found = mod.resolveWorkspaceDatabase({ cwd: nested, env: {} });
-
-    expect(found.path).toBe(beads_dir);
-    expect(found.source).toBe('metadata');
-    expect(found.exists).toBe(true);
-  });
-
-  test('prefers nearest sqlite database when present', () => {
-    const root = mkdtemp();
-    const nested = path.join(root, 'workspace', 'nested');
-    fs.mkdirSync(nested, { recursive: true });
-    const beads_dir = path.join(root, '.beads');
-    fs.mkdirSync(beads_dir, { recursive: true });
-    fs.writeFileSync(path.join(beads_dir, 'metadata.json'), '{}');
-    const sqlite_db = path.join(beads_dir, 'workspace.db');
-    fs.writeFileSync(sqlite_db, '');
-
-    const found = resolveWorkspaceDatabase({ cwd: nested, env: {} });
-
-    expect(found.path).toBe(sqlite_db);
-    expect(found.source).toBe('nearest');
-    expect(found.exists).toBe(true);
-  });
-});

package/server/dolt-pool.js

@@ -1,313 +0,0 @@
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import mysql from 'mysql2/promise';
-import { findNearestBeadsMetadata } from './db.js';
-import { debug } from './logging.js';
-
-const log = debug('dolt-pool');
-
-const DOLT_PORT = 3307;
-const DOLT_SOCK = '/tmp/bdui-dolt.sock';
-
-/** @type {import('mysql2/promise').Pool | null} */
-let pool = null;
-
-/** @type {import('node:child_process').ChildProcess | null} */
-let serverProcess = null;
-
-/** @type {string | null} */
-let currentDataDir = null;
-
-/** @type {'embedded' | 'server' | null} */
-let currentMode = null;
-
-/**
- * @typedef {{ mode: 'embedded', dataDir: string, database: string }} EmbeddedDoltInfo
- * @typedef {{ mode: 'server', host: string, port: number, user: string, password: string, database: string }} ServerDoltInfo
- * @typedef {EmbeddedDoltInfo | ServerDoltInfo} DoltInfo
- */
-
-/**
- * Resolve Dolt connection info from the workspace root.
- * Walks up from cwd to find .beads/metadata.json, then returns either
- * embedded or server connection info depending on dolt_mode.
- *
- * @param {string} cwd
- * @returns {DoltInfo | null}
- */
-export function resolveDoltDir(cwd) {
-  const metadataPath = findNearestBeadsMetadata(cwd);
-  if (!metadataPath) return null;
-
-  const beadsDir = path.dirname(metadataPath);
-  let metadata;
-  try {
-    metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
-  } catch {
-    return null;
-  }
-
-  if (metadata.backend !== 'dolt' && metadata.database !== 'dolt') return null;
-
-  const database = metadata.dolt_database || 'default';
-
-  if (metadata.dolt_mode === 'server') {
-    return {
-      mode: 'server',
-      host: metadata.dolt_server_host || '127.0.0.1',
-      port: metadata.dolt_server_port || 3306,
-      user: metadata.dolt_server_user || 'root',
-      password: process.env.BEADS_DOLT_PASSWORD || '',
-      database
-    };
-  }
-
-  const dataDir = path.join(beadsDir, 'embeddeddolt', database);
-
-  try {
-    fs.accessSync(path.join(dataDir, '.dolt'), fs.constants.F_OK);
-  } catch {
-    return null;
-  }
-
-  return { mode: 'embedded', dataDir, database };
-}
-
-/**
- * Start the Dolt SQL server and create a connection pool.
- * Idempotent — returns existing pool if already running for the same dataDir.
- *
- * @param {string} cwd - Workspace root directory
- * @returns {Promise<import('mysql2/promise').Pool | null>}
- */
-export async function startDoltServer(cwd) {
-  const resolved = resolveDoltDir(cwd);
-  if (!resolved) {
-    log('no Dolt database found for %s', cwd);
-    return null;
-  }
-
-  // Server mode — connect directly, no child process
-  if (resolved.mode === 'server') {
-    const { host, port, user, password, database } = resolved;
-
-    // Already connected to this server
-    if (pool && currentMode === 'server') {
-      return pool;
-    }
-
-    await stopDoltServer();
-
-    log('connecting to remote dolt server at %s:%d (database=%s)', host, port, database);
-    currentMode = 'server';
-
-    try {
-      pool = await createPool({ host, port, user, password, database });
-      log('connected to remote dolt server at %s:%d', host, port);
-      ensureIndexes(pool).catch((err) => log('ensureIndexes error: %o', err));
-      return pool;
-    } catch (err) {
-      log('failed to connect to remote dolt server: %o', err);
-      pool = null;
-      currentMode = null;
-      return null;
-    }
-  }
-
-  // Embedded mode — spawn local dolt sql-server
-  const { dataDir, database } = resolved;
-
-  // Already running for this data dir
-  if (pool && currentDataDir === dataDir && serverProcess && !serverProcess.killed) {
-    return pool;
-  }
-
-  // Clean up any previous server
-  await stopDoltServer();
-
-  log('starting dolt sql-server at %s (database=%s)', dataDir, database);
-
-  // Clean up stale socket
-  try { fs.unlinkSync(DOLT_SOCK); } catch { /* ignore */ }
-
-  currentDataDir = dataDir;
-  currentMode = 'embedded';
-
-  return new Promise((resolve) => {
-    const child = spawn('dolt', [
-      'sql-server',
-      '-P', String(DOLT_PORT),
-      '--socket', DOLT_SOCK,
-      '-l', 'warning'
-    ], {
-      cwd: dataDir,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      detached: false
-    });
-
-    serverProcess = child;
-
-    let resolved_already = false;
-
-    child.stderr?.setEncoding('utf8');
-    child.stderr?.on('data', (chunk) => {
-      // Log warnings/errors from dolt
-      if (chunk.trim()) log('dolt: %s', chunk.trim());
-    });
-
-    child.on('error', (err) => {
-      log('dolt sql-server spawn error: %o', err);
-      if (!resolved_already) {
-        resolved_already = true;
-        resolve(null);
-      }
-    });
-
-    child.on('exit', (code) => {
-      log('dolt sql-server exited with code %d', code);
-      pool = null;
-      serverProcess = null;
-      currentDataDir = null;
-      currentMode = null;
-      if (!resolved_already) {
-        resolved_already = true;
-        resolve(null);
-      }
-    });
-
-    // Poll for connectivity instead of parsing stdout
-    let attempts = 0;
-    const maxAttempts = 50; // 50 * 100ms = 5s max
-    const pollInterval = setInterval(async () => {
-      attempts++;
-      if (resolved_already) {
-        clearInterval(pollInterval);
-        return;
-      }
-      if (attempts > maxAttempts) {
-        clearInterval(pollInterval);
-        if (!resolved_already) {
-          resolved_already = true;
-          log('dolt sql-server start timeout after %d attempts', attempts);
-          resolve(null);
-        }
-        return;
-      }
-      try {
-        const p = await createPool({ host: '127.0.0.1', port: DOLT_PORT, user: 'root', database });
-        clearInterval(pollInterval);
-        if (!resolved_already) {
-          resolved_already = true;
-          pool = p;
-          log('dolt sql-server ready on port %d (after %d polls)', DOLT_PORT, attempts);
-          ensureIndexes(p).catch((err) => log('ensureIndexes error: %o', err));
-          resolve(pool);
-        } else {
-          // Pool created after we already resolved (race); close it
-          try { await p.end(); } catch { /* ignore */ }
-        }
-      } catch (poolErr) {
-        // Not ready yet, retry. Clean up any partial pool.
-        if (poolErr && typeof /** @type {any} */ (poolErr).pool?.end === 'function') {
-          try { await /** @type {any} */ (poolErr).pool.end(); } catch { /* ignore */ }
-        }
-      }
-    }, 100);
-  });
-}
-
-/**
- * Create a mysql2 connection pool.
- *
- * @param {{ host: string, port: number, user: string, password?: string, database: string }} opts
- * @returns {Promise<import('mysql2/promise').Pool>}
- */
-async function createPool(opts) {
-  const p = mysql.createPool({
-    host: opts.host,
-    port: opts.port,
-    user: opts.user,
-    password: opts.password || undefined,
-    database: opts.database,
-    waitForConnections: true,
-    connectionLimit: 10,
-    queueLimit: 50,
-    enableKeepAlive: true,
-    keepAliveInitialDelay: 10000,
-    // Dolt dates come as strings; avoid extra parsing
-    dateStrings: true
-  });
-
-  // Verify connectivity
-  const conn = await p.getConnection();
-  conn.release();
-  return p;
-}
-
-/**
- * Ensure required indexes exist. Idempotent — skips if already present.
- *
- * @param {import('mysql2/promise').Pool} p
- */
-async function ensureIndexes(p) {
-  const [rows] = await p.query(
-    `SELECT 1 FROM information_schema.statistics
-     WHERE table_schema = DATABASE() AND table_name = 'issues'
-       AND index_name = 'idx_ft_issues_title_desc' LIMIT 1`
-  );
-  if (/** @type {any[]} */ (rows).length > 0) {
-    log('FULLTEXT index already exists');
-    return;
-  }
-  log('creating FULLTEXT index on issues(title, description)');
-  await p.query(`ALTER TABLE issues ADD FULLTEXT idx_ft_issues_title_desc (title, description)`);
-  await p.query(`CALL dolt_commit('-Am', 'add FULLTEXT index on issues(title, description)')`);
-  log('FULLTEXT index created');
-}
-
-/**
- * Get the current pool, or null if not started.
- *
- * @returns {import('mysql2/promise').Pool | null}
- */
-export function getPool() {
-  return pool;
-}
-
-/**
- * Stop the Dolt SQL server and close the pool.
- */
-export async function stopDoltServer() {
-  if (pool) {
-    try { await pool.end(); } catch { /* ignore */ }
-    pool = null;
-  }
-  if (serverProcess && !serverProcess.killed) {
-    serverProcess.kill('SIGTERM');
-    serverProcess = null;
-  }
-  currentDataDir = null;
-  currentMode = null;
-}
-
-/**
- * Rebind to a new workspace directory (e.g., after workspace switch).
- *
- * @param {string} cwd
- * @returns {Promise<import('mysql2/promise').Pool | null>}
- */
-export async function rebindDoltServer(cwd) {
-  const resolved = resolveDoltDir(cwd);
-  if (!resolved) {
-    await stopDoltServer();
-    return null;
-  }
-  if (resolved.mode === 'server' && pool && currentMode === 'server') {
-    return pool;
-  }
-  if (resolved.mode === 'embedded' && resolved.dataDir === currentDataDir && pool && serverProcess && !serverProcess.killed) {
-    return pool;
-  }
-  return startDoltServer(cwd);
-}