@myagentroam/node 0.9.94 → 0.9.96

package/dist/runner/mar-agent/managed-run-controller.js

@@ -24,6 +24,7 @@ export class MarAgentManagedRunController {
     #resourceIdleTtlMs;
     #createAgent;
     #modelFactory;
+    #computerUse;
     #disposePromise;
     #disposed = false;
     constructor(runner, host, options = {}) {
@@ -43,6 +44,7 @@ export class MarAgentManagedRunController {
                 };
             })
         };
+        this.#computerUse = options.computerUse;
     }
     dispose() {
         if (this.#disposePromise !== undefined)
@@ -56,6 +58,7 @@ export class MarAgentManagedRunController {
                 execution.cancel();
             await Promise.all([...new Set(this.#sessionRuntimes.values())].map((runtime) => this.#releaseRuntime(runtime)));
             await this.#mcpClients.close();
+            await this.#computerUse?.dispose();
         })();
         return this.#disposePromise;
     }
@@ -66,11 +69,17 @@ export class MarAgentManagedRunController {
         const release = (async () => {
             await this.#runtimeAcquisitions.get(sessionId)?.catch(() => undefined);
             const runtime = this.#sessionRuntimes.get(sessionId);
-            if (runtime === undefined)
+            if (runtime === undefined) {
+                await this.#computerUse?.releaseSession(sessionId);
                 return;
+            }
             if (runtime.activeRunId !== undefined)
                 this.#executions.get(runtime.activeRunId)?.cancel();
             await this.#releaseRuntime(runtime);
+            await Promise.all([
+                this.#computerUse?.releaseSession(sessionId),
+                this.#computerUse?.releaseSession(runtime.session.id)
+            ]);
         })();
         const tracked = release.finally(() => {
             if (this.#sessionReleases.get(sessionId) === tracked)
@@ -157,6 +166,8 @@ export class MarAgentManagedRunController {
                 ...secretEnvironment,
                 ...mcpSecretEnvironment
             });
+            if (mcpServers.some((server) => server.name === 'computer'))
+                throw new Error('MAR_AGENT_MCP_RESERVED_NAMESPACE');
             images = parseRunnerImageAttachments(payload.attachments);
         }
         catch {
@@ -190,7 +201,8 @@ export class MarAgentManagedRunController {
                 : {}),
             ...(typeof payload.personalInstructions === 'string'
                 ? { personalInstructions: payload.personalInstructions }
-                : {})
+                : {}),
+            computerUseEnabled: payload.computerUse === true
         });
     }
     cancel(runId, intent) {
@@ -230,6 +242,7 @@ export class MarAgentManagedRunController {
         let runtime;
         let executionMcpLease;
         let executionMcpBinding;
+        let computerUseBinding;
         try {
             const sessionKey = input.externalSessionId ?? input.sessionId;
             const acquisitionKeys = [...new Set([sessionKey, input.sessionId])];
@@ -257,16 +270,45 @@ export class MarAgentManagedRunController {
                 throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');
             runtime.activeRunId = input.runId;
             const executionMcpServers = input.mcpServers.filter((server) => server.lifecycle === 'EXECUTION');
+            computerUseBinding = await this.#computerUse?.bind({
+                runId: input.runId,
+                sessionId: runtime.session.id,
+                mode: input.mode,
+                enabled: input.computerUseEnabled === true,
+                modelSupportsImages: input.model.inputCapabilities.includes('IMAGE')
+            });
+            if (this.#disposed ||
+                this.#sessionReleases.has(sessionKey) ||
+                this.#sessionReleases.has(input.sessionId) ||
+                this.#sessionReleases.has(runtime.session.id)) {
+                await computerUseBinding?.close().catch(() => undefined);
+                computerUseBinding = undefined;
+                await this.#computerUse?.releaseSession(runtime.session.id);
+                throw new Error('MAR_AGENT_SESSION_RUNTIME_RELEASED');
+            }
             if (executionMcpServers.length > 0) {
                 executionMcpLease = await this.#mcpClients.acquire(executionMcpServers, input.cwd, {
                     reusable: false
                 });
-                const mcp = executionMcpLease.pool;
+            }
+            const userTools = executionMcpLease?.pool.definitions() ?? [];
+            const nodeTools = computerUseBinding?.tools ?? [];
+            if (userTools.some((tool) => tool.name.startsWith('mcp__computer__')))
+                throw new Error('MAR_AGENT_MCP_RESERVED_NAMESPACE');
+            if (new Set([...userTools, ...nodeTools].map((tool) => tool.name)).size !==
+                userTools.length + nodeTools.length)
+                throw new Error('MAR_AGENT_MCP_TOOL_NAMES_CONFLICT');
+            if (userTools.length > 0 || nodeTools.length > 0)
                 executionMcpBinding = runtime.host.bindExecutionMcp({
-                    tools: mcp.definitions(),
-                    call: async (call) => mcp.call(call.name, call.arguments)
+                    tools: [...nodeTools, ...userTools],
+                    call: async (call, signal) => {
+                        if (computerUseBinding?.tools.some((tool) => tool.name === call.name))
+                            return computerUseBinding.call(call, signal);
+                        if (executionMcpLease?.pool.definitions().some((tool) => tool.name === call.name))
+                            return executionMcpLease.pool.call(call.name, call.arguments);
+                        throw new Error('MAR_AGENT_MCP_TOOL_NOT_FOUND');
+                    }
                 });
-            }
             const session = runtime.session;
             const reasoningEffort = input.effort
                 ? marAgentReasoningEffortSchema.parse(input.effort)
@@ -330,6 +372,7 @@ export class MarAgentManagedRunController {
             this.#normalizers.delete(input.runId);
             this.host.active.delete(input.runId);
             this.#executions.delete(input.runId);
+            await computerUseBinding?.close().catch(() => undefined);
             runtime?.host.unbindExecutionMcp(executionMcpBinding);
             await executionMcpLease?.release().catch(() => undefined);
             if (runtime !== undefined)
@@ -511,7 +554,12 @@ export class MarAgentManagedRunController {
                 delete runtime.idleTimer;
             }
             try {
-                await runtime.agent.dispose();
+                try {
+                    await this.#computerUse?.releaseSession(runtime.session.id);
+                }
+                finally {
+                    await runtime.agent.dispose();
+                }
             }
             finally {
                 await runtime.mcpLease.release().catch(() => undefined);

package/dist/service/computer-use-enablement-service.js

@@ -0,0 +1,172 @@
+import { computerUseDisableInputSchema, computerUseEnableInputSchema, computerUseEnableResultSchema } from '@myagentroam/protocol';
+import { computerUseRuntimeExecutable, saveNodeConfig } from '../config.js';
+import { nodeOperationData } from '../util/node-operation-data.js';
+/** Persists Computer Use authorization and owns its asynchronous capability probe. */
+export class ComputerUseEnablementService {
+    options;
+    #now;
+    #capability;
+    #probeGeneration = 0;
+    constructor(options) {
+        this.options = options;
+        this.#now = options.now ?? Date.now;
+        this.#capability = this.#disabled();
+    }
+    capability() {
+        return this.#capability;
+    }
+    operations() {
+        return {
+            'computer.use.enable': (data) => this.enable(data),
+            'computer.use.disable': (data) => this.disable(data)
+        };
+    }
+    initialize() {
+        if (this.options.config()?.computerUse?.enabled !== true) {
+            this.#set(this.#disabled(), false);
+            return;
+        }
+        this.#beginProbe();
+    }
+    async enable(data) {
+        const parsed = computerUseEnableInputSchema.safeParse(nodeOperationData(data));
+        if (!parsed.success)
+            throw new Error('COMPUTER_USE_ENABLE_INPUT_INVALID');
+        const current = this.options.config();
+        if (current === undefined)
+            throw new Error('NODE_CONFIG_UNAVAILABLE');
+        if (current.computerUse?.enabled !== true) {
+            const next = {
+                ...current,
+                computerUse: {
+                    ...current.computerUse,
+                    enabled: true
+                }
+            };
+            await saveNodeConfig(next, this.options.configPath);
+            this.options.setConfig(next);
+        }
+        this.#beginProbe();
+        return computerUseEnableResultSchema.parse({ capability: this.#capability });
+    }
+    async disable(data) {
+        const parsed = computerUseDisableInputSchema.safeParse(nodeOperationData(data));
+        if (!parsed.success)
+            throw new Error('COMPUTER_USE_DISABLE_INPUT_INVALID');
+        const current = this.options.config();
+        if (current === undefined)
+            throw new Error('NODE_CONFIG_UNAVAILABLE');
+        this.#probeGeneration += 1;
+        if (current.computerUse?.enabled === true) {
+            const next = {
+                ...current,
+                computerUse: {
+                    ...current.computerUse,
+                    enabled: false
+                }
+            };
+            this.options.setConfig(next);
+            try {
+                await this.options.provider.reset();
+                await saveNodeConfig(next, this.options.configPath);
+            }
+            catch (error) {
+                this.options.setConfig(current);
+                this.initialize();
+                throw error;
+            }
+        }
+        else {
+            await this.options.provider.reset();
+        }
+        this.#set(this.#disabled());
+        return computerUseEnableResultSchema.parse({ capability: this.#capability });
+    }
+    #beginProbe() {
+        const config = this.options.config();
+        if (config === undefined || config.computerUse?.enabled !== true) {
+            this.#set(this.#disabled());
+            return;
+        }
+        const runtimeExecutable = computerUseRuntimeExecutable(config, this.options.configPath);
+        if (runtimeExecutable === undefined) {
+            this.#set(this.#unavailable('COMPUTER_RUNTIME_MISSING'));
+            return;
+        }
+        const generation = ++this.#probeGeneration;
+        this.#set({
+            apiVersion: 1,
+            enabled: true,
+            state: 'INITIALIZING',
+            backend: 'PYAUTOGUI',
+            supportsScreenshot: false,
+            supportsInput: false,
+            supportsUnicodePaste: false,
+            supportsPrimaryDisplay: false,
+            measuredAt: this.#now()
+        });
+        void this.options.provider
+            .reset()
+            .then(() => this.options.prepareRuntime())
+            .then(() => this.options.provider.support())
+            .then((support) => {
+            if (generation !== this.#probeGeneration)
+                return;
+            this.#set(this.#fromSupport(support));
+        })
+            .catch((error) => {
+            if (generation !== this.#probeGeneration)
+                return;
+            this.#set(this.#unavailable(error instanceof Error && /^[A-Z][A-Z0-9_]{0,79}$/u.test(error.message)
+                ? error.message
+                : 'COMPUTER_PROBE_FAILED'));
+        });
+    }
+    #fromSupport(support) {
+        if (!support.available)
+            return this.#unavailable(support.reasonCode ?? 'COMPUTER_UNAVAILABLE', support);
+        return {
+            apiVersion: 1,
+            enabled: true,
+            state: 'AVAILABLE',
+            backend: 'PYAUTOGUI',
+            supportsScreenshot: support.supportsScreenshot,
+            supportsInput: support.supportsInput,
+            supportsUnicodePaste: support.supportsUnicodePaste,
+            supportsPrimaryDisplay: support.supportsPrimaryDisplay,
+            measuredAt: this.#now()
+        };
+    }
+    #disabled() {
+        return {
+            apiVersion: 1,
+            enabled: false,
+            state: 'DISABLED',
+            backend: 'PYAUTOGUI',
+            supportsScreenshot: false,
+            supportsInput: false,
+            supportsUnicodePaste: false,
+            supportsPrimaryDisplay: false,
+            measuredAt: this.#now()
+        };
+    }
+    #unavailable(reasonCode, support) {
+        return {
+            apiVersion: 1,
+            enabled: true,
+            state: 'UNAVAILABLE',
+            backend: 'PYAUTOGUI',
+            supportsScreenshot: support?.supportsScreenshot ?? false,
+            supportsInput: support?.supportsInput ?? false,
+            supportsUnicodePaste: support?.supportsUnicodePaste ?? false,
+            supportsPrimaryDisplay: support?.supportsPrimaryDisplay ?? false,
+            reasonCode,
+            measuredAt: this.#now()
+        };
+    }
+    #set(capability, publish = true) {
+        this.#capability = computerUseEnableResultSchema.parse({ capability }).capability;
+        if (publish)
+            this.options.publish(this.#capability);
+    }
+}

package/dist/service/continuous-run-coordinator.js

@@ -320,6 +320,7 @@ export class ContinuousRunCoordinator {
                 ...(pending.marAgentRuntimeScopeId === undefined
                     ? {}
                     : { marAgentRuntimeScopeId: pending.marAgentRuntimeScopeId }),
+                ...(pending.computerUse === undefined ? {} : { computerUse: pending.computerUse }),
                 mcpInstallations: [
                     ...this.options.mcps(pending.workspaceId),
                     ...(missionMcp === undefined ? [] : [missionMcp.installation])

package/dist/service/node-connection-lifecycle-service.js

@@ -38,6 +38,7 @@ export class NodeConnectionLifecycleService {
                 ? {}
                 : { conversationHosting: config.conversationHosting }),
             ...(config.directTransfer === undefined ? {} : { directTransfer: config.directTransfer }),
+            ...(config.computerUse === undefined ? {} : { computerUse: config.computerUse }),
             nodeId,
             credential
         };

package/dist/service/session-lifecycle-service.js

@@ -215,6 +215,7 @@ export class SessionLifecycleService {
                 ...(input.marAgentRuntimeScopeId === undefined
                     ? {}
                     : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId }),
+                ...(input.computerUse === undefined ? {} : { computerUse: input.computerUse }),
                 ...(input.attachmentIds === undefined ? {} : { attachmentIds: input.attachmentIds })
             }));
             const nativeSessionId = await identity;

package/dist/service/session-message-service.js

@@ -160,6 +160,7 @@ export class SessionMessageService {
                         ...(input.marAgentRuntimeScopeId === undefined
                             ? {}
                             : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId }),
+                        ...(input.computerUse === undefined ? {} : { computerUse: input.computerUse }),
                         ...(missionMessage !== undefined
                             ? { mission: missionMessage.mission }
                             : isMissionRef(input.__missionRef)