@sovovs/bycli 2.1.40 → 2.1.42

package/dist/src/adapter-scheduler.js

@@ -0,0 +1,349 @@
+import * as crypto from 'node:crypto';
+export class AdapterSchedulerError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'AdapterSchedulerError';
+    }
+}
+export class AdapterScheduler {
+    now;
+    leaseExpiryMs;
+    runtimeCeiling;
+    releasedLeaseRetentionMs;
+    pools = new Map();
+    releasedLeaseIds = new Map();
+    generations = new Map();
+    resourceOwners = new Map();
+    resourceGrants = new Map();
+    resourceQueue = [];
+    sequence = 0;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        this.leaseExpiryMs = options.leaseExpiryMs ?? 45_000;
+        this.runtimeCeiling = options.runtimeCeiling ?? 3;
+        this.releasedLeaseRetentionMs = options.releasedLeaseRetentionMs ?? 300_000;
+    }
+    acquire(request) {
+        this.validateRequest(request);
+        const pool = this.getOrCreatePool(request);
+        if (pool.closed) {
+            return Promise.reject(this.poolClosedError(pool.closed));
+        }
+        pool.maxParallel = Math.min(pool.maxParallel, request.maxParallel, this.runtimeCeiling);
+        if ([...pool.running.values()].some(lease => lease.requestId === request.requestId)
+            || pool.queued.some(entry => entry.request.requestId === request.requestId)) {
+            return Promise.reject(new AdapterSchedulerError('ADAPTER_QUEUE_RESET', 'Duplicate Adapter lease request id'));
+        }
+        return new Promise((resolve, reject) => {
+            const enqueuedAt = this.now();
+            const pending = {
+                request,
+                enqueuedAt,
+                deadline: enqueuedAt + request.queueTimeoutMs,
+                sequence: ++this.sequence,
+                resolve,
+                reject,
+            };
+            pending.timer = setTimeout(() => this.sweepExpired(), request.queueTimeoutMs);
+            pending.timer.unref?.();
+            pool.queued.push(pending);
+            this.schedule(pool);
+        });
+    }
+    heartbeat(identity) {
+        const lease = this.requireLease(identity);
+        lease.heartbeatDeadline = this.now() + this.leaseExpiryMs;
+        return { ...lease };
+    }
+    assertLease(identity) {
+        return { ...this.requireLease(identity) };
+    }
+    release(release) {
+        this.pruneReleasedLeaseIds();
+        if (this.releasedLeaseIds.has(release.leaseId))
+            return false;
+        const lease = this.requireLease(release);
+        const pool = this.pools.get(lease.poolKey);
+        this.releaseAllResourcesForLease(lease.leaseId);
+        this.rejectResourceWaitersForLease(lease.leaseId);
+        pool.running.delete(lease.leaseId);
+        pool.activeSessions.delete(lease.adapterSession);
+        this.releasedLeaseIds.set(lease.leaseId, this.now() + this.releasedLeaseRetentionMs);
+        if (release.reason === 'auth_gate' || release.reason === 'rate_limited') {
+            pool.closed = release.reason;
+            const error = this.poolClosedError(release.reason);
+            for (const pending of pool.queued.splice(0)) {
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                pending.reject(error);
+            }
+        }
+        else {
+            this.schedule(pool);
+        }
+        this.scheduleResources();
+        this.removeDrainedPool(pool);
+        return true;
+    }
+    acquireResources(leaseIdentity, rawKeys, timeoutMs) {
+        const lease = this.requireLease(leaseIdentity);
+        const keys = [...new Set(rawKeys.map(key => key.trim()).filter(Boolean))].sort();
+        if (keys.length === 0) {
+            return Promise.reject(new AdapterSchedulerError('ADAPTER_RESOURCE_TIMEOUT', 'At least one resource key is required'));
+        }
+        if (!Number.isInteger(timeoutMs) || timeoutMs < 1) {
+            return Promise.reject(new AdapterSchedulerError('ADAPTER_RESOURCE_TIMEOUT', 'Invalid Adapter resource timeout'));
+        }
+        return new Promise((resolve, reject) => {
+            const pending = {
+                lease: { ...lease },
+                keys,
+                deadline: this.now() + timeoutMs,
+                sequence: ++this.sequence,
+                resolve,
+                reject,
+            };
+            pending.timer = setTimeout(() => this.sweepExpired(), timeoutMs);
+            pending.timer.unref?.();
+            this.resourceQueue.push(pending);
+            this.scheduleResources();
+        });
+    }
+    releaseResources(leaseIdentity, grantId) {
+        const lease = this.requireLease(leaseIdentity);
+        const grant = this.resourceGrants.get(grantId);
+        if (!grant || grant.leaseId !== lease.leaseId) {
+            throw new AdapterSchedulerError('ADAPTER_LEASE_LOST', 'Adapter resource grant is no longer valid');
+        }
+        this.resourceGrants.delete(grantId);
+        for (const key of grant.keys) {
+            const owner = this.resourceOwners.get(key);
+            if (owner?.grantId === grantId)
+                this.resourceOwners.delete(key);
+        }
+        this.scheduleResources();
+        return true;
+    }
+    cancel(requestId, code = 'ADAPTER_QUEUE_RESET') {
+        for (const pool of this.pools.values()) {
+            const index = pool.queued.findIndex(entry => entry.request.requestId === requestId);
+            if (index === -1)
+                continue;
+            const [pending] = pool.queued.splice(index, 1);
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new AdapterSchedulerError(code, 'Adapter lease request was cancelled'));
+            this.removeDrainedPool(pool);
+            return true;
+        }
+        return false;
+    }
+    sweepExpired() {
+        const now = this.now();
+        this.pruneReleasedLeaseIds(now);
+        for (const pool of [...this.pools.values()]) {
+            for (const pending of [...pool.queued]) {
+                if (pending.deadline > now)
+                    continue;
+                pool.queued.splice(pool.queued.indexOf(pending), 1);
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                pending.reject(new AdapterSchedulerError('ADAPTER_QUEUE_TIMEOUT', 'Timed out waiting for an Adapter command lease'));
+            }
+            for (const lease of [...pool.running.values()]) {
+                if (lease.heartbeatDeadline > now)
+                    continue;
+                this.releaseAllResourcesForLease(lease.leaseId);
+                this.rejectResourceWaitersForLease(lease.leaseId);
+                pool.running.delete(lease.leaseId);
+                pool.activeSessions.delete(lease.adapterSession);
+            }
+            if (!pool.closed)
+                this.schedule(pool);
+            this.removeDrainedPool(pool);
+        }
+        for (const pending of [...this.resourceQueue]) {
+            if (pending.deadline > now)
+                continue;
+            this.resourceQueue.splice(this.resourceQueue.indexOf(pending), 1);
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new AdapterSchedulerError('ADAPTER_RESOURCE_TIMEOUT', 'Timed out waiting for Adapter resource locks'));
+        }
+        this.scheduleResources();
+    }
+    reset() {
+        for (const pool of this.pools.values()) {
+            for (const pending of pool.queued) {
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                pending.reject(new AdapterSchedulerError('ADAPTER_QUEUE_RESET', 'Adapter scheduler restarted'));
+            }
+        }
+        this.pools.clear();
+        for (const pending of this.resourceQueue.splice(0)) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new AdapterSchedulerError('ADAPTER_QUEUE_RESET', 'Adapter scheduler restarted'));
+        }
+        this.resourceOwners.clear();
+        this.resourceGrants.clear();
+        this.releasedLeaseIds.clear();
+    }
+    snapshot() {
+        let running = 0;
+        let queued = 0;
+        for (const pool of this.pools.values()) {
+            running += pool.running.size;
+            queued += pool.queued.length;
+        }
+        return { running, queued, pools: this.pools.size };
+    }
+    resourceSnapshot() {
+        return {
+            locked: this.resourceOwners.size,
+            queued: this.resourceQueue.length,
+            grants: this.resourceGrants.size,
+        };
+    }
+    schedule(pool) {
+        while (!pool.closed && pool.running.size < pool.maxParallel) {
+            const eligible = pool.queued
+                .filter(entry => !pool.activeSessions.has(entry.request.adapterSession)
+                && pool.running.size < pool.maxParallel)
+                .sort((a, b) => a.enqueuedAt - b.enqueuedAt || a.sequence - b.sequence)[0];
+            if (!eligible)
+                return;
+            pool.queued.splice(pool.queued.indexOf(eligible), 1);
+            if (eligible.timer)
+                clearTimeout(eligible.timer);
+            const grantedAt = this.now();
+            const lease = {
+                leaseId: crypto.randomUUID(),
+                requestId: eligible.request.requestId,
+                poolKey: pool.key,
+                contextId: eligible.request.contextId,
+                surface: 'adapter',
+                site: eligible.request.site,
+                adapterSession: eligible.request.adapterSession,
+                sessionKey: eligible.request.sessionKey,
+                generation: pool.generation,
+                grantedAt,
+                heartbeatDeadline: grantedAt + this.leaseExpiryMs,
+            };
+            pool.running.set(lease.leaseId, lease);
+            pool.activeSessions.add(lease.adapterSession);
+            eligible.resolve({ ...lease });
+        }
+    }
+    scheduleResources() {
+        for (const pending of [...this.resourceQueue].sort((a, b) => a.sequence - b.sequence)) {
+            try {
+                this.requireLease(pending.lease);
+            }
+            catch {
+                this.resourceQueue.splice(this.resourceQueue.indexOf(pending), 1);
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                pending.reject(new AdapterSchedulerError('ADAPTER_LEASE_LOST', 'Adapter command lease was lost while waiting for resources'));
+                continue;
+            }
+            if (!pending.keys.every(key => !this.resourceOwners.has(key)))
+                continue;
+            this.resourceQueue.splice(this.resourceQueue.indexOf(pending), 1);
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            const grant = {
+                grantId: crypto.randomUUID(),
+                leaseId: pending.lease.leaseId,
+                keys: pending.keys,
+            };
+            this.resourceGrants.set(grant.grantId, grant);
+            for (const key of grant.keys)
+                this.resourceOwners.set(key, { leaseId: grant.leaseId, grantId: grant.grantId });
+            pending.resolve({ ...grant, keys: [...grant.keys] });
+        }
+    }
+    releaseAllResourcesForLease(leaseId) {
+        for (const grant of [...this.resourceGrants.values()]) {
+            if (grant.leaseId !== leaseId)
+                continue;
+            this.resourceGrants.delete(grant.grantId);
+            for (const key of grant.keys) {
+                const owner = this.resourceOwners.get(key);
+                if (owner?.grantId === grant.grantId)
+                    this.resourceOwners.delete(key);
+            }
+        }
+    }
+    pruneReleasedLeaseIds(now = this.now()) {
+        for (const [leaseId, expiresAt] of this.releasedLeaseIds) {
+            if (expiresAt <= now)
+                this.releasedLeaseIds.delete(leaseId);
+        }
+    }
+    rejectResourceWaitersForLease(leaseId) {
+        for (const pending of [...this.resourceQueue]) {
+            if (pending.lease.leaseId !== leaseId)
+                continue;
+            this.resourceQueue.splice(this.resourceQueue.indexOf(pending), 1);
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new AdapterSchedulerError('ADAPTER_LEASE_LOST', 'Adapter command lease ended while waiting for resources'));
+        }
+    }
+    requireLease(identity) {
+        const pool = this.pools.get(identity.poolKey);
+        const lease = pool?.running.get(identity.leaseId);
+        if (!lease
+            || lease.requestId !== identity.requestId
+            || lease.contextId !== identity.contextId
+            || lease.site !== identity.site
+            || lease.adapterSession !== identity.adapterSession
+            || lease.sessionKey !== identity.sessionKey
+            || lease.generation !== identity.generation) {
+            throw new AdapterSchedulerError('ADAPTER_LEASE_LOST', 'Adapter command lease is no longer valid');
+        }
+        return lease;
+    }
+    getOrCreatePool(request) {
+        const key = `${request.contextId}\u0000${request.surface}\u0000${request.site}`;
+        const existing = this.pools.get(key);
+        if (existing)
+            return existing;
+        const generation = (this.generations.get(key) ?? 0) + 1;
+        this.generations.set(key, generation);
+        const pool = {
+            key,
+            generation,
+            maxParallel: Math.min(request.maxParallel, this.runtimeCeiling),
+            running: new Map(),
+            activeSessions: new Set(),
+            queued: [],
+        };
+        this.pools.set(key, pool);
+        return pool;
+    }
+    removeDrainedPool(pool) {
+        if (pool.running.size === 0 && pool.queued.length === 0)
+            this.pools.delete(pool.key);
+    }
+    poolClosedError(reason) {
+        return reason === 'auth_gate'
+            ? new AdapterSchedulerError('ADAPTER_POOL_AUTH_GATE', 'Adapter pool stopped at an authentication or verification gate')
+            : new AdapterSchedulerError('ADAPTER_POOL_RATE_LIMITED', 'Adapter pool stopped after account rate limiting');
+    }
+    validateRequest(request) {
+        if (!request.requestId || !request.contextId || !request.site || !request.adapterSession || !request.sessionKey) {
+            throw new AdapterSchedulerError('ADAPTER_QUEUE_RESET', 'Invalid Adapter lease request');
+        }
+        if (!Number.isInteger(request.queueTimeoutMs) || request.queueTimeoutMs < 1) {
+            throw new AdapterSchedulerError('ADAPTER_QUEUE_RESET', 'Invalid Adapter queue timeout');
+        }
+        if (!Number.isInteger(request.maxParallel) || request.maxParallel < 1 || request.maxParallel > this.runtimeCeiling) {
+            throw new AdapterSchedulerError('ADAPTER_QUEUE_RESET', 'Invalid Adapter concurrency limit');
+        }
+    }
+}

package/dist/src/adapter-scheduler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/browser/daemon-client.d.ts

@@ -3,6 +3,7 @@
  *
  * Provides a typed send() function that posts a Command and returns a Result.
  */
+import type { AdapterLease, AdapterLeaseRelease, AdapterLeaseRequest, AdapterResourceGrant } from '../adapter-scheduler.js';
 export interface DaemonCommand {
     id: string;
     action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'set-file-input' | 'insert-text' | 'bind' | 'network-capture-start' | 'network-capture-read' | 'ima-auth-start' | 'ima-auth-read' | 'ima-reader-request' | 'ima-auth-release' | 'wait-download' | 'cdp' | 'frames';
@@ -47,6 +48,8 @@ export interface DaemonCommand {
     frameIndex?: number;
     /** Browser profile/context to route the command to. */
     contextId?: string;
+    /** Active Adapter lease used by the daemon to fence every browser action. */
+    adapterLease?: AdapterLease;
 }
 export interface DaemonResult {
     id: string;
@@ -107,6 +110,12 @@ export type DaemonStatusProbe = {
 } | {
     kind: 'network_error';
 };
+export declare function acquireAdapterLease(request: AdapterLeaseRequest): Promise<AdapterLease>;
+export declare function heartbeatAdapterLease(lease: AdapterLease): Promise<AdapterLease>;
+export declare function releaseAdapterLease(release: AdapterLeaseRelease): Promise<boolean>;
+export declare function cancelAdapterLease(requestId: string): Promise<boolean>;
+export declare function acquireAdapterResources(lease: AdapterLease, keys: string[], timeoutMs: number): Promise<AdapterResourceGrant>;
+export declare function releaseAdapterResources(lease: AdapterLease, grantId: string): Promise<boolean>;
 export declare function probeDaemonStatus(opts?: {
     timeout?: number;
     contextId?: string;
@@ -139,6 +148,8 @@ export declare function getDaemonHealth(opts?: {
     timeout?: number;
     contextId?: string;
 }): Promise<DaemonHealth>;
+/** Resolve the concrete daemon profile used to key Adapter scheduler pools. */
+export declare function resolveAdapterLeaseContextId(requestedContextId?: string): Promise<string>;
 export declare function requestDaemonShutdown(opts?: {
     timeout?: number;
 }): Promise<boolean>;

package/dist/src/browser/daemon-client.js

@@ -7,6 +7,8 @@ import { sleep } from '../utils.js';
 import { resolveDaemonPort } from './daemon-config.js';
 import { classifyBrowserError } from './errors.js';
 import { resolveProfileContextId } from './profile.js';
+import { AdapterCoordinationError } from '../errors.js';
+import { getAdapterExecutionContext } from '../adapter-execution-context.js';
 const BYCLI_HEADERS = { 'X-byCLI': '1' };
 let _idCounter = 0;
 function generateId() {
@@ -44,6 +46,40 @@ async function consumeDaemonResponse(pathname, init, consume, port) {
 async function requestDaemon(pathname, init) {
     return consumeDaemonResponse(pathname, init, async (response) => response);
 }
+async function postAdapterLease(pathname, body, timeout) {
+    const response = await requestDaemon(pathname, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+        timeout,
+    });
+    const envelope = await response.json();
+    if (!response.ok || envelope.ok !== true || envelope.data === undefined) {
+        throw new AdapterCoordinationError(envelope.errorCode ?? 'ADAPTER_QUEUE_RESET', envelope.error ?? 'Adapter scheduler request failed', true);
+    }
+    return envelope.data;
+}
+export function acquireAdapterLease(request) {
+    return postAdapterLease('/v1/adapter-leases/acquire', request, request.queueTimeoutMs + 5_000);
+}
+export function heartbeatAdapterLease(lease) {
+    return postAdapterLease('/v1/adapter-leases/heartbeat', lease, 5_000);
+}
+export async function releaseAdapterLease(release) {
+    const data = await postAdapterLease('/v1/adapter-leases/release', release, 5_000);
+    return data.released;
+}
+export async function cancelAdapterLease(requestId) {
+    const data = await postAdapterLease('/v1/adapter-leases/cancel', { requestId }, 5_000);
+    return data.cancelled;
+}
+export function acquireAdapterResources(lease, keys, timeoutMs) {
+    return postAdapterLease('/v1/adapter-resources/acquire', { lease, keys, timeoutMs }, timeoutMs + 5_000);
+}
+export async function releaseAdapterResources(lease, grantId) {
+    const data = await postAdapterLease('/v1/adapter-resources/release', { lease, grantId }, 5_000);
+    return data.released;
+}
 function errorCode(error) {
     if (!error || typeof error !== 'object')
         return undefined;
@@ -102,6 +138,16 @@ export async function getDaemonHealth(opts) {
         return { state: 'no-extension', status };
     return { state: 'ready', status };
 }
+/** Resolve the concrete daemon profile used to key Adapter scheduler pools. */
+export async function resolveAdapterLeaseContextId(requestedContextId) {
+    const health = await getDaemonHealth({ contextId: requestedContextId });
+    if (health.state === 'ready' && health.status.contextId) {
+        return health.status.contextId;
+    }
+    throw new AdapterCoordinationError('ADAPTER_PROFILE_UNAVAILABLE', 'The browser daemon could not identify the authenticated profile for this Adapter session.', true, requestedContextId
+        ? `Check that profile "${requestedContextId}" is connected.`
+        : 'Connect exactly one browser profile or pass --profile explicitly.');
+}
 export async function requestDaemonShutdown(opts) {
     try {
         const res = await requestDaemon('/shutdown', { method: 'POST', timeout: opts?.timeout ?? 5000 });
@@ -130,7 +176,13 @@ async function sendCommandRaw(action, params) {
             : undefined;
         const contextId = params.contextId ?? resolveProfileContextId();
         const windowMode = params.windowMode ?? envWindowMode;
-        const command = { id, action, ...params, ...(contextId && { contextId }), ...(windowMode && { windowMode }) };
+        const adapterLease = getAdapterExecutionContext()?.lease;
+        const command = {
+            id, action, ...params,
+            ...(contextId && { contextId }),
+            ...(windowMode && { windowMode }),
+            ...(adapterLease && { adapterLease }),
+        };
         try {
             const res = await requestDaemon('/command', {
                 method: 'POST',

package/dist/src/browser/extension-capabilities.d.ts

@@ -1,4 +1,5 @@
 export declare const FOCUS_WINDOW_CAPABILITY = "focus-window-v1";
+export declare const IMA_READER_CAPABILITY = "ima-reader-v1";
 export declare const EXTENSION_CAPABILITY_MISSING_ERROR_CODE = "extension_capability_missing";
 export declare const EXTENSION_CAPABILITY_MISSING_HTTP_STATUS = 412;
 export declare function normalizeExtensionCapabilities(value: unknown): string[];

package/dist/src/browser/extension-capabilities.js

@@ -1,14 +1,23 @@
 export const FOCUS_WINDOW_CAPABILITY = 'focus-window-v1';
+export const IMA_READER_CAPABILITY = 'ima-reader-v1';
 export const EXTENSION_CAPABILITY_MISSING_ERROR_CODE = 'extension_capability_missing';
 export const EXTENSION_CAPABILITY_MISSING_HTTP_STATUS = 412;
+const IMA_READER_ACTIONS = new Set([
+    'ima-auth-start',
+    'ima-auth-read',
+    'ima-reader-request',
+    'ima-auth-release',
+]);
 export function normalizeExtensionCapabilities(value) {
     if (!Array.isArray(value))
         return [];
     return [...new Set(value.filter((entry) => typeof entry === 'string' && entry.length > 0))];
 }
 export function requiredExtensionCapability(command) {
-    return command.action === 'tabs' && command.op === 'focus'
-        ? FOCUS_WINDOW_CAPABILITY
+    if (command.action === 'tabs' && command.op === 'focus')
+        return FOCUS_WINDOW_CAPABILITY;
+    return typeof command.action === 'string' && IMA_READER_ACTIONS.has(command.action)
+        ? IMA_READER_CAPABILITY
         : undefined;
 }
 export function missingRequiredExtensionCapability(command, capabilities) {
@@ -16,7 +25,11 @@ export function missingRequiredExtensionCapability(command, capabilities) {
     return required && !capabilities.includes(required) ? required : undefined;
 }
 export function extensionCapabilityHint(capability) {
-    return capability === FOCUS_WINDOW_CAPABILITY
-        ? 'Update and reload the byCLI Browser Bridge extension, then retry the login flow.'
-        : 'Update and reload the byCLI Browser Bridge extension, then retry.';
+    if (capability === FOCUS_WINDOW_CAPABILITY) {
+        return 'Update and reload the byCLI Browser Bridge extension, then retry the login flow.';
+    }
+    if (capability === IMA_READER_CAPABILITY) {
+        return 'Update and reload the byCLI Browser Bridge extension with private ima reader support, then retry.';
+    }
+    return 'Update and reload the byCLI Browser Bridge extension, then retry.';
 }

package/dist/src/browser/page.d.ts

@@ -15,12 +15,13 @@ import { BasePage } from './base-page.js';
  */
 export declare class Page extends BasePage {
     private readonly session;
-    readonly contextId?: string | undefined;
+    contextId?: string | undefined;
     private readonly windowMode?;
     private readonly surface;
     private readonly siteSession?;
     private readonly _idleTimeout;
     constructor(session: string, idleTimeout?: number, contextId?: string | undefined, windowMode?: "foreground" | "background" | undefined, surface?: 'browser' | 'adapter', siteSession?: "ephemeral" | "persistent" | undefined);
+    setContextId(contextId: string): void;
     /** Active page identity (targetId), set after navigate and used in all subsequent commands */
     private _page;
     private _networkCaptureUnsupported;

package/dist/src/browser/page.js

@@ -51,6 +51,9 @@ export class Page extends BasePage {
         this.siteSession = siteSession;
         this._idleTimeout = idleTimeout;
     }
+    setContextId(contextId) {
+        this.contextId = contextId;
+    }
     /** Active page identity (targetId), set after navigate and used in all subsequent commands */
     _page;
     _networkCaptureUnsupported = false;

package/dist/src/build-manifest.js

@@ -105,6 +105,7 @@ function toManifestEntry(cmd, modulePath, sourceFile) {
         sourceFile,
         navigateBefore: cmd.navigateBefore,
         siteSession: cmd.siteSession,
+        adapterConcurrency: cmd.adapterConcurrency,
     };
 }
 /**

package/dist/src/cli-argv-preprocess.d.ts

@@ -50,6 +50,9 @@ export interface DashPositionalManifestEntry {
         default?: unknown;
     }>;
     browser?: boolean;
+    adapterConcurrency?: {
+        isolatedTabs?: boolean;
+    };
 }
 /**
  * `bycli boss detail -abc123def` fails because commander parses

package/dist/src/cli-argv-preprocess.js

@@ -144,6 +144,10 @@ function knownCommandOptions(cmd) {
         options.set('--site-session', 'required');
         options.set('--keep-tab', 'required');
     }
+    if (cmd.adapterConcurrency?.isolatedTabs === true) {
+        options.set('--adapter-session', 'required');
+        options.set('--adapter-queue-timeout', 'required');
+    }
     for (const arg of cmd.args ?? []) {
         if (arg.positional)
             continue;

package/dist/src/commanderAdapter.js

@@ -54,6 +54,11 @@ export function registerCommandToProgram(siteCmd, cmd) {
             .option('--site-session <mode>', 'Adapter site session lifecycle: ephemeral or persistent')
             .option('--keep-tab <bool>', 'Keep the browser tab lease after the command finishes');
     }
+    if (cmd.adapterConcurrency?.isolatedTabs === true) {
+        subCmd
+            .option('--adapter-session <name>', 'Named persistent Adapter tab session')
+            .option('--adapter-queue-timeout <seconds>', 'Seconds to wait for an Adapter command lease');
+    }
     const originalHelpInformation = subCmd.helpInformation.bind(subCmd);
     subCmd.helpInformation = ((contextOptions) => {
         const format = getRequestedHelpFormat();
@@ -111,6 +116,12 @@ export function registerCommandToProgram(siteCmd, cmd) {
                 ...(hasBrowserCapability(cmd) && typeof optionsRecord.window === 'string' ? { windowMode: optionsRecord.window } : {}),
                 ...(hasBrowserCapability(cmd) && typeof optionsRecord.siteSession === 'string' ? { siteSession: optionsRecord.siteSession } : {}),
                 ...(hasBrowserCapability(cmd) && typeof optionsRecord.keepTab === 'string' ? { keepTab: optionsRecord.keepTab } : {}),
+                ...(cmd.adapterConcurrency?.isolatedTabs === true && typeof optionsRecord.adapterSession === 'string'
+                    ? { adapterSession: optionsRecord.adapterSession }
+                    : {}),
+                ...(cmd.adapterConcurrency?.isolatedTabs === true && typeof optionsRecord.adapterQueueTimeout === 'string'
+                    ? { adapterQueueTimeout: optionsRecord.adapterQueueTimeout }
+                    : {}),
             });
             if (result === null || result === undefined) {
                 return;