@phnx-labs/agents-cli 1.22.22 → 1.22.24

package/dist/lib/session/discover.js

@@ -47,6 +47,8 @@ const HOME = os.homedir();
 const VERSIONS_ROOTS = [getHistoryDir(), getAgentsDir()];
 const RUSH_SESSIONS_DIR = path.join(HOME, '.rush', 'sessions');
 const HERMES_SESSIONS_DIR = path.join(HOME, '.hermes', 'sessions');
+/** Muse Code sessions: ~/.local/share/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl */
+const MUSE_SESSIONS_DIR = path.join(HOME, '.local', 'share', 'muse', 'sessions');
 /** How long OpenClaw channel/cron snapshots stay valid before we re-shell-out. */
 const OPENCLAW_TTL_MS = 60_000;
 const ACTIVE_APPEND_RESCAN_DEBOUNCE_MS = 5_000;
@@ -303,6 +305,7 @@ function dispatchAgentScan(agent, onProgress) {
         case 'droid': return scanDroidIncremental(onProgress);
         case 'grok': return scanGrokIncremental(onProgress);
         case 'cursor': return scanCursorIncremental(onProgress);
+        case 'muse': return scanMuseIncremental(onProgress);
         default: return Promise.resolve();
     }
 }
@@ -2274,6 +2277,171 @@ function readHermesMeta(filePath) {
     };
     return { meta, content: userTexts.join('\n') };
 }
+/**
+ * Muse Code stores one session per directory under
+ * ~/.local/share/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl (event-sourced
+ * JSONL). Walk the tree for session.jsonl files and index each one.
+ *
+ * Also scan version homes (`versions/muse/<v>/home/.local/share/muse/sessions`)
+ * so managed/isolated runs that rewrite HOME still show up in `agents sessions`.
+ */
+function scanMuseIncremental(onProgress) {
+    const roots = [];
+    if (fs.existsSync(MUSE_SESSIONS_DIR))
+        roots.push(MUSE_SESSIONS_DIR);
+    for (const root of VERSIONS_ROOTS) {
+        const versionsBase = path.join(root, 'versions', 'muse');
+        if (!fs.existsSync(versionsBase))
+            continue;
+        try {
+            for (const version of fs.readdirSync(versionsBase)) {
+                const dir = path.join(versionsBase, version, 'home', '.local', 'share', 'muse', 'sessions');
+                if (fs.existsSync(dir))
+                    roots.push(dir);
+            }
+        }
+        catch {
+            /* unreadable */
+        }
+    }
+    if (roots.length === 0)
+        return Promise.resolve();
+    const filePaths = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const full = path.join(dir, ent.name);
+            if (ent.isDirectory()) {
+                // Skip subagent child sessions — nested under subagent/<id>/
+                if (ent.name === 'subagent')
+                    continue;
+                walk(full);
+            }
+            else if (ent.name === 'session.jsonl') {
+                filePaths.push(full);
+            }
+        }
+    };
+    for (const root of roots)
+        walk(root);
+    const changed = filterChangedFiles(filePaths);
+    if (changed.length === 0)
+        return Promise.resolve();
+    onProgress?.({ agent: 'muse', parsed: 0, total: changed.length });
+    const scanEntries = [];
+    const touched = [];
+    const seen = new Set();
+    let parsed = 0;
+    for (const { filePath, scan } of changed) {
+        try {
+            const result = readMuseMeta(filePath);
+            if (result && !seen.has(result.meta.id)) {
+                seen.add(result.meta.id);
+                scanEntries.push({ meta: result.meta, content: result.content, scan });
+            }
+            else {
+                touched.push({ filePath, scan });
+            }
+        }
+        catch {
+            touched.push({ filePath, scan });
+        }
+        parsed++;
+        onProgress?.({ agent: 'muse', parsed, total: changed.length });
+    }
+    upsertSessionsBatch(scanEntries);
+    recordScans(touched);
+    return Promise.resolve();
+}
+/** Parse a Muse session.jsonl for session metadata + first user prompt text. */
+function readMuseMeta(filePath) {
+    // Path shape: .../sessions/YYYY/MM/DD/<uuid>/session.jsonl
+    const sessionId = path.basename(path.dirname(filePath));
+    if (!/^[0-9a-f-]{36}$/i.test(sessionId))
+        return null;
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const userTexts = [];
+    let topic;
+    let messageCount = 0;
+    let model;
+    let project;
+    let firstTs;
+    let lastTs;
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof raw.recorded_at === 'number') {
+            const v = raw.recorded_at;
+            // Muse logs use microseconds; values < 1e14 are treated as milliseconds.
+            const ms = v > 1e14 ? Math.floor(v / 1000) : v;
+            const ts = new Date(ms).toISOString();
+            if (!firstTs)
+                firstTs = ts;
+            lastTs = ts;
+        }
+        const payloadType = raw.payload_type;
+        const payload = raw.payload;
+        if (payloadType === 'runtime.session.metadata') {
+            const record = payload?.record;
+            if (typeof record?.workspace_root === 'string')
+                project = record.workspace_root;
+        }
+        if (payloadType === 'runtime.command_intake.received') {
+            const cmd = payload?.record?.command;
+            if (cmd?.kind === 'turn_submit' && typeof cmd.prompt === 'string' && cmd.prompt.trim()) {
+                messageCount++;
+                userTexts.push(cmd.prompt.trim());
+                if (!topic)
+                    topic = extractSessionTopic(cmd.prompt.trim());
+            }
+        }
+        const event = payload?.event ?? payload;
+        if (event?.kind === 'assistant_message_committed' && typeof event.text === 'string') {
+            messageCount++;
+        }
+        if (event?.kind === 'model_request_configured' && typeof event.model === 'string') {
+            model = event.model;
+        }
+        if (typeof event?.model === 'string' && !model)
+            model = event.model;
+    }
+    const stat = safeStatSync(filePath);
+    const timestamp = lastTs
+        || firstTs
+        || (stat ? stat.mtime.toISOString() : new Date().toISOString());
+    const shortId = deriveShortId(sessionId);
+    const meta = {
+        id: sessionId,
+        shortId,
+        agent: 'muse',
+        timestamp,
+        project,
+        filePath,
+        model,
+        topic,
+        messageCount: messageCount || undefined,
+    };
+    return { meta, content: userTexts.join('\n') };
+}
 /** Extract plain text from a Hermes message content field (string or list of parts). */
 function extractHermesMessageText(content) {
     if (typeof content === 'string')

package/dist/lib/session/parse.d.ts

@@ -133,6 +133,16 @@ export declare function parseGrok(filePath: string): SessionEvent[];
 export declare function parseOpenCode(filePath: string): SessionEvent[];
 /** Parse a Rush JSONL session file into normalized events. */
 export declare function parseRush(filePath: string): SessionEvent[];
+/**
+ * Muse Code session.jsonl → normalized events.
+ *
+ * Muse records an append-only event log. We map:
+ *   - runtime.command_intake.received / turn_submit → user message
+ *   - assistant_message_committed → assistant message
+ *   - model_completed.usage → usage
+ *   - tool-related events when present
+ */
+export declare function parseMuse(filePath: string): SessionEvent[];
 /** Parse a Hermes session JSON file into normalized events. */
 export declare function parseHermes(filePath: string): SessionEvent[];
 /** Parse a Kimi session state.json file by reading its agents/main/wire.jsonl. */

package/dist/lib/session/parse.js

@@ -160,6 +160,9 @@ export function parseSession(filePath, agent, opts = {}) {
         case 'cursor':
             events = parseCursor(filePath);
             break;
+        case 'muse':
+            events = parseMuse(filePath);
+            break;
     }
     // Chokepoint: every string field that originated in an untrusted session
     // file gets stripped of terminal escapes here, so renderers downstream can
@@ -206,6 +209,13 @@ export function detectAgent(filePath) {
         return 'droid';
     if (filePath.includes('/.cursor/') || filePath.includes('\\.cursor\\'))
         return 'cursor';
+    // Muse sessions: ~/.local/share/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl
+    if (filePath.includes('/muse/sessions/') ||
+        filePath.includes('\\muse\\sessions\\') ||
+        filePath.includes('/.local/share/muse/') ||
+        filePath.includes('\\.local\\share\\muse\\')) {
+        return 'muse';
+    }
     // Cloud convention: cloud-sessions/<id>/session.<format>.jsonl
     const cloudMatch = filePath.match(/session\.(claude|codex|rush)\.jsonl(?:$|[?#])/);
     if (cloudMatch)
@@ -1504,6 +1514,94 @@ export function parseRush(filePath) {
 //     system_prompt, message_count, messages: [{role, content}, ...] }
 // Content may be a string or an array of text parts.
 // ---------------------------------------------------------------------------
+/**
+ * Muse Code session.jsonl → normalized events.
+ *
+ * Muse records an append-only event log. We map:
+ *   - runtime.command_intake.received / turn_submit → user message
+ *   - assistant_message_committed → assistant message
+ *   - model_completed.usage → usage
+ *   - tool-related events when present
+ */
+export function parseMuse(filePath) {
+    const content = safeReadSessionFile(filePath);
+    const lines = content.split('\n').filter((l) => l.trim());
+    const events = [];
+    const museTs = (raw) => {
+        if (typeof raw?.recorded_at === 'number') {
+            const v = raw.recorded_at;
+            const ms = v > 1e14 ? Math.floor(v / 1000) : v;
+            return new Date(ms).toISOString();
+        }
+        return new Date().toISOString();
+    };
+    for (const line of lines) {
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const timestamp = museTs(raw);
+        const payloadType = raw.payload_type;
+        const payload = raw.payload;
+        const event = payload?.event ?? payload;
+        if (payloadType === 'runtime.command_intake.received') {
+            const cmd = payload?.record?.command;
+            if (cmd?.kind === 'turn_submit' && typeof cmd.prompt === 'string' && cmd.prompt.trim()) {
+                events.push({
+                    type: 'message',
+                    agent: 'muse',
+                    timestamp,
+                    role: 'user',
+                    content: cmd.prompt.trim(),
+                });
+            }
+            continue;
+        }
+        if (event?.kind === 'assistant_message_committed' && typeof event.text === 'string') {
+            events.push({
+                type: 'message',
+                agent: 'muse',
+                timestamp,
+                role: 'assistant',
+                content: event.text,
+            });
+            continue;
+        }
+        if (event?.kind === 'model_completed' && event.usage && typeof event.usage === 'object') {
+            const u = event.usage;
+            events.push({
+                type: 'usage',
+                agent: 'muse',
+                timestamp,
+                content: JSON.stringify({
+                    input_tokens: u.input_tokens ?? 0,
+                    output_tokens: u.output_tokens ?? 0,
+                    cached_tokens: u.cached_tokens ?? 0,
+                    reasoning_tokens: u.reasoning_tokens ?? 0,
+                }),
+            });
+            continue;
+        }
+        // Tool call / result shapes when Muse records them under task events
+        if (event?.kind === 'tool_call' || event?.kind === 'tool.called') {
+            const tool = event.tool || event.name || event.tool_name;
+            if (typeof tool === 'string') {
+                events.push({
+                    type: 'tool_use',
+                    agent: 'muse',
+                    timestamp,
+                    tool,
+                    args: typeof event.args === 'object' ? event.args : undefined,
+                    callId: typeof event.call_id === 'string' ? event.call_id : undefined,
+                });
+            }
+        }
+    }
+    return events;
+}
 /** Parse a Hermes session JSON file into normalized events. */
 export function parseHermes(filePath) {
     let session;

package/dist/lib/session/recovery.d.ts

@@ -0,0 +1,37 @@
+import { type RotateCandidate } from '../rotate.js';
+import type { AgentId } from '../types.js';
+import type { SessionMeta } from './types.js';
+export type SessionRecoveryTarget = {
+    mode: 'native';
+    agent: AgentId;
+    version: string;
+    reason: string;
+} | {
+    mode: 'continue';
+    agent: AgentId;
+    version: string;
+    reason: string;
+};
+export declare class SessionRecoveryError extends Error {
+    constructor(message: string);
+}
+/** Canonical origin-device label for every recovery consumer. */
+export declare function sessionOriginDevice(session: Pick<SessionMeta, 'machine'>, self?: string): string;
+/** The peer that must execute recovery, or undefined when this is the origin. */
+export declare function sessionRecoveryPeer(session: Pick<SessionMeta, 'machine'>, selfCheck?: (host: string) => boolean): string | undefined;
+/** Whether an explicit placement names the session's origin device. */
+export declare function sessionRecoveryDestinationMatches(session: Pick<SessionMeta, 'machine'>, requestedHost: string, self?: string): boolean;
+/**
+ * Decide how a durable session resumes on the device that owns it.
+ *
+ * Native resume is legal only in the exact origin version's isolated home and
+ * only while that account is healthy. Every other successful path stays on the
+ * same harness and uses `/continue`, whose indexed transcript reader can reach
+ * retained version trash. No healthy same-harness account is a loud failure.
+ */
+export declare function resolveSessionRecoveryFromCandidates(session: SessionMeta, candidates: RotateCandidate[], supportsNative?: (agent: AgentId, version?: string) => boolean): SessionRecoveryTarget;
+export declare function resolveSessionRecovery(session: SessionMeta): Promise<SessionRecoveryTarget>;
+/** Stable self-command used by focus, resume, and attach. The owning device runs
+ * the recovery resolver above; callers must not native-resume another version's
+ * isolated home themselves. */
+export declare function sessionRecoveryRunArgs(session: Pick<SessionMeta, 'id'>): string[];

package/dist/lib/session/recovery.js

@@ -0,0 +1,95 @@
+import { AGENTS } from '../agents.js';
+import { isSelfHost } from '../devices/self-host.js';
+import { nativeResume } from '../exec.js';
+import { machineId, normalizeHost } from '../machine-id.js';
+import { collectRunCandidates, formatNoHealthyAccountError, pickBalancedCandidate, readinessFromCandidate, } from '../rotate.js';
+export class SessionRecoveryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SessionRecoveryError';
+    }
+}
+/** Canonical origin-device label for every recovery consumer. */
+export function sessionOriginDevice(session, self = machineId()) {
+    return normalizeHost(session.machine ?? self);
+}
+/** The peer that must execute recovery, or undefined when this is the origin. */
+export function sessionRecoveryPeer(session, selfCheck = isSelfHost) {
+    if (!session.machine || selfCheck(session.machine))
+        return undefined;
+    return normalizeHost(session.machine);
+}
+/** Whether an explicit placement names the session's origin device. */
+export function sessionRecoveryDestinationMatches(session, requestedHost, self = machineId()) {
+    const requested = normalizeHost(requestedHost.split('@').pop() || requestedHost);
+    return requested === sessionOriginDevice(session, self);
+}
+function runnableSessionAgent(session) {
+    if (!(session.agent in AGENTS)) {
+        throw new SessionRecoveryError(`Session ${session.shortId} belongs to ${session.agent}, which is indexed but cannot be launched by agents run.`);
+    }
+    return session.agent;
+}
+function sourceReason(session, candidates) {
+    if (!session.version)
+        return 'the origin version was not recorded';
+    const source = candidates.find((candidate) => candidate.version === session.version);
+    if (!source)
+        return `origin ${session.agent}@${session.version} is not installed`;
+    const readiness = readinessFromCandidate(source);
+    return readiness.ready
+        ? `origin ${session.agent}@${session.version} has no native resume form`
+        : `origin ${session.agent}@${session.version} is ${readiness.reason}`;
+}
+/**
+ * Decide how a durable session resumes on the device that owns it.
+ *
+ * Native resume is legal only in the exact origin version's isolated home and
+ * only while that account is healthy. Every other successful path stays on the
+ * same harness and uses `/continue`, whose indexed transcript reader can reach
+ * retained version trash. No healthy same-harness account is a loud failure.
+ */
+export function resolveSessionRecoveryFromCandidates(session, candidates, supportsNative = nativeResume) {
+    const agent = runnableSessionAgent(session);
+    const device = sessionOriginDevice(session);
+    const source = session.version
+        ? candidates.find((candidate) => candidate.version === session.version)
+        : undefined;
+    const sourceReady = source ? readinessFromCandidate(source).ready : false;
+    // An exact healthy origin is deterministic: preserve its isolated home. If
+    // native resume is unavailable for that harness, /continue still launches in
+    // that same healthy home. Only an unusable/missing origin enters balanced
+    // account selection.
+    const selection = sourceReady
+        ? { picked: source }
+        : pickBalancedCandidate(candidates);
+    if (!selection) {
+        const detail = formatNoHealthyAccountError(agent, 'balanced', candidates);
+        throw new SessionRecoveryError(`Cannot recover session ${session.shortId} on ${device}; origin ${agent}@${session.version ?? 'unknown'}. ${detail}`);
+    }
+    const version = selection.picked.version;
+    if (session.version === version && supportsNative(agent, version)) {
+        return {
+            mode: 'native',
+            agent,
+            version,
+            reason: `origin ${agent}@${version} is installed and healthy`,
+        };
+    }
+    return {
+        mode: 'continue',
+        agent,
+        version,
+        reason: `${sourceReason(session, candidates)}; continuing with healthy ${agent}@${version}`,
+    };
+}
+export async function resolveSessionRecovery(session) {
+    const agent = runnableSessionAgent(session);
+    return resolveSessionRecoveryFromCandidates(session, await collectRunCandidates(agent));
+}
+/** Stable self-command used by focus, resume, and attach. The owning device runs
+ * the recovery resolver above; callers must not native-resume another version's
+ * isolated home themselves. */
+export function sessionRecoveryRunArgs(session) {
+    return ['run', 'auto', '--resume', session.id, '--interactive'];
+}

package/dist/lib/session/remote-list.d.ts

@@ -73,7 +73,16 @@ export declare function isAutomaticSessionPeer(d: DeviceProfile, self: string):
  * address. `forwardedArgs` are the caller's own sessions args (query + filters,
  * already `--json`) so every peer returns the same slice this machine asked for.
  */
-export declare function gatherRemoteList(forwardedArgs: string[], hosts?: string[]): Promise<RemoteListResult>;
+export interface GatherRemoteListOptions {
+    /**
+     * Opt-in early-exit for a globally-unique id lookup (a full UUID): the first
+     * peer to return the matching row resolves the fan-out and cancels the rest.
+     * Omitted for browse/label/prefix sweeps, which must wait for every peer to
+     * know whether the match is unique or conflicting.
+     */
+    isDefinitive?: (session: SessionMeta, machine: string) => boolean;
+}
+export declare function gatherRemoteList(forwardedArgs: string[], hosts?: string[], opts?: GatherRemoteListOptions): Promise<RemoteListResult>;
 export interface RemoteToolSearchResult {
     envelopes: Array<{
         machine: string;

package/dist/lib/session/remote-list.js

@@ -191,19 +191,13 @@ export function isAutomaticSessionPeer(d, self) {
         return false;
     return d.platform === 'windows' || d.platform === 'linux' || d.platform === 'macos';
 }
-/**
- * Gather listing sessions from other machines. With an explicit `hosts` list
- * (from `--host`), fan out to exactly those. Otherwise sweep the registered,
- * online devices from `ag devices`, excluding this machine and any without an
- * address. `forwardedArgs` are the caller's own sessions args (query + filters,
- * already `--json`) so every peer returns the same slice this machine asked for.
- */
-export async function gatherRemoteList(forwardedArgs, hosts) {
+export async function gatherRemoteList(forwardedArgs, hosts, opts) {
     const safeResolver = forwardedArgs.includes('--resolve-safe-v1');
     const result = await gatherRemoteAgentsJson({
         args: forwardedArgs,
         noFanoutEnv: NO_FANOUT_ENV,
         hosts,
+        earlyExit: opts?.isDefinitive ? { isDefinitive: opts.isDefinitive } : undefined,
         parse: (stdout, machine) => parseRemoteListPayload(stdout, machine, safeResolver),
     });
     return {

package/dist/lib/session/remote.d.ts

@@ -54,20 +54,74 @@ export declare function classifySshFailure(res: {
     error?: Error | null;
     status: number | null;
 }): SshOutcome;
+/**
+ * How long a successful remote fetch may be served without re-SSHing.
+ * Short on purpose: session listings must stay near-live (RUSH-2062). Match the
+ * active-session snapshot window so surfaces share one freshness model.
+ */
+export declare const REMOTE_CACHE_MAX_AGE_MS = 15000;
 /**
  * Deterministic cache path for a (host, forwarded-args) pair. The forwarded args
  * are hashed so distinct queries cache independently; the host stays readable in
  * the filename (sanitised so `user@host` and aliases are filesystem-safe).
  */
 export declare function remoteCachePath(host: string, forwardedArgs: string[]): string;
+/**
+ * Pure freshness check for a remote-sessions cache entry. A reachable host
+ * skips SSH only while this returns true; unreachable fallback ignores age.
+ */
+export declare function isRemoteCacheFresh(mtimeMs: number, nowMs: number, maxAgeMs?: number): boolean;
+export interface RemoteCacheHit {
+    output: string;
+    mtimeMs: number;
+}
+/**
+ * Read a cached remote fetch. When `maxAgeMs` is set, returns null if the
+ * entry is older than the window (cache-first path for reachable hosts).
+ * Omit `maxAgeMs` to accept any age (unreachable fallback).
+ */
+export declare function readRemoteCache(host: string, forwardedArgs: string[], opts?: {
+    maxAgeMs?: number;
+    nowMs?: number;
+}): RemoteCacheHit | null;
 /** Banner shown above replayed cache rows when the peer is offline. */
 export declare function formatStaleBanner(host: string, mtimeMs: number): string;
 /** Message shown when a host is unreachable and there is no cache to fall back to. */
 export declare function formatUnreachable(host: string): string;
+/** Persist a successful fetch for later cache-first / offline replay.
+ * Best-effort: a cache write must never break the live query. Exported for tests. */
+export declare function writeRemoteCache(host: string, forwardedArgs: string[], output: string): void;
+/**
+ * Serve a *fresh* cache entry for a reachable-host skip (no banner — the data
+ * is still within the freshness window). Returns false when missing/stale so
+ * the caller SSHes. RUSH-2062: without this, a reachable host never skipped SSH
+ * even when the cache was just written.
+ */
+export declare function serveWarmRemoteCache(host: string, forwardedArgs: string[], opts?: {
+    maxAgeMs?: number;
+    nowMs?: number;
+}): boolean;
+/** Replay a cached fetch for an unreachable host (any age). Banner goes to
+ * stderr (so a piped stdout stays exactly the cached rows); returns false when
+ * nothing is cached for this exact (host, query). */
+export declare function replayRemoteCache(host: string, forwardedArgs: string[]): boolean;
+export interface RunRemoteSessionsOptions {
+    /** Skip warm cache and SSH every host (force-refresh). */
+    forceRefresh?: boolean;
+    /** Override freshness window for the warm path. */
+    maxAgeMs?: number;
+    /** Clock (tests). */
+    nowMs?: number;
+}
 /**
  * Run the current `agents sessions` invocation on one or more remote machines over
- * SSH, writing each remote's output to the terminal. A successful fetch is cached;
- * an unreachable host falls back to that cache (with a stale banner) when present.
+ * SSH, writing each remote's output to the terminal.
+ *
+ * Cache policy (RUSH-2062):
+ * - **Default:** serve a fresh cache hit without SSH; SSH only on miss/stale.
+ * - **`forceRefresh`:** always SSH, then rewrite the cache.
+ * - **Unreachable:** fall back to any cached output (with a stale banner).
+ *
  * Sets `process.exitCode = 1` if any host could not be answered (live or cached).
  * Reads the invocation from `process.argv` (override via `argv` for testing).
  *
@@ -75,4 +129,4 @@ export declare function formatUnreachable(host: string): string;
  * Session output is small and the remote returns quickly, so buffering is
  * imperceptible; `maxBuffer` is generous for the rare large `--markdown <id>` dump.
  */
-export declare function runRemoteSessions(hosts: string[], argv?: string[]): void;
+export declare function runRemoteSessions(hosts: string[], argv?: string[], opts?: RunRemoteSessionsOptions): void;