browser-debugger-cli 0.8.0 → 0.9.0

package/dist/session/QueryCacheManager.js

@@ -23,6 +23,7 @@ import { readFile, rm, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { getSessionDir } from './paths.js';
 import { createLogger } from '../ui/logging/index.js';
+import { sessionCommand } from '../ui/messages/sessionCommand.js';
 import { getErrorMessage } from '../utils/errors.js';
 const log = createLogger('session');
 /**
@@ -34,6 +35,27 @@ const CACHE_VERSION = 2;
  * Selector recorded for `dom form` results (fields carry their own selectors).
  */
 export const FORM_DISCOVERY_CACHE_SELECTOR = 'form:auto-discovered';
+/** Prefix of the selector recorded for `dom a11y query` results (followed by the pattern) */
+export const A11Y_CACHE_SELECTOR_PREFIX = 'a11y ';
+/**
+ * The list an index refers to, from the selector recorded with the cache.
+ *
+ * @param index - The index the user gave
+ * @param cacheSelector - Selector recorded with the cached results
+ * @returns The command whose results are cached, and its query
+ */
+export function indexSourceOf(index, cacheSelector) {
+    if (cacheSelector === FORM_DISCOVERY_CACHE_SELECTOR)
+        return { index, command: 'dom form' };
+    if (cacheSelector.startsWith(A11Y_CACHE_SELECTOR_PREFIX)) {
+        return {
+            index,
+            command: 'dom a11y query',
+            query: cacheSelector.slice(A11Y_CACHE_SELECTOR_PREFIX.length),
+        };
+    }
+    return { index, command: 'dom query', query: cacheSelector };
+}
 /**
  * Singleton manager for the on-disk query cache.
  */
@@ -89,7 +111,7 @@ export class QueryCacheManager {
                 valid: false,
                 cache: null,
                 error: 'No cached query results found',
-                suggestion: 'Run "bdg dom query <selector>" first to generate indexed results',
+                suggestion: `Run "${sessionCommand('bdg dom query <selector>')}" first to generate indexed results`,
             };
         }
         const { version, ...cache } = raw;
@@ -99,8 +121,8 @@ export class QueryCacheManager {
                 cache: null,
                 error: 'Cached query results are from an older bdg version',
                 suggestion: cache.selector === FORM_DISCOVERY_CACHE_SELECTOR
-                    ? 'Re-run "bdg dom form" to refresh cached results'
-                    : `Re-run "bdg dom query ${cache.selector}" to refresh cached results`,
+                    ? `Re-run "${sessionCommand('bdg dom form')}" to refresh cached results`
+                    : `Re-run "${sessionCommand(`bdg dom query ${cache.selector}`)}" to refresh cached results`,
             };
         }
         return { valid: true, cache };

package/dist/session/chromeOwners.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Which other bdg session uses a Chrome, so `--chrome-ws-url` never takes over
+ * a tab another session drives, nor a Chrome another session launched (and
+ * closes when it stops).
+ *
+ * Sessions are found in this base directory and, through the machine-wide
+ * port registry, in other base directories whose sessions claimed a port.
+ */
+/**
+ * A running session and the Chrome tab it drives.
+ */
+export interface ChromeOwner {
+    /** Session name, or null for a default session */
+    name: string | null;
+    /** Session directory */
+    dir: string;
+    /** Base directory of the session (its `BDG_SESSION_DIR`) */
+    baseDir: string;
+    /** Target (tab) the session drives */
+    targetId: string;
+    /** Whether the session launched that Chrome (it closes Chrome when it stops) */
+    launched: boolean;
+}
+/**
+ * Another running session that a new session attaching to a Chrome would
+ * collide with: one that launched that Chrome, or one driving the tab the
+ * new session would use.
+ *
+ * @param chromeTargetIds - Ids of every target of the Chrome being attached to
+ * @param targetId - Tab the new session would drive
+ * @returns The conflicting session, or null
+ */
+export declare function findConflictingOwner(chromeTargetIds: readonly string[], targetId: string): Promise<ChromeOwner | null>;
+//# sourceMappingURL=chromeOwners.d.ts.map

package/dist/session/chromeOwners.js

@@ -0,0 +1,51 @@
+/**
+ * Which other bdg session uses a Chrome, so `--chrome-ws-url` never takes over
+ * a tab another session drives, nor a Chrome another session launched (and
+ * closes when it stops).
+ *
+ * Sessions are found in this base directory and, through the machine-wide
+ * port registry, in other base directories whose sessions claimed a port.
+ */
+import * as fs from 'fs';
+import { probeDaemonSocket } from './daemonSocket.js';
+import { sessionFilePathIn, sessionOfDir } from './paths.js';
+import { otherSessionDirs } from './portClaims.js';
+import { createLogger, logDebugError } from '../ui/logging/index.js';
+const log = createLogger('session');
+/**
+ * The tab a running session drives, from its metadata.
+ *
+ * @param dir - Session directory
+ * @returns Owner info, or null without a running session or metadata
+ */
+async function readOwner(dir) {
+    if ((await probeDaemonSocket(sessionFilePathIn(dir, 'DAEMON_SOCKET'))) !== 'alive')
+        return null;
+    try {
+        const meta = JSON.parse(fs.readFileSync(sessionFilePathIn(dir, 'METADATA'), 'utf8'));
+        if (typeof meta.targetId !== 'string')
+            return null;
+        const launched = typeof meta.chromePid === 'number' && meta.chromePid > 0;
+        return { ...sessionOfDir(dir), dir, targetId: meta.targetId, launched };
+    }
+    catch (error) {
+        logDebugError(log, `read the metadata in ${dir}`, error);
+        return null;
+    }
+}
+/**
+ * Another running session that a new session attaching to a Chrome would
+ * collide with: one that launched that Chrome, or one driving the tab the
+ * new session would use.
+ *
+ * @param chromeTargetIds - Ids of every target of the Chrome being attached to
+ * @param targetId - Tab the new session would drive
+ * @returns The conflicting session, or null
+ */
+export async function findConflictingOwner(chromeTargetIds, targetId) {
+    const owners = await Promise.all(otherSessionDirs().map(readOwner));
+    return (owners.find((owner) => owner !== null &&
+        chromeTargetIds.includes(owner.targetId) &&
+        (owner.launched || owner.targetId === targetId)) ?? null);
+}
+//# sourceMappingURL=chromeOwners.js.map

package/dist/session/cleanup/staleSession.d.ts

@@ -26,6 +26,15 @@ export declare function removeStaleDaemonFiles(): Promise<boolean>;
  * @returns Chrome PID, or null
  */
 export declare function findOrphanedChrome(): number | null;
+/**
+ * Whether a process is the Chrome bdg launched for a session directory: its
+ * command line carries the directory's marker flag.
+ *
+ * @param pid - Process ID
+ * @param sessionDir - Session directory
+ * @returns True for that session's Chrome
+ */
+export declare function isSessionChrome(pid: number, sessionDir: string): boolean;
 /**
  * Kill the Chrome recorded in chrome.pid, if it is still the Chrome bdg launched
  * for this session directory (verified by its marker flag).
@@ -43,7 +52,8 @@ export declare function reapOrphanedChrome(): Promise<boolean>;
 /**
  * Read the PID of a live bdg daemon from daemon.pid.
  *
+ * @param dir - Session directory (defaults to the selected session's)
  * @returns Daemon PID if the process is alive and is a bdg daemon, else null
  */
-export declare function readLiveDaemonPid(): number | null;
+export declare function readLiveDaemonPid(dir?: string): number | null;
 //# sourceMappingURL=staleSession.d.ts.map

package/dist/session/cleanup/staleSession.js

@@ -10,8 +10,8 @@ import { chromeSessionMarkerFlag } from '../../connection/launcher/flagsBuilder.
 import { QueryCacheManager } from '../QueryCacheManager.js';
 import { clearChromePid, readChromePid } from '../chrome.js';
 import { probeDaemonSocket } from '../daemonSocket.js';
-import { getSessionDir, getSessionFilePath } from '../paths.js';
-import { readDaemonPid } from '../pid.js';
+import { getSessionDir, getSessionFilePath, sessionFilePathIn } from '../paths.js';
+import { readPidFromFile } from '../pid.js';
 import { createLogger, logDebugError } from '../../ui/logging/index.js';
 import { delay } from '../../utils/async.js';
 import { safeRemoveFile } from '../../utils/file.js';
@@ -66,13 +66,23 @@ export function findOrphanedChrome() {
     const chromePid = readChromePid();
     if (!chromePid)
         return null;
-    if (hasArgument(getProcessCommand(chromePid), chromeSessionMarkerFlag(getSessionDir()))) {
+    if (isSessionChrome(chromePid, getSessionDir()))
         return chromePid;
-    }
     log.debug(`PID ${chromePid} is no longer a bdg Chrome; dropping chrome.pid`);
     clearChromePid();
     return null;
 }
+/**
+ * Whether a process is the Chrome bdg launched for a session directory: its
+ * command line carries the directory's marker flag.
+ *
+ * @param pid - Process ID
+ * @param sessionDir - Session directory
+ * @returns True for that session's Chrome
+ */
+export function isSessionChrome(pid, sessionDir) {
+    return hasArgument(getProcessCommand(pid), chromeSessionMarkerFlag(sessionDir));
+}
 /**
  * Kill the Chrome recorded in chrome.pid, if it is still the Chrome bdg launched
  * for this session directory (verified by its marker flag).
@@ -113,10 +123,11 @@ export async function reapOrphanedChrome() {
 /**
  * Read the PID of a live bdg daemon from daemon.pid.
  *
+ * @param dir - Session directory (defaults to the selected session's)
  * @returns Daemon PID if the process is alive and is a bdg daemon, else null
  */
-export function readLiveDaemonPid() {
-    const pid = readDaemonPid();
+export function readLiveDaemonPid(dir = getSessionDir()) {
+    const pid = readPidFromFile(sessionFilePathIn(dir, 'DAEMON_PID'));
     if (!pid || !isProcessAlive(pid))
         return null;
     return hasArgument(getProcessCommand(pid), DAEMON_SCRIPT_PATH) ? pid : null;

package/dist/session/cleanup/userCommands.js

@@ -5,7 +5,7 @@ import * as fs from 'fs';
 import { killOrphanedChrome, readLiveDaemonPid, removeStaleDaemonFiles, } from './staleSession.js';
 import { isDaemonAlive } from '../daemonSocket.js';
 import { clearLastSessionEnd } from '../lastSession.js';
-import { getSessionFilePath } from '../paths.js';
+import { SESSION_STATE_FILES, getSessionFilePath } from '../paths.js';
 import { createLogger } from '../../ui/logging/index.js';
 import { getErrorMessage } from '../../utils/errors.js';
 const log = createLogger('cleanup');
@@ -39,15 +39,13 @@ export async function performSessionCleanup(options) {
         warnings,
     };
 }
-/** Files a session leaves behind (stale ones are what cleanup removes) */
-const SESSION_FILE_TYPES = ['DAEMON_PID', 'DAEMON_SOCKET', 'CHROME_PID', 'METADATA'];
 /**
  * How many session files exist.
  *
  * @returns Number of existing session files
  */
 function countSessionFiles() {
-    return SESSION_FILE_TYPES.filter((type) => fs.existsSync(getSessionFilePath(type))).length;
+    return SESSION_STATE_FILES.filter((type) => fs.existsSync(getSessionFilePath(type))).length;
 }
 /**
  * SIGKILL a live bdg daemon and wait briefly for its socket to go away.

package/dist/session/metadata.d.ts

@@ -4,7 +4,7 @@
  * Handles reading/writing session metadata (Chrome PID, CDP port, target info, etc).
  * WHY: Metadata persistence enables `bdg status` and other commands to inspect active sessions.
  */
-import type { TelemetryType } from '../types.js';
+import type { ColorScheme, TelemetryType, ViewportSize } from '../types.js';
 /**
  * Session metadata stored in ~/.bdg/session.meta.json
  */
@@ -18,6 +18,10 @@ export interface SessionMetadata {
     activeTelemetry?: TelemetryType[] | undefined;
     /** When `--timeout` stops the session (epoch ms) */
     autoStopAt?: number | undefined;
+    /** Viewport the page is emulated at (`--viewport`) */
+    viewport?: ViewportSize | undefined;
+    /** `prefers-color-scheme` the page is emulated with (`--color-scheme`) */
+    colorScheme?: ColorScheme | undefined;
 }
 /**
  * Options for reading session metadata.

package/dist/session/metadata.js

@@ -6,6 +6,7 @@
  */
 import * as fs from 'fs';
 import { createLogger } from '../ui/logging/index.js';
+import { sessionCommand } from '../ui/messages/sessionCommand.js';
 import { AtomicFileWriter } from '../utils/atomicFile.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { getSessionFilePath, ensureSessionDir } from './paths.js';
@@ -20,7 +21,7 @@ const log = createLogger('session');
 function handleCorruptedMetadata(metaPath, error, options) {
     if (options?.warnOnCorruption) {
         log.info(`Session metadata corrupted (cannot read details): ${getErrorMessage(error)}`);
-        log.info('Troubleshooting: Run "bdg cleanup" to remove corrupted files');
+        log.info(`Troubleshooting: Run "${sessionCommand('bdg cleanup')}" to remove corrupted files`);
     }
     if (options?.selfHealOnCorruption) {
         try {

package/dist/session/paths.d.ts

@@ -2,6 +2,7 @@
  * Session path generation and management.
  *
  * Centralized path generation for all session-related files in ~/.bdg/
+ * (or `~/.bdg/sessions/<name>/` for a named session).
  * WHY: Single source of truth for file locations prevents path inconsistencies.
  */
 /**
@@ -17,18 +18,91 @@ declare const SESSION_FILES: {
     readonly PORT: "port.txt";
     readonly LAST_SESSION: "last-session.json";
 };
+/** Environment variable holding the selected session name (set by `--session`) */
+export declare const SESSION_NAME_ENV = "BDG_SESSION";
+/** Longest Unix socket path (sun_path is 104 bytes on macOS, 108 on Linux, NUL included) */
+export declare const MAX_SOCKET_PATH_BYTES: number;
+/**
+ * Longest public daemon socket path: the daemon first listens on
+ * `<path>.<pid>` and then links it into place, so the pid suffix (up to 7
+ * digits) must fit too.
+ */
+export declare const MAX_DAEMON_SOCKET_PATH_BYTES: number;
+/**
+ * A session directory: the default session (`name` null) or a named one.
+ */
+export interface SessionDirEntry {
+    /** Session name, or null for the default session */
+    name: string | null;
+    /** Absolute session directory */
+    dir: string;
+}
 /**
  * Session file type for type-safe path generation
  */
 export type SessionFileType = keyof typeof SESSION_FILES;
 /**
- * Get the session directory path (~/.bdg)
+ * Files a running session keeps in its directory; left behind (stale) when
+ * its daemon dies without tearing down.
+ */
+export declare const SESSION_STATE_FILES: readonly ["DAEMON_PID", "DAEMON_SOCKET", "CHROME_PID", "METADATA"];
+/**
+ * Get the base session directory: `$BDG_SESSION_DIR`, else `~/.bdg`.
+ *
+ * It is the default session's directory and holds named sessions under
+ * `sessions/<name>/`. Uses os.homedir() dynamically to support test
+ * environment variable changes.
+ *
+ * @returns Full path to the base session directory
+ */
+export declare function getSessionBaseDir(): string;
+/**
+ * The selected session name (`--session` / `BDG_SESSION`), lower-cased:
+ * session names are case-insensitive.
+ *
+ * @returns Session name, or null for the default session
+ */
+export declare function getSessionName(): string | null;
+/**
+ * Directory of a named session.
  *
- * Uses os.homedir() dynamically to support test environment variable changes.
+ * @param name - Session name
+ * @returns `<base>/sessions/<name>`
+ */
+export declare function getNamedSessionDir(name: string): string;
+/**
+ * Get the directory of the selected session: the base directory for the
+ * default session, `<base>/sessions/<name>` for a named one.
  *
- * @returns Full path to session directory
+ * @returns Full path to the session directory
  */
 export declare function getSessionDir(): string;
+/**
+ * Every session directory on disk: the default one, then named sessions
+ * sorted by name. Directories need not hold a running session.
+ *
+ * @returns Session directory entries
+ */
+export declare function listSessionDirs(): SessionDirEntry[];
+/**
+ * Which session a directory holds, from its location: `<base>/sessions/<name>`
+ * is a named session, any other directory a default session (its own base).
+ *
+ * @param dir - Absolute session directory
+ * @returns Session name (null for a default session) and base directory
+ */
+export declare function sessionOfDir(dir: string): {
+    name: string | null;
+    baseDir: string;
+};
+/**
+ * Path of a session file in a given session directory.
+ *
+ * @param dir - Session directory
+ * @param fileType - The type of session file
+ * @returns Full path to the file
+ */
+export declare function sessionFilePathIn(dir: string, fileType: SessionFileType): string;
 /**
  * Get the path to a session file by type.
  *

package/dist/session/paths.js

@@ -2,11 +2,14 @@
  * Session path generation and management.
  *
  * Centralized path generation for all session-related files in ~/.bdg/
+ * (or `~/.bdg/sessions/<name>/` for a named session).
  * WHY: Single source of truth for file locations prevents path inconsistencies.
  */
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { createLogger, logDebugError } from '../ui/logging/index.js';
+const log = createLogger('session');
 /**
  * Session file paths relative to ~/.bdg/
  * Centralized definition for all session-related files.
@@ -21,20 +24,123 @@ const SESSION_FILES = {
     LAST_SESSION: 'last-session.json',
 };
 const SESSION_DIR_OVERRIDE_ENV = 'BDG_SESSION_DIR';
+/** Environment variable holding the selected session name (set by `--session`) */
+export const SESSION_NAME_ENV = 'BDG_SESSION';
+/** Subdirectory of the base session directory that holds named sessions */
+const NAMED_SESSIONS_DIR = 'sessions';
+/** Longest Unix socket path (sun_path is 104 bytes on macOS, 108 on Linux, NUL included) */
+export const MAX_SOCKET_PATH_BYTES = process.platform === 'darwin' ? 103 : 107;
 /**
- * Get the session directory path (~/.bdg)
+ * Longest public daemon socket path: the daemon first listens on
+ * `<path>.<pid>` and then links it into place, so the pid suffix (up to 7
+ * digits) must fit too.
+ */
+export const MAX_DAEMON_SOCKET_PATH_BYTES = MAX_SOCKET_PATH_BYTES - '.9999999'.length;
+/**
+ * Files a running session keeps in its directory; left behind (stale) when
+ * its daemon dies without tearing down.
+ */
+export const SESSION_STATE_FILES = [
+    'DAEMON_PID',
+    'DAEMON_SOCKET',
+    'CHROME_PID',
+    'METADATA',
+];
+/**
+ * Get the base session directory: `$BDG_SESSION_DIR`, else `~/.bdg`.
  *
- * Uses os.homedir() dynamically to support test environment variable changes.
+ * It is the default session's directory and holds named sessions under
+ * `sessions/<name>/`. Uses os.homedir() dynamically to support test
+ * environment variable changes.
  *
- * @returns Full path to session directory
+ * @returns Full path to the base session directory
  */
-export function getSessionDir() {
+export function getSessionBaseDir() {
     const override = process.env[SESSION_DIR_OVERRIDE_ENV];
     if (override && override.trim().length > 0) {
         return path.isAbsolute(override) ? override : path.resolve(override);
     }
     return path.join(os.homedir(), '.bdg');
 }
+/**
+ * The selected session name (`--session` / `BDG_SESSION`), lower-cased:
+ * session names are case-insensitive.
+ *
+ * @returns Session name, or null for the default session
+ */
+export function getSessionName() {
+    const name = process.env[SESSION_NAME_ENV]?.trim();
+    if (!name)
+        return null;
+    return name.toLowerCase();
+}
+/**
+ * Directory of a named session.
+ *
+ * @param name - Session name
+ * @returns `<base>/sessions/<name>`
+ */
+export function getNamedSessionDir(name) {
+    return path.join(getSessionBaseDir(), NAMED_SESSIONS_DIR, name);
+}
+/**
+ * Get the directory of the selected session: the base directory for the
+ * default session, `<base>/sessions/<name>` for a named one.
+ *
+ * @returns Full path to the session directory
+ */
+export function getSessionDir() {
+    const name = getSessionName();
+    return name === null ? getSessionBaseDir() : getNamedSessionDir(name);
+}
+/**
+ * Every session directory on disk: the default one, then named sessions
+ * sorted by name. Directories need not hold a running session.
+ *
+ * @returns Session directory entries
+ */
+export function listSessionDirs() {
+    const namedRoot = path.join(getSessionBaseDir(), NAMED_SESSIONS_DIR);
+    let names = [];
+    try {
+        names = fs
+            .readdirSync(namedRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        logDebugError(log, `list ${namedRoot}`, error);
+    }
+    return [
+        { name: null, dir: getSessionBaseDir() },
+        ...names.map((name) => ({ name, dir: path.join(namedRoot, name) })),
+    ];
+}
+/**
+ * Which session a directory holds, from its location: `<base>/sessions/<name>`
+ * is a named session, any other directory a default session (its own base).
+ *
+ * @param dir - Absolute session directory
+ * @returns Session name (null for a default session) and base directory
+ */
+export function sessionOfDir(dir) {
+    const parent = path.dirname(dir);
+    if (path.basename(parent) === NAMED_SESSIONS_DIR) {
+        return { name: path.basename(dir), baseDir: path.dirname(parent) };
+    }
+    return { name: null, baseDir: dir };
+}
+/**
+ * Path of a session file in a given session directory.
+ *
+ * @param dir - Session directory
+ * @param fileType - The type of session file
+ * @returns Full path to the file
+ */
+export function sessionFilePathIn(dir, fileType) {
+    return path.join(dir, SESSION_FILES[fileType]);
+}
 /**
  * Get the path to a session file by type.
  *
@@ -48,7 +154,7 @@ export function getSessionDir() {
  * ```
  */
 export function getSessionFilePath(fileType) {
-    return path.join(getSessionDir(), SESSION_FILES[fileType]);
+    return sessionFilePathIn(getSessionDir(), fileType);
 }
 /**
  * Get the path to the daemon's Unix domain socket.

package/dist/session/port.d.ts

@@ -3,8 +3,25 @@
  *
  * Handles automatic port selection and persistence for session isolation.
  * Each session directory can have its own persistent port, enabling multiple
- * concurrent bdg sessions with different BDG_SESSION_DIR values.
+ * concurrent bdg sessions (named sessions or different BDG_SESSION_DIR values).
  */
+/**
+ * First port tried for this session: the default session starts at
+ * DEFAULT_CDP_PORT, named sessions one above so they leave it to the default
+ * session.
+ *
+ * @returns First candidate port
+ */
+export declare function firstCandidatePort(): number;
+/**
+ * Find an available port starting from a given port.
+ *
+ * @param startPort - Port to start scanning from
+ * @param claimed - Ports to skip (claimed by other sessions)
+ * @returns Promise resolving to an available port
+ * @throws CommandError if no available port found in range
+ */
+export declare function findAvailablePort(startPort?: number, claimed?: ReadonlySet<number>): Promise<number>;
 /**
  * Read the saved port from the session directory.
  *
@@ -21,13 +38,20 @@ export declare function writeSessionPort(port: number): void;
  * Get or allocate a port for this session.
  *
  * Logic:
- * 1. If a port is explicitly provided, use it (user override)
- * 2. Check if there's a saved port in the session directory
- * 3. If saved port exists and is available, reuse it (session stability)
- * 4. Otherwise, find a new available port and save it
+ * 1. If a port is explicitly provided, use it (user override; a named session
+ *    saves and claims it under the lock so other sessions skip it)
+ * 2. Otherwise, under a lock shared by all sessions on the machine (any
+ *    BDG_SESSION_DIR), reuse the saved port if it is free and no other
+ *    running session claims it (session stability)
+ * 3. Otherwise, take the first free, unclaimed port from
+ *    {@link firstCandidatePort} upwards and save it (the claim)
+ *
+ * The claim is also recorded in the machine-wide registry (under the lock),
+ * so sessions of other base directories skip it too.
  *
- * This provides session isolation: different BDG_SESSION_DIR values
- * will automatically use different ports.
+ * This provides session isolation: named sessions and different
+ * BDG_SESSION_DIR values automatically use different ports, even when they
+ * start at the same time.
  *
  * @param explicitPort - User-provided port (takes precedence)
  * @returns Promise resolving to the port to use