@monoes/monobrowse 2.24.0 → 2.24.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monobrowse",
-  "version": "2.24.0",
+  "version": "2.24.1",
   "description": "Native browser automation via Chrome DevTools Protocol — the engine powering monomind browse",
   "type": "module",
   "bin": {
@@ -13,6 +13,10 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
+    "./cdp-port": {
+      "types": "./dist/src/browser/cdp-port.d.ts",
+      "import": "./dist/src/browser/cdp-port.js"
+    },
     "./cli": {
       "types": "./dist/src/cli.d.ts",
       "import": "./dist/src/cli.js"
@@ -33,6 +37,13 @@
   "engines": {
     "node": ">=22.12.0"
   },
+  "scripts": {
+    "build": "tsc && node ../../../scripts/build-fs.mjs copy-into dist/src/browser/dashboard src/browser/dashboard/ui.html",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "prebuild": "node ../../../scripts/build-fs.mjs clean dist tsconfig.tsbuildinfo",
+    "prepublishOnly": "npm run build"
+  },
   "keywords": [
     "browser-automation",
     "cdp",
@@ -59,11 +70,5 @@
   "devDependencies": {
     "typescript": "^7.0.2",
     "vitest": "^4.1.4"
-  },
-  "scripts": {
-    "build": "tsc && node ../../../scripts/build-fs.mjs copy-into dist/src/browser/dashboard src/browser/dashboard/ui.html",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "prebuild": "node ../../../scripts/build-fs.mjs clean dist tsconfig.tsbuildinfo"
   }
-}
+}

package/src/__tests__/browse-concurrency.test.ts

@@ -13,9 +13,9 @@
  */
 
 import { execFile, execFileSync, spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { freemem, tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { afterEach, beforeAll, describe, expect, it } from 'vitest';
@@ -38,7 +38,40 @@ function chromeAvailable(): boolean {
   }
 }
 
-const runnable = existsSync(CLI) && chromeAvailable();
+/**
+ * #651: under host memory pressure the kernel/Chrome aborts a launching Chrome
+ * (SIGABRT), which looks like a code failure. Real Chromes alive at once: the
+ * named-session test holds three (ref, build, and the bare command's own); the
+ * rest hold two. Each headless Chrome (browser + GPU/network/renderer
+ * processes) needs on the order of 400 MiB, rounded up to 512 MiB with
+ * headroom for the warm-up Chrome and the test runner itself.
+ */
+const MAX_CONCURRENT_CHROMES = 3;
+const BYTES_PER_CHROME = 512 * 1024 * 1024;
+const REQUIRED_AVAILABLE_BYTES = MAX_CONCURRENT_CHROMES * BYTES_PER_CHROME;
+
+/** Bytes the kernel reports as available without swapping (MemAvailable). */
+function availableMemoryBytes(): number {
+  try {
+    const m = /^MemAvailable:\s+(\d+) kB/m.exec(readFileSync('/proc/meminfo', 'utf8'));
+    if (m) return Number(m[1]) * 1024;
+  } catch {
+    // not Linux: fall through to os.freemem()
+  }
+  return freemem();
+}
+
+const availableBytes = availableMemoryBytes();
+const enoughMemory = availableBytes >= REQUIRED_AVAILABLE_BYTES;
+const runnable = existsSync(CLI) && chromeAvailable() && enoughMemory;
+
+if (existsSync(CLI) && !enoughMemory) {
+  const mib = (n: number) => Math.round(n / 1024 / 1024);
+  console.warn(
+    `SKIP browse-concurrency: ${mib(availableBytes)} MiB available, ` +
+      `${mib(REQUIRED_AVAILABLE_BYTES)} MiB needed for ${MAX_CONCURRENT_CHROMES} concurrent Chromes (#651)`,
+  );
+}
 
 interface Run {
   code: number | null;

package/src/__tests__/cdp-port.test.ts

@@ -0,0 +1,76 @@
+/**
+ * #666: monomind's own Chrome must not default to 9222, which mono-agent's
+ * extension bridge owns. Covers the shared port constant and its env aliases,
+ * and the bridge's fall-through from a dead relay endpoint to a live one.
+ */
+import type { AddressInfo } from 'node:net';
+import { afterEach, describe, expect, it } from 'vitest';
+import { WebSocketServer } from 'ws';
+import { BridgeTransport } from '../browser/bridge.js';
+import { CDP_PROBE_PORTS, DEFAULT_CDP_PORT, resolveCdpPort } from '../browser/cdp-port.js';
+
+describe('resolveCdpPort', () => {
+  it('defaults to 9422, not the bridge port', () => {
+    expect(DEFAULT_CDP_PORT).toBe(9422);
+    expect(resolveCdpPort({})).toBe(9422);
+  });
+
+  it('prefers MONOBROWSE_CDP_PORT over the deprecated aliases', () => {
+    expect(
+      resolveCdpPort({
+        MONOBROWSE_CDP_PORT: '9500',
+        MONOBROWSE_PORT: '9501',
+        MONOMIND_CDP_PORT: '9502',
+      }),
+    ).toBe(9500);
+    expect(resolveCdpPort({ MONOBROWSE_PORT: '9501', MONOMIND_CDP_PORT: '9502' })).toBe(9501);
+    expect(resolveCdpPort({ MONOMIND_CDP_PORT: '9502' })).toBe(9502);
+  });
+
+  it('ignores a non-numeric value', () => {
+    expect(resolveCdpPort({ MONOBROWSE_CDP_PORT: 'nope' })).toBe(9422);
+  });
+
+  it('probes 9422 first and keeps 9222 so a user-launched Chrome is still found', () => {
+    expect(CDP_PROBE_PORTS).toEqual([9422, 9222, 9229]);
+  });
+});
+
+describe('BridgeTransport endpoint fall-through', () => {
+  let server: WebSocketServer | undefined;
+  const saved = process.env.MONOAGENT_BRIDGE_URL;
+
+  afterEach(async () => {
+    if (saved === undefined) delete process.env.MONOAGENT_BRIDGE_URL;
+    else process.env.MONOAGENT_BRIDGE_URL = saved;
+    if (server) await new Promise((r) => server?.close(r));
+    server = undefined;
+  });
+
+  it('moves past a refused endpoint to the next one', async () => {
+    server = new WebSocketServer({ port: 0, host: '127.0.0.1' });
+    await new Promise((r) => server?.once('listening', r));
+    const live = (server.address() as AddressInfo).port;
+    server.on('connection', (ws) => {
+      ws.on('message', (raw) => {
+        const env = JSON.parse(String(raw));
+        ws.send(JSON.stringify({ id: env.id, success: true, data: { tabId: 7 } }));
+      });
+    });
+    // Port 1 refuses connections; the live relay is second.
+    process.env.MONOAGENT_BRIDGE_URL = `ws://127.0.0.1:1/monoagent/cdp, ws://127.0.0.1:${live}/monoagent/cdp`;
+
+    const transport = new BridgeTransport({});
+    await transport.open({ message: () => {}, close: () => {}, error: () => {} });
+    expect(transport.attachedTabId).toBe(7);
+    transport.close();
+  });
+
+  it('rejects when every endpoint is down', async () => {
+    process.env.MONOAGENT_BRIDGE_URL = 'ws://127.0.0.1:1/monoagent/cdp';
+    const transport = new BridgeTransport({});
+    await expect(
+      transport.open({ message: () => {}, close: () => {}, error: () => {} }),
+    ).rejects.toThrow();
+  });
+});

package/src/__tests__/profile-dir.test.ts

@@ -14,6 +14,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import {
+  chromeSpawnEnv,
   isOwnedProfileDir,
   isProfileDirInUse,
   profileDirOwnerPid,
@@ -194,3 +195,21 @@ describe('#395 isOwnedProfileDir / removeOwnedProfileDir', () => {
     15_000,
   );
 });
+
+describe('chromeSpawnEnv (#663)', () => {
+  const env = { TMPDIR: '/x', KEEP: '1' };
+
+  it.skipIf(process.platform === 'win32')(
+    'leaves the env alone when the singleton socket path fits',
+    () => {
+      expect(chromeSpawnEnv(env, '/tmp/mb-abcdef')).toBe(env);
+    },
+  );
+
+  it.skipIf(process.platform === 'win32')(
+    'redirects TMPDIR to /tmp when it would overflow the socket path',
+    () => {
+      expect(chromeSpawnEnv(env, `/tmp/${'x'.repeat(80)}`)).toEqual({ TMPDIR: '/tmp', KEEP: '1' });
+    },
+  );
+});

package/src/browser/bridge.ts

@@ -38,8 +38,18 @@ import { WebSocketTransport } from './transport.js';
 /** Header the Go relay authenticates with; mirrors internal/extension/token.go. */
 export const BRIDGE_TOKEN_HEADER = 'X-Monoagent-Extension-Token';
 
-/** Default relay endpoint; mirrors the extension server's default port. */
-export const DEFAULT_BRIDGE_URL = 'ws://127.0.0.1:9222/monoagent/cdp';
+/**
+ * Relay endpoints tried in order: the extension server's default port, then
+ * the one mono-agent falls back to when 9222 is held. MONOAGENT_BRIDGE_URL
+ * (or the `url` option; comma-separated for several) overrides the list.
+ */
+export const DEFAULT_BRIDGE_URLS: readonly string[] = [
+  'ws://127.0.0.1:9222/monoagent/cdp',
+  'ws://127.0.0.1:9323/monoagent/cdp',
+];
+
+/** The first default relay endpoint. */
+export const DEFAULT_BRIDGE_URL = DEFAULT_BRIDGE_URLS[0];
 
 /** How long the attach handshake may take before open() gives up. */
 const DEFAULT_ATTACH_TIMEOUT_MS = 15_000;
@@ -67,7 +77,7 @@ export interface BridgeTransportOptions {
    * to hand, only a browser with the user's session in it.
    */
   tabId?: number;
-  /** Relay endpoint. Defaults to DEFAULT_BRIDGE_URL. */
+  /** Relay endpoint. Defaults to MONOAGENT_BRIDGE_URL, else DEFAULT_BRIDGE_URLS in order. */
   url?: string;
   /** Relay token, from ~/.monoagent (the Go side writes it). */
   token?: string;
@@ -114,7 +124,10 @@ interface OutboundCdp {
 export class BridgeTransport implements CdpTransport {
   /** 0 until the extension resolves the active tab (see open()). */
   private tabId: number;
-  private readonly socket: CdpTransport;
+  private socket: CdpTransport | undefined;
+  /** Endpoints open() tries in order; empty when a socket was injected. */
+  private readonly urls: readonly string[];
+  private readonly headers: Record<string, string> | undefined;
   private readonly attachTimeoutMs: number;
   private handlers: CdpTransportHandlers | null = null;
   private nextEnvelopeId = 1;
@@ -124,24 +137,62 @@ export class BridgeTransport implements CdpTransport {
   constructor(opts: BridgeTransportOptions) {
     this.tabId = opts.tabId ?? 0;
     this.attachTimeoutMs = opts.attachTimeoutMs ?? DEFAULT_ATTACH_TIMEOUT_MS;
-    this.socket =
-      opts.socket ??
-      new WebSocketTransport(
-        opts.url ?? DEFAULT_BRIDGE_URL,
-        opts.token ? { [BRIDGE_TOKEN_HEADER]: opts.token } : undefined,
-      );
+    this.socket = opts.socket;
+    const pinned = (opts.url ?? process.env.MONOAGENT_BRIDGE_URL)
+      ?.split(',')
+      .map((u) => u.trim())
+      .filter(Boolean);
+    this.urls = opts.socket ? [] : pinned?.length ? pinned : DEFAULT_BRIDGE_URLS;
+    this.headers = opts.token ? { [BRIDGE_TOKEN_HEADER]: opts.token } : undefined;
+  }
+
+  private get sock(): CdpTransport {
+    if (!this.socket) throw new Error('extension bridge is not open');
+    return this.socket;
+  }
+
+  /** Open the relay socket, falling through the candidate endpoints. */
+  private async openSocket(handlers: CdpTransportHandlers): Promise<CdpTransport> {
+    const live: CdpTransportHandlers = {
+      message: handlers.message,
+      close: (err) => this.onGone(err ?? new Error('extension bridge closed')),
+      error: (err) => this.onGone(err),
+    };
+    if (this.socket) {
+      await this.socket.open(live);
+      return this.socket;
+    }
+    let last: unknown;
+    for (const url of this.urls) {
+      // A refused endpoint rejects open(); its error callback must not
+      // report the bridge gone while the next endpoint is still to try.
+      let connecting = true;
+      const socket = new WebSocketTransport(url, this.headers);
+      try {
+        await socket.open({
+          message: live.message,
+          close: (err) => !connecting && live.close(err),
+          error: (err) => !connecting && live.error(err),
+        });
+        connecting = false;
+        return socket;
+      } catch (err) {
+        last = err;
+      }
+    }
+    throw last instanceof Error ? last : new Error('extension bridge unreachable');
   }
 
   async open(handlers: CdpTransportHandlers): Promise<void> {
     this.handlers = handlers;
-    await this.socket.open({
+    this.socket = await this.openSocket({
       message: (data) => this.onBridgeMessage(data),
-      close: (err) => this.onGone(err ?? new Error('extension bridge closed')),
-      error: (err) => this.onGone(err),
+      close: () => {},
+      error: () => {},
     });
     const reply = await this.command('cdp_attach', undefined, this.attachTimeoutMs);
     if (reply.success === false) {
-      this.socket.close();
+      this.sock.close();
       const where = this.tabId ? `tab ${this.tabId}` : 'the active tab';
       throw new Error(`bridge attach to ${where} failed: ${reply.error ?? 'unknown'}`);
     }
@@ -149,7 +200,7 @@ export class BridgeTransport implements CdpTransport {
     // the only way to learn the id when we asked for "whatever is active".
     if (typeof reply.data?.tabId === 'number') this.tabId = reply.data.tabId;
     if (!this.tabId) {
-      this.socket.close();
+      this.sock.close();
       throw new Error('bridge attach did not report a tab id');
     }
   }
@@ -199,7 +250,7 @@ export class BridgeTransport implements CdpTransport {
     // attached leaves Chrome's debugging banner on the user's tab. The
     // extension's idle sweep would eventually detach anyway.
     void this.command('cdp_detach').catch(() => {});
-    this.socket.close();
+    this.socket?.close();
     this.failPending(new Error('extension bridge closed'));
   }
 
@@ -252,7 +303,7 @@ export class BridgeTransport implements CdpTransport {
         if (timer) clearTimeout(timer);
         resolve(reply);
       });
-      this.socket.send(JSON.stringify(envelope)).catch((err) => {
+      this.sock.send(JSON.stringify(envelope)).catch((err) => {
         if (timer) clearTimeout(timer);
         this.pending.delete(id);
         reject(err);

package/src/browser/browser-launch.ts

@@ -16,14 +16,15 @@ import {
 } from './browser-discovery.js';
 import { reapIdleLaunchedBrowser } from './browser-lifecycle.js';
 import { launchedPids, launchedUserDataDirs, ownedUserDataDirPorts } from './browser-state.js';
+import { DEFAULT_CDP_PORT } from './cdp-port.js';
 import {
+  chromeSpawnEnv,
   launchProfileDirPath,
   removeOwnedProfileDir,
   sweepStaleProfileDirs,
 } from './profile-dir.js';
 import type { BrowserConfig } from './types.js';
 
-const DEFAULT_PORT = 9222;
 const LAUNCH_TIMEOUT = 10_000;
 const POLL_INTERVAL = 200;
 
@@ -40,7 +41,7 @@ const LAUNCH_PORT_SCAN_TRIES = 10;
 class ChromeExitedEarlyError extends Error {}
 
 export async function launchBrowser(config: BrowserConfig = {}): Promise<number> {
-  const rawPort = config.port ?? DEFAULT_PORT;
+  const rawPort = config.port ?? DEFAULT_CDP_PORT;
   // Port 0 means "let Chrome bind a free port and tell us which" — see
   // launchOnFreePort. Otherwise validate port is in a safe range for
   // localhost CDP debugging.
@@ -236,6 +237,7 @@ async function launchOnFreePort(config: BrowserConfig, port: number): Promise<nu
   const args = [...defaultArgs, ...callerArgs];
   const child = spawn(chromePath, args, {
     detached: true,
+    env: chromeSpawnEnv(process.env),
     // stderr carries the fixed-port ownership proof (see above). The pipe is
     // closed as soon as this launch settles, so a Chrome that outlives us
     // never blocks writing to it.

package/src/browser/cdp-port.ts

@@ -0,0 +1,26 @@
+/**
+ * The CDP port monomind's own Chrome defaults to. Not 9222: mono-agent's
+ * extension bridge permanently owns that one and answers only /monoagent
+ * routes, so a connect to it never reaches Chrome (#666). 9422 sits outside
+ * the 922x/932x neighbourhood mono-agent uses (9222 bridge, 9232 test
+ * bridge, 9323 bridge fallback); launching still scans upward if it is busy.
+ */
+export const DEFAULT_CDP_PORT = 9422;
+
+/**
+ * Ports probed by `connect --auto-connect`. 9222 stays a probe so a user's
+ * own `--remote-debugging-port=9222` Chrome is still found.
+ */
+export const CDP_PROBE_PORTS: readonly number[] = [DEFAULT_CDP_PORT, 9222, 9229];
+
+/**
+ * The configured CDP port: MONOBROWSE_CDP_PORT, else the two older names
+ * (MONOBROWSE_PORT, MONOMIND_CDP_PORT; deprecated aliases), else the default.
+ */
+export function resolveCdpPort(env: NodeJS.ProcessEnv = process.env): number {
+  for (const name of ['MONOBROWSE_CDP_PORT', 'MONOBROWSE_PORT', 'MONOMIND_CDP_PORT']) {
+    const port = Number.parseInt(env[name] ?? '', 10);
+    if (Number.isInteger(port) && port > 0) return port;
+  }
+  return DEFAULT_CDP_PORT;
+}

package/src/browser/cdp.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_CDP_PORT } from './cdp-port.js';
 import type { CdpTransport } from './transport.js';
 import { WebSocketTransport } from './transport.js';
 import type { CdpCommand, CdpResponse, CdpTarget } from './types.js';
@@ -233,7 +234,10 @@ export interface BrowserPage {
   close(): Promise<void>;
 }
 
-export async function createBrowserPage(url: string, port = 9222): Promise<BrowserPage> {
+export async function createBrowserPage(
+  url: string,
+  port = DEFAULT_CDP_PORT,
+): Promise<BrowserPage> {
   const target = await fetchNewTarget(port, url);
   const wsDebuggerUrl = target.webSocketDebuggerUrl;
   if (!wsDebuggerUrl) {

package/src/browser/index.ts

@@ -4,6 +4,7 @@ export * from './batch.js';
 export * from './bridge.js';
 export * from './browser.js';
 export * from './cdp.js';
+export * from './cdp-port.js';
 export * from './console-log.js';
 export * from './dialog.js';
 export * from './emulation.js';

package/src/browser/profile-dir.ts

@@ -38,6 +38,25 @@ const HOLDER_WAIT_MS = 2000;
 const POLL_MS = 50;
 const RM_RETRY_DELAY_MS = 250;
 
+/** Longest unix socket path Chrome's singleton lock can bind (sun_path is 104
+ *  bytes on macOS, 108 on Linux; both include the NUL). */
+const MAX_SOCKET_PATH = 103;
+/** `/org.chromium.Chromium.XXXXXX/SingletonSocket` — what Chrome appends to TMPDIR. */
+const SINGLETON_SOCKET_SUFFIX_LEN = '/org.chromium.Chromium.XXXXXX/SingletonSocket'.length;
+
+/**
+ * Environment to spawn Chrome with (#663). Chrome binds its singleton lock
+ * socket under $TMPDIR regardless of --user-data-dir, and aborts at startup
+ * (`FATAL: Socket path too long`, SIGABRT) once that path passes the unix
+ * socket limit — which a deep TMPDIR (CI work dirs, sandboxed runners) does.
+ * Only then is TMPDIR redirected to /tmp; otherwise the env is untouched.
+ */
+export function chromeSpawnEnv(env: NodeJS.ProcessEnv, tmp = tmpdir()): NodeJS.ProcessEnv {
+  if (process.platform === 'win32') return env;
+  if (Buffer.byteLength(tmp) + SINGLETON_SOCKET_SUFFIX_LEN <= MAX_SOCKET_PATH) return env;
+  return { ...env, TMPDIR: '/tmp' };
+}
+
 /** Name for a new default launch profile, directly under `root`. */
 export function launchProfileDirPath(port: number, id: string, root = tmpdir()): string {
   return join(root, `monomind-browser-${port}-${process.pid}-${id}`);

package/src/cli/action.ts

@@ -4,6 +4,7 @@ import { existsSync } from 'node:fs';
 import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Command } from 'commander';
+import { resolveCdpPort } from '../browser/cdp-port.js';
 import type { ActionDef, StepDef } from '../index.js';
 import { type AnalyzerPage, analyzePageForAction } from '../index.js';
 
@@ -72,7 +73,7 @@ export function createActionCommand(): Command {
           | null;
         if (!createBrowserPage) {
           throw new Error(
-            'Browser CDP client not available. Ensure Chrome is running with --remote-debugging-port=9222',
+            'Browser CDP client not available. Ensure Chrome is running with --remote-debugging-port=9422',
           );
         }
         const page = await createBrowserPage(opts.url);
@@ -119,7 +120,7 @@ export function createActionCommand(): Command {
       const { clickElement, fillElement, evaluateJs } = await import('../browser/actions.js');
       const { findBySelector } = await import('../browser/find.js');
       const { waitFor } = await import('../browser/wait.js');
-      const port = parseInt(process.env.MONOBROWSE_PORT ?? '9222', 10);
+      const port = resolveCdpPort();
       const { client, sessionId } = await connectToTarget(port);
       const refs = new Map<string, import('../browser/types.js').ElementRef>();
 

package/src/cli/commands-session.ts

@@ -8,6 +8,7 @@
  * differently: it must never kill a Chrome it did not launch.
  */
 
+import { CDP_PROBE_PORTS, DEFAULT_CDP_PORT } from '../browser/cdp-port.js';
 import { detectAttentionNeeded, switchToHeaded } from './attention-wall.js';
 import { output } from './output.js';
 import {
@@ -299,22 +300,28 @@ export const closeCommand: Command = {
 export const connectCommand: Command = {
   name: 'connect',
   description:
-    'Connect to existing Chrome instance; later commands reuse this session (note: `open` without --port still launches on its own default). Usage: monomind browse connect [--port 9222] [--target <id>] [--auto-connect]',
+    'Connect to existing Chrome instance; later commands reuse this session (note: `open` without --port still launches on its own default). Usage: monomind browse connect [--port 9422] [--target <id>] [--auto-connect]',
   options: [
-    { name: 'port', short: 'p', type: 'number', description: 'CDP port', default: 9222 },
+    {
+      name: 'port',
+      short: 'p',
+      type: 'number',
+      description: 'CDP port',
+      default: DEFAULT_CDP_PORT,
+    },
     { name: 'target', type: 'string', description: 'Target ID to attach to' },
     {
       name: 'auto-connect',
       type: 'boolean',
-      description: 'Auto-discover running Chrome on ports 9222 and 9229',
+      description: 'Auto-discover running Chrome on ports 9422, 9222 and 9229',
       default: false,
     },
   ],
   action: async (ctx: CommandContext): Promise<CommandResult> => {
-    let port = (ctx.flags.port as number) ?? 9222;
+    let port = (ctx.flags.port as number) ?? DEFAULT_CDP_PORT;
 
     if (ctx.flags['auto-connect']) {
-      const probePorts = [9222, 9229];
+      const probePorts = CDP_PROBE_PORTS;
       let found = false;
       for (const p of probePorts) {
         try {

package/src/cli/platform.ts

@@ -8,9 +8,10 @@ import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { Command } from 'commander';
+import { resolveCdpPort } from '../browser/cdp-port.js';
 import { getAdapter } from '../index.js';
 
-const CDP_PORT = Number(process.env.MONOMIND_CDP_PORT ?? 9222);
+const CDP_PORT = resolveCdpPort();
 
 const SESSIONS_FILE = join(homedir(), '.monomind', 'sessions.json');