@rsktash/beads-ui 0.1.51 → 0.10.3

package/server/bd.test.js

@@ -1,194 +0,0 @@
-import { spawn as spawnMock } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { PassThrough } from 'node:stream';
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { getBdBin, getGitUserName, runBd, runBdJson } from './bd.js';
-
-// Mock child_process.spawn before importing the module under test
-vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
-
-/**
- * @param {string} stdoutText
- * @param {string} stderrText
- * @param {number} code
- */
-function makeFakeProc(stdoutText, stderrText, code) {
-  const cp = /** @type {any} */ (new EventEmitter());
-  const out = new PassThrough();
-  const err = new PassThrough();
-  cp.stdout = out;
-  cp.stderr = err;
-  // Simulate async emission
-  setTimeout(() => {
-    if (stdoutText) {
-      out.write(stdoutText);
-    }
-    out.end();
-    if (stderrText) {
-      err.write(stderrText);
-    }
-    err.end();
-    cp.emit('close', code);
-  }, 0);
-  return cp;
-}
-
-const mockedSpawn = /** @type {import('vitest').Mock} */ (spawnMock);
-/** @type {string[]} */
-const temp_dirs = [];
-
-function make_temp_dir() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bdui-bd-'));
-  temp_dirs.push(dir);
-  return dir;
-}
-
-beforeEach(() => {
-  mockedSpawn.mockReset();
-});
-
-afterEach(() => {
-  for (const dir of temp_dirs.splice(0)) {
-    try {
-      fs.rmSync(dir, { recursive: true, force: true });
-    } catch {
-      // ignore cleanup errors
-    }
-  }
-});
-
-describe('getBdBin', () => {
-  test('returns env BD_BIN when set', () => {
-    const prev = process.env.BD_BIN;
-    process.env.BD_BIN = '/custom/bd';
-    expect(getBdBin()).toBe('/custom/bd');
-    if (prev) {
-      process.env.BD_BIN = prev;
-    } else {
-      delete process.env.BD_BIN;
-    }
-  });
-});
-
-describe('runBd', () => {
-  test('prepends --sandbox by default', async () => {
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('ok', '', 0));
-    await runBd(['list', '--json']);
-
-    const args = mockedSpawn.mock.calls[0][1];
-    expect(args[0]).toBe('--sandbox');
-    expect(args.slice(1)).toEqual(['list', '--json']);
-  });
-
-  test('does not duplicate --sandbox when caller already provides it', async () => {
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('ok', '', 0));
-    await runBd(['--sandbox', 'list', '--json']);
-
-    const args = mockedSpawn.mock.calls[0][1];
-    expect(args).toEqual(['--sandbox', 'list', '--json']);
-  });
-
-  test('allows disabling default sandbox via BDUI_BD_SANDBOX', async () => {
-    const prev = process.env.BDUI_BD_SANDBOX;
-    process.env.BDUI_BD_SANDBOX = '0';
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('ok', '', 0));
-
-    await runBd(['list', '--json']);
-
-    const args = mockedSpawn.mock.calls[0][1];
-    expect(args).toEqual(['list', '--json']);
-
-    if (prev === undefined) {
-      delete process.env.BDUI_BD_SANDBOX;
-    } else {
-      process.env.BDUI_BD_SANDBOX = prev;
-    }
-  });
-
-  test('returns stdout/stderr and exit code', async () => {
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('ok', '', 0));
-    const res = await runBd(['--version']);
-    expect(res.code).toBe(0);
-    expect(res.stdout).toContain('ok');
-  });
-
-  test('non-zero exit propagates code and stderr', async () => {
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('', 'boom', 1));
-    const res = await runBd(['list']);
-    expect(res.code).toBe(1);
-    expect(res.stderr).toContain('boom');
-  });
-
-  test('sets BEADS_DB for workspace-local SQLite db', async () => {
-    const root = make_temp_dir();
-    const beads_dir = path.join(root, '.beads');
-    fs.mkdirSync(beads_dir, { recursive: true });
-    const workspace_db = path.join(beads_dir, 'ui.db');
-    fs.writeFileSync(workspace_db, '');
-
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('ok', '', 0));
-    await runBd(['list'], { cwd: root, env: {} });
-
-    const options = mockedSpawn.mock.calls[0][2];
-    expect(options.env.BEADS_DB).toBe(workspace_db);
-  });
-
-  test('does not force BEADS_DB when workspace has no local SQLite db', async () => {
-    const root = make_temp_dir();
-
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('ok', '', 0));
-    await runBd(['list'], { cwd: root, env: {} });
-
-    const options = mockedSpawn.mock.calls[0][2];
-    expect(options.env.BEADS_DB).toBeUndefined();
-  });
-
-  test('preserves explicit BEADS_DB from caller env', async () => {
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('ok', '', 0));
-    await runBd(['list'], { env: { BEADS_DB: '/custom/workspace.db' } });
-
-    const options = mockedSpawn.mock.calls[0][2];
-    expect(options.env.BEADS_DB).toBe('/custom/workspace.db');
-  });
-});
-
-describe('runBdJson', () => {
-  test('parses valid JSON output', async () => {
-    const json = JSON.stringify([{ id: 'UI-1' }]);
-    mockedSpawn.mockReturnValueOnce(makeFakeProc(json, '', 0));
-    const res = await runBdJson(['list', '--json']);
-    expect(res.code).toBe(0);
-    expect(Array.isArray(res.stdoutJson)).toBe(true);
-  });
-
-  test('invalid JSON yields stderr message with code 0', async () => {
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('not-json', '', 0));
-    const res = await runBdJson(['list', '--json']);
-    expect(res.code).toBe(0);
-    expect(res.stderr).toContain('Invalid JSON');
-  });
-
-  test('non-zero exit returns code and stderr', async () => {
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('', 'oops', 2));
-    const res = await runBdJson(['list', '--json']);
-    expect(res.code).toBe(2);
-    expect(res.stderr).toContain('oops');
-  });
-});
-
-describe('getGitUserName', () => {
-  test('returns git user name on success', async () => {
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('Alice Smith\n', '', 0));
-    const name = await getGitUserName();
-    expect(name).toBe('Alice Smith');
-  });
-
-  test('returns empty string on failure', async () => {
-    mockedSpawn.mockReturnValueOnce(makeFakeProc('', 'error', 1));
-    const name = await getGitUserName();
-    expect(name).toBe('');
-  });
-});

package/server/cli/cli.test.js

@@ -1,207 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-import * as logging from '../logging.js';
-import * as commands from './commands.js';
-import { main, parseArgs } from './index.js';
-
-vi.mock('node:fs/promises', () => ({
-  readFile: vi.fn()
-}));
-
-vi.mock('../logging.js', () => ({
-  enableAllDebug: vi.fn(),
-  debug: () => () => {}
-}));
-
-vi.mock('./commands.js', () => ({
-  handleStart: vi.fn().mockResolvedValue(0),
-  handleStop: vi.fn().mockResolvedValue(0),
-  handleRestart: vi.fn().mockResolvedValue(0)
-}));
-
-/** @type {import('vitest').MockInstance} */
-let write_mock;
-/** @type {import('vitest').MockInstance} */
-let read_file_mock;
-
-beforeEach(() => {
-  write_mock = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-  read_file_mock = vi.mocked(readFile);
-  read_file_mock.mockResolvedValue(JSON.stringify({ version: '1.2.3' }));
-});
-
-describe('parseArgs', () => {
-  test('returns help flag when -h or --help present', () => {
-    const r1 = parseArgs(['-h']);
-    const r2 = parseArgs(['--help']);
-
-    expect(r1.flags.includes('help')).toBe(true);
-    expect(r2.flags.includes('help')).toBe(true);
-  });
-
-  test('returns command token when valid', () => {
-    expect(parseArgs(['start']).command).toBe('start');
-    expect(parseArgs(['stop']).command).toBe('stop');
-    expect(parseArgs(['restart']).command).toBe('restart');
-  });
-
-  test('recognizes --debug and -d flags', () => {
-    const r1 = parseArgs(['--debug']);
-    const r2 = parseArgs(['-d']);
-
-    expect(r1.flags.includes('debug')).toBe(true);
-    expect(r2.flags.includes('debug')).toBe(true);
-  });
-  test('recognizes --open flag', () => {
-    const r = parseArgs(['start', '--open']);
-
-    expect(r.flags.includes('open')).toBe(true);
-  });
-
-  test('recognizes -v and --version flags', () => {
-    const r1 = parseArgs(['-v']);
-    const r2 = parseArgs(['--version']);
-
-    expect(r1.flags.includes('version')).toBe(true);
-    expect(r2.flags.includes('version')).toBe(true);
-  });
-
-  test('parses --host option', () => {
-    const r = parseArgs(['start', '--host', '0.0.0.0']);
-
-    expect(r.options.host).toBe('0.0.0.0');
-  });
-
-  test('parses --port option', () => {
-    const r = parseArgs(['start', '--port', '8080']);
-
-    expect(r.options.port).toBe(8080);
-  });
-
-  test('ignores invalid --port value', () => {
-    const r = parseArgs(['start', '--port', 'abc']);
-
-    expect(r.options.port).toBeUndefined();
-  });
-});
-
-describe('main', () => {
-  test('prints usage and exits 0 on --help', async () => {
-    const code = await main(['--help']);
-
-    expect(code).toBe(0);
-    expect(write_mock).toHaveBeenCalled();
-  });
-
-  test('prints version and exits 0 on --version', async () => {
-    const code = await main(['--version']);
-
-    expect(code).toBe(0);
-    expect(write_mock).toHaveBeenCalled();
-    const output = write_mock.mock.calls.map((c) => String(c[0])).join('');
-    expect(output.trim()).toBe('1.2.3');
-  });
-
-  test('enables debug when --debug passed', async () => {
-    const spy = vi.spyOn(logging, 'enableAllDebug');
-
-    await main(['--debug', '--help']);
-
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  test('prints usage and exits 1 on no command', async () => {
-    const code = await main([]);
-
-    expect(code).toBe(1);
-    expect(write_mock).toHaveBeenCalled();
-  });
-
-  test('dispatches to start handler', async () => {
-    const code = await main(['start']);
-
-    expect(code).toBe(0);
-    expect(commands.handleStart).toHaveBeenCalledTimes(1);
-  });
-
-  test('propagates --open to start handler', async () => {
-    await main(['start', '--open']);
-
-    expect(commands.handleStart).toHaveBeenCalledWith({
-      open: true,
-      is_debug: false,
-      host: undefined,
-      port: undefined
-    });
-  });
-
-  test('propagates --host and --port to start handler', async () => {
-    await main(['start', '--host', '0.0.0.0', '--port', '8080']);
-
-    expect(commands.handleStart).toHaveBeenCalledWith({
-      open: false,
-      is_debug: false,
-      host: '0.0.0.0',
-      port: 8080
-    });
-  });
-
-  test('help lists --open', async () => {
-    const write_spy = write_mock;
-    write_spy.mockClear();
-
-    await main(['--help']);
-
-    const output = write_spy.mock.calls.map((c) => String(c[0])).join('');
-    expect(output.includes('--open')).toBe(true);
-  });
-
-  test('dispatches to stop handler', async () => {
-    const code = await main(['stop']);
-
-    expect(code).toBe(0);
-    expect(commands.handleStop).toHaveBeenCalledTimes(1);
-  });
-
-  test('dispatches to restart handler', async () => {
-    const code = await main(['restart']);
-
-    expect(code).toBe(0);
-    expect(commands.handleRestart).toHaveBeenCalledTimes(1);
-    expect(commands.handleRestart).toHaveBeenCalledWith({
-      open: false,
-      is_debug: false,
-      host: undefined,
-      port: undefined
-    });
-  });
-
-  test('propagates --open to restart handler', async () => {
-    await main(['restart', '--open']);
-
-    expect(commands.handleRestart).toHaveBeenCalledWith({
-      open: true,
-      is_debug: false,
-      host: undefined,
-      port: undefined
-    });
-  });
-
-  test('propagates --host and --port to restart handler', async () => {
-    await main(['restart', '--host', '0.0.0.0', '--port', '9000']);
-
-    expect(commands.handleRestart).toHaveBeenCalledWith({
-      open: false,
-      is_debug: false,
-      host: '0.0.0.0',
-      port: 9000
-    });
-  });
-
-  test('unknown command prints usage and exits 1', async () => {
-    const code = await main(['unknown']);
-
-    expect(code).toBe(1);
-    expect(write_mock).toHaveBeenCalled();
-  });
-});

package/server/cli/commands.integration.test.js

@@ -1,148 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  afterAll,
-  afterEach,
-  beforeAll,
-  describe,
-  expect,
-  test,
-  vi
-} from 'vitest';
-import { handleRestart, handleStart, handleStop } from './commands.js';
-import * as daemon from './daemon.js';
-
-// Mock browser open + readiness wait to avoid external effects and flakiness
-vi.mock('./open.js', () => ({
-  openUrl: async () => true,
-  waitForServer: async () => {},
-  registerWorkspaceWithServer: async () => true
-}));
-
-// Mock db resolution to avoid file system dependencies
-vi.mock('../db.js', () => ({
-  resolveDbPath: () => ({
-    path: '/mock/test.db',
-    source: 'nearest',
-    exists: true
-  }),
-  resolveWorkspaceDatabase: () => ({
-    path: '/mock/test.db',
-    source: 'nearest',
-    exists: true
-  })
-}));
-
-/** @type {string} */
-let tmp_runtime_dir;
-/** @type {Record<string, string | undefined>} */
-let prev_env;
-
-beforeAll(() => {
-  // Snapshot selected env vars to restore later
-  prev_env = {
-    BDUI_RUNTIME_DIR: process.env.BDUI_RUNTIME_DIR,
-    PORT: process.env.PORT
-  };
-
-  tmp_runtime_dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bdui-it-'));
-  process.env.BDUI_RUNTIME_DIR = tmp_runtime_dir;
-  // Use port 0 so OS assigns an ephemeral port; URL printing still occurs
-  process.env.PORT = '0';
-  vi.spyOn(console, 'log').mockImplementation(() => {});
-});
-
-afterEach(async () => {
-  // Ensure no stray daemon is left between tests
-  const pid = daemon.readPidFile();
-  if (pid && daemon.isProcessRunning(pid)) {
-    await daemon.terminateProcess(pid, 2000);
-  }
-  daemon.removePidFile();
-});
-
-afterAll(() => {
-  // Restore env
-  if (prev_env.BDUI_RUNTIME_DIR === undefined) {
-    delete process.env.BDUI_RUNTIME_DIR;
-  } else {
-    process.env.BDUI_RUNTIME_DIR = prev_env.BDUI_RUNTIME_DIR;
-  }
-
-  if (prev_env.PORT === undefined) {
-    delete process.env.PORT;
-  } else {
-    process.env.PORT = prev_env.PORT;
-  }
-
-  try {
-    fs.rmSync(tmp_runtime_dir, { recursive: true, force: true });
-  } catch {
-    // ignore
-  }
-});
-
-describe('commands integration', () => {
-  test('start then stop returns 0 and manages PID file', async () => {
-    // setup
-    vi.spyOn(daemon, 'printServerUrl').mockImplementation(() => {});
-
-    // execution
-    const start_code = await handleStart({ open: false });
-
-    // assertion
-    expect(start_code).toBe(0);
-    const pid_after_start = daemon.readPidFile();
-    expect(typeof pid_after_start).toBe('number');
-    expect(Number(pid_after_start)).toBeGreaterThan(0);
-
-    // execution
-    const stop_code = await handleStop();
-
-    // assertion
-    expect(stop_code).toBe(0);
-    const pid_after_stop = daemon.readPidFile();
-    expect(pid_after_stop).toBeNull();
-  });
-
-  test('stop returns 2 when not running', async () => {
-    // execution
-    const code = await handleStop();
-
-    // assertion
-    expect(code).toBe(2);
-  });
-
-  test('start is idempotent when already running', async () => {
-    // setup
-    await handleStart({ open: false });
-    const start_spy = vi.spyOn(daemon, 'startDaemon');
-
-    // execution
-    const code = await handleStart({ open: false });
-
-    // assertion
-    expect(code).toBe(0);
-    expect(start_spy).not.toHaveBeenCalled();
-
-    // cleanup
-    await handleStop();
-  });
-
-  test('restart stops (when needed) and starts', async () => {
-    // setup
-    vi.spyOn(daemon, 'printServerUrl').mockImplementation(() => {});
-
-    // execution
-    const code = await handleRestart();
-
-    // assertion
-    expect(code).toBe(0);
-    const pid = daemon.readPidFile();
-    expect(typeof pid).toBe('number');
-
-    // cleanup
-    await handleStop();
-  });
-});