@rsktash/beads-ui 0.1.50 → 0.10.3

package/server/cli/commands.js

@@ -1,285 +0,0 @@
-import { getConfig } from '../config.js';
-import { resolveWorkspaceDatabase } from '../db.js';
-import {
-  detectListeningPort,
-  findAvailablePort,
-  isProcessRunning,
-  printServerUrl,
-  readPidFile,
-  removePidFile,
-  startDaemon,
-  terminateProcess
-} from './daemon.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;
-const REGISTER_RETRY_DELAY_MS = 150;
-
-/**
- * Handle `start` command. Idempotent when already running.
- * - Spawns a detached server process, writes PID file, returns 0.
- * - If already running (PID file present and process alive), prints URL and returns 0.
- *
- * @param {{ open?: boolean, is_debug?: boolean, host?: string, port?: number }} [options]
- * @returns {Promise<number>} Exit code (0 on success)
- */
-export async function handleStart(options) {
-  // Default: do not open a browser unless explicitly requested via `open: true`.
-  const should_open = options?.open === true;
-  const cwd = process.cwd();
-
-  // Set env vars early so getConfig() reflects CLI overrides in ALL branches,
-  // including the "already running" path that registers workspaces via HTTP.
-  if (options?.host) {
-    process.env.HOST = options.host;
-  }
-  if (options?.port) {
-    process.env.PORT = String(options.port);
-  }
-
-  const existing_pid = readPidFile();
-  if (existing_pid && isProcessRunning(existing_pid)) {
-    // Server is already running - register this workspace dynamically
-    const { url } = getConfig();
-    const registered = await registerCurrentWorkspace(url, cwd);
-    if (registered) {
-      console.log('Workspace registered: %s', cwd);
-    }
-    console.warn('Server is already running.');
-    if (should_open) {
-      await openUrl(url);
-    }
-    return 0;
-  }
-  if (existing_pid && !isProcessRunning(existing_pid)) {
-    // stale PID file
-    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);
-        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: effective_port
-  });
-  if (started && started.pid > 0) {
-    // Give the spawned daemon a brief moment to fail fast (for example EADDRINUSE).
-    await sleep(STARTUP_SETTLE_MS);
-
-    if (!isProcessRunning(started.pid)) {
-      removePidFile();
-
-      // If another server is already running at the configured URL, register this
-      // workspace there so it appears in the picker instead of silently missing.
-      const registered = await registerCurrentWorkspaceWithRetry(url, cwd);
-      if (registered) {
-        console.warn(
-          'Daemon exited early; registered workspace with existing server: %s',
-          cwd
-        );
-        return 0;
-      }
-      return 1;
-    }
-
-    // Register against the currently reachable server to ensure this workspace
-    // appears in the picker even when startup races with other daemons.
-    void registerCurrentWorkspaceWithRetry(url, cwd);
-
-    printServerUrl();
-    // Auto-open the browser once for a fresh daemon start
-    if (should_open) {
-      // Wait briefly for the server to accept connections (single retry window)
-      await waitForServer(url, 600);
-      // Best-effort open; ignore result
-      await openUrl(url);
-    }
-    return 0;
-  }
-
-  return 1;
-}
-
-/**
- * @param {number} ms
- * @returns {Promise<void>}
- */
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve();
-    }, ms);
-  });
-}
-
-/**
- * @param {string} url
- * @param {string} cwd
- * @returns {Promise<boolean>}
- */
-async function registerCurrentWorkspace(url, cwd) {
-  const workspace_database = resolveWorkspaceDatabase({ cwd });
-  if (
-    workspace_database.source === 'home-default' ||
-    !workspace_database.exists
-  ) {
-    return false;
-  }
-
-  return registerWorkspaceWithServer(url, {
-    path: cwd,
-    database: workspace_database.path
-  });
-}
-
-/**
- * @param {string} url
- * @param {string} cwd
- * @returns {Promise<boolean>}
- */
-async function registerCurrentWorkspaceWithRetry(url, cwd) {
-  for (let i = 0; i < REGISTER_RETRY_ATTEMPTS; i++) {
-    const registered = await registerCurrentWorkspace(url, cwd);
-    if (registered) {
-      return true;
-    }
-    if (i < REGISTER_RETRY_ATTEMPTS - 1) {
-      await sleep(REGISTER_RETRY_DELAY_MS);
-    }
-  }
-  return false;
-}
-
-/**
- * Handle `stop` command.
- * - Sends SIGTERM and waits for exit (with SIGKILL fallback), removes PID file.
- * - Returns 2 if not running.
- *
- * @returns {Promise<number>} Exit code
- */
-export async function handleStop() {
-  const existing_pid = readPidFile();
-  if (!existing_pid) {
-    return 2;
-  }
-
-  if (!isProcessRunning(existing_pid)) {
-    // stale PID file
-    removePidFile();
-    return 2;
-  }
-
-  const terminated = await terminateProcess(existing_pid, 5000);
-  if (terminated) {
-    removePidFile();
-    return 0;
-  }
-
-  // Not terminated within timeout
-  return 1;
-}
-
-/**
- * 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.
- *
- * 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;
-  }
-
-  // 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/commands.unit.test.js

@@ -1,408 +0,0 @@
-import path from 'node:path';
-import { afterEach, describe, expect, test, vi } from 'vitest';
-import { handleRestart, handleStart, handleStop } from './commands.js';
-import * as daemon from './daemon.js';
-import * as open from './open.js';
-
-// Mock open.js to avoid external effects
-vi.mock('./open.js', () => ({
-  openUrl: async () => true,
-  waitForServer: async () => {},
-  fetchWorkspacesFromServer: vi.fn(async () => []),
-  registerWorkspaceWithServer: vi.fn(async () => true)
-}));
-
-// Mock db resolution
-vi.mock('../db.js', () => ({
-  resolveDbPath: () => ({
-    path: path.join(process.cwd(), '.beads', 'workspace.db'),
-    source: 'nearest',
-    exists: true
-  }),
-  resolveWorkspaceDatabase: () => ({
-    path: path.join(process.cwd(), '.beads'),
-    source: 'metadata',
-    exists: true
-  })
-}));
-
-// Mock config - mirrors real getConfig() so env var overrides are testable
-vi.mock('../config.js', () => ({
-  getConfig: () => {
-    const port = Number.parseInt(process.env.PORT || '', 10) || 3000;
-    const host = process.env.HOST || '127.0.0.1';
-    return { host, port, url: `http://${host}:${port}` };
-  }
-}));
-
-afterEach(() => {
-  delete process.env.PORT;
-  delete process.env.HOST;
-});
-
-describe('handleStart (unit)', () => {
-  test('returns 1 when daemon start fails', async () => {
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(null);
-    vi.spyOn(daemon, 'isProcessRunning').mockReturnValue(false);
-    vi.spyOn(daemon, 'findAvailablePort').mockResolvedValue(3000);
-    vi.spyOn(daemon, 'startDaemon').mockReturnValue(null);
-
-    const code = await handleStart({ open: false });
-
-    expect(code).toBe(1);
-  });
-
-  test('returns 0 when already running', async () => {
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(12345);
-    vi.spyOn(daemon, 'isProcessRunning').mockReturnValue(true);
-    const print_url = vi
-      .spyOn(daemon, 'printServerUrl')
-      .mockImplementation(() => {});
-
-    const code = await handleStart({ open: false });
-
-    expect(code).toBe(0);
-    expect(print_url).not.toHaveBeenCalled();
-  });
-
-  test('registers workspace from metadata when already running', async () => {
-    const register_workspace_with_server =
-      /** @type {import('vitest').Mock} */ (open.registerWorkspaceWithServer);
-    register_workspace_with_server.mockReset();
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(12345);
-    vi.spyOn(daemon, 'isProcessRunning').mockReturnValue(true);
-
-    const code = await handleStart({ open: false });
-
-    expect(code).toBe(0);
-    expect(register_workspace_with_server).toHaveBeenCalledTimes(1);
-    expect(register_workspace_with_server).toHaveBeenCalledWith(
-      'http://127.0.0.1:3000',
-      {
-        path: process.cwd(),
-        database: path.join(process.cwd(), '.beads')
-      }
-    );
-  });
-
-  test('registers workspace at custom port when already running', async () => {
-    const register_workspace_with_server =
-      /** @type {import('vitest').Mock} */ (open.registerWorkspaceWithServer);
-    register_workspace_with_server.mockReset();
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(12345);
-    vi.spyOn(daemon, 'isProcessRunning').mockReturnValue(true);
-
-    const code = await handleStart({ open: false, port: 3030 });
-
-    expect(code).toBe(0);
-    expect(register_workspace_with_server).toHaveBeenCalledTimes(1);
-    expect(register_workspace_with_server).toHaveBeenCalledWith(
-      'http://127.0.0.1:3030',
-      {
-        path: process.cwd(),
-        database: path.join(process.cwd(), '.beads')
-      }
-    );
-  });
-
-  test('registers workspace with existing server when spawned daemon exits early', async () => {
-    const register_workspace_with_server =
-      /** @type {import('vitest').Mock} */ (open.registerWorkspaceWithServer);
-    register_workspace_with_server.mockReset();
-
-    const remove_pid = vi
-      .spyOn(daemon, 'removePidFile')
-      .mockImplementation(() => {});
-
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(null);
-    vi.spyOn(daemon, 'findAvailablePort').mockResolvedValue(3000);
-    vi.spyOn(daemon, 'startDaemon').mockReturnValue({ pid: 7777 });
-    vi.spyOn(daemon, 'isProcessRunning').mockImplementation((pid) => pid === 1);
-
-    const code = await handleStart({ open: false });
-
-    expect(code).toBe(0);
-    expect(remove_pid).toHaveBeenCalledTimes(1);
-    expect(register_workspace_with_server).toHaveBeenCalledTimes(1);
-    expect(register_workspace_with_server).toHaveBeenCalledWith(
-      'http://127.0.0.1:3000',
-      {
-        path: process.cwd(),
-        database: path.join(process.cwd(), '.beads')
-      }
-    );
-  });
-
-  test('attempts workspace registration after successful daemon start', async () => {
-    const register_workspace_with_server =
-      /** @type {import('vitest').Mock} */ (open.registerWorkspaceWithServer);
-    register_workspace_with_server.mockReset();
-
-    const print_url = vi
-      .spyOn(daemon, 'printServerUrl')
-      .mockImplementation(() => {});
-
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(null);
-    vi.spyOn(daemon, 'findAvailablePort').mockResolvedValue(3000);
-    vi.spyOn(daemon, 'startDaemon').mockReturnValue({ pid: 4321 });
-    vi.spyOn(daemon, 'isProcessRunning').mockImplementation(
-      (pid) => pid === 4321
-    );
-
-    const code = await handleStart({ open: false });
-
-    expect(code).toBe(0);
-    expect(print_url).toHaveBeenCalledTimes(1);
-    expect(register_workspace_with_server).toHaveBeenCalledTimes(1);
-    expect(register_workspace_with_server).toHaveBeenCalledWith(
-      'http://127.0.0.1:3000',
-      {
-        path: process.cwd(),
-        database: path.join(process.cwd(), '.beads')
-      }
-    );
-  });
-});
-
-describe('handleStop (unit)', () => {
-  test('returns 2 when not running and no PID file', async () => {
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(null);
-
-    const code = await handleStop();
-
-    expect(code).toBe(2);
-  });
-
-  test('returns 2 on stale PID and removes file', async () => {
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(1111);
-    vi.spyOn(daemon, 'isProcessRunning').mockReturnValue(false);
-    const remove_pid = vi
-      .spyOn(daemon, 'removePidFile')
-      .mockImplementation(() => {});
-
-    const code = await handleStop();
-
-    expect(code).toBe(2);
-    expect(remove_pid).toHaveBeenCalledTimes(1);
-  });
-
-  test('returns 0 when process terminates and removes PID', async () => {
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(2222);
-    vi.spyOn(daemon, 'isProcessRunning').mockReturnValue(true);
-    vi.spyOn(daemon, 'terminateProcess').mockResolvedValue(true);
-    const remove_pid = vi
-      .spyOn(daemon, 'removePidFile')
-      .mockImplementation(() => {});
-
-    const code = await handleStop();
-
-    expect(code).toBe(0);
-    expect(remove_pid).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('handleRestart (unit)', () => {
-  test('reuses detected port when no explicit port given', async () => {
-    // First call: restart reads PID (running daemon)
-    // Second call: handleStop reads PID (to terminate)
-    // Third call: handleStart reads PID (no existing daemon after stop)
-    vi.spyOn(daemon, 'readPidFile')
-      .mockReturnValueOnce(3333) // restart: detect port
-      .mockReturnValueOnce(3333) // handleStop: find process
-      .mockReturnValueOnce(null); // handleStart: no existing
-    vi.spyOn(daemon, 'detectListeningPort').mockReturnValue(4000);
-    vi.spyOn(daemon, 'findAvailablePort').mockResolvedValue(4000);
-    vi.spyOn(daemon, 'isProcessRunning').mockImplementation(
-      (pid) => pid === 3333 || pid === 5555
-    );
-    vi.spyOn(daemon, 'terminateProcess').mockResolvedValue(true);
-    vi.spyOn(daemon, 'removePidFile').mockImplementation(() => {});
-    vi.spyOn(daemon, 'printServerUrl').mockImplementation(() => {});
-
-    const start_daemon = vi
-      .spyOn(daemon, 'startDaemon')
-      .mockReturnValue({ pid: 5555 });
-
-    const code = await handleRestart();
-
-    expect(code).toBe(0);
-    expect(start_daemon).toHaveBeenCalledWith(
-      expect.objectContaining({ port: 4000 })
-    );
-  });
-
-  test('explicit port overrides detected port', async () => {
-    vi.spyOn(daemon, 'readPidFile')
-      .mockReturnValueOnce(3333)
-      .mockReturnValueOnce(3333)
-      .mockReturnValueOnce(null);
-    vi.spyOn(daemon, 'detectListeningPort').mockReturnValue(4000);
-    vi.spyOn(daemon, 'isProcessRunning').mockImplementation(
-      (pid) => pid === 3333 || pid === 6666
-    );
-    vi.spyOn(daemon, 'terminateProcess').mockResolvedValue(true);
-    vi.spyOn(daemon, 'removePidFile').mockImplementation(() => {});
-
-    const start_daemon = vi
-      .spyOn(daemon, 'startDaemon')
-      .mockReturnValue({ pid: 6666 });
-
-    const code = await handleRestart({ port: 9999 });
-
-    expect(code).toBe(0);
-    expect(start_daemon).toHaveBeenCalledWith(
-      expect.objectContaining({ port: 9999 })
-    );
-  });
-
-  test('falls back to default when port detection fails', async () => {
-    vi.spyOn(daemon, 'readPidFile')
-      .mockReturnValueOnce(3333)
-      .mockReturnValueOnce(3333)
-      .mockReturnValueOnce(null);
-    vi.spyOn(daemon, 'detectListeningPort').mockReturnValue(null);
-    vi.spyOn(daemon, 'findAvailablePort').mockResolvedValue(3000);
-    vi.spyOn(daemon, 'isProcessRunning').mockImplementation(
-      (pid) => pid === 3333 || pid === 7777
-    );
-    vi.spyOn(daemon, 'terminateProcess').mockResolvedValue(true);
-    vi.spyOn(daemon, 'removePidFile').mockImplementation(() => {});
-    vi.spyOn(daemon, 'printServerUrl').mockImplementation(() => {});
-
-    const start_daemon = vi
-      .spyOn(daemon, 'startDaemon')
-      .mockReturnValue({ pid: 7777 });
-
-    const code = await handleRestart();
-
-    expect(code).toBe(0);
-    // port should not be set — falls through to default
-    expect(start_daemon.mock.calls[0]?.[0]).toEqual(
-      expect.not.objectContaining({ port: expect.any(Number) })
-    );
-  });
-
-  test('re-registers workspaces from previous server after restart', async () => {
-    const fetch_workspaces = /** @type {import('vitest').Mock} */ (
-      open.fetchWorkspacesFromServer
-    );
-    fetch_workspaces.mockResolvedValueOnce([
-      { path: '/project/a', database: '/project/a/.beads' },
-      { path: '/project/b', database: '/project/b/.beads' }
-    ]);
-
-    const register_workspace = /** @type {import('vitest').Mock} */ (
-      open.registerWorkspaceWithServer
-    );
-    register_workspace.mockReset();
-
-    vi.spyOn(daemon, 'readPidFile')
-      .mockReturnValueOnce(3333) // restart: detect port
-      .mockReturnValueOnce(3333) // handleStop: find process
-      .mockReturnValueOnce(null); // handleStart: no existing
-    vi.spyOn(daemon, 'detectListeningPort').mockReturnValue(null);
-    vi.spyOn(daemon, 'isProcessRunning').mockImplementation(
-      (pid) => pid === 3333 || pid === 9999
-    );
-    vi.spyOn(daemon, 'terminateProcess').mockResolvedValue(true);
-    vi.spyOn(daemon, 'removePidFile').mockImplementation(() => {});
-    vi.spyOn(daemon, 'printServerUrl').mockImplementation(() => {});
-    vi.spyOn(daemon, 'startDaemon').mockReturnValue({ pid: 9999 });
-
-    const code = await handleRestart();
-
-    expect(code).toBe(0);
-    // The cwd workspace is registered by handleStart, plus the two saved ones
-    expect(register_workspace).toHaveBeenCalledWith('http://127.0.0.1:3000', {
-      path: '/project/a',
-      database: '/project/a/.beads'
-    });
-    expect(register_workspace).toHaveBeenCalledWith('http://127.0.0.1:3000', {
-      path: '/project/b',
-      database: '/project/b/.beads'
-    });
-  });
-});
-
-describe('port auto-increment (unit)', () => {
-  test('auto-increments port when default is in use by non-bdui', async () => {
-    const register_workspace = /** @type {import('vitest').Mock} */ (
-      open.registerWorkspaceWithServer
-    );
-    // Registration fails — not a bdui instance on that port
-    register_workspace.mockResolvedValueOnce(false);
-
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(null);
-    vi.spyOn(daemon, 'findAvailablePort').mockResolvedValue(3001);
-    vi.spyOn(daemon, 'isProcessRunning').mockImplementation(
-      (pid) => pid === 8888
-    );
-    vi.spyOn(daemon, 'printServerUrl').mockImplementation(() => {});
-
-    const start_daemon = vi
-      .spyOn(daemon, 'startDaemon')
-      .mockReturnValue({ pid: 8888 });
-
-    const code = await handleStart({ open: false });
-
-    expect(code).toBe(0);
-    expect(start_daemon).toHaveBeenCalledWith(
-      expect.objectContaining({ port: 3001 })
-    );
-  });
-
-  test('reuses existing bdui when default port is occupied', async () => {
-    const register_workspace = /** @type {import('vitest').Mock} */ (
-      open.registerWorkspaceWithServer
-    );
-    // Registration succeeds — existing bdui on that port
-    register_workspace.mockResolvedValueOnce(true);
-
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(null);
-    vi.spyOn(daemon, 'findAvailablePort').mockResolvedValue(3001);
-
-    const start_daemon = vi
-      .spyOn(daemon, 'startDaemon')
-      .mockReturnValue({ pid: 8888 });
-
-    const code = await handleStart({ open: false });
-
-    expect(code).toBe(0);
-    // Should NOT have started a new daemon — reused existing
-    expect(start_daemon).not.toHaveBeenCalled();
-  });
-
-  test('does not auto-increment when explicit port is given', async () => {
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(null);
-    vi.spyOn(daemon, 'isProcessRunning').mockImplementation(
-      (pid) => pid === 8888
-    );
-    vi.spyOn(daemon, 'printServerUrl').mockImplementation(() => {});
-
-    const find_port = vi
-      .spyOn(daemon, 'findAvailablePort')
-      .mockResolvedValue(5000);
-
-    const start_daemon = vi
-      .spyOn(daemon, 'startDaemon')
-      .mockReturnValue({ pid: 8888 });
-
-    const code = await handleStart({ open: false, port: 5000 });
-
-    expect(code).toBe(0);
-    // findAvailablePort should not be called when port is explicit
-    expect(find_port).not.toHaveBeenCalled();
-    expect(start_daemon).toHaveBeenCalledWith(
-      expect.objectContaining({ port: 5000 })
-    );
-  });
-
-  test('returns 1 when no port is available', async () => {
-    vi.spyOn(daemon, 'readPidFile').mockReturnValue(null);
-    vi.spyOn(daemon, 'findAvailablePort').mockResolvedValue(null);
-
-    const code = await handleStart({ open: false });
-
-    expect(code).toBe(1);
-  });
-});