@sovovs/bycli 2.1.39 → 2.1.41

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;

package/dist/src/daemon.js

@@ -39,6 +39,7 @@ import { recordExtensionVersion } from './update-check.js';
 import { EXTENSION_CAPABILITY_MISSING_ERROR_CODE, EXTENSION_CAPABILITY_MISSING_HTTP_STATUS, extensionCapabilityHint, missingRequiredExtensionCapability, normalizeExtensionCapabilities, } from './browser/extension-capabilities.js';
 import { buildCommandDispatchFailure, buildExtensionDisconnectFailure, getResponseCorsHeaders, } from './daemon-utils.js';
 import { resolveDaemonHost } from './daemon-config.js';
+import { AdapterScheduler, AdapterSchedulerError, } from './adapter-scheduler.js';
 const PORT = parseInt(process.env.BYCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const HOST = resolveDaemonHost();
 const BROWSER_RECOVERY_COMMAND = process.env.BYCLI_BROWSER_RECOVERY_COMMAND?.trim();
@@ -60,6 +61,9 @@ const logger = createRecorderLogger(LOG_LEVELS.includes(envLogLevel) ? envLogLev
 // runner counters surface on GET /metrics and runner logs share the daemon's level.
 setDefaultRunnerObservability(metrics, logger);
 const extensionProfiles = new Map();
+const adapterScheduler = new AdapterScheduler();
+const adapterSchedulerSweep = setInterval(() => adapterScheduler.sweepExpired(), 5_000);
+adapterSchedulerSweep.unref?.();
 const pending = new Map();
 let commandResultUnknownCount = 0;
 const LOG_BUFFER_SIZE = 200;
@@ -386,6 +390,92 @@ async function handleRequest(req, res) {
         }
         return;
     }
+    if (req.method === 'POST' && pathname.startsWith('/v1/adapter-leases/')) {
+        try {
+            const body = JSON.parse(await readBody(req));
+            if (pathname === '/v1/adapter-leases/acquire') {
+                const request = body;
+                let clientGone = false;
+                const onClose = () => {
+                    if (res.writableEnded)
+                        return;
+                    clientGone = true;
+                    adapterScheduler.cancel(request.requestId);
+                };
+                res.once('close', onClose);
+                const lease = await adapterScheduler.acquire(request);
+                res.off('close', onClose);
+                if (clientGone || res.destroyed) {
+                    adapterScheduler.release({ ...lease, reason: 'cancelled' });
+                    return;
+                }
+                jsonResponse(res, 200, { ok: true, data: lease });
+                return;
+            }
+            if (pathname === '/v1/adapter-leases/heartbeat') {
+                const lease = adapterScheduler.heartbeat(body);
+                jsonResponse(res, 200, { ok: true, data: lease });
+                return;
+            }
+            if (pathname === '/v1/adapter-leases/release') {
+                const released = adapterScheduler.release(body);
+                jsonResponse(res, 200, { ok: true, data: { released } });
+                return;
+            }
+            if (pathname === '/v1/adapter-leases/cancel') {
+                const requestId = typeof body.requestId === 'string' ? body.requestId : '';
+                const cancelled = requestId ? adapterScheduler.cancel(requestId) : false;
+                jsonResponse(res, 200, { ok: true, data: { cancelled } });
+                return;
+            }
+            jsonResponse(res, 404, { ok: false, errorCode: 'ADAPTER_QUEUE_RESET', error: 'Unknown Adapter lease operation' });
+        }
+        catch (error) {
+            if (res.destroyed)
+                return;
+            const schedulerError = error instanceof AdapterSchedulerError ? error : null;
+            const status = schedulerError?.code === 'ADAPTER_QUEUE_TIMEOUT' ? 408
+                : schedulerError?.code === 'ADAPTER_LEASE_LOST' ? 409
+                    : schedulerError?.code === 'ADAPTER_POOL_AUTH_GATE' || schedulerError?.code === 'ADAPTER_POOL_RATE_LIMITED' ? 409
+                        : 400;
+            jsonResponse(res, status, {
+                ok: false,
+                errorCode: schedulerError?.code ?? 'ADAPTER_QUEUE_RESET',
+                error: error instanceof Error ? error.message : 'Adapter scheduler request failed',
+            });
+        }
+        return;
+    }
+    if (req.method === 'POST' && pathname.startsWith('/v1/adapter-resources/')) {
+        try {
+            const body = JSON.parse(await readBody(req));
+            const lease = body.lease;
+            if (pathname === '/v1/adapter-resources/acquire') {
+                const keys = Array.isArray(body.keys) ? body.keys.filter((key) => typeof key === 'string') : [];
+                const timeoutMs = typeof body.timeoutMs === 'number' ? body.timeoutMs : 0;
+                const grant = await adapterScheduler.acquireResources(lease, keys, timeoutMs);
+                jsonResponse(res, 200, { ok: true, data: grant });
+                return;
+            }
+            if (pathname === '/v1/adapter-resources/release') {
+                const grantId = typeof body.grantId === 'string' ? body.grantId : '';
+                const released = adapterScheduler.releaseResources(lease, grantId);
+                jsonResponse(res, 200, { ok: true, data: { released } });
+                return;
+            }
+            jsonResponse(res, 404, { ok: false, errorCode: 'ADAPTER_QUEUE_RESET', error: 'Unknown Adapter resource operation' });
+        }
+        catch (error) {
+            const schedulerError = error instanceof AdapterSchedulerError ? error : null;
+            const status = schedulerError?.code === 'ADAPTER_RESOURCE_TIMEOUT' ? 408 : 409;
+            jsonResponse(res, status, {
+                ok: false,
+                errorCode: schedulerError?.code ?? 'ADAPTER_LEASE_LOST',
+                error: error instanceof Error ? error.message : 'Adapter resource request failed',
+            });
+        }
+        return;
+    }
     if (req.method === 'GET' && pathname === '/status') {
         const uptime = process.uptime();
         const mem = process.memoryUsage();
@@ -415,6 +505,8 @@ async function handleRequest(req, res) {
             profileDisconnected: route.errorCode === 'profile_disconnected',
             profiles,
             pending: pending.size,
+            adapterLeases: adapterScheduler.snapshot(),
+            adapterResources: adapterScheduler.resourceSnapshot(),
             commandResultUnknown: commandResultUnknownCount,
             memoryMB: Math.round(mem.rss / 1024 / 1024 * 10) / 10,
             port: PORT,
@@ -454,6 +546,30 @@ async function handleRequest(req, res) {
                 jsonResponse(res, 400, { ok: false, error: 'Missing command id' });
                 return;
             }
+            const namedAdapterSession = body.surface === 'adapter'
+                && body.siteSession === 'persistent'
+                && typeof body.session === 'string'
+                && /^site:[^:\s]+:[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(body.session);
+            if (namedAdapterSession && !body.adapterLease) {
+                throw new DaemonCommandFailure('Named Adapter browser commands require an active lease', 'ADAPTER_LEASE_LOST', undefined, 409);
+            }
+            if (body.adapterLease) {
+                try {
+                    const lease = adapterScheduler.assertLease(body.adapterLease);
+                    if (body.contextId !== lease.contextId
+                        || body.surface !== 'adapter'
+                        || body.siteSession !== 'persistent'
+                        || body.session !== lease.sessionKey) {
+                        throw new AdapterSchedulerError('ADAPTER_LEASE_LOST', 'Adapter browser command does not match its lease scope');
+                    }
+                }
+                catch (error) {
+                    if (error instanceof AdapterSchedulerError) {
+                        throw new DaemonCommandFailure(error.message, error.code, undefined, 409);
+                    }
+                    throw error;
+                }
+            }
             const route = resolveExtensionConnection(typeof body.contextId === 'string' ? body.contextId : undefined);
             if (!route.connection) {
                 jsonResponse(res, route.errorCode === 'profile_required' ? 409 : 503, {
@@ -722,6 +838,8 @@ function shutdown() {
         p.reject(new Error('Daemon shutting down'));
     }
     pending.clear();
+    clearInterval(adapterSchedulerSweep);
+    adapterScheduler.reset();
     for (const profile of extensionProfiles.values())
         profile.ws.close();
     httpServer.close();

package/dist/src/discovery.js

@@ -137,6 +137,7 @@ export async function loadFromManifest(manifestPath, clisDir) {
                 source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : modulePath,
                 navigateBefore: entry.navigateBefore,
                 siteSession: entry.siteSession,
+                adapterConcurrency: entry.adapterConcurrency,
                 _lazy: true,
                 _modulePath: modulePath,
             };

package/dist/src/download/article-download.d.ts

@@ -53,6 +53,8 @@ export interface ArticleDownloadOptions {
     stdout?: boolean;
     /** Opt-in hardened Markdown rules used by HTML-focused adapters. */
     secureMarkdown?: boolean;
+    /** Lease fencing check invoked immediately before the final Markdown write. */
+    beforePublish?: () => Promise<void>;
 }
 export interface ArticleDownloadResult {
     title: string;

package/dist/src/download/article-download.js

@@ -325,7 +325,7 @@ async function downloadImages(imgUrls, imgDir, headers, detectExt) {
  * 6. File write
  */
 export async function downloadArticle(data, options) {
-    const { output, downloadImages: shouldDownloadImages = true, imageHeaders, maxTitleLength = 80, configureTurndown, detectImageExt, frontmatterLabels, cleanSelectors, stdout = false, secureMarkdown = false, } = options;
+    const { output, downloadImages: shouldDownloadImages = true, imageHeaders, maxTitleLength = 80, configureTurndown, detectImageExt, frontmatterLabels, cleanSelectors, stdout = false, secureMarkdown = false, beforePublish, } = options;
     const labels = { ...DEFAULT_LABELS, ...frontmatterLabels };
     if (!data.title) {
         return [{
@@ -350,12 +350,14 @@ export async function downloadArticle(data, options) {
     // Convert HTML to Markdown
     let markdown = convertToMarkdown(data.contentHtml, data.codeBlocks || [], configureTurndown, cleanSelectors, secureMarkdown);
     const safeTitle = sanitizeFilename(data.title, maxTitleLength);
+    const stagingDir = !stdout && beforePublish
+        ? path.join(output, `.bycli-article-${crypto.randomUUID()}.tmp`)
+        : undefined;
     // Download images only when writing to disk. In stdout mode remote URLs
     // stay intact so the piped output is self-contained.
     if (!stdout && shouldDownloadImages && data.imageUrls && data.imageUrls.length > 0) {
         const articleDir = path.join(output, safeTitle);
-        fs.mkdirSync(articleDir, { recursive: true });
-        const imagesDir = path.join(articleDir, 'images');
+        const imagesDir = path.join(stagingDir ?? articleDir, 'images');
         fs.mkdirSync(imagesDir, { recursive: true });
         const urlMap = await downloadImages(data.imageUrls, imagesDir, imageHeaders, detectImageExt);
         markdown = replaceImageUrls(markdown, urlMap);
@@ -396,7 +398,31 @@ export async function downloadArticle(data, options) {
     fs.mkdirSync(articleDir, { recursive: true });
     const filename = `${safeTitle}.md`;
     const filePath = path.join(articleDir, filename);
-    fs.writeFileSync(filePath, fullContent, 'utf-8');
+    if (stagingDir) {
+        fs.mkdirSync(stagingDir, { recursive: true });
+        const stagedMarkdown = path.join(stagingDir, filename);
+        fs.writeFileSync(stagedMarkdown, fullContent, { encoding: 'utf-8', flag: 'wx' });
+        try {
+            await beforePublish?.();
+            const stagedImages = path.join(stagingDir, 'images');
+            if (fs.existsSync(stagedImages)) {
+                const finalImages = path.join(articleDir, 'images');
+                fs.mkdirSync(finalImages, { recursive: true });
+                for (const image of fs.readdirSync(stagedImages)) {
+                    fs.linkSync(path.join(stagedImages, image), path.join(finalImages, image));
+                }
+            }
+            // Same-filesystem rename makes the Markdown replacement atomic.
+            fs.renameSync(stagedMarkdown, filePath);
+        }
+        finally {
+            fs.rmSync(stagingDir, { recursive: true, force: true });
+        }
+    }
+    else {
+        await beforePublish?.();
+        fs.writeFileSync(filePath, fullContent, 'utf-8');
+    }
     return [{
             title: data.title,
             author: data.author || '-',

package/dist/src/errors.d.ts

@@ -67,6 +67,9 @@ export declare class TimeoutError extends CliError {
 export declare class ArgumentError extends CliError {
     constructor(message: string, hint?: string);
 }
+export declare class AdapterCoordinationError extends CliError {
+    constructor(code: string, message: string, temporary?: boolean, hint?: string);
+}
 export declare class EmptyResultError extends CliError {
     constructor(command: string, hint?: string);
 }

package/dist/src/errors.js

@@ -86,6 +86,11 @@ export class ArgumentError extends CliError {
         super('ARGUMENT', message, hint, EXIT_CODES.USAGE_ERROR);
     }
 }
+export class AdapterCoordinationError extends CliError {
+    constructor(code, message, temporary = false, hint) {
+        super(code, message, hint, temporary ? EXIT_CODES.TEMPFAIL : EXIT_CODES.USAGE_ERROR);
+    }
+}
 export class EmptyResultError extends CliError {
     constructor(command, hint) {
         super('EMPTY_RESULT', `${command} returned no data`, hint ?? 'The page structure may have changed, or you may need to log in', EXIT_CODES.EMPTY_RESULT);

package/dist/src/execution.d.ts

@@ -22,6 +22,8 @@ export declare function executeCommand(cmd: CliCommand, rawKwargs: CommandArgs,
     keepTab?: string;
     windowMode?: string;
     siteSession?: string;
+    adapterSession?: string;
+    adapterQueueTimeout?: string;
     onTraceExport?: (trace: ObservationExportResult) => void;
 }): Promise<unknown>;
 export declare function prepareCommandArgs(cmd: CliCommand, rawKwargs: CommandArgs): CommandArgs;