@lotagate/cli 0.1.24 → 0.1.26

package/dist/application/protocol/desktop-approval-broker.d.ts

@@ -0,0 +1,26 @@
+import type { ToolApprovalRequest } from '@lotagate/agent-sdk';
+import type { DesktopExecutionPolicy } from './desktop-execution-policy.js';
+export type DesktopApprovalDecision = {
+    decision: 'allow';
+} | {
+    decision: 'deny';
+} | {
+    decision: 'redirect';
+    message: string;
+};
+/** Owns Desktop approval/trust waiters and their AbortSignal lifecycle. */
+export declare class DesktopApprovalBroker {
+    private readonly writeEvent;
+    private readonly approvals;
+    private readonly trusts;
+    constructor(writeEvent: (event: string, data: Record<string, unknown>) => Promise<void>);
+    waitForApproval(request: ToolApprovalRequest, sessionId: string, turnId: string, signal: AbortSignal, executionBoundary: DesktopExecutionPolicy['isolation'], fallbackReason?: string): Promise<DesktopApprovalDecision>;
+    waitForTrust(trustRequestId: string, signal: AbortSignal): Promise<boolean>;
+    respondApproval(approvalId: string, decision: DesktopApprovalDecision | boolean): boolean;
+    respondTrust(trustRequestId: string, trusted: boolean): boolean;
+    close(): void;
+    private waitApproval;
+    private waitTrust;
+    private respondApprovalDecision;
+    private respondTrustDecision;
+}

package/dist/application/protocol/desktop-approval-broker.js

@@ -0,0 +1 @@
+import{randomUUID as l}from"node:crypto";import{actionDisplayName as d,actionKind as v}from"../orchestration/cli-turn-events.js";import{describeApproval as u}from"./desktop-protocol-helpers.js";class m{writeEvent;approvals=new Map;trusts=new Map;constructor(e){this.writeEvent=e}async waitForApproval(e,t,r,o,s,n){const i=l(),a=this.waitApproval(i,o);try{await this.writeEvent("approval.requested",{approvalId:i,turnId:r,sessionId:t,toolName:e.toolName,displayName:d(e.toolName),kind:v(e.toolName,e.toolInfo?.source),detail:u(e),executionBoundary:s,...n===void 0?{}:{fallbackReason:n}})}catch(p){throw this.respondApproval(i,{decision:"deny"}),p}return a}waitForTrust(e,t){return this.waitTrust(e,t)}respondApproval(e,t){return this.respondApprovalDecision(e,t)}respondTrust(e,t){return this.respondTrustDecision(e,t)}close(){for(const e of this.approvals.values())e.resolve({decision:"deny"});for(const e of this.trusts.values())e.resolve(!1);this.approvals.clear(),this.trusts.clear()}waitApproval(e,t){return new Promise(r=>{const o=()=>s({decision:"deny"}),s=n=>{this.approvals.delete(e),t.removeEventListener("abort",o),r(n)};if(t.aborted){s({decision:"deny"});return}t.addEventListener("abort",o,{once:!0}),this.approvals.set(e,{resolve:s,signal:t,onAbort:o})})}waitTrust(e,t){return new Promise(r=>{const o=()=>s(!1),s=n=>{this.trusts.delete(e),t.removeEventListener("abort",o),r(n)};if(t.aborted){s(!1);return}t.addEventListener("abort",o,{once:!0}),this.trusts.set(e,{resolve:s,signal:t,onAbort:o})})}respondApprovalDecision(e,t){const r=this.approvals.get(e);return r===void 0?!1:(r.resolve(typeof t=="boolean"?{decision:t?"allow":"deny"}:t),!0)}respondTrustDecision(e,t){const r=this.trusts.get(e);return r===void 0?!1:(r.resolve(t),!0)}}export{m as DesktopApprovalBroker};

package/dist/application/protocol/desktop-attachment-store.d.ts

@@ -0,0 +1,33 @@
+import type { AttachmentPayload } from '../../domain/session/attachment.js';
+export interface DesktopAttachmentStoreOptions {
+    readonly ttlMs?: number;
+}
+export declare class DesktopAttachmentStore {
+    private readonly pending;
+    private readonly completed;
+    private readonly ttlMs;
+    constructor(options?: DesktopAttachmentStoreOptions);
+    begin(input: {
+        id: string;
+        sessionId?: string;
+        name: string;
+        mimeType: string;
+        sizeBytes: number;
+        storageName?: string;
+    }): void;
+    appendChunk(id: string, index: number, encoded: string): void;
+    complete(id: string): AttachmentUpload;
+    take(ids: readonly string[], sessionId?: string): AttachmentPayload[];
+    replace(id: string, upload: AttachmentUpload): void;
+    delete(id: string, sessionId?: string): void;
+    clear(): void;
+    private totalReservedBytes;
+    private schedulePendingExpiry;
+    private createRetainedAttachment;
+    private removePending;
+    private removeCompleted;
+    private clearExpiryTimer;
+}
+export interface AttachmentUpload extends AttachmentPayload {
+    sessionId: string;
+}

package/dist/application/protocol/desktop-attachment-store.js

@@ -0,0 +1 @@
+import{CLI_ERROR_CODES as i}from"../../domain/errors/error-codes.js";import{CliError as d}from"../../domain/errors/cli-error.js";import{createImageAttachment as c,normalizeImage as l}from"../../infrastructure/clipboard/image-normalizer.js";import{RESOURCE_LIMITS as h}from"../../domain/runtime/resource-limits.js";class E{pending=new Map;completed=new Map;ttlMs;constructor(e={}){if(this.ttlMs=e.ttlMs??h.desktopAttachmentTtlMs,!Number.isSafeInteger(this.ttlMs)||this.ttlMs<=0)throw new RangeError("Desktop attachment TTL must be a positive safe integer.")}begin(e){if(!T(e.id)||!A(e.name)||!g(e.mimeType))throw o(i.ATTACHMENT_INVALID_IMAGE,"Invalid desktop attachment metadata.","The attachment metadata is invalid.");if(!Number.isSafeInteger(e.sizeBytes)||e.sizeBytes<=0||e.sizeBytes>h.maxAttachmentBytes)throw o(i.ATTACHMENT_TOO_LARGE,"Desktop attachment size is outside the allowed range.","The attachment exceeds the maximum allowed size.",!0);if(this.pending.has(e.id)||this.completed.has(e.id))throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment id is already in use.","This attachment has already been uploaded.");if(this.totalReservedBytes()+e.sizeBytes>h.pendingAttachmentTotalBytes||this.pending.size+this.completed.size>=h.pendingAttachments)throw o(i.ATTACHMENT_TOO_LARGE,"Desktop attachment limits exceeded.","Too many or too-large attachments are pending.",!0);const t={id:e.id,sessionId:e.sessionId??"",name:e.name,mimeType:e.mimeType,sizeBytes:e.sizeBytes,...e.storageName===void 0?{}:{storageName:e.storageName},nextIndex:0,receivedBytes:0,chunks:[]};this.pending.set(e.id,t),this.schedulePendingExpiry(t)}appendChunk(e,t,r){const s=this.pending.get(e);if(s===void 0)throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment upload was not started.","The attachment upload is not active.");if(!Number.isSafeInteger(t)||t!==s.nextIndex)throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment chunk order is invalid.","The attachment upload is out of order.");const n=p(r);if(n.byteLength===0||n.byteLength>h.desktopAttachmentChunkBytes||s.receivedBytes+n.byteLength>s.sizeBytes)throw o(i.ATTACHMENT_TOO_LARGE,"Desktop attachment chunk exceeds its declared size.","The attachment upload is invalid or too large.",!0);s.chunks.push(n),s.receivedBytes+=n.byteLength,s.nextIndex+=1,this.schedulePendingExpiry(s)}complete(e){const t=this.pending.get(e);if(t===void 0)throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment upload was not started.","The attachment upload is not active.");if(t.receivedBytes!==t.sizeBytes)throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment upload is incomplete.","The attachment upload did not finish.");const r=Buffer.concat(t.chunks),s=t.mimeType.startsWith("image/")?(()=>{const n=l(r,t.mimeType),m=c(n,"file",t.id);return{sessionId:t.sessionId,attachment:{...m,name:t.name,...t.storageName===void 0?{}:{storageName:t.storageName}},bytes:n.bytes}})():{sessionId:t.sessionId,attachment:{id:t.id,name:t.name,mimeType:t.mimeType,sizeBytes:r.byteLength,source:"file",...t.storageName===void 0?{}:{storageName:t.storageName}},bytes:r};return this.removePending(e),this.completed.set(e,this.createRetainedAttachment(s)),s}take(e,t){if(new Set(e).size!==e.length)throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment ids must be unique.","An attachment was referenced more than once.");const r=e.map(s=>{const n=this.completed.get(s);if(n===void 0)throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment is not complete.","Complete the attachment upload before sending the prompt.");if(t!==void 0&&n.upload.sessionId.length>0&&n.upload.sessionId!==t)throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment belongs to another session.","The attachment is not available in this session.");return{attachment:n.upload.attachment,bytes:n.upload.bytes}});return e.forEach(s=>this.removeCompleted(s)),r}replace(e,t){if(!this.completed.has(e))throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment upload was not retained.","The attachment upload is not available.");this.removeCompleted(e),this.completed.set(e,this.createRetainedAttachment(t))}delete(e,t){const r=this.pending.get(e),s=this.completed.get(e),n=r?.sessionId??s?.upload.sessionId;if(t!==void 0&&n!==void 0&&n.length>0&&n!==t)throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment belongs to another session.","The attachment is not available in this session.");this.removePending(e),this.removeCompleted(e)}clear(){for(const e of this.pending.values())this.clearExpiryTimer(e.expiryTimer);for(const e of this.completed.values())this.clearExpiryTimer(e.expiryTimer);this.pending.clear(),this.completed.clear()}totalReservedBytes(){let e=0;for(const t of this.pending.values())e+=t.sizeBytes;for(const t of this.completed.values())e+=t.upload.bytes.byteLength;return e}schedulePendingExpiry(e){this.clearExpiryTimer(e.expiryTimer);const t=setTimeout(()=>{this.pending.get(e.id)===e&&this.pending.delete(e.id)},this.ttlMs);t.unref?.(),e.expiryTimer=t}createRetainedAttachment(e){const t={upload:e},r=setTimeout(()=>{this.completed.get(e.attachment.id)===t&&this.completed.delete(e.attachment.id)},this.ttlMs);return r.unref?.(),t.expiryTimer=r,t}removePending(e){const t=this.pending.get(e);t!==void 0&&(this.clearExpiryTimer(t.expiryTimer),this.pending.delete(e))}removeCompleted(e){const t=this.completed.get(e);t!==void 0&&(this.clearExpiryTimer(t.expiryTimer),this.completed.delete(e))}clearExpiryTimer(e){e!==void 0&&clearTimeout(e)}}function p(a){if(!/^[A-Za-z0-9+/]*={0,2}$/u.test(a)||a.length===0||a.length%4!==0)throw o(i.ATTACHMENT_INVALID_IMAGE,"Desktop attachment chunk is not valid Base64.","The attachment upload is invalid.");return Buffer.from(a,"base64")}function T(a){return/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(a)}function A(a){return a.length>0&&a.length<=200&&!a.includes("\0")}function g(a){return a.length<=h.jsonlIdBytes&&/^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*\/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*$/u.test(a)}function o(a,e,t,r=!1){return new d(a,e,{category:"attachment",userMessage:t,retryable:r})}export{E as DesktopAttachmentStore};

package/dist/application/protocol/desktop-command-catalog.d.ts

@@ -0,0 +1,2 @@
+import type { DesktopCommandListResult } from './desktop-command-contract.js';
+export declare function getDesktopCommandCatalog(): DesktopCommandListResult;

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

@@ -0,0 +1 @@
+import{COMMAND_REGISTRY as r}from"../commands/command-runtime.js";import{isDesktopCommandExposed as t}from"./desktop-command-contract.js";function n(){return{commands:r.list("direct").filter(t).map(e)}}function e(m){return{id:m.id,path:m.path,summary:m.summary,...m.arguments===void 0?{}:{arguments:m.arguments},...m.options===void 0?{}:{options:m.options}}}export{n as getDesktopCommandCatalog};

package/dist/application/protocol/desktop-command-contract.d.ts

@@ -0,0 +1,26 @@
+import type { CommandActionSpec, CommandArgumentSpec, CommandOptionSpec } from '../commands/command-contract.js';
+export interface DesktopCommandDescriptor {
+    readonly id: string;
+    readonly path: readonly string[];
+    readonly summary: string;
+    readonly arguments?: readonly CommandArgumentSpec[];
+    readonly options?: readonly CommandOptionSpec[];
+}
+export interface DesktopCommandListResult {
+    readonly commands: readonly DesktopCommandDescriptor[];
+}
+export interface DesktopCommandInvocation {
+    readonly actionId: string;
+    readonly positionals: readonly string[];
+    readonly options: Readonly<Record<string, string | boolean>>;
+    /** Secrets are transported out-of-band from regular command options. */
+    readonly secrets?: Readonly<{
+        apiKey?: string;
+    }>;
+}
+export interface DesktopCommandExecutionResult {
+    readonly accepted: true;
+    readonly commandId: string;
+    readonly actionId: string;
+}
+export declare function isDesktopCommandExposed(action: CommandActionSpec): boolean;

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

@@ -0,0 +1 @@
+function s(e){return e.surfaces.includes("direct")&&e.desktop?.exposed!==!1}export{s as isDesktopCommandExposed};

package/dist/application/protocol/desktop-command-executor.d.ts

@@ -0,0 +1,17 @@
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+import type { DesktopCommandInvocation } from './desktop-command-contract.js';
+import { type DesktopCommandOutputSink } from './desktop-command-output.js';
+export interface DesktopCommandExecutorOptions {
+    readonly runtime: CliRuntime;
+    readonly cwd: string;
+    readonly invocation: DesktopCommandInvocation;
+    readonly signal: AbortSignal;
+    readonly output: DesktopCommandOutputSink;
+    readonly activity?: DesktopCommandActivitySink;
+    readonly onActivityError?: (error: unknown) => void;
+}
+export interface DesktopCommandActivitySink {
+    started(key: string, label: string): Promise<void>;
+    completed(key: string, isError: boolean): Promise<void>;
+}
+export declare function executeDesktopCommand(options: DesktopCommandExecutorOptions): Promise<number>;

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

@@ -0,0 +1 @@
+import{executeApplicationCommand as r}from"../commands/application-command-executor.js";import{COMMAND_REGISTRY as a}from"../commands/command-runtime.js";import{parseCommandInvocationForAction as m}from"../commands/command-parser.js";import{CliError as s}from"../../domain/errors/cli-error.js";import{CLI_ERROR_CODES as d}from"../../domain/errors/error-codes.js";import{isDesktopCommandExposed as p}from"./desktop-command-contract.js";import{DesktopCommandOutput as u}from"./desktop-command-output.js";async function b(t){const i=l(t.invocation),o=new u(t.output),e={runtime:t.runtime,cwd:t.cwd,output:o,...t.invocation.secrets===void 0?{}:{secrets:t.invocation.secrets},writableOutput:o.writable,signal:t.signal,...t.activity===void 0?{}:{activity:f(t.activity,t.onActivityError)}};try{const n=await r(i,e);return await o.flush(),n}finally{await o.flush(),o.writable.destroy()}}function l(t){const i=a.get(t.actionId);if(i===void 0||!p(i))throw new s(d.INVALID_ARGUMENT,`Command action '${t.actionId}' is not available through the Desktop protocol.`,{category:"command",userMessage:`The command '${t.actionId}' is not available in the Desktop application.`});const o=new Map(Object.entries(t.options));return m(t.actionId,t.positionals,o,"direct",a)}function f(t,i){return{start(o,e){return c(t.started(o,e),i),{complete:n=>c(t.completed(o,n),i)}}}}function c(t,i){Promise.resolve(t).catch(o=>i?.(o))}export{b as executeDesktopCommand};

package/dist/application/protocol/desktop-command-output.d.ts

@@ -0,0 +1,15 @@
+import { Writable } from 'node:stream';
+import type { CommandOutput } from '../commands/command-output.js';
+export interface DesktopCommandOutputSink {
+    write(content: string, structured?: object): Promise<void>;
+}
+/** Adapts existing command output to ordered JSONL command.output events. */
+export declare class DesktopCommandOutput implements CommandOutput {
+    private readonly _sink;
+    private _pending;
+    readonly writable: Writable;
+    constructor(_sink: DesktopCommandOutputSink);
+    write(value: string): void;
+    writeStructured<T extends object>(value: T, fallbackText?: string): void;
+    flush(): Promise<void>;
+}

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

@@ -0,0 +1 @@
+import{Writable as e}from"node:stream";class h{_sink;_pending=Promise.resolve();writable=new e({write:(i,t,n)=>{this.write(String(i)),n()}});constructor(i){this._sink=i}write(i){this._pending=this._pending.then(()=>this._sink.write(i))}writeStructured(i,t){this._pending=this._pending.then(()=>this._sink.write(t??"",i))}async flush(){await this._pending}}export{h as DesktopCommandOutput};

package/dist/application/protocol/desktop-execution-policy.d.ts

@@ -0,0 +1,19 @@
+export type DesktopPermissionPolicy = 'ask' | 'allowlist' | 'review' | 'autonomous';
+export type DesktopBrowserAccess = 'disabled' | 'read-only' | 'interactive' | 'autonomous';
+export type DesktopBrowserExecution = 'isolated' | 'interactive';
+export interface DesktopExecutionPolicy {
+    readonly permissionPolicy: DesktopPermissionPolicy;
+    readonly allowedTools?: readonly string[];
+    readonly browserAccess: DesktopBrowserAccess;
+    readonly browserExecution: DesktopBrowserExecution;
+    readonly isolation: 'sandbox' | 'host';
+    readonly hostFallback: 'ask' | 'deny' | 'allow';
+    readonly timeoutMs: number;
+    readonly retryAttempt?: number;
+}
+/**
+ * Parses the required Desktop-only execution context at the CLI boundary.
+ * Standalone CLI commands use a separate protocol and never provide this
+ * object. Unknown fields are ignored so the new contract can grow additively.
+ */
+export declare function parseDesktopExecutionPolicy(value: unknown): DesktopExecutionPolicy;

package/dist/application/protocol/desktop-execution-policy.js

@@ -0,0 +1 @@
+import{RESOURCE_LIMITS as f}from"../../domain/runtime/resource-limits.js";function m(o){if(!a(o))throw new Error("Invalid Desktop execution policy.");const r=e(o.permissionPolicy,["ask","allowlist","review","autonomous"],"permissionPolicy"),t=e(o.browserAccess,["disabled","read-only","interactive","autonomous"],"browserAccess"),n=e(o.browserExecution,["isolated","interactive"],"browserExecution"),d=e(o.isolation,["sandbox","host"],"isolation"),l=e(o.hostFallback,["ask","deny","allow"],"hostFallback"),s=o.allowedTools===void 0?void 0:p(o.allowedTools),w=c(o.timeoutMs,1e4,7200*1e3,"timeoutMs"),i=o.retryAttempt===void 0?void 0:c(o.retryAttempt,0,3,"retryAttempt");return{permissionPolicy:r,...s===void 0?{}:{allowedTools:s},browserAccess:t,browserExecution:n,isolation:d,hostFallback:l,timeoutMs:w,...i===void 0?{}:{retryAttempt:i}}}function p(o){if(!Array.isArray(o)||o.length>128)throw new Error("Invalid Desktop allowedTools.");const r=o.map(t=>{if(typeof t!="string"||t.trim().length===0||Buffer.byteLength(t,"utf8")>f.jsonlIdBytes)throw new Error("Invalid Desktop allowedTools entry.");return t.trim()});if(new Set(r).size!==r.length)throw new Error("Desktop allowedTools must not contain duplicates.");return r}function e(o,r,t){if(typeof o!="string"||!r.includes(o))throw new Error(`Invalid Desktop ${t}.`);return o}function c(o,r,t,n){if(typeof o!="number"||!Number.isSafeInteger(o)||o<r||o>t)throw new Error(`Invalid Desktop ${n}.`);return o}function a(o){return typeof o=="object"&&o!==null&&!Array.isArray(o)}export{m as parseDesktopExecutionPolicy};

package/dist/application/protocol/desktop-extension-request-handler.d.ts

@@ -0,0 +1,14 @@
+import type { DesktopExtensionService } from './desktop-extension-service.js';
+import type { DesktopRequest } from './desktop-agent-request-parser.js';
+type ExtensionRequest = Extract<DesktopRequest, {
+    method: 'extension.listPublicPlugins' | 'extension.resolvePublicPluginSource' | 'extension.readPublicPluginContribution' | 'extension.readDetail' | 'extension.readPluginIcon';
+}>;
+/** Keeps CLI-owned extension request dispatch separate from the agent turn lifecycle. */
+export declare class DesktopExtensionRequestHandler {
+    private readonly service;
+    private readonly respond;
+    private readonly cwd;
+    constructor(service: DesktopExtensionService, respond: (request: DesktopRequest, result: unknown) => Promise<void>, cwd: string);
+    handle(request: ExtensionRequest): Promise<void>;
+}
+export {};

package/dist/application/protocol/desktop-extension-request-handler.js

@@ -0,0 +1 @@
+class e{service;respond;cwd;constructor(i,a,s){this.service=i,this.respond=a,this.cwd=s}async handle(i){switch(i.method){case"extension.listPublicPlugins":return this.respond(i,await this.service.listPublicPlugins(i.params.root));case"extension.resolvePublicPluginSource":return this.respond(i,{path:await this.service.resolvePublicPluginSource(i.params.root,i.params.name)});case"extension.readPublicPluginContribution":return this.respond(i,await this.service.readPublicPluginContribution(i.params.root,i.params.pluginName,i.params.kind,i.params.sourceName));case"extension.readDetail":return this.respond(i,await this.service.readDetail(this.cwd,i.params));case"extension.readPluginIcon":return this.respond(i,await this.service.readPluginIcon(this.cwd,i.params.name,i.params.scope))}}}export{e as DesktopExtensionRequestHandler};

package/dist/application/protocol/desktop-extension-service.d.ts

@@ -0,0 +1,44 @@
+type Detail = {
+    content: string;
+    format: 'json' | 'markdown' | 'text';
+    editable: boolean;
+    fileName?: string;
+};
+type PublicContribution = {
+    kind: 'skill' | 'mcp' | 'hook' | 'agent';
+    sourceName: string;
+    description: string;
+};
+type PublicPlugin = {
+    directory: string;
+    name: string;
+    displayName?: string;
+    version: string;
+    description: string;
+    author?: string;
+    license?: string;
+    homepage?: string;
+    privacyPolicy?: string;
+    termsOfService?: string;
+    icon?: string;
+    contributions: readonly PublicContribution[];
+};
+/** CLI-owned extension reads exposed only through the Desktop JSONL protocol. */
+export declare class DesktopExtensionService {
+    listPublicPlugins(root: string): Promise<readonly PublicPlugin[]>;
+    resolvePublicPluginSource(root: string, name: string): Promise<string>;
+    readPublicPluginContribution(root: string, pluginName: string, kind: 'skill' | 'mcp' | 'hook', sourceName: string): Promise<Detail>;
+    readDetail(cwd: string, input: {
+        kind: 'hook' | 'skill' | 'plugin' | 'mcp';
+        name: string;
+        scope?: 'user' | 'project' | 'plugin' | 'builtin';
+        pluginName?: string;
+        pluginScope?: 'user' | 'project';
+        sourceName?: string;
+    }): Promise<Detail>;
+    readPluginIcon(cwd: string, name: string, scope: 'user' | 'project'): Promise<{
+        mimeType: 'image/svg+xml';
+        data: string;
+    } | undefined>;
+}
+export {};

package/dist/application/protocol/desktop-extension-service.js

@@ -0,0 +1,3 @@
+import{fileURLToPath as I}from"node:url";import d from"node:fs/promises";import n from"node:path";import{PLUGIN_LAYOUT as c}from"../../domain/extensions/plugin-manifest.js";import{PluginDiscovery as j}from"../../infrastructure/extensions/plugin-discovery.js";import{PluginAgentDiscovery as F}from"../../infrastructure/extensions/plugin-agent-discovery.js";import{SkillDiscovery as T}from"../../infrastructure/extensions/skill-discovery.js";import{discoverHooks as A}from"../../infrastructure/extensions/hook-runtime.js";import{loadPluginMcpConfig as R}from"../extensions/plugin-contribution-registry.js";import{readFileBounded as v}from"../../infrastructure/filesystem/bounded-file-reader.js";import{readJsonFileBounded as O}from"../../infrastructure/filesystem/bounded-json-reader.js";import{RESOURCE_LIMITS as x}from"../../domain/runtime/resource-limits.js";import{resolvePlatformPaths as M,resolveProjectConfigPaths as D}from"../../infrastructure/platform/platform-paths.js";const _=2*1024*1024,B=256*1024;class ot{async listPublicPlugins(o){const t=await d.realpath(o),r=await new j().discover([t]);return Promise.all(r.map(async i=>{const s=await P(i.directory),a=await new T().discover([n.join(i.directory,c.skillsDirectory)]),u=await R([i]),p=await A(n.join(i.directory,c.hooksDirectory)),C=await new F().discover(n.join(i.directory,c.agentsDirectory)),$=[...a.map(l=>({kind:"skill",sourceName:l.name,description:l.description})),...u.contributions.map(l=>({kind:"mcp",sourceName:l.sourceName,description:z(u.config[l.qualifiedName]?.config)})),...p.map(l=>({kind:"hook",sourceName:l.id,description:`${l.event} hook`})),...C.map(l=>({kind:"agent",sourceName:l.name,description:l.description}))].sort((l,k)=>l.kind.localeCompare(k.kind)||l.sourceName.localeCompare(k.sourceName));return{directory:n.basename(i.directory),name:i.name,...i.displayName===void 0?{}:{displayName:i.displayName},version:i.version,description:i.description??"No description provided.",...i.author===void 0?{}:{author:i.author},...i.license===void 0?{}:{license:i.license},homepage:i.homepage??"https://lotagate.com/",privacyPolicy:"https://lotagate.com/privacy",termsOfService:"https://lotagate.com/terms",...s===void 0?{}:{icon:`data:${s.mimeType};base64,${s.data}`},contributions:$}}))}async resolvePublicPluginSource(o,t){m(t,"public plugin");const r=await d.realpath(o),i=n.resolve(r,t);w(r,i);const s=await d.lstat(i);if(!s.isDirectory()||s.isSymbolicLink())throw new Error(`Public plugin source is invalid: ${t}.`);const a=await d.realpath(i);w(r,a);const u=await d.lstat(n.join(a,c.markerDirectory,c.manifestFile));if(!u.isFile()||u.isSymbolicLink())throw new Error(`Public plugin manifest is missing: ${t}.`);return a}async readPublicPluginContribution(o,t,r,i){const s=await this.resolvePublicPluginSource(o,t);m(i,r);const a=r==="skill"?{path:n.join(s,c.skillsDirectory,i,"SKILL.md"),format:"markdown"}:r==="hook"?{path:n.join(s,c.hooksDirectory,`${i}.json`),format:"json"}:{path:n.join(s,c.mcpDirectory,`${i}.json`),format:"json"};return await E(s,a.path),{content:r==="mcp"?await S(a.path,i,!0):await f(a.path),format:a.format,editable:!1,...r==="mcp"?{}:{fileName:n.basename(a.path)}}}async readDetail(o,t){if(t.scope==="builtin"&&t.kind==="skill"){m(t.name,"skill");const p=n.join(U(),t.name,"SKILL.md");return await J(p)?{content:await f(p),format:"markdown",editable:!1,fileName:"SKILL.md"}:y()}const r=await d.realpath(o),i=t.scope==="plugin"?t.pluginName===void 0?void 0:await g(r,t.pluginName,t.pluginScope):t.kind==="plugin"&&t.scope!=="builtin"?await g(r,t.name,t.scope==="user"?"user":"project"):void 0;if(t.kind==="plugin"&&t.scope!=="plugin"&&t.scope!=="builtin")return i===void 0?y():N(n.join(i,c.markerDirectory,c.manifestFile),"json",!0);if(t.scope!=="plugin"||i===void 0||t.pluginName===void 0)return y();if(t.kind==="plugin")return N(n.join(i,c.markerDirectory,c.manifestFile),"json",!1);const s=t.sourceName??t.name.split(":").slice(1).join(":");m(s,t.kind);const a=t.kind==="skill"?{path:n.join(i,c.skillsDirectory,s,"SKILL.md"),format:"markdown"}:t.kind==="hook"?{path:n.join(i,c.hooksDirectory,`${s}.json`),format:"json"}:{path:n.join(i,c.mcpDirectory,`${s}.json`),format:"json"};return await E(i,a.path),{content:t.kind==="mcp"?await S(a.path,s,!0):await f(a.path),format:a.format,editable:!1,...t.kind==="mcp"?{}:{fileName:n.basename(a.path)}}}async readPluginIcon(o,t,r){const i=await g(await d.realpath(o),t,r);return i===void 0?void 0:P(i)}}async function g(e,o,t){m(o,"plugin");const r=M(),i=t==="project"?[D(e).pluginsDir]:t==="user"?[r.pluginsDir]:[D(e).pluginsDir,r.pluginsDir];return(await new j().discover(i)).find(a=>a.name===o)?.directory}async function N(e,o,t){return{content:await f(e),format:o,editable:t,fileName:n.basename(e)}}async function f(e){const o=await v(e,_);if(o.truncated)throw new Error("The extension detail is too large to display.");return o.bytes.toString("utf8")}async function S(e,o,t){const r=await O(e,x.mcpConfigBytes);if(!b(r))throw new Error("Extension configuration must be a JSON object.");if(t)return`${JSON.stringify(h(r),null,2)}
+`;if(!b(r[o]))throw new Error(`MCP server ${o} was not found in its configuration file.`);return`${JSON.stringify(h(r[o]),null,2)}
+`}async function P(e){const o=n.join(e,"icon.svg");try{const t=await v(o,B);if(t.truncated)return;const r=t.bytes.toString("utf8");return!/^\s*<svg(?:\s|>)/iu.test(r)||/<script\b|\bon[a-z]+\s*=|javascript:/iu.test(r)?void 0:{mimeType:"image/svg+xml",data:t.bytes.toString("base64")}}catch(t){if(L(t))return;throw t}}async function E(e,o){w(e,n.resolve(e,n.relative(e,o)));const t=await d.lstat(o);if(!t.isFile()||t.isSymbolicLink())throw new Error("Extension contribution is invalid.");w(e,await d.realpath(o))}function y(){return{content:"This item is provided by the CLI and has no editable project file.",format:"text",editable:!1}}function U(){return n.resolve(n.dirname(I(import.meta.url)),"../../../skills")}function m(e,o){if(!/^[a-z0-9][a-z0-9-]{0,63}$/u.test(e))throw new Error(`Invalid ${o} name.`)}function w(e,o){const t=n.relative(e,o);if(t.length===0||t.startsWith("..")||n.isAbsolute(t))throw new Error("Extension path is outside its owning directory.")}function z(e){return e?.type==="stdio"||e?.type==="http"||e?.type==="sse"?`${e.type} MCP server`:"MCP server contribution"}function h(e,o){return typeof e=="string"&&o!==void 0&&/(token|secret|password|api[-_]?key|authorization)/iu.test(o)?"[REDACTED]":Array.isArray(e)?e.map(t=>h(t)):b(e)?Object.fromEntries(Object.entries(e).map(([t,r])=>[t,h(r,t)])):e}function b(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function L(e){return typeof e=="object"&&e!==null&&"code"in e&&e.code==="ENOENT"}async function J(e){try{return(await d.lstat(e)).isFile()}catch(o){if(L(o))return!1;throw o}}export{ot as DesktopExtensionService};

package/dist/application/protocol/desktop-host-bridge.d.ts

@@ -0,0 +1,33 @@
+import type { BrowserHostRequest, BrowserHostResponse } from './browser-host-tool-executor.js';
+import type { DesktopHostExecutionRequest, DesktopHostExecutionResponse } from './desktop-host-tool-executor.js';
+import type { ComputerHostRequest, ComputerHostResponse } from './computer-host-tool-executor.js';
+import type { JsonLineWriter } from './json-line-writer.js';
+type HostCancel = {
+    version: 1;
+    type: 'host.cancel';
+    requestId: string;
+    tool: 'browser' | 'computer' | 'filesystem' | 'shell' | 'git' | 'artifact';
+    sessionId: string;
+};
+export type DesktopHostWireMessage = BrowserHostRequest | BrowserHostResponse | DesktopHostExecutionRequest | DesktopHostExecutionResponse | ComputerHostRequest | ComputerHostResponse | HostCancel;
+/** Owns the request/response lifecycle for Desktop-hosted capabilities. */
+export declare class DesktopHostBridge {
+    private readonly writer;
+    private readonly isStopping;
+    private readonly browserRequests;
+    private readonly desktopRequests;
+    private readonly computerRequests;
+    constructor(writer: JsonLineWriter<DesktopHostWireMessage>, isStopping: () => boolean);
+    requestBrowser(request: BrowserHostRequest, signal?: AbortSignal): Promise<BrowserHostResponse>;
+    requestDesktop(request: DesktopHostExecutionRequest, signal?: AbortSignal): Promise<DesktopHostExecutionResponse>;
+    requestComputer(request: ComputerHostRequest, signal?: AbortSignal): Promise<ComputerHostResponse>;
+    resolveBrowser(response: BrowserHostResponse): void;
+    resolveDesktop(response: DesktopHostExecutionResponse): void;
+    resolveComputer(response: ComputerHostResponse): void;
+    close(): void;
+    private request;
+    private resolve;
+    private rejectAll;
+    private sendCancel;
+}
+export {};

package/dist/application/protocol/desktop-host-bridge.js

@@ -0,0 +1 @@
+class c{writer;isStopping;browserRequests=new Map;desktopRequests=new Map;computerRequests=new Map;constructor(e,t){this.writer=e,this.isStopping=t}requestBrowser(e,t){return this.request(e,t,this.browserRequests,"Browser action was cancelled.")}requestDesktop(e,t){return this.request(e,t,this.desktopRequests,"Host execution was cancelled.")}requestComputer(e,t){return this.request(e,t,this.computerRequests,"Computer action was cancelled.")}resolveBrowser(e){this.resolve(this.browserRequests,e)}resolveDesktop(e){this.resolve(this.desktopRequests,e)}resolveComputer(e){this.resolve(this.computerRequests,e)}close(){this.rejectAll(this.browserRequests,"The Desktop browser bridge was closed."),this.rejectAll(this.desktopRequests,"The Desktop execution bridge was closed."),this.rejectAll(this.computerRequests,"The Desktop computer bridge was closed.")}request(e,t,s,i){if(this.isStopping())return Promise.reject(new Error("The Desktop host bridge is stopping."));if(t?.aborted===!0)return Promise.reject(new Error(i));const n=new Promise((r,d)=>{const o={resolve:r,reject:d,...t===void 0?{}:{signal:t}};t!==void 0&&(o.onAbort=()=>{s.delete(e.requestId),this.sendCancel(e),d(new Error(i))},t.addEventListener("abort",o.onAbort,{once:!0})),s.set(e.requestId,o)});return n.catch(()=>{}),this.writer.write(e).then(()=>n).finally(()=>{const r=s.get(e.requestId);r!==void 0&&(r.onAbort!==void 0&&r.signal?.removeEventListener("abort",r.onAbort),s.delete(e.requestId))})}resolve(e,t){const s=e.get(t.requestId);s!==void 0&&(s.onAbort!==void 0&&s.signal?.removeEventListener("abort",s.onAbort),e.delete(t.requestId),s.resolve(t))}rejectAll(e,t){for(const s of e.values())s.onAbort!==void 0&&s.signal?.removeEventListener("abort",s.onAbort),s.reject(new Error(t));e.clear()}async sendCancel(e){this.isStopping()||await this.writer.write({version:1,type:"host.cancel",requestId:e.requestId,tool:e.tool,sessionId:e.sessionId}).catch(()=>{})}}export{c as DesktopHostBridge};

package/dist/application/protocol/desktop-host-capabilities.d.ts

@@ -0,0 +1,12 @@
+/** Capability metadata supplied by the Desktop native host during handshake. */
+export interface DesktopHostCapability {
+    readonly available: boolean;
+    readonly provider: string;
+    readonly operations: readonly string[];
+    readonly reason?: string;
+}
+export interface DesktopHostCapabilities {
+    readonly computer?: DesktopHostCapability;
+}
+export declare function hostCapabilityAvailable(capabilities: DesktopHostCapabilities | undefined, capability: DesktopHostCapability | undefined): boolean;
+export declare function normalizeDesktopHostCapabilities(value: unknown): DesktopHostCapabilities | undefined;

package/dist/application/protocol/desktop-host-capabilities.js

@@ -0,0 +1 @@
+function a(r,n){return r===void 0?n?.available!==!1:n?.available===!0}function s(r){if(!i(r))return;const n=o(r.computer);return{...n===void 0?{}:{computer:n}}}function o(r){if(!i(r)||typeof r.available!="boolean"||typeof r.provider!="string"||r.provider.trim().length===0||!Array.isArray(r.operations))return;const n=r.operations.filter(t=>typeof t=="string"&&t.length>0),e=typeof r.reason=="string"&&r.reason.length>0?r.reason:void 0;return{available:r.available,provider:r.provider,operations:n,...e===void 0?{}:{reason:e}}}function i(r){return typeof r=="object"&&r!==null&&!Array.isArray(r)}export{a as hostCapabilityAvailable,s as normalizeDesktopHostCapabilities};

package/dist/application/protocol/desktop-host-tool-executor.d.ts

@@ -0,0 +1,76 @@
+import type { ToolDefinition } from '@lotagate/sdk';
+import type { ToolAuthorizationDecision, ToolExecutionContext, ToolExecutor, ToolInfo, ToolResult } from '@lotagate/agent-sdk';
+import type { ToolActivityObserver } from '../../ports/tool-activity.js';
+import type { ToolApprovalRequest } from '@lotagate/agent-sdk';
+import type { FileChangeDiff } from '../../domain/filesystem/file-change-diff.js';
+import { type HostPlatformContext } from '../../infrastructure/platform/host-platform.js';
+export type DesktopHostExecutionTool = 'filesystem' | 'shell' | 'git' | 'artifact';
+export interface DesktopHostExecutionRequest {
+    version: 1;
+    type: 'host.request';
+    requestId: string;
+    tool: DesktopHostExecutionTool;
+    sessionId: string;
+    runId: string;
+    action: string;
+    params: Record<string, unknown>;
+    taskId?: string;
+    executionBoundary: 'sandbox' | 'host';
+    hostFallback: 'ask' | 'deny' | 'allow';
+    projectRoot?: string;
+    executionCwd?: string;
+    executionWorkspaceId?: string;
+}
+export interface DesktopHostExecutionResponse {
+    version: 1;
+    type: 'host.response';
+    requestId: string;
+    tool: DesktopHostExecutionTool;
+    ok: boolean;
+    environmentId?: string;
+    result?: unknown;
+    error?: {
+        code: string;
+        category: string;
+        message: string;
+        retryable: boolean;
+    };
+    executionBoundary?: 'sandbox' | 'host';
+    fallbackReason?: string;
+    fileChange?: FileChangeDiff;
+    artifacts?: readonly DesktopArtifactDescriptor[];
+}
+export interface DesktopArtifactDescriptor {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly sizeBytes: number;
+}
+export type DesktopHostInvoker = (request: DesktopHostExecutionRequest, signal?: AbortSignal) => Promise<DesktopHostExecutionResponse>;
+/**
+ * Routes Desktop-only host operations through the versioned host protocol.
+ * Standalone CLI callers never provide this executor and continue to use the
+ * local filesystem and shell executors.
+ */
+export declare class DesktopHostToolExecutor implements ToolExecutor {
+    private readonly options;
+    private readonly definitions;
+    constructor(options: {
+        request: DesktopHostInvoker;
+        executionBoundary: 'sandbox' | 'host';
+        hostFallback: 'ask' | 'deny' | 'allow';
+        projectRoot?: string;
+        executionCwd?: string;
+        executionWorkspaceId?: string;
+        executionPlatform?: HostPlatformContext;
+        readOnly?: boolean;
+        onWrite?: (change: FileChangeDiff) => void | Promise<void>;
+        onArtifacts?: (artifacts: readonly DesktopArtifactDescriptor[], context: ToolExecutionContext) => void | Promise<void>;
+        onFallbackApproval?: (request: ToolApprovalRequest, reason: string) => boolean | ToolAuthorizationDecision | Promise<boolean | ToolAuthorizationDecision>;
+        onActivity?: ToolActivityObserver;
+    });
+    listTools(): readonly ToolDefinition[];
+    getToolInfo(toolName: string): ToolInfo | undefined;
+    execute(toolName: string, input: Record<string, unknown>, context: ToolExecutionContext): Promise<ToolResult>;
+    private request;
+}

package/dist/application/protocol/desktop-host-tool-executor.js

@@ -0,0 +1,2 @@
+import{randomUUID as y}from"node:crypto";import{isReadOnlyShellRequest as b}from"../security/tool-risk-classifier.js";import{resolveWorkspacePath as x}from"../../infrastructure/filesystem/path-resolver.js";import{readOnlyArguments as g,resolveReadOnlyExecutable as E}from"../../infrastructure/platform/read-only-executable.js";import{filesystemToolDefinitions as k,filesystemToolRisk as I}from"../../infrastructure/filesystem/local-filesystem-tool-executor.js";import{shellToolDefinitions as w}from"../../infrastructure/shell/shell-tool-executor.js";import{formatFilesystemActivityName as C,formatShellCommandForDisplay as O}from"../agent/tool-display.js";import{normalizePowerShellScriptInput as R}from"../../infrastructure/platform/host-process.js";import{detectHostPlatform as T}from"../../infrastructure/platform/host-platform.js";class W{options;definitions;constructor(t){this.options=t,this.definitions=[...k(),...w(t.executionBoundary==="sandbox"?"linux-guest":"host"),_()]}listTools(){return this.definitions}getToolInfo(t){if(!this.definitions.some(i=>h(i)===t))return;const o=t==="artifact.publish"?"write":I(t);return{toolName:t,source:t==="shell.exec"?"shell":t==="artifact.publish"?"custom":"filesystem",executorId:t==="artifact.publish"?"desktop-artifact-publisher":"desktop-host-execution",metadata:{boundary:this.options.executionBoundary,...o===void 0?{}:{risk:o}}}}async execute(t,o,r){if(!this.definitions.some(e=>h(e)===t))return{content:`Unknown Desktop host tool: ${t}`,isError:!0};const i=t==="shell.exec"?"shell":t==="artifact.publish"?"artifact":"filesystem";let s;const f=this.options.executionPlatform??T();try{s=t==="shell.exec"?R(o,f,{allowNonWindows:this.options.executionBoundary!=="sandbox"}):o}catch(e){return{content:e instanceof Error?e.message:"Invalid shell.exec PowerShell script.",isError:!0}}const p=t==="shell.exec"?await b(s.command,s.args,r,x,s.cwd,f):!1;if(t==="shell.exec"&&this.options.readOnly&&!p)return{content:"This subagent is limited to read-only shell commands inside the trusted workspace.",isError:!0,metadata:{code:"READ_ONLY_SHELL_REQUIRED"}};if(t==="shell.exec"&&p){const e=s.command,a=this.options.executionBoundary==="sandbox"?e:await E(e,r.workspaceRoot??r.cwd??process.cwd(),f);if(a===void 0)return{content:"Read-only executable is no longer available.",isError:!0};s={...s,command:a,args:g(e,s.args)}}const m=t==="shell.exec"&&typeof s.command=="string"?O(s.command,Array.isArray(s.args)?s.args.filter(e=>typeof e=="string"):[]):C(t,s.path),u=this.options.onActivity?.start({key:`${r.runId}:${t}`,toolName:t,source:i==="artifact"?"custom":i,label:m});try{let e=await this.options.request(this.request(i,t,s,r),r.signal);if(!e.ok&&e.error?.code==="SANDBOX_FALLBACK_REQUIRED"&&this.options.hostFallback==="ask"){const d=this.getToolInfo(t),c=await this.options.onFallbackApproval?.({toolName:t,input:s,context:r,...d===void 0?{}:{toolInfo:d}},e.error.message)??!1;if(typeof c=="boolean"?c:c.decision==="allow")e=await this.options.request({...this.request(i,t,s,r),executionBoundary:"host",hostFallback:"deny"},r.signal);else if(typeof c!="boolean"&&c.decision==="redirect")return u?.complete(!0,{userRedirect:!0}),{content:c.message,isError:!0,metadata:{code:"USER_REDIRECTED_ACTION",boundary:this.options.executionBoundary,userRedirect:!0}}}if(!e.ok)return u?.complete(!0),{content:e.error?.message??"Desktop rejected the execution request.",isError:!0,metadata:{code:e.error?.code??"HOST_EXECUTION_ERROR",boundary:e.executionBoundary??this.options.executionBoundary,retryable:e.error?.retryable??!1}};const a=S(i,e.result);if(a!==void 0){const d={code:a.code,boundary:e.executionBoundary??this.options.executionBoundary,retryable:a.retryable,...a.exitCode===void 0?{}:{exitCode:a.exitCode}};return u?.complete(!0,d),{content:a.message,isError:!0,metadata:d}}const l=e.artifacts??[];return l.length>0&&await this.options.onArtifacts?.(l,r),u?.complete(!1,e.fileChange===void 0?void 0:{fileChange:{path:e.fileChange.path,additions:e.fileChange.additions,deletions:e.fileChange.deletions}}),e.fileChange!==void 0&&await this.options.onWrite?.(e.fileChange),{content:D(e.result,r.maxResultBytes),isError:!1,metadata:{boundary:e.executionBoundary??this.options.executionBoundary,...e.environmentId===void 0?{}:{environmentId:e.environmentId},...e.fallbackReason===void 0?{}:{fallbackReason:e.fallbackReason},...l.length===0?{}:{artifactIds:l.map(d=>d.id)}}}}catch(e){return u?.complete(!0),{content:e instanceof Error?e.message:"Desktop execution failed.",isError:!0,metadata:{boundary:this.options.executionBoundary}}}}request(t,o,r,i){return{version:1,type:"host.request",requestId:y(),tool:t,sessionId:i.sessionId,runId:i.runId,action:o,params:r,executionBoundary:this.options.executionBoundary,hostFallback:this.options.hostFallback,...this.options.projectRoot===void 0?{}:{projectRoot:this.options.projectRoot},...this.options.executionCwd===void 0?{}:{executionCwd:this.options.executionCwd},...this.options.executionWorkspaceId===void 0?{}:{executionWorkspaceId:this.options.executionWorkspaceId},...typeof i.metadata?.taskId=="string"?{taskId:i.metadata.taskId}:{}}}}function _(){return{type:"function",function:{name:"artifact.publish",description:"Publish one completed output file from the execution workspace to the current task artifacts. The path must be workspace-relative and the file must already exist.",parameters:{type:"object",properties:{path:{type:"string",description:"Workspace-relative path of the completed output file."}},required:["path"],additionalProperties:!1}}}}function h(n){return"function"in n?n.function.name:void 0}function D(n,t){const o=typeof n=="string"?n:JSON.stringify(n??null);return Buffer.byteLength(o,"utf8")<=t?o:`${o.slice(0,Math.max(0,t-12))}
+[truncated]`}function S(n,t){if(n!=="shell"||typeof t!="object"||t===null||Array.isArray(t))return;const o=t,r=typeof o.stderr=="string"?o.stderr.trim():"",i=typeof o.stdout=="string"?o.stdout.trim():"";if(o.diskLimitExceeded===!0)return{code:"HOST_EXECUTION_DISK_LIMIT",message:r||"The sandbox workspace disk limit was exceeded while the command was running.",retryable:!1};if(o.processLimitExceeded===!0)return{code:"HOST_EXECUTION_PROCESS_LIMIT",message:r||"The sandbox process limit was exceeded while the command was running.",retryable:!1};if(o.cancelled===!0)return{code:"HOST_EXECUTION_CANCELLED",message:r||"Desktop host execution was cancelled.",retryable:!1};if(o.timedOut===!0)return{code:"HOST_EXECUTION_TIMEOUT",message:r||"Desktop host execution timed out.",retryable:!0};if(o.error===!0)return{code:"HOST_EXECUTION_PROCESS_ERROR",message:r||"Desktop host process failed to start or communicate.",retryable:!0};if(Object.hasOwn(o,"exitCode")&&o.exitCode!==0){const s=typeof o.exitCode=="number"?o.exitCode:null;return{code:"HOST_COMMAND_FAILED",message:r||i||`Desktop host command exited with code ${String(s)}.`,retryable:!1,exitCode:s}}}export{W as DesktopHostToolExecutor};

package/dist/application/protocol/desktop-intent-event-writer.d.ts

@@ -0,0 +1,20 @@
+import type { IntentLifecycleEvent } from '../intent/intent-run-controller.js';
+export interface DesktopIntentEventWriterOptions {
+    readonly writeEvent: (event: string, data: Record<string, unknown>) => Promise<void>;
+    readonly log: (message: string, details: Record<string, unknown>) => void;
+}
+/** Projects host-owned intent state into the stable Desktop event contract. */
+export declare class DesktopIntentEventWriter {
+    private readonly options;
+    private readonly progress;
+    constructor(options: DesktopIntentEventWriterOptions);
+    clear(turnId: string): void;
+    write(event: IntentLifecycleEvent, sessionId: string, turnId: string): Promise<void>;
+    private writeCompiled;
+    private writeEvidence;
+    private writeVerificationRequired;
+    private writeBlocked;
+    private nextVersion;
+    private setActiveStep;
+    private evidenceStep;
+}

package/dist/application/protocol/desktop-intent-event-writer.js

@@ -0,0 +1 @@
+class o{options;progress=new Map;constructor(i){this.options=i}clear(i){this.progress.delete(i)}async write(i,t,e){if(this.options.log("Intent lifecycle updated.",{lifecycle:i.type,intentId:i.contract.id,sessionId:t,turnId:e,...i.type==="intent.evidence"?{evidenceKind:i.evidence.kind,evidenceStatus:i.evidence.status}:{},...i.type==="intent.verification.required"||i.type==="intent.blocked"?{missingCount:i.missing.length}:{}}),i.type==="intent.compiled")return this.writeCompiled(i,t,e);if(i.type==="intent.evidence")return this.writeEvidence(i,t,e);if(i.type==="intent.verification.required")return this.writeVerificationRequired(i,t,e);if(i.type==="intent.blocked")return this.writeBlocked(i,t,e);await this.options.writeEvent("intent.completed",{turnId:e,sessionId:t,intentId:i.contract.id});for(const n of i.contract.steps)await this.options.writeEvent("work.task.completed",{turnId:e,sessionId:t,planId:i.contract.id,version:this.nextVersion(e),stepId:n.id});await this.options.writeEvent("work.plan.completed",{turnId:e,sessionId:t,planId:i.contract.id,version:this.nextVersion(e)}),this.clear(e)}async writeCompiled(i,t,e){const n=i.contract.steps[0]?.id;n!==void 0&&(this.progress.set(e,{version:1,activeStepId:n}),await this.options.writeEvent("intent.compiled",{turnId:e,sessionId:t,contract:i.contract}),await this.options.writeEvent("work.plan.created",{turnId:e,sessionId:t,planId:i.contract.id,version:1,goal:i.contract.objective,language:"und",totalSteps:i.contract.steps.length,steps:i.contract.steps.map((c,r)=>({index:r,id:c.id,title:c.title,description:c.title,dependencies:[],scope:[],acceptanceCriteria:c.acceptanceCriteria,verificationHints:c.requiresVerification?["Host-observed verification required"]:[],evidenceIds:[],status:r===0?"active":"queued"}))}))}async writeEvidence(i,t,e){const n=this.evidenceStep(e,i.contract,i.evidence.kind);await this.options.writeEvent("intent.evidence.recorded",{turnId:e,sessionId:t,intentId:i.contract.id,evidence:i.evidence}),await this.options.writeEvent("work.evidence.recorded",{turnId:e,sessionId:t,planId:i.contract.id,version:this.nextVersion(e),evidence:{id:i.evidence.id,stepId:n,kind:i.evidence.kind,summary:i.evidence.summary,status:i.evidence.status,...i.evidence.command===void 0?{}:{command:i.evidence.command},...i.evidence.paths===void 0?{}:{paths:i.evidence.paths},...i.evidence.exitCode===void 0?{}:{exitCode:i.evidence.exitCode},createdAt:i.evidence.timestamp}})}async writeVerificationRequired(i,t,e){await this.options.writeEvent("intent.verification.required",{turnId:e,sessionId:t,intentId:i.contract.id,missing:i.missing});const n=i.contract.steps.find(c=>c.requiresVerification);n!==void 0&&(this.setActiveStep(e,n.id),await this.options.writeEvent("work.task.started",{turnId:e,sessionId:t,planId:i.contract.id,version:this.nextVersion(e),stepId:n.id}))}async writeBlocked(i,t,e){await this.options.writeEvent("intent.blocked",{turnId:e,sessionId:t,intentId:i.contract.id,missing:i.missing}),await this.options.writeEvent("work.plan.blocked",{turnId:e,sessionId:t,planId:i.contract.id,version:this.nextVersion(e),reason:i.missing.join(", ")}),this.clear(e)}nextVersion(i){const t=this.progress.get(i);return t===void 0?1:(t.version+=1,t.version)}setActiveStep(i,t){const e=this.progress.get(i);e!==void 0&&(e.activeStepId=t)}evidenceStep(i,t,e){return e!=="read"?t.steps.find(n=>n.requiresVerification)?.id??t.steps.at(-1)?.id??t.steps[0].id:this.progress.get(i)?.activeStepId??t.steps[0].id}}export{o as DesktopIntentEventWriter};

package/dist/application/protocol/desktop-mcp-events.d.ts

@@ -0,0 +1,10 @@
+import type { AgentEvent } from '@lotagate/agent-sdk';
+import type { McpRuntimeEvent } from '../../infrastructure/extensions/mcp-runtime.js';
+type DesktopMcpEvent = Extract<AgentEvent, {
+    type: 'mcp.server.status' | 'mcp.tool.catalog.updated';
+}> | McpRuntimeEvent;
+export declare function desktopMcpEvent(event: DesktopMcpEvent, sessionId: string, turnId: string): {
+    name: string;
+    data: Record<string, unknown>;
+};
+export {};

package/dist/application/protocol/desktop-mcp-events.js

@@ -0,0 +1 @@
+function t(r,o,a){if(r.type==="mcp.tool.catalog.updated")return{name:"mcp.tool.catalog.updated",data:{sessionId:o,turnId:a,serverId:r.serverId,toolCount:"toolCount"in r?r.toolCount:r.tools.length,...r.error===void 0?{}:{error:u(r.error),retryable:!0}}};const s=r.summary.status==="closed"?"disconnected":r.summary.status==="created"?"connecting":r.summary.status;return{name:`mcp.server.${s}`,data:{sessionId:o,turnId:a,serverId:r.summary.serverId,status:s,...!("latencyMs"in r.summary)||r.summary.latencyMs===void 0?{}:{latencyMs:r.summary.latencyMs},...r.summary.protocolEra===void 0?{}:{protocolEra:r.summary.protocolEra},...r.summary.protocolVersion===void 0?{}:{protocolVersion:r.summary.protocolVersion},...r.summary.error===void 0?{}:{error:u(r.summary.error),retryable:!0}}}}function u(r){return r.message.replace(/(api[-_ ]?key|authorization|bearer|token|password)\s*[:=]\s*[^\s,;]+/giu,"$1=[REDACTED]").slice(0,1024)}export{t as desktopMcpEvent};

package/dist/application/protocol/desktop-orchestration-events.d.ts

@@ -0,0 +1,2 @@
+import type { SubagentLifecycleEvent } from '../../ports/subagent-lifecycle.js';
+export declare function subagentDesktopPayload(event: SubagentLifecycleEvent, turnId?: string): Record<string, unknown>;

package/dist/application/protocol/desktop-orchestration-events.js

@@ -0,0 +1,2 @@
+function u(d,s){return{...s===void 0?{}:{turnId:s},sessionId:d.sessionId,id:d.id,displayName:d.displayName,task:o(d.task,16384),mode:d.mode,model:d.model,status:d.status,background:d.background,timestamp:d.timestamp,...d.durationMs===void 0?{}:{durationMs:d.durationMs},...d.summary===void 0?{}:{summary:o(d.summary,24576)},...d.lastAction===void 0?{}:{lastAction:d.lastAction},...d.handoff===void 0?{}:{handoff:d.handoff}}}function o(d,s){const a=Buffer.from(d,"utf8");return a.byteLength<=s?d:`${a.subarray(0,s).toString("utf8")}
+[truncated]`}export{u as subagentDesktopPayload};

package/dist/application/protocol/desktop-protocol-helpers.d.ts

@@ -0,0 +1,13 @@
+import type { ToolApprovalRequest } from '@lotagate/agent-sdk';
+import type { SessionMetadata } from '../../domain/session/session.js';
+import type { CliApprovalMode } from '../security/tool-approval-service.js';
+import type { DesktopExecutionPolicy } from './desktop-execution-policy.js';
+export declare function desktopApprovalMode(policy: DesktopExecutionPolicy['permissionPolicy']): CliApprovalMode;
+export declare function toDesktopError(error: unknown): {
+    code: string;
+    category: string;
+    message: string;
+    retryable: boolean;
+};
+export declare function sessionResult(session: SessionMetadata): Record<string, unknown>;
+export declare function describeApproval(request: ToolApprovalRequest): Record<string, unknown>;

package/dist/application/protocol/desktop-protocol-helpers.js

@@ -0,0 +1 @@
+import{asCliError as s}from"../../domain/errors/cli-error.js";import{formatShellCommandForDisplay as p,formatToolActivityName as c}from"../agent/tool-display.js";function l(e){return e==="allowlist"?"auto":e==="review"?"review":e==="autonomous"?"autonomous":"ask"}function f(e){if(typeof e=="object"&&e!==null){const t=e;if(typeof t.code=="string"&&typeof t.category=="string"&&typeof t.userMessage=="string"&&typeof t.retryable=="boolean")return{code:t.code,category:t.category,message:t.userMessage,retryable:t.retryable}}const r=s(e);return{code:r.code,category:r.category,message:r.userMessage,retryable:r.retryable}}function y(e){return{session:e}}function g(e){if(e.toolName==="filesystem.write")return{summary:`Write workspace file: ${a(e.input.path)}`,path:a(e.input.path)};if(e.toolName==="shell.exec"){const r=typeof e.input.command=="string"?e.input.command:"",t=Array.isArray(e.input.args)?e.input.args.filter(i=>typeof i=="string"):[],o=typeof e.input.script=="string"?a(e.input.script):void 0,n=o===void 0?t:[...t,"-Command",o];return{summary:`Run command: ${p(r,n,240)}`,command:r,args:t,...o===void 0?{}:{script:o}}}return{summary:`This ${c(e.toolName)} operation may change workspace or external state.`}}function a(e){return String(e??"").replace(/Bearer\s+[^\s]+/giu,"Bearer [REDACTED]").replace(/sk-[A-Za-z0-9_-]{8,}/gu,"[REDACTED]").slice(0,240)}export{g as describeApproval,l as desktopApprovalMode,y as sessionResult,f as toDesktopError};

package/dist/application/protocol/json-line-writer.d.ts

@@ -0,0 +1,31 @@
+import type { Writable } from 'node:stream';
+export type JsonLineDelivery = 'reliable' | 'best-effort';
+export interface JsonLineWriteOptions {
+    readonly delivery?: JsonLineDelivery;
+}
+export interface JsonLineWriterOptions {
+    readonly maxQueuedEntries?: number;
+    readonly maxQueuedBytes?: number;
+}
+export declare function waitForWritableDrain(output: Writable): Promise<void>;
+/** Serializes protocol messages in order and applies Writable backpressure. */
+export declare class JsonLineWriter<T> {
+    private readonly output;
+    private tail;
+    private activeEntries;
+    private activeBytes;
+    private waitingBytes;
+    private readonly waiting;
+    private closed;
+    private readonly maxQueuedEntries;
+    private readonly maxQueuedBytes;
+    constructor(output: Writable, options?: JsonLineWriterOptions);
+    write(value: T, options?: JsonLineWriteOptions): Promise<void>;
+    flush(): Promise<void>;
+    close(error?: Error): void;
+    private schedule;
+    private readonly complete;
+    private admitWaiting;
+    private canSchedule;
+    private canWait;
+}

package/dist/application/protocol/json-line-writer.js

@@ -0,0 +1,2 @@
+import{RESOURCE_LIMITS as c}from"../../domain/runtime/resource-limits.js";function h(i){return i.destroyed||i.writableEnded?Promise.reject(new Error("The protocol output is closed.")):new Promise((e,t)=>{const s=()=>{i.removeListener("drain",r),i.removeListener("error",o),i.removeListener("close",n),i.removeListener("finish",n)},r=()=>{s(),e()},o=a=>{s(),t(a)},n=()=>{s(),t(new Error("The protocol output is closed."))};i.once("drain",r),i.once("error",o),i.once("close",n),i.once("finish",n),(i.destroyed||i.writableEnded)&&n()})}class u{output;tail=Promise.resolve();activeEntries=0;activeBytes=0;waitingBytes=0;waiting=[];closed=!1;maxQueuedEntries;maxQueuedBytes;constructor(e,t={}){this.output=e,this.maxQueuedEntries=t.maxQueuedEntries??c.protocolWriteQueueEntries,this.maxQueuedBytes=t.maxQueuedBytes??c.protocolWriteQueueBytes}write(e,t={}){const s=`${JSON.stringify(e)}
+`,r=Buffer.byteLength(s,"utf8"),o=t.delivery??"reliable";return this.closed?Promise.reject(new Error("The protocol writer is closed.")):this.waiting.length>0||!this.canSchedule(r)?o==="best-effort"?Promise.reject(new Error("The protocol output queue is full.")):this.canWait(r)?new Promise((n,a)=>{this.waiting.push({serialized:s,bytes:r,resolve:n,reject:a}),this.waitingBytes+=r}):Promise.reject(new Error("The protocol output queue limit was exceeded.")):this.schedule(s,r)}async flush(){for(;;){const e=this.tail;if(await e,await new Promise(t=>setImmediate(t)),e===this.tail&&this.activeEntries===0&&this.waiting.length===0)return}}close(e=new Error("The protocol writer is closed.")){this.closed=!0;const t=this.waiting.splice(0);this.waitingBytes=0;for(const s of t)s.reject(e)}schedule(e,t){this.activeEntries+=1,this.activeBytes+=t;const s=this.tail.then(async()=>{this.output.write(e)||await h(this.output)});return this.tail=s.catch(()=>{}),s.then(()=>this.complete(t),()=>this.complete(t)),s}complete=e=>{this.activeEntries-=1,this.activeBytes-=e,this.admitWaiting()};admitWaiting(){for(;this.waiting.length>0;){const e=this.waiting[0];if(!this.canSchedule(e.bytes))return;this.waiting.shift(),this.waitingBytes-=e.bytes,this.schedule(e.serialized,e.bytes).then(e.resolve,e.reject)}}canSchedule(e){return this.activeEntries<this.maxQueuedEntries&&this.activeBytes+e<=this.maxQueuedBytes}canWait(e){return this.activeEntries+this.waiting.length<this.maxQueuedEntries&&this.activeBytes+this.waitingBytes+e<=this.maxQueuedBytes}}export{u as JsonLineWriter,h as waitForWritableDrain};

package/dist/application/protocol/jsonl-agent-command.d.ts

@@ -0,0 +1,3 @@
+import type { Readable, Writable } from 'node:stream';
+import type { createCompositionRoot } from '../../bootstrap/composition-root.js';
+export declare function runAgentCommand(positionals: readonly string[], runtime: ReturnType<typeof createCompositionRoot>, cwd: string, stdin: Readable, stdout: Writable, signal?: AbortSignal): Promise<number>;

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

@@ -0,0 +1,3 @@
+import{AuthenticationService as O}from"../auth/authentication-service.js";import{JsonlProtocolRunner as _}from"./jsonl-protocol.js";import{createLotaGateClient as b}from"../../infrastructure/sdk/lotagate-client-factory.js";import{CliError as C}from"../../domain/errors/cli-error.js";import{CLI_ERROR_CODES as d}from"../../domain/errors/error-codes.js";import{prepareCliAgent as v}from"../agent/cli-agent-execution-service.js";import{AgentRunTracker as P}from"../agent/agent-run-tracker.js";import{loadExecutionConfig as S}from"../config/execution-config.js";import{agentLimitNotice as T,classifyAgentLimit as D}from"../agent/agent-limit.js";import{runDesktopAgentCommand as I}from"./desktop-agent-command.js";import{createContextManagement as F}from"../agent/context-compaction.js";import{formatContinuationCheckpoint as U}from"../agent/continuation-checkpoint.js";import{resolveModelContextWindow as G}from"../model/model-context-window.js";async function oe(k,t,i,h,w,y){const N=k[0]??"stdio";if(N==="desktop")return I(t,i,h,w,y);if(N!=="stdio")throw new C(d.INVALID_ARGUMENT,"Unsupported agent action.",{category:"arguments",userMessage:"Use `lotagate agent stdio` or `lotagate agent desktop`."});const s=await S(t,i);if(s.config.model===null)throw new C(d.MODEL_NOT_FOUND,"No model is selected.",{category:"model",userMessage:"Select a model before running the stdio agent."});const M=s.config.profile??O.defaultProfileName(),x=await t.auth.requireCredential(M);return(await new _(async function*(m,L){const n=m.params.model??s.config.model;t.logger.info("Protocol agent request started.",{model:n,promptLength:m.params.prompt.length});const a=new P,E=b(x.profile,x.apiKey),R=await G(t,n,M),A=o=>{a.observeModel(o),t.logger.debug("Model turn completed.",{model:o.model,stream:o.stream,contentLength:o.contentLength,toolCallCount:o.toolCallCount,toolNames:o.toolNames,finishReason:o.finishReason})},f=await v({runtime:t,projectRoot:i,executionCwd:i,model:n,client:E,profile:"protocol-safe",approvalMode:s.config.approvalMode,onModelComplete:A,contextManagement:F({client:E,model:n,...R===void 0?{}:{contextWindow:R},onSummaryFailure:o=>t.logger.warn("Context summarization failed; using fallback summary.",{reason:o instanceof Error?o.message:String(o)}),continuationContext:()=>U({snapshot:a.snapshot()})})});let g=!1,l="",r,c;try{const o=await f.buildInput(m.params.prompt);for await(const e of f.run({input:o.input,userInput:o.userInput,...o.workspaceContext===void 0?{}:{workspaceContext:o.workspaceContext},model:n,signal:L}))if(a.observe(e),e.type==="tool.called"&&t.logger.info("Agent tool called.",{toolName:e.toolName}),e.type==="tool.completed"&&t.logger.info("Agent tool completed.",{toolName:e.toolName,isError:e.isError}),e.type==="model.delta"&&e.content.length>0?(g=!0,l+=e.content,yield{type:"delta",content:e.content}):e.type==="session.completed"&&(r=e.content),e.type==="session.failed"){const p=D(e.error);if(p===void 0)throw e.error;c=T(p);break}if(c!==void 0){const e=l.length===0?c:`
+
+${c}`;g=!0,l+=e,r=l,yield{type:"delta",content:e}}const u=r===void 0||r.trim().length===0?l:r;if(u.trim().length===0){const e=a.snapshot();e.toolCalls>0&&a.markStuck();const p=e.toolCalls>0?d.MODEL_EMPTY_FINAL:d.MODEL_PROTOCOL_EMPTY_RESPONSE;throw new C(p,"Agent completed without a final text response.",{category:"model",userMessage:"The model completed without a final text response.",retryable:!0,details:{toolCalls:e.toolCalls,toolCompletions:e.toolCompletions,toolNames:e.toolNames,finishReason:e.lastFinishReason}})}g||(yield{type:"delta",content:u}),yield{type:"completed",content:u},t.logger.info("Protocol agent request completed.",{model:n})}finally{await f.close()}}).run(h,w,y)).errorCount===0?0:1}export{oe as runAgentCommand};