@sovovs/bycli 2.1.39 → 2.1.41

package/dist/src/execution.js

@@ -16,10 +16,11 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { getUserClisDir } from './config-paths.js';
 import { executePipeline } from './pipeline/index.js';
-import { adapterLoadError, ArgumentError, CliError, CommandExecutionError, attachTraceReceipt, getErrorMessage } from './errors.js';
+import { AdapterCoordinationError, adapterLoadError, ArgumentError, CliError, CommandExecutionError, TimeoutError, attachTraceReceipt, getErrorMessage } from './errors.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { resolveProfileContextId } from './browser/profile.js';
+import { resolveAdapterLeaseContextId } from './browser/daemon-client.js';
 import { emitHook } from './hooks.js';
 import { log } from './logger.js';
 import { isElectronApp } from './electron-apps.js';
@@ -27,6 +28,7 @@ import { probeCDP, resolveElectronEndpoint } from './launcher.js';
 import { ObservationSession, exportObservationSession } from './observation/index.js';
 import { resolveAdapterSourcePath } from './adapter-source.js';
 import { canonicalizeManifestArgSchema, ManifestSchemaError } from './manifest-schema.js';
+import { settleAdapterOperationAfterTimeout, withAdapterCommandLease } from './adapter-coordination.js';
 import { capturedRegistryValues, closeRegistryTransaction, createRegistryTransaction, finalizeRegistryTransaction, resetRegistryTransactionStateForTests, rollbackRegistryTransaction, runRegistryTransaction, transactionGroupsForKey, } from './registry-transaction.js';
 const _loadedModules = new Map();
 /** Independent cache-busting generation; retained when an import promise is discarded. */
@@ -402,6 +404,8 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
     let result;
     try {
         const resolvedBrowser = resolveBrowserRequirement(cmd, kwargs);
+        const adapterSession = normalizeAdapterSession(cmd, resolvedBrowser, opts.adapterSession);
+        const adapterQueueTimeoutSeconds = normalizeAdapterQueueTimeout(opts.adapterQueueTimeout, adapterSession);
         const userTimeoutSec = readUserTimeoutSeconds(cmd, kwargs);
         if (shouldUseBrowserSession(cmd, resolvedBrowser)) {
             const electron = isElectronApp(cmd.site);
@@ -424,126 +428,154 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
             const contextId = resolveProfileContextId(opts.profile);
             const internal = cmd;
             const siteSession = resolveSiteSession(cmd, opts.siteSession);
-            const session = resolveAdapterBrowserSession(cmd, siteSession);
+            assertAdapterSessionLifecycle(siteSession, adapterSession);
+            const session = resolveAdapterBrowserSession(cmd, siteSession, adapterSession);
             const keepTab = resolveKeepTab(siteSession, opts.keepTab);
             const windowMode = resolveBrowserWindowMode('background', opts.windowMode);
-            result = await browserSession(BrowserFactory, async (page) => {
-                const observation = traceMode === 'off'
-                    ? null
-                    : new ObservationSession({
-                        scope: {
-                            contextId,
-                            session,
-                            target: page.getActivePage?.(),
-                            site: cmd.site,
-                            command: fullName(cmd),
-                            adapterSourcePath: resolveAdapterSourcePath(internal)
-                                ?? resolveAdapterSourcePath(initialTraceCommand),
-                        },
-                    });
-                if (observation) {
-                    observation.record({
-                        stream: 'action',
-                        name: 'command',
-                        phase: 'start',
-                        data: { args: kwargs },
-                    });
-                    await page.startNetworkCapture?.().catch(() => false);
-                }
-                const preNavUrl = resolvePreNav(cmd);
-                if (preNavUrl && await shouldRunPreNav(cmd, page, siteSession, preNavUrl)) {
-                    observation?.record({
-                        stream: 'action',
-                        name: 'pre_navigate',
-                        phase: 'start',
-                        data: { url: preNavUrl },
-                    });
-                    // Navigate directly — the extension's handleNavigate already has a fast-path
-                    // that skips navigation if the tab is already at the target URL.
-                    // This avoids an extra exec round-trip (getCurrentUrl) on first command and
-                    // lets the extension create the automation window with the target URL directly
-                    // instead of about:blank.
-                    try {
-                        await page.goto(preNavUrl);
-                        observation?.record({
+            const executeInBrowser = () => browserSession(BrowserFactory, async (page) => {
+                // BrowserBridge.connect() has started/probed the daemon by this point. Resolve
+                // the daemon's canonical profile before acquiring a profile-scoped lease.
+                const leaseContextId = adapterSession
+                    ? await resolveAdapterLeaseContextId(contextId)
+                    : undefined;
+                if (leaseContextId)
+                    page.setContextId?.(leaseContextId);
+                const executeOnPage = async () => {
+                    const observation = traceMode === 'off'
+                        ? null
+                        : new ObservationSession({
+                            scope: {
+                                contextId,
+                                session,
+                                target: page.getActivePage?.(),
+                                site: cmd.site,
+                                command: fullName(cmd),
+                                adapterSourcePath: resolveAdapterSourcePath(internal)
+                                    ?? resolveAdapterSourcePath(initialTraceCommand),
+                            },
+                        });
+                    if (observation) {
+                        observation.record({
                             stream: 'action',
-                            name: 'pre_navigate',
-                            phase: 'end',
-                            data: { url: preNavUrl },
+                            name: 'command',
+                            phase: 'start',
+                            data: { args: kwargs },
                         });
+                        await page.startNetworkCapture?.().catch(() => false);
                     }
-                    catch (err) {
+                    const preNavUrl = resolvePreNav(cmd);
+                    if (preNavUrl && await shouldRunPreNav(cmd, page, siteSession, preNavUrl)) {
                         observation?.record({
                             stream: 'action',
                             name: 'pre_navigate',
-                            phase: 'error',
-                            data: { url: preNavUrl, error: err instanceof Error ? err.message : String(err) },
+                            phase: 'start',
+                            data: { url: preNavUrl },
                         });
-                        const wrapped = new CommandExecutionError(`Pre-navigation to ${preNavUrl} failed: ${err instanceof Error ? err.message : err}`, 'Check that the site is reachable and the browser extension is running.');
-                        if (observation && (traceMode === 'on' || traceMode === 'retain-on-failure')) {
-                            observation.record({
-                                stream: 'error',
-                                message: wrapped.message,
-                                stack: wrapped.stack,
-                                code: wrapped.code,
-                                hint: wrapped.hint,
+                        // Navigate directly — the extension's handleNavigate already has a fast-path
+                        // that skips navigation if the tab is already at the target URL.
+                        // This avoids an extra exec round-trip (getCurrentUrl) on first command and
+                        // lets the extension create the automation window with the target URL directly
+                        // instead of about:blank.
+                        try {
+                            await page.goto(preNavUrl);
+                            observation?.record({
+                                stream: 'action',
+                                name: 'pre_navigate',
+                                phase: 'end',
+                                data: { url: preNavUrl },
                             });
-                            await collectObservationEvidence(observation, page).catch(() => { });
-                            exportTraceArtifact(observation, 'failure', wrapped, opts.onTraceExport);
                         }
-                        throw wrapped;
-                    }
-                }
-                try {
-                    const browserTimeout = userTimeoutSec !== null
-                        ? userTimeoutSec + RUNTIME_TIMEOUT_PADDING_SECONDS
-                        : DEFAULT_BROWSER_COMMAND_TIMEOUT;
-                    const result = await runWithTimeout(runCommand(cmd, page, kwargs, debug), {
-                        timeout: browserTimeout,
-                        label: fullName(cmd),
-                    });
-                    observation?.record({
-                        stream: 'action',
-                        name: 'command',
-                        phase: 'end',
-                    });
-                    if (observation && traceMode === 'on') {
-                        await collectObservationEvidence(observation, page).catch(() => { });
-                        exportTraceArtifact(observation, 'success', undefined, opts.onTraceExport);
+                        catch (err) {
+                            observation?.record({
+                                stream: 'action',
+                                name: 'pre_navigate',
+                                phase: 'error',
+                                data: { url: preNavUrl, error: err instanceof Error ? err.message : String(err) },
+                            });
+                            const wrapped = new CommandExecutionError(`Pre-navigation to ${preNavUrl} failed: ${err instanceof Error ? err.message : err}`, 'Check that the site is reachable and the browser extension is running.');
+                            if (observation && (traceMode === 'on' || traceMode === 'retain-on-failure')) {
+                                observation.record({
+                                    stream: 'error',
+                                    message: wrapped.message,
+                                    stack: wrapped.stack,
+                                    code: wrapped.code,
+                                    hint: wrapped.hint,
+                                });
+                                await collectObservationEvidence(observation, page).catch(() => { });
+                                exportTraceArtifact(observation, 'failure', wrapped, opts.onTraceExport);
+                            }
+                            throw wrapped;
+                        }
                     }
-                    // Adapter commands are one-shot — release the current tab lease immediately
-                    // instead of waiting for the 30s idle timeout. The automation container
-                    // window stays open for reuse.
-                    if (!keepTab)
-                        await page.closeWindow?.().catch(() => { });
-                    return result;
-                }
-                catch (err) {
-                    if (observation) {
-                        observation.record({
+                    try {
+                        const browserTimeout = userTimeoutSec !== null
+                            ? userTimeoutSec + RUNTIME_TIMEOUT_PADDING_SECONDS
+                            : DEFAULT_BROWSER_COMMAND_TIMEOUT;
+                        const commandOperation = runCommand(cmd, page, kwargs, debug);
+                        const result = adapterSession
+                            ? await settleAdapterOperationAfterTimeout(commandOperation, browserTimeout * 1_000, new TimeoutError(fullName(cmd), browserTimeout), async () => { await page.closeWindow?.().catch(() => { }); })
+                            : await runWithTimeout(commandOperation, {
+                                timeout: browserTimeout,
+                                label: fullName(cmd),
+                            });
+                        observation?.record({
                             stream: 'action',
                             name: 'command',
-                            phase: 'error',
-                            data: { error: err instanceof Error ? err.message : String(err) },
-                        });
-                        observation.record({
-                            stream: 'error',
-                            message: err instanceof Error ? err.message : String(err),
-                            stack: err instanceof Error ? err.stack : undefined,
+                            phase: 'end',
                         });
-                        if (traceMode === 'on' || traceMode === 'retain-on-failure') {
+                        if (observation && traceMode === 'on') {
                             await collectObservationEvidence(observation, page).catch(() => { });
-                            exportTraceArtifact(observation, 'failure', err, opts.onTraceExport);
+                            exportTraceArtifact(observation, 'success', undefined, opts.onTraceExport);
                         }
+                        // Adapter commands are one-shot — release the current tab lease immediately
+                        // instead of waiting for the 30s idle timeout. The automation container
+                        // window stays open for reuse.
+                        if (!keepTab)
+                            await page.closeWindow?.().catch(() => { });
+                        return result;
                     }
-                    // Release the tab lease on failure too — without this, the lease lingers
-                    // until the extension's idle timer fires (unreliable on Windows where
-                    // MV3 service workers may be suspended before setTimeout triggers).
-                    if (!keepTab)
-                        await page.closeWindow?.().catch(() => { });
-                    throw err;
-                }
+                    catch (err) {
+                        if (observation) {
+                            observation.record({
+                                stream: 'action',
+                                name: 'command',
+                                phase: 'error',
+                                data: { error: err instanceof Error ? err.message : String(err) },
+                            });
+                            observation.record({
+                                stream: 'error',
+                                message: err instanceof Error ? err.message : String(err),
+                                stack: err instanceof Error ? err.stack : undefined,
+                            });
+                            if (traceMode === 'on' || traceMode === 'retain-on-failure') {
+                                await collectObservationEvidence(observation, page).catch(() => { });
+                                exportTraceArtifact(observation, 'failure', err, opts.onTraceExport);
+                            }
+                        }
+                        // Release the tab lease on failure too — without this, the lease lingers
+                        // until the extension's idle timer fires (unreliable on Windows where
+                        // MV3 service workers may be suspended before setTimeout triggers).
+                        if (!keepTab)
+                            await page.closeWindow?.().catch(() => { });
+                        throw err;
+                    }
+                };
+                if (!adapterSession)
+                    return executeOnPage();
+                return withAdapterCommandLease({
+                    requestId: crypto.randomUUID(),
+                    contextId: leaseContextId,
+                    surface: 'adapter',
+                    site: cmd.site,
+                    adapterSession,
+                    sessionKey: session,
+                    queueTimeoutMs: (adapterQueueTimeoutSeconds ?? 300) * 1_000,
+                    maxParallel: cmd.adapterConcurrency?.maxParallel ?? 1,
+                }, executeOnPage, {
+                    onLeaseLost: async () => { await page.closeWindow?.().catch(() => { }); },
+                });
             }, { session, cdpEndpoint, contextId, windowMode, surface: 'adapter', siteSession });
+            result = await executeInBrowser();
         }
         else {
             // Non-browser commands: enforce a timeout only when the command exposes
@@ -674,9 +706,40 @@ function normalizeSiteSession(raw) {
 function resolveSiteSession(cmd, rawOption) {
     return normalizeSiteSession(rawOption) ?? cmd.siteSession ?? 'ephemeral';
 }
-function resolveAdapterBrowserSession(cmd, siteSession) {
-    if (siteSession === 'persistent')
-        return `site:${cmd.site}`;
+function normalizeAdapterSession(cmd, resolvedBrowser, rawOption) {
+    if (rawOption === undefined || rawOption === null || rawOption === '')
+        return undefined;
+    if (!resolvedBrowser || cmd.adapterConcurrency?.isolatedTabs !== true) {
+        throw new AdapterCoordinationError('ADAPTER_SESSION_NOT_SUPPORTED', `${fullName(cmd)} does not support named Adapter sessions`);
+    }
+    const value = String(rawOption);
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(value)) {
+        throw new AdapterCoordinationError('INVALID_ADAPTER_SESSION', '--adapter-session must match [A-Za-z0-9][A-Za-z0-9_-]{0,63}');
+    }
+    return value;
+}
+function normalizeAdapterQueueTimeout(rawOption, adapterSession) {
+    if (rawOption === undefined || rawOption === null || rawOption === '') {
+        return adapterSession ? 300 : undefined;
+    }
+    if (!adapterSession) {
+        throw new AdapterCoordinationError('INVALID_ADAPTER_QUEUE_TIMEOUT', '--adapter-queue-timeout requires --adapter-session');
+    }
+    const value = typeof rawOption === 'string' && /^\d+$/.test(rawOption) ? Number(rawOption) : NaN;
+    if (!Number.isInteger(value) || value < 1 || value > 3600) {
+        throw new AdapterCoordinationError('INVALID_ADAPTER_QUEUE_TIMEOUT', '--adapter-queue-timeout must be an integer between 1 and 3600 seconds');
+    }
+    return value;
+}
+function assertAdapterSessionLifecycle(siteSession, adapterSession) {
+    if (adapterSession && siteSession !== 'persistent') {
+        throw new AdapterCoordinationError('ADAPTER_SESSION_REQUIRES_PERSISTENT', '--adapter-session requires --site-session persistent');
+    }
+}
+function resolveAdapterBrowserSession(cmd, siteSession, adapterSession) {
+    if (siteSession === 'persistent') {
+        return adapterSession ? `site:${cmd.site}:${adapterSession}` : `site:${cmd.site}`;
+    }
     return `site:${cmd.site}:${crypto.randomUUID()}`;
 }
 function normalizeBooleanOption(name, raw) {

package/dist/src/help.d.ts

@@ -82,6 +82,7 @@ export declare function siteHelpData(site: string, commands: readonly CliCommand
 export declare function commandHelpData(cmd: CliCommand): Record<string, unknown>;
 export declare function formatCommonOptionsHelpText(): string;
 export declare function formatBrowserCommonOptionsHelpText(): string;
+export declare function formatAdapterSessionOptionsHelpText(): string;
 export declare function formatSiteHelpText(site: string, commands: readonly CliCommand[]): string;
 export declare function formatCommandHelpText(cmd: CliCommand): string;
 export declare function installStructuredHelp(command: Command, data: () => unknown, textSuffix?: string | (() => string)): void;

package/dist/src/help.js

@@ -48,6 +48,19 @@ const BROWSER_COMMON_OPTIONS = [
         choices: ['true', 'false'],
     },
 ];
+const ADAPTER_SESSION_OPTIONS = [
+    {
+        flags: '--adapter-session <name>',
+        name: 'adapter-session',
+        help: 'Named persistent Adapter tab session',
+    },
+    {
+        flags: '--adapter-queue-timeout <seconds>',
+        name: 'adapter-queue-timeout',
+        help: 'Seconds to wait for an Adapter command lease',
+        default: 300,
+    },
+];
 function normalizeStructuredHelpFormat(value) {
     const normalized = value?.toLowerCase();
     if (normalized === 'yaml' || normalized === 'yml')
@@ -369,6 +382,12 @@ function compactCommand(cmd) {
         positionals: positionals(cmd).map(compactArg),
         command_options: commandOptions(cmd).map(compactArg),
         ...(hasBrowserCapability(cmd) ? { browser_common_options: BROWSER_COMMON_OPTIONS.map(compactCommonOption) } : {}),
+        ...(cmd.adapterConcurrency?.isolatedTabs === true
+            ? {
+                adapterConcurrency: cmd.adapterConcurrency,
+                adapter_common_options: ADAPTER_SESSION_OPTIONS.map(compactCommonOption),
+            }
+            : {}),
         example: formatCommandExample(cmd),
         ...(cmd.siteSession ? { siteSession: cmd.siteSession } : {}),
         ...(cmd.defaultFormat ? { defaultFormat: cmd.defaultFormat } : {}),
@@ -417,6 +436,9 @@ export function siteHelpData(site, commands) {
         commands: unique.map(cmd => compactCommand(cmd)),
         common_options: COMMON_OPTIONS.map(compactCommonOption),
         ...(unique.some(hasBrowserCapability) ? { browser_common_options: BROWSER_COMMON_OPTIONS.map(compactCommonOption) } : {}),
+        ...(unique.some(cmd => cmd.adapterConcurrency?.isolatedTabs === true)
+            ? { adapter_common_options: ADAPTER_SESSION_OPTIONS.map(compactCommonOption) }
+            : {}),
         next: [
             `bycli ${site} <command> --help -f yaml`,
             `bycli ${site} <command> -f yaml`,
@@ -429,6 +451,12 @@ export function commandHelpData(cmd) {
         ...compactCommand(cmd),
         common_options: COMMON_OPTIONS.map(compactCommonOption),
         ...(hasBrowserCapability(cmd) ? { browser_common_options: BROWSER_COMMON_OPTIONS.map(compactCommonOption) } : {}),
+        ...(cmd.adapterConcurrency?.isolatedTabs === true
+            ? {
+                adapterConcurrency: cmd.adapterConcurrency,
+                adapter_common_options: ADAPTER_SESSION_OPTIONS.map(compactCommonOption),
+            }
+            : {}),
         output_formats: ['table', 'plain', 'yaml', 'json', 'md', 'csv'],
     };
 }
@@ -468,6 +496,15 @@ export function formatBrowserCommonOptionsHelpText() {
     });
     return ['Browser common options:', ...formatRows(rows)].join('\n');
 }
+export function formatAdapterSessionOptionsHelpText() {
+    const rows = ADAPTER_SESSION_OPTIONS.map(option => {
+        const details = [option.help];
+        if ('default' in option)
+            details.push(`default: ${option.default}`);
+        return [option.flags, details.join('  ')];
+    });
+    return ['Adapter session options:', ...formatRows(rows)].join('\n');
+}
 export function formatSiteHelpText(site, commands) {
     const unique = [...new Map(commands.map(cmd => [fullName(cmd), cmd])).values()]
         .sort((a, b) => a.name.localeCompare(b.name));
@@ -481,6 +518,7 @@ export function formatSiteHelpText(site, commands) {
         '',
         formatCommonOptionsHelpText(),
         ...(unique.some(hasBrowserCapability) ? ['', formatBrowserCommonOptionsHelpText()] : []),
+        ...(unique.some(cmd => cmd.adapterConcurrency?.isolatedTabs === true) ? ['', formatAdapterSessionOptionsHelpText()] : []),
         '',
         `Agent tip: use 'bycli ${site} --help -f yaml' to get all command args/options in one structured response.`,
         '',
@@ -511,6 +549,8 @@ export function formatCommandHelpText(cmd) {
     lines.push(formatCommonOptionsHelpText(), '');
     if (hasBrowserCapability(cmd))
         lines.push(formatBrowserCommonOptionsHelpText(), '');
+    if (cmd.adapterConcurrency?.isolatedTabs === true)
+        lines.push(formatAdapterSessionOptionsHelpText(), '');
     const meta = [];
     meta.push(`Access: ${cmd.access}`);
     meta.push(`Browser: ${browserRequirementLabel(cmd)}`);

package/dist/src/manifest-types.d.ts

@@ -38,4 +38,8 @@ export interface ManifestEntry {
     navigateBefore?: boolean | string;
     /** Site session lifecycle defaults — see CliCommand.siteSession */
     siteSession?: 'ephemeral' | 'persistent';
+    adapterConcurrency?: {
+        isolatedTabs: true;
+        maxParallel: number;
+    };
 }

package/dist/src/registry.d.ts

@@ -28,6 +28,10 @@ export type ConditionalBrowserCommandFunc = (page: IPage | null, kwargs: Command
 export type NonBrowserCommandFunc = (kwargs: CommandArgs, debug?: boolean) => Promise<unknown>;
 export type CommandAccess = 'read' | 'write';
 export type SiteSessionMode = 'ephemeral' | 'persistent';
+export interface AdapterConcurrency {
+    isolatedTabs: true;
+    maxParallel: number;
+}
 /**
  * 所有已注册 adapter command 的共享元数据和运行选项。
  *
@@ -82,6 +86,8 @@ interface BaseCliCommand {
     navigateBefore?: boolean | string;
     /** adapter 浏览器站点 session 生命周期：临时 session 或持久 session。 */
     siteSession?: SiteSessionMode;
+    /** Opt-in authorization for isolated persistent Adapter tabs. */
+    adapterConcurrency?: AdapterConcurrency;
     /** 用户没有传 `-f/--format` 时使用的默认输出格式。 */
     defaultFormat?: 'table' | 'plain' | 'json' | 'yaml' | 'yml' | 'md' | 'markdown' | 'csv';
 }

package/dist/src/registry.js

@@ -95,6 +95,7 @@ function rawCommandBase(opts) {
         validateArgs: opts.validateArgs,
         navigateBefore: opts.navigateBefore,
         siteSession: opts.siteSession,
+        adapterConcurrency: opts.adapterConcurrency,
         defaultFormat: opts.defaultFormat,
     };
 }
@@ -190,6 +191,27 @@ function assertSiteSession(cmd) {
         throw new Error(`Command ${key} siteSession must be one of: ephemeral, persistent`);
     }
 }
+function assertAdapterConcurrency(cmd) {
+    if (cmd.adapterConcurrency === undefined)
+        return;
+    const key = `${cmd.site}/${cmd.name}`;
+    if (!cmd.adapterConcurrency || typeof cmd.adapterConcurrency !== 'object') {
+        throw new Error(`Command ${key} adapterConcurrency must be an object`);
+    }
+    const metadata = cmd.adapterConcurrency;
+    if (metadata.isolatedTabs !== true) {
+        throw new Error(`Command ${key} adapterConcurrency.isolatedTabs must be true`);
+    }
+    if (!Number.isInteger(metadata.maxParallel)
+        || metadata.maxParallel < 1
+        || metadata.maxParallel > 3) {
+        throw new Error(`Command ${key} adapterConcurrency.maxParallel must be an integer between 1 and 3`);
+    }
+    if (cmd.browser === false
+        || (cmd.browser === undefined && (cmd.strategy === Strategy.PUBLIC || cmd.strategy === Strategy.LOCAL))) {
+        throw new Error(`Command ${key} adapterConcurrency requires browser capability`);
+    }
+}
 export function registerCommand(cmd) {
     registerCommandInput(cmd);
 }
@@ -197,6 +219,7 @@ function registerCommandInput(cmd) {
     withRegistryMutationGroup(() => {
         assertCommandAccess(cmd);
         assertSiteSession(cmd);
+        assertAdapterConcurrency(cmd);
         if (cmd.browser === 'conditional') {
             if (typeof cmd.requiresBrowser !== 'function') {
                 const key = `${cmd.site}/${cmd.name}`;

package/dist/src/serialization.d.ts

@@ -33,6 +33,7 @@ export declare function serializeCommand(cmd: CliCommand): {
     example: string;
     defaultFormat: "table" | "plain" | "json" | "yaml" | "yml" | "md" | "markdown" | "csv" | null;
     siteSession: import("./registry.js").SiteSessionMode | null;
+    adapterConcurrency: import("./registry.js").AdapterConcurrency | null;
 };
 /** Human-readable arg summary: `<required> [optional]` style. */
 export declare function formatArgSummary(args: Arg[]): string;

package/dist/src/serialization.js

@@ -35,6 +35,7 @@ export function serializeCommand(cmd) {
         example: formatCommandExample(cmd),
         defaultFormat: cmd.defaultFormat ?? null,
         siteSession: cmd.siteSession ?? null,
+        adapterConcurrency: cmd.adapterConcurrency ?? null,
     };
 }
 // ── Formatting ──────────────────────────────────────────────────────────────

package/dist/src/types.d.ts

@@ -222,6 +222,8 @@ export interface IPage {
     /** Focus the browser window containing the active page for interactive login. */
     focusWindow?(): Promise<void>;
     closeWindow?(): Promise<void>;
+    /** Pin subsequent commands to the daemon profile selected for this operation. */
+    setContextId?(contextId: string): void;
     /** Returns the current page URL, or null if unavailable. */
     getCurrentUrl?(): Promise<string | null>;
     /** Returns the active page identity (targetId), or undefined if not yet resolved. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sovovs/bycli",
-  "version": "2.1.39",
+  "version": "2.1.41",
   "publishConfig": {
     "access": "public"
   },
@@ -33,7 +33,8 @@
     "./download/media-download": "./dist/src/download/media-download.js",
     "./download/progress": "./dist/src/download/progress.js",
     "./download/wechat-article": "./dist/src/download/wechat-article.js",
-    "./pipeline": "./dist/src/pipeline/index.js"
+    "./pipeline": "./dist/src/pipeline/index.js",
+    "./adapter-coordination": "./dist/src/adapter-coordination.js"
   },
   "files": [
     "dist/src/",