@lotagate/cli 0.1.22 → 0.1.23

package/dist/application/protocol/desktop-agent-command.js

@@ -1,663 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { AuthenticationService } from '../auth/authentication-service.js';
-import { createLotaGateClient } from '../../infrastructure/sdk/lotagate-client-factory.js';
-import { ModelCatalogAdapter } from '../../infrastructure/sdk/model-catalog-adapter.js';
-import { loadExecutionConfig } from '../config/execution-config.js';
-import { prepareCliAgent } from '../agent/cli-agent-execution-service.js';
-import { buildSafeSystemPrompt } from '../agent/safe-system-prompt.js';
-import { createContextManagement } from '../agent/context-compaction.js';
-import { persistContextCompaction } from '../agent/context-compaction-persistence.js';
-import { buildAgentInputContext } from '../agent/agent-input-context.js';
-import { CliAgentSessionStore } from '../agent/agent-session-store.js';
-import { ChatService } from '../chat/chat-service.js';
-import { SdkChatCompletionAdapter } from '../../infrastructure/sdk/chat-completion-adapter.js';
-import { CliTurnEventProjector } from '../orchestration/cli-turn-event-projector.js';
-import { persistCliTurnEvent } from '../orchestration/cli-turn-persistence.js';
-import { actionDisplayName, actionKind } from '../orchestration/cli-turn-events.js';
-import { createTurnId, recordTurnCompletion, recordTurnFailure, recordTurnStart } from '../session/session-turn-lifecycle.js';
-import { ProjectSessionAccess } from '../session/project-session-access.js';
-import { formatShellCommandForDisplay, formatToolActivityName } from '../agent/tool-display.js';
-import { permissionRuleForRequest } from '../security/workspace-permission-policy.js';
-import { agentLimitNotice, classifyAgentLimit } from '../agent/agent-limit.js';
-import { asCliError, CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { readLinesBounded } from './jsonl-protocol.js';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-import { getDesktopCommandCatalog } from './desktop-command-catalog.js';
-import { executeDesktopCommand } from './desktop-command-executor.js';
-import { DesktopAttachmentStore } from './desktop-attachment-store.js';
-import { PlanGenerator } from '../orchestration/plan-generator.js';
-import { planDesktopPayload, planStepPayload, subagentDesktopPayload } from './desktop-orchestration-events.js';
-import { resolveModelContextWindow } from '../model/model-context-window.js';
-import { parseDesktopExecutionPolicy } from './desktop-execution-policy.js';
-import { JsonLineWriter } from './json-line-writer.js';
-export const DESKTOP_PROTOCOL_VERSION = 2;
-/**
- * Local JSONL bridge for the Desktop application. It is deliberately kept in
- * the CLI application layer: Desktop reuses CLI policy and runtime, while the
- * public SDK packages remain independent libraries.
- */
-export async function runDesktopAgentCommand(runtime, cwd, input, output) {
-    const protocol = new DesktopAgentProtocol(runtime, cwd, output);
-    return protocol.run(input);
-}
-class DesktopAgentProtocol {
-    runtime;
-    cwd;
-    writer;
-    turns = new Map();
-    sessionStores = new Map();
-    attachments = new DesktopAttachmentStore();
-    approvals = new Map();
-    trusts = new Map();
-    commands = new Map();
-    browserRequests = new Map();
-    hostRequests = new Map();
-    browserHostEnabled = false;
-    stopping = false;
-    constructor(runtime, cwd, output) {
-        this.runtime = runtime;
-        this.cwd = cwd;
-        this.writer = new JsonLineWriter(output);
-    }
-    async run(input) {
-        let errors = 0;
-        try {
-            for await (const line of readLinesBounded(input, RESOURCE_LIMITS.jsonlLineBytes)) {
-                if (line.trim().length === 0)
-                    continue;
-                let raw;
-                try {
-                    raw = JSON.parse(line);
-                }
-                catch (error) {
-                    errors += 1;
-                    await this.writeError('unknown', 'protocol', toDesktopError(error));
-                    continue;
-                }
-                if (isBrowserHostResponse(raw)) {
-                    this.resolveBrowserRequest(raw);
-                    continue;
-                }
-                if (isDesktopHostResponse(raw)) {
-                    this.resolveDesktopHostRequest(raw);
-                    continue;
-                }
-                let request;
-                try {
-                    request = parseDesktopRequest(raw);
-                }
-                catch (error) {
-                    errors += 1;
-                    await this.writeError('unknown', 'protocol', toDesktopError(error));
-                    continue;
-                }
-                try {
-                    await this.handle(request);
-                }
-                catch (error) {
-                    errors += 1;
-                    await this.writeError(request.id, request.method, toDesktopError(error));
-                }
-                if (this.stopping)
-                    break;
-            }
-        }
-        catch (error) {
-            errors += 1;
-            await this.writeError('unknown', 'protocol', toDesktopError(error));
-        }
-        finally {
-            for (const turn of this.turns.values())
-                turn.controller.abort();
-            await Promise.allSettled([...this.turns.values()].map((turn) => turn.operation));
-            for (const command of this.commands.values())
-                command.controller.abort();
-            await Promise.allSettled([...this.commands.values()].map((command) => command.operation));
-            for (const waiter of this.browserRequests.values()) {
-                if (waiter.onAbort !== undefined)
-                    waiter.signal?.removeEventListener('abort', waiter.onAbort);
-                waiter.reject(new Error('The Desktop browser bridge was closed.'));
-            }
-            this.browserRequests.clear();
-            for (const waiter of this.hostRequests.values()) {
-                if (waiter.onAbort !== undefined)
-                    waiter.signal?.removeEventListener('abort', waiter.onAbort);
-                waiter.reject(new Error('The Desktop execution bridge was closed.'));
-            }
-            this.hostRequests.clear();
-            this.attachments.clear();
-            await this.writer.flush();
-        }
-        return errors === 0 ? 0 : 1;
-    }
-    async handle(request) {
-        switch (request.method) {
-            case 'initialize':
-                this.browserHostEnabled = request.params['browserHost'] === true;
-                return this.respond(request, { protocol: 'lotagate.desktop', version: DESKTOP_PROTOCOL_VERSION, capabilities: ['sessions', 'streaming', 'tool-approval', 'project-trust', 'models', 'auth', 'commands', 'image-attachments', 'file-attachments', 'execution-context', 'tool-allowlist', 'approval-reviews', 'lifecycle-controls', 'execution-broker', ...(this.browserHostEnabled ? ['browser-host'] : [])] });
-            case 'session.create': return this.createSession(request);
-            case 'session.list': return this.listSessions(request);
-            case 'session.resume': return this.resumeSession(request);
-            case 'attachment.begin':
-                this.attachments.begin({ id: request.params.attachmentId, name: request.params.name, mimeType: request.params.mimeType, sizeBytes: request.params.sizeBytes });
-                return this.respond(request, { accepted: true, attachmentId: request.params.attachmentId });
-            case 'attachment.chunk':
-                this.attachments.appendChunk(request.params.attachmentId, request.params.index, request.params.dataBase64);
-                return this.respond(request, { accepted: true, attachmentId: request.params.attachmentId, index: request.params.index });
-            case 'attachment.complete':
-                this.attachments.complete(request.params.attachmentId);
-                return this.respond(request, { accepted: true, attachmentId: request.params.attachmentId });
-            case 'turn.start': return this.startTurn(request);
-            case 'turn.cancel': return this.cancelTurn(request);
-            case 'approval.respond': return this.respondApproval(request);
-            case 'trust.respond': return this.respondTrust(request);
-            case 'model.list': return this.listModels(request);
-            case 'auth.status': return this.authStatus(request);
-            case 'command.list': return this.listCommands(request);
-            case 'command.execute': return this.startCommand(request);
-            case 'command.cancel': return this.cancelCommand(request);
-            case 'shutdown':
-                this.stopping = true;
-                await this.respond(request, { stopping: true });
-                return;
-        }
-    }
-    async createSession(request) {
-        const identity = await this.runtime.projectTrust.inspect(this.cwd);
-        const loaded = await loadExecutionConfig(this.runtime, this.cwd);
-        const profile = loaded.config.profile ?? AuthenticationService.defaultProfileName();
-        const session = await this.runtime.sessionStore.create({ projectFingerprint: identity.fingerprint, cwd: identity.canonicalPath, model: request.params.model ?? loaded.config.model, profile, status: 'active', ...(request.params.name === undefined ? {} : { name: request.params.name }) });
-        await this.respond(request, sessionResult(session));
-    }
-    async listSessions(request) {
-        const identity = await this.runtime.projectTrust.inspect(this.cwd);
-        await this.respond(request, { sessions: await this.runtime.sessionStore.list(identity.fingerprint) });
-    }
-    async resumeSession(request) {
-        const identity = await this.runtime.projectTrust.inspect(this.cwd);
-        const session = await new ProjectSessionAccess(this.runtime.sessionStore).require(request.params.sessionId, identity.fingerprint);
-        await this.respond(request, { ...sessionResult(session), history: await this.runtime.sessionStore.readHistory(session.id) });
-    }
-    async startTurn(request) {
-        const { sessionId } = request.params;
-        if ([...this.turns.values()].some((turn) => turn.sessionId === sessionId))
-            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'A turn is already active for this session.', { category: 'session', userMessage: 'This session already has an active turn.' });
-        const identity = await this.runtime.projectTrust.inspect(this.cwd);
-        const session = await new ProjectSessionAccess(this.runtime.sessionStore).require(sessionId, identity.fingerprint);
-        const attachments = this.attachments.take(request.params.attachmentIds ?? []);
-        const turnId = createTurnId();
-        const controller = new AbortController();
-        const operation = this.executeTurn(request, session, identity, turnId, controller, attachments).catch(async (error) => {
-            await this.writeEvent(controller.signal.aborted ? 'turn.cancelled' : 'turn.failed', { turnId, sessionId, ...(controller.signal.aborted ? {} : { error: toDesktopError(error) }) });
-        }).finally(() => { this.turns.delete(turnId); });
-        this.turns.set(turnId, { sessionId, controller, operation });
-        await this.respond(request, { accepted: true, turnId, sessionId });
-    }
-    async executeTurn(request, session, identity, turnId, controller, attachments) {
-        const loaded = await loadExecutionConfig(this.runtime, this.cwd);
-        const trusted = await this.runtime.projectTrust.isTrusted(identity);
-        if (!trusted) {
-            const trustRequestId = randomUUID();
-            await this.writeEvent('trust.requested', { trustRequestId, sessionId: session.id, path: identity.canonicalPath });
-            if (!(await this.waitForTrust(trustRequestId, controller.signal)))
-                throw new CliError(CLI_ERROR_CODES.PROJECT_TRUST_REQUIRED, 'Project trust was not granted.', { category: 'project', userMessage: 'Trust this project in the Desktop application before running tools.' });
-            await this.runtime.projectTrust.grant(identity);
-            await this.runtime.workspaceSettings.ensureInitialized(identity.canonicalPath);
-        }
-        const model = request.params.model ?? session.model ?? loaded.config.model;
-        if (model === null || model === undefined)
-            throw new CliError(CLI_ERROR_CODES.MODEL_NOT_FOUND, 'No model is selected.', { category: 'model', userMessage: 'Select a model before starting a turn.' });
-        const profileName = session.profile ?? loaded.config.profile ?? AuthenticationService.defaultProfileName();
-        const credential = await this.runtime.auth.requireCredential(profileName);
-        const client = createLotaGateClient(credential.profile, credential.apiKey);
-        const contextWindow = await resolveModelContextWindow(this.runtime, model, profileName);
-        const store = this.sessionStores.get(session.id) ?? new CliAgentSessionStore();
-        this.sessionStores.set(session.id, store);
-        const response = [];
-        const persistedAttachments = await Promise.all(attachments.map(async (payload) => ({ ...payload, attachment: await this.runtime.sessionStore.saveAttachment(session.id, payload.attachment, payload.bytes) })));
-        await recordTurnStart(this.runtime.sessionStore, session.id, turnId, request.params.prompt, persistedAttachments.map(item => item.attachment.id));
-        await this.runtime.sessionStore.updateStatus(session.id, 'active');
-        await this.writeEvent('turn.started', { turnId, sessionId: session.id, model });
-        const plan = new PlanGenerator().generate(request.params.prompt);
-        const planned = plan.requiresApproval ? plan : undefined;
-        if (planned !== undefined) {
-            await this.writeEvent('plan.started', { ...planDesktopPayload(planned, turnId), sessionId: session.id });
-            if (planned.tasks[0] !== undefined)
-                await this.writeEvent('plan.step.started', { ...planStepPayload(planned, turnId, 0, 'started'), sessionId: session.id });
-        }
-        const subagentLifecycle = {
-            onSubagentLifecycle: event => this.writeEvent(`subagent.${event.type}`, subagentDesktopPayload(event, turnId)),
-        };
-        let closePrepared;
-        const timeout = setTimeout(() => controller.abort(), request.params.execution.timeoutMs);
-        try {
-            if (persistedAttachments.length > 0) {
-                response.push(await this.executeAttachmentTurn(request, session, identity, model, client, persistedAttachments, controller, turnId));
-            }
-            else {
-                const execution = request.params.execution;
-                const prepared = await prepareCliAgent({
-                    runtime: this.runtime, cwd: this.cwd, model, client, profile: 'interactive-trusted', approvalMode: desktopApprovalMode(execution.permissionPolicy), ...(execution.allowedTools === undefined ? {} : { allowedTools: execution.allowedTools }), ...(request.params.skills === undefined ? {} : { selectedSkills: request.params.skills }), browserAccess: execution.browserAccess, subagentLifecycle,
-                    ...(this.browserHostEnabled ? { browserHost: (hostRequest, signal) => this.requestBrowserHost(hostRequest, signal) } : {}),
-                    ...(this.browserHostEnabled ? { desktopHost: ((hostRequest, signal) => this.requestDesktopHost(hostRequest, signal)) } : {}),
-                    executionBoundary: execution.isolation,
-                    hostFallback: execution.hostFallback,
-                    ...(this.browserHostEnabled ? { onExecutionFallbackApproval: (approval, reason) => this.waitForApproval(approval, session.id, turnId, controller.signal, 'host', reason) } : {}),
-                    contextManagement: createContextManagement({
-                        client,
-                        model,
-                        ...(contextWindow === undefined ? {} : { contextWindow }),
-                        onCompactionStart: () => this.writeEvent('context.compacting', { turnId, sessionId: session.id }),
-                        onSummaryFailure: (error) => this.runtime.logger.warn('Context summarization failed; using fallback summary.', { reason: error instanceof Error ? error.message : String(error) }),
-                    }),
-                    agentSessionStore: store,
-                    prompt: (approval) => this.waitForApproval(approval, session.id, turnId, controller.signal, execution.isolation),
-                    rememberApproval: (approval) => this.runtime.workspaceSettings.rememberAllow(identity.canonicalPath, permissionRuleForRequest(approval.toolName, approval.input)),
-                    audit: async (decision) => { this.runtime.logger.info('Tool authorization decision.', { toolName: decision.toolName, decision: decision.decision, reason: decision.reason }); await this.runtime.sessionStore.appendEvent({ type: 'tool.approval', timestamp: new Date().toISOString(), sessionId: session.id, turnId, data: { toolName: decision.toolName, decision: decision.decision, reason: decision.reason } }); },
-                    onModelComplete: (summary) => { if (summary.usage !== undefined)
-                        void this.writeEvent('usage.updated', { turnId, sessionId: session.id, usage: summary.usage }); },
-                    onWrite: (change) => { void this.writeEvent('file.changed', { turnId, sessionId: session.id, change }); },
-                });
-                closePrepared = prepared.close;
-                const projector = new CliTurnEventProjector();
-                const input = await prepared.buildInput(request.params.prompt);
-                await prepared.agent.initialize();
-                for await (const event of prepared.run({ input: input.input, model, sessionId: session.id, stream: true, signal: controller.signal })) {
-                    if (event.type === 'context.compacted')
-                        await persistContextCompaction(this.runtime, prepared, session.id, event.metrics, turnId);
-                    for (const projected of projector.observe(event))
-                        await this.emitProjected(projected, session.id, turnId, response);
-                    if (event.type === 'session.failed') {
-                        const limit = classifyAgentLimit(event.error);
-                        if (limit === undefined)
-                            throw event.error;
-                        const notice = agentLimitNotice(limit);
-                        response.push(notice);
-                        const segmentId = `${turnId}:final`;
-                        await this.writeEvent('assistant.delta', { turnId, sessionId: session.id, segmentId, iteration: 0, content: notice });
-                        await this.writeEvent('assistant.segment.completed', { turnId, sessionId: session.id, segmentId, iteration: 0, phase: 'final' });
-                        break;
-                    }
-                }
-            }
-            if (response.join('').trim().length === 0)
-                throw new CliError(CLI_ERROR_CODES.MODEL_PROTOCOL_EMPTY_RESPONSE, 'Agent completed without a final text response.', { category: 'model', userMessage: 'The model completed without a final text response.', retryable: true });
-            await recordTurnCompletion(this.runtime.sessionStore, session.id, turnId, response.join(''));
-            await this.runtime.sessionStore.updateStatus(session.id, 'completed');
-            if (planned !== undefined) {
-                for (let index = 0; index < planned.tasks.length; index += 1) {
-                    await this.writeEvent('plan.step.completed', { ...planStepPayload(planned, turnId, index, 'completed'), sessionId: session.id });
-                    if (index + 1 < planned.tasks.length)
-                        await this.writeEvent('plan.step.started', { ...planStepPayload(planned, turnId, index + 1, 'started'), sessionId: session.id });
-                }
-                await this.writeEvent('plan.completed', { turnId, planId: planned.id, sessionId: session.id });
-            }
-            await this.writeEvent('turn.completed', { turnId, sessionId: session.id, content: response.join('') });
-        }
-        catch (error) {
-            if (planned !== undefined)
-                await this.writeEvent('plan.failed', { turnId, planId: planned.id, sessionId: session.id, error: toDesktopError(error) });
-            const cancelled = controller.signal.aborted;
-            await recordTurnFailure(this.runtime.sessionStore, session.id, turnId, error, cancelled);
-            await this.runtime.sessionStore.updateStatus(session.id, cancelled ? 'cancelled' : 'failed');
-            throw error;
-        }
-        finally {
-            if (timeout !== undefined)
-                clearTimeout(timeout);
-            if (closePrepared !== undefined) {
-                try {
-                    await closePrepared();
-                }
-                catch (error) {
-                    this.runtime.logger.warn('Desktop agent cleanup failed.', { reason: error instanceof Error ? error.message : String(error) });
-                }
-            }
-        }
-    }
-    async executeAttachmentTurn(request, session, identity, model, client, attachments, controller, turnId) {
-        const input = await buildAgentInputContext(request.params.prompt, identity.canonicalPath, true);
-        const system = await buildSafeSystemPrompt(this.runtime, this.cwd, model, 'interactive-untrusted');
-        const service = new ChatService(new SdkChatCompletionAdapter(client));
-        const response = [];
-        for await (const event of service.stream(model, input.input, { system, signal: controller.signal, attachments })) {
-            if (event.type === 'usage')
-                await this.writeEvent('usage.updated', { turnId, sessionId: session.id, usage: event.usage });
-            if (event.type === 'delta') {
-                response.push(event.content);
-                await this.writeEvent('assistant.delta', { turnId, sessionId: session.id, segmentId: `${turnId}:final`, iteration: 0, content: event.content });
-            }
-        }
-        if (response.length > 0)
-            await this.writeEvent('assistant.segment.completed', { turnId, sessionId: session.id, segmentId: `${turnId}:final`, iteration: 0, phase: 'final' });
-        return response.join('');
-    }
-    async emitProjected(event, sessionId, turnId, response) {
-        if (event.type === 'assistant.delta') {
-            response.push(event.content);
-            await this.writeEvent('assistant.delta', { turnId, sessionId, segmentId: event.segmentId, iteration: event.iteration, content: event.content });
-        }
-        else if (event.type === 'assistant.segment.completed')
-            await this.writeEvent('assistant.segment.completed', { turnId, sessionId, segmentId: event.segmentId, iteration: event.iteration, phase: event.phase });
-        else if (event.type === 'action.started')
-            await this.writeEvent('tool.started', { turnId, sessionId, actionId: event.actionId, toolName: event.toolName, displayName: event.displayName, kind: event.kind, ...(event.source === undefined ? {} : { source: event.source }) });
-        else if (event.type === 'action.completed')
-            await this.writeEvent('tool.completed', { turnId, sessionId, actionId: event.actionId, toolName: event.toolName, displayName: event.displayName, kind: event.kind, status: event.status, isError: event.isError });
-        else if (event.type === 'context.compacted')
-            await this.writeEvent('context.compacted', { turnId, sessionId });
-        await persistCliTurnEvent(this.runtime.sessionStore, sessionId, event, { turnId });
-    }
-    async waitForApproval(request, sessionId, turnId, signal, executionBoundary, fallbackReason) {
-        const approvalId = randomUUID();
-        await this.writeEvent('approval.requested', { approvalId, turnId, sessionId, toolName: request.toolName, displayName: actionDisplayName(request.toolName), kind: actionKind(request.toolName, request.toolInfo?.source), detail: describeApproval(request), executionBoundary, ...(fallbackReason === undefined ? {} : { fallbackReason }) });
-        return new Promise((resolve) => {
-            const finish = (approved) => { this.approvals.delete(approvalId); resolve(approved); };
-            if (signal.aborted) {
-                finish(false);
-                return;
-            }
-            signal.addEventListener('abort', () => finish(false), { once: true });
-            this.approvals.set(approvalId, { resolve: finish, signal });
-        });
-    }
-    async waitForTrust(trustRequestId, signal) {
-        return new Promise((resolve) => {
-            const finish = (trusted) => { this.trusts.delete(trustRequestId); resolve(trusted); };
-            if (signal.aborted) {
-                finish(false);
-                return;
-            }
-            signal.addEventListener('abort', () => finish(false), { once: true });
-            this.trusts.set(trustRequestId, { resolve: finish, signal });
-        });
-    }
-    async cancelTurn(request) {
-        const turn = this.turns.get(request.params.turnId);
-        if (turn === undefined)
-            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'Turn is not active.', { category: 'session', userMessage: 'The requested turn is not active.' });
-        turn.controller.abort();
-        await this.respond(request, { cancelled: true, turnId: request.params.turnId });
-    }
-    async respondApproval(request) {
-        const waiter = this.approvals.get(request.params.approvalId);
-        if (waiter === undefined)
-            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'Approval request is no longer active.', { category: 'arguments', userMessage: 'This approval request is no longer active.' });
-        waiter.resolve(request.params.approved);
-        await this.respond(request, { accepted: true });
-    }
-    async respondTrust(request) {
-        const waiter = this.trusts.get(request.params.trustRequestId);
-        if (waiter === undefined)
-            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'Trust request is no longer active.', { category: 'arguments', userMessage: 'This trust request is no longer active.' });
-        waiter.resolve(request.params.trusted);
-        await this.respond(request, { accepted: true });
-    }
-    async listModels(request) {
-        const loaded = await loadExecutionConfig(this.runtime, this.cwd);
-        const profile = loaded.config.profile ?? AuthenticationService.defaultProfileName();
-        const credential = await this.runtime.auth.requireCredential(profile);
-        const models = await new ModelCatalogAdapter(createLotaGateClient(credential.profile, credential.apiKey)).listModels();
-        await this.respond(request, { models: models.data });
-    }
-    async authStatus(request) {
-        const loaded = await this.runtime.configLoader.load(this.cwd, { includeProject: false });
-        const profile = loaded.config.profile ?? AuthenticationService.defaultProfileName();
-        const credential = await this.runtime.credentialStore.get(profile);
-        await this.respond(request, { authenticated: credential !== undefined, profile, ...(credential === undefined ? {} : { baseUrl: credential.profile.baseUrl, credentialRef: credential.profile.credentialRef }) });
-    }
-    async listCommands(request) {
-        await this.respond(request, getDesktopCommandCatalog());
-    }
-    async startCommand(request) {
-        const commandId = randomUUID();
-        const controller = new AbortController();
-        const operation = Promise.resolve()
-            .then(() => this.executeCommand(request, commandId, controller))
-            .catch(async (error) => {
-            if (controller.signal.aborted) {
-                await this.writeEvent('command.cancelled', { commandId, actionId: request.params.actionId });
-                return;
-            }
-            await this.writeEvent('command.failed', { commandId, actionId: request.params.actionId, error: toDesktopError(error) });
-        })
-            .finally(() => this.commands.delete(commandId));
-        this.commands.set(commandId, { controller, operation });
-        const result = { accepted: true, commandId, actionId: request.params.actionId };
-        await this.respond(request, result);
-    }
-    async executeCommand(request, commandId, controller) {
-        await this.writeEvent('command.started', { commandId, actionId: request.params.actionId });
-        const exitCode = await executeDesktopCommand({
-            runtime: this.runtime,
-            cwd: this.cwd,
-            invocation: request.params,
-            signal: controller.signal,
-            output: {
-                write: (content, structured) => this.writeEvent('command.output', {
-                    commandId,
-                    actionId: request.params.actionId,
-                    content,
-                    ...(structured === undefined ? {} : { structured }),
-                }),
-            },
-            activity: {
-                started: (key, label) => this.writeEvent('command.activity.started', { commandId, actionId: request.params.actionId, key, label }),
-                completed: (key, isError) => this.writeEvent('command.activity.completed', { commandId, actionId: request.params.actionId, key, isError }),
-            },
-        });
-        await this.writeEvent('command.completed', { commandId, actionId: request.params.actionId, exitCode, success: exitCode === 0 });
-    }
-    async cancelCommand(request) {
-        const command = this.commands.get(request.params.commandId);
-        if (command === undefined) {
-            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'Command is not active.', { category: 'command', userMessage: 'The requested command is not active.' });
-        }
-        command.controller.abort();
-        await this.respond(request, { accepted: true, commandId: request.params.commandId });
-    }
-    async requestBrowserHost(request, signal) {
-        if (this.stopping)
-            throw new Error('The Desktop browser bridge is stopping.');
-        const operation = new Promise((resolve, reject) => {
-            const waiter = { resolve, reject, ...(signal === undefined ? {} : { signal }) };
-            if (signal !== undefined) {
-                if (signal.aborted) {
-                    reject(new Error('Browser action was cancelled.'));
-                    return;
-                }
-                waiter.onAbort = () => { this.browserRequests.delete(request.requestId); reject(new Error('Browser action was cancelled.')); };
-                signal.addEventListener('abort', waiter.onAbort, { once: true });
-            }
-            this.browserRequests.set(request.requestId, waiter);
-        });
-        try {
-            await this.writer.write(request);
-            return await operation;
-        }
-        finally {
-            const waiter = this.browserRequests.get(request.requestId);
-            if (waiter !== undefined) {
-                if (waiter.onAbort !== undefined)
-                    waiter.signal?.removeEventListener('abort', waiter.onAbort);
-                this.browserRequests.delete(request.requestId);
-            }
-        }
-    }
-    async requestDesktopHost(request, signal) {
-        if (this.stopping)
-            throw new Error('The Desktop execution bridge is stopping.');
-        const operation = new Promise((resolve, reject) => {
-            const waiter = { resolve, reject, ...(signal === undefined ? {} : { signal }) };
-            if (signal !== undefined) {
-                if (signal.aborted) {
-                    reject(new Error('Host execution was cancelled.'));
-                    return;
-                }
-                waiter.onAbort = () => { this.hostRequests.delete(request.requestId); reject(new Error('Host execution was cancelled.')); };
-                signal.addEventListener('abort', waiter.onAbort, { once: true });
-            }
-            this.hostRequests.set(request.requestId, waiter);
-        });
-        try {
-            await this.writer.write(request);
-            return await operation;
-        }
-        finally {
-            const waiter = this.hostRequests.get(request.requestId);
-            if (waiter !== undefined) {
-                if (waiter.onAbort !== undefined)
-                    waiter.signal?.removeEventListener('abort', waiter.onAbort);
-                this.hostRequests.delete(request.requestId);
-            }
-        }
-    }
-    resolveBrowserRequest(response) {
-        const waiter = this.browserRequests.get(response.requestId);
-        if (waiter === undefined)
-            return;
-        if (waiter.onAbort !== undefined)
-            waiter.signal?.removeEventListener('abort', waiter.onAbort);
-        this.browserRequests.delete(response.requestId);
-        waiter.resolve(response);
-    }
-    resolveDesktopHostRequest(response) {
-        const waiter = this.hostRequests.get(response.requestId);
-        if (waiter === undefined)
-            return;
-        if (waiter.onAbort !== undefined)
-            waiter.signal?.removeEventListener('abort', waiter.onAbort);
-        this.hostRequests.delete(response.requestId);
-        waiter.resolve(response);
-    }
-    async respond(request, result) { await this.writer.write({ version: DESKTOP_PROTOCOL_VERSION, id: request.id, type: 'response', method: request.method, ok: true, result }); }
-    async writeError(id, method, error) { await this.writer.write({ version: DESKTOP_PROTOCOL_VERSION, id, type: 'response', method, ok: false, error }); }
-    async writeEvent(event, data) { await this.writer.write({ version: DESKTOP_PROTOCOL_VERSION, type: 'event', event, data }); }
-}
-function parseDesktopRequest(value) {
-    if (!isRecord(value) || value['version'] !== DESKTOP_PROTOCOL_VERSION || !validId(value['id']) || !isRecord(value['params']) || typeof value['method'] !== 'string')
-        throw protocolError('Invalid Desktop protocol request.');
-    const id = value['id'];
-    const method = value['method'];
-    const params = value['params'];
-    if (method === 'initialize' || method === 'session.list' || method === 'model.list' || method === 'auth.status' || method === 'command.list' || method === 'shutdown')
-        return { version: 2, id, method, params };
-    if (method === 'session.create')
-        return { version: 2, id, method, params: { ...(optionalString(params, 'model')), ...(optionalString(params, 'name')) } };
-    if (method === 'session.resume')
-        return { version: 2, id, method, params: { sessionId: requiredId(params, 'sessionId') } };
-    if (method === 'attachment.begin')
-        return { version: 2, id, method, params: { attachmentId: requiredId(params, 'attachmentId'), name: requiredAttachmentName(params), mimeType: requiredMimeType(params), sizeBytes: requiredAttachmentSize(params) } };
-    if (method === 'attachment.chunk')
-        return { version: 2, id, method, params: { attachmentId: requiredId(params, 'attachmentId'), index: requiredChunkIndex(params), dataBase64: requiredChunkData(params) } };
-    if (method === 'attachment.complete')
-        return { version: 2, id, method, params: { attachmentId: requiredId(params, 'attachmentId') } };
-    if (method === 'turn.start')
-        return { version: 2, id, method, params: { sessionId: requiredId(params, 'sessionId'), prompt: requiredPrompt(params), ...(optionalString(params, 'model')), ...(optionalAttachmentIds(params)), ...(optionalSkills(params)), execution: requiredExecutionPolicy(params) } };
-    if (method === 'turn.cancel')
-        return { version: 2, id, method, params: { turnId: requiredId(params, 'turnId') } };
-    if (method === 'approval.respond')
-        return { version: 2, id, method, params: { approvalId: requiredId(params, 'approvalId'), approved: requiredBoolean(params, 'approved') } };
-    if (method === 'trust.respond')
-        return { version: 2, id, method, params: { trustRequestId: requiredId(params, 'trustRequestId'), trusted: requiredBoolean(params, 'trusted') } };
-    if (method === 'command.execute')
-        return { version: 2, id, method, params: parseCommandInvocation(params) };
-    if (method === 'command.cancel')
-        return { version: 2, id, method, params: { commandId: requiredId(params, 'commandId') } };
-    throw protocolError('Unsupported Desktop protocol method.');
-}
-function isBrowserHostResponse(value) {
-    if (!isRecord(value) || value['version'] !== DESKTOP_PROTOCOL_VERSION || value['type'] !== 'host.response' || value['tool'] !== 'browser' || !validId(value['requestId']) || typeof value['ok'] !== 'boolean')
-        return false;
-    if (value['error'] !== undefined && !isRecord(value['error']))
-        return false;
-    return true;
-}
-function isDesktopHostResponse(value) {
-    if (!isRecord(value) || value['version'] !== DESKTOP_PROTOCOL_VERSION || value['type'] !== 'host.response' || !['filesystem', 'shell', 'git', 'artifact'].includes(String(value['tool'])) || !validId(value['requestId']) || typeof value['ok'] !== 'boolean')
-        return false;
-    if (value['error'] !== undefined && !isRecord(value['error']))
-        return false;
-    return true;
-}
-function parseCommandInvocation(params) {
-    const actionId = requiredId(params, 'actionId');
-    const positionals = params['positionals'];
-    if (!Array.isArray(positionals) || positionals.some(value => typeof value !== 'string' || Buffer.byteLength(value, 'utf8') > RESOURCE_LIMITS.jsonlPromptBytes)) {
-        throw protocolError('Invalid command positionals.');
-    }
-    const options = params['options'];
-    if (!isRecord(options) || Object.entries(options).some(([key, value]) => !validId(key) || (typeof value !== 'string' && typeof value !== 'boolean') || (typeof value === 'string' && Buffer.byteLength(value, 'utf8') > RESOURCE_LIMITS.jsonlPromptBytes))) {
-        throw protocolError('Invalid command options.');
-    }
-    return { actionId, positionals, options: options };
-}
-function requiredId(params, key) { const value = params[key]; if (!validId(value))
-    throw protocolError(`Invalid ${key}.`); return value; }
-function requiredPrompt(params) { const value = params['prompt']; if (typeof value !== 'string' || value.trim().length === 0 || Buffer.byteLength(value, 'utf8') > RESOURCE_LIMITS.jsonlPromptBytes)
-    throw protocolError('Invalid prompt.'); return value; }
-function requiredBoolean(params, key) { if (typeof params[key] !== 'boolean')
-    throw protocolError(`Invalid ${key}.`); return params[key]; }
-function optionalString(params, key) { const value = params[key]; if (value === undefined)
-    return {}; if (typeof value !== 'string' || value.length === 0 || Buffer.byteLength(value, 'utf8') > RESOURCE_LIMITS.jsonlIdBytes)
-    throw protocolError(`Invalid ${key}.`); return { [key]: value }; }
-function requiredAttachmentName(params) { const value = params['name']; if (typeof value !== 'string' || value.length === 0 || value.length > 200 || value.includes('\0'))
-    throw protocolError('Invalid attachment name.'); return value; }
-function requiredMimeType(params) { const value = params['mimeType']; if (typeof value !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*\/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*$/u.test(value) || Buffer.byteLength(value, 'utf8') > RESOURCE_LIMITS.jsonlIdBytes)
-    throw protocolError('Invalid attachment MIME type.'); return value; }
-function requiredAttachmentSize(params) { const value = params['sizeBytes']; if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0 || value > RESOURCE_LIMITS.maxAttachmentBytes)
-    throw protocolError('Invalid attachment size.'); return value; }
-function requiredChunkIndex(params) { const value = params['index']; if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
-    throw protocolError('Invalid attachment chunk index.'); return value; }
-function requiredChunkData(params) { const value = params['dataBase64']; if (typeof value !== 'string' || value.length === 0 || Buffer.byteLength(value, 'utf8') > Math.ceil(RESOURCE_LIMITS.desktopAttachmentChunkBytes / 3) * 4 + 4)
-    throw protocolError('Invalid attachment chunk.'); return value; }
-function optionalAttachmentIds(params) {
-    const value = params['attachmentIds'];
-    if (value === undefined)
-        return {};
-    if (!Array.isArray(value) || value.length > RESOURCE_LIMITS.pendingAttachments || value.some(id => !validId(id)) || new Set(value).size !== value.length)
-        throw protocolError('Invalid attachment ids.');
-    return { attachmentIds: value };
-}
-function optionalSkills(params) {
-    const value = params['skills'];
-    if (value === undefined)
-        return {};
-    if (!Array.isArray(value) || value.length > 32 || value.some(skill => !validId(skill)) || new Set(value).size !== value.length)
-        throw protocolError('Invalid skills.');
-    return { skills: value };
-}
-function requiredExecutionPolicy(params) { return parseDesktopExecutionPolicy(params['execution']); }
-function validId(value) { return typeof value === 'string' && value.length > 0 && Buffer.byteLength(value, 'utf8') <= RESOURCE_LIMITS.jsonlIdBytes; }
-function isRecord(value) { return typeof value === 'object' && value !== null && !Array.isArray(value); }
-function protocolError(message) { return new Error(message); }
-function desktopApprovalMode(policy) {
-    if (policy === 'allowlist')
-        return 'auto';
-    if (policy === 'review')
-        return 'review';
-    if (policy === 'autonomous')
-        return 'autonomous';
-    return 'ask';
-}
-function toDesktopError(error) {
-    if (typeof error === 'object' && error !== null) {
-        const value = error;
-        if (typeof value['code'] === 'string' && typeof value['category'] === 'string' && typeof value['userMessage'] === 'string' && typeof value['retryable'] === 'boolean')
-            return { code: value['code'], category: value['category'], message: value['userMessage'], retryable: value['retryable'] };
-    }
-    const cliError = asCliError(error);
-    return { code: cliError.code, category: cliError.category, message: cliError.userMessage, retryable: cliError.retryable };
-}
-function sessionResult(session) { return { session }; }
-function describeApproval(request) {
-    if (request.toolName === 'filesystem.write')
-        return { summary: `Write workspace file: ${safeText(request.input['path'])}`, path: safeText(request.input['path']) };
-    if (request.toolName === 'shell.exec') {
-        const command = typeof request.input['command'] === 'string' ? request.input['command'] : '';
-        const args = Array.isArray(request.input['args']) ? request.input['args'].filter((value) => typeof value === 'string') : [];
-        return { summary: `Run command: ${formatShellCommandForDisplay(command, args, 240)}`, command, args };
-    }
-    return { summary: `This ${formatToolActivityName(request.toolName)} operation may change workspace or external state.` };
-}
-function safeText(value) { return String(value ?? '').replace(/Bearer\s+[^\s]+/giu, 'Bearer [REDACTED]').replace(/sk-[A-Za-z0-9_-]{8,}/gu, '[REDACTED]').slice(0, 240); }