@myagentroam/node 0.11.37 → 0.11.39

package/dist/computer-use/worker.js

@@ -0,0 +1,321 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { terminateProcessTree } from '../process-tree.js';
+import { ComputerUseError } from './contracts.js';
+import { MAX_IMAGE_BYTES, MAX_IMAGES, PYTHON_CLEANUP_SOURCE, PYTHON_WORKER_SOURCE } from './worker-source.js';
+const MAX_TEXT_BYTES = 1024 * 1024;
+export class PythonWorker {
+    child;
+    lines;
+    directory;
+    #exited;
+    #pending = new Map();
+    #stderr = '';
+    #closed = false;
+    #closePromise;
+    #requestStarted = false;
+    constructor(child, lines, directory) {
+        this.child = child;
+        this.lines = lines;
+        this.directory = directory;
+        this.#exited = new Promise((resolveExit) => this.child.once('close', () => resolveExit()));
+        this.lines.on('line', (line) => this.#handleLine(line));
+        this.child.stderr.on('data', (chunk) => {
+            this.#stderr = boundedText(`${this.#stderr}${chunk.toString('utf8')}`);
+        });
+        this.child.once('exit', (code, signal) => {
+            const error = new ComputerUseError('COMPUTER_WORKER_EXITED', `Computer Use worker exited (${code ?? signal ?? 'unknown'}).${this.#stderr ? ` ${this.#stderr}` : ''}`);
+            for (const pending of this.#pending.values())
+                pending.reject(error);
+            this.#pending.clear();
+        });
+    }
+    get startedRequest() {
+        return this.#requestStarted;
+    }
+    static async start(runtimeExecutable, onStarting) {
+        const directory = await mkdtemp(resolve(tmpdir(), 'mar-computer-use-'));
+        const script = resolve(directory, 'worker.py');
+        let child;
+        try {
+            await writeFile(script, PYTHON_WORKER_SOURCE, { encoding: 'utf8', mode: 0o600 });
+            child = spawn(runtimeExecutable, ['-u', script], {
+                cwd: directory,
+                env: minimalWorkerEnvironment(),
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+                detached: process.platform !== 'win32'
+            });
+        }
+        catch (error) {
+            try {
+                await rm(directory, { recursive: true, force: true });
+            }
+            catch (cleanup) {
+                throw new ComputerUseError('COMPUTER_CLEANUP_FAILED', 'Computer Use worker startup cleanup failed.', {
+                    cause: new AggregateError([error, cleanup])
+                });
+            }
+            throw error;
+        }
+        const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        const worker = new PythonWorker(child, lines, directory);
+        try {
+            onStarting(worker);
+        }
+        catch (error) {
+            try {
+                await worker.close();
+            }
+            catch (cleanup) {
+                throw new ComputerUseError('COMPUTER_CLEANUP_FAILED', 'Computer Use worker handoff cleanup failed.', {
+                    cause: new AggregateError([error, cleanup])
+                });
+            }
+            throw error;
+        }
+        await waitForWorkerReady(lines, child);
+        return worker;
+    }
+    execute(code, timeoutMs, signal) {
+        this.#requestStarted = false;
+        if (this.#closed)
+            return Promise.reject(new ComputerUseError('COMPUTER_WORKER_EXITED', 'Computer Use worker is closed.'));
+        const id = randomUUID();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (callback) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                signal.removeEventListener('abort', abort);
+                this.#pending.delete(id);
+                callback();
+            };
+            const abort = () => finish(() => reject(new ComputerUseError('COMPUTER_EXECUTION_CANCELLED', 'Computer Use execution cancelled.')));
+            const timer = setTimeout(() => finish(() => reject(new ComputerUseError('COMPUTER_EXECUTION_TIMEOUT', 'Computer Use execution timed out.'))), timeoutMs);
+            if (signal.aborted) {
+                abort();
+                return;
+            }
+            this.#requestStarted = true;
+            this.#pending.set(id, {
+                resolve: (value) => finish(() => resolve(value)),
+                reject: (error) => finish(() => reject(error))
+            });
+            signal.addEventListener('abort', abort, { once: true });
+            if (signal.aborted) {
+                abort();
+                return;
+            }
+            this.child.stdin.write(`${JSON.stringify({ id, code })}\n`, (error) => {
+                if (error !== null && error !== undefined)
+                    finish(() => reject(new ComputerUseError('COMPUTER_WORKER_WRITE_FAILED', 'Worker request failed.', {
+                        cause: error
+                    })));
+            });
+        });
+    }
+    close() {
+        if (this.#closePromise !== undefined)
+            return this.#closePromise;
+        this.#closed = true;
+        this.#closePromise = (async () => {
+            this.lines.close();
+            this.child.stdin.end();
+            if (this.child.exitCode === null && this.child.signalCode === null)
+                await terminateProcessTree(this.child).catch(() => this.child.kill('SIGKILL'));
+            if (!(await this.#waitForExit(2_000))) {
+                try {
+                    if (process.platform !== 'win32' && this.child.pid !== undefined)
+                        process.kill(-this.child.pid, 'SIGKILL');
+                    else
+                        this.child.kill('SIGKILL');
+                }
+                catch {
+                    this.child.kill('SIGKILL');
+                }
+                if (!(await this.#waitForExit(2_000)))
+                    throw new ComputerUseError('COMPUTER_WORKER_EXIT_FAILED', 'Computer Use worker did not exit.');
+            }
+            if (this.child.pid !== undefined)
+                await runWorkerCleanup(this.child.spawnfile, this.directory);
+            await rm(this.directory, { recursive: true, force: true });
+        })();
+        return this.#closePromise;
+    }
+    #waitForExit(timeoutMs) {
+        return new Promise((resolveWait) => {
+            const timer = setTimeout(() => resolveWait(false), timeoutMs);
+            void this.#exited.then(() => {
+                clearTimeout(timer);
+                resolveWait(true);
+            });
+        });
+    }
+    #handleLine(line) {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            return;
+        const message = value;
+        if (message.type === 'ready')
+            return;
+        const pending = typeof message.id === 'string' ? this.#pending.get(message.id) : undefined;
+        if (pending === undefined)
+            return;
+        if (message.type === 'result') {
+            try {
+                pending.resolve({
+                    logs: Array.isArray(message.logs)
+                        ? message.logs
+                            .filter((value) => typeof value === 'string')
+                            .map((value) => boundedText(value))
+                        : [],
+                    images: parseWorkerImages(message.images)
+                });
+            }
+            catch (error) {
+                pending.reject(error);
+            }
+            return;
+        }
+        if (message.type !== 'error')
+            return;
+        pending.reject(new ComputerUseError('COMPUTER_PYTHON_FAILED', typeof message.error === 'string' ? boundedText(message.error) : 'Python execution failed.'));
+    }
+}
+function parseWorkerImages(value) {
+    if (!Array.isArray(value) || value.length > MAX_IMAGES)
+        throw new ComputerUseError('COMPUTER_IMAGE_INVALID', 'Worker returned invalid images.');
+    return value.map((candidate) => {
+        if (candidate === null ||
+            typeof candidate !== 'object' ||
+            candidate['mimeType'] !== 'image/png' ||
+            typeof candidate['dataBase64'] !== 'string')
+            throw new ComputerUseError('COMPUTER_IMAGE_INVALID', 'Worker returned an invalid image.');
+        const dataBase64 = candidate['dataBase64'];
+        if (dataBase64.length > Math.ceil((MAX_IMAGE_BYTES * 4) / 3) + 4)
+            throw new ComputerUseError('COMPUTER_IMAGE_TOO_LARGE', 'Worker image exceeds the size limit.');
+        const bytes = Buffer.from(dataBase64, 'base64');
+        if (bytes.length === 0 ||
+            bytes.length > MAX_IMAGE_BYTES ||
+            !bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+            throw new ComputerUseError('COMPUTER_IMAGE_INVALID', 'Worker returned an invalid PNG image.');
+        return { mimeType: 'image/png', dataBase64 };
+    });
+}
+async function waitForWorkerReady(lines, child) {
+    await new Promise((resolveReady, reject) => {
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(new ComputerUseError('COMPUTER_WORKER_START_FAILED', 'Worker start timed out.'));
+        }, 10_000);
+        const line = (value) => {
+            try {
+                if (JSON.parse(value).type !== 'ready')
+                    return;
+            }
+            catch {
+                return;
+            }
+            cleanup();
+            resolveReady();
+        };
+        const exit = () => {
+            cleanup();
+            reject(new ComputerUseError('COMPUTER_WORKER_START_FAILED', 'Worker exited during startup.'));
+        };
+        const failed = (error) => {
+            cleanup();
+            reject(new ComputerUseError('COMPUTER_WORKER_START_FAILED', 'Worker could not start.', {
+                cause: error
+            }));
+        };
+        const cleanup = () => {
+            clearTimeout(timeout);
+            lines.off('line', line);
+            child.off('exit', exit);
+            child.off('error', failed);
+        };
+        lines.on('line', line);
+        child.once('exit', exit);
+        child.once('error', failed);
+    });
+}
+async function runWorkerCleanup(executable, directory) {
+    const child = spawn(executable, ['-c', PYTHON_CLEANUP_SOURCE], {
+        cwd: directory,
+        env: minimalWorkerEnvironment(),
+        detached: process.platform !== 'win32',
+        stdio: 'ignore',
+        windowsHide: true
+    });
+    await new Promise((resolveCleanup, reject) => {
+        let timedOut = false;
+        let forceTimer;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            void terminateProcessTree(child).catch(() => child.kill('SIGKILL'));
+            forceTimer = setTimeout(() => {
+                child.kill('SIGKILL');
+                reject(new ComputerUseError('COMPUTER_CLEANUP_FAILED', 'Computer Use cleanup process did not exit.'));
+            }, 2_000);
+        }, 5_000);
+        const finish = (error) => {
+            clearTimeout(timer);
+            if (forceTimer !== undefined)
+                clearTimeout(forceTimer);
+            if (error !== undefined)
+                reject(error);
+            else
+                resolveCleanup();
+        };
+        child.once('close', (code) => {
+            if (timedOut || code !== 0)
+                finish(new ComputerUseError('COMPUTER_CLEANUP_FAILED', 'Computer Use cleanup process failed.'));
+            else
+                finish();
+        });
+        child.once('error', (error) => finish(new ComputerUseError('COMPUTER_CLEANUP_FAILED', 'Computer Use cleanup process could not start.', { cause: error })));
+    });
+}
+function minimalWorkerEnvironment() {
+    const keys = [
+        'PATH',
+        'SystemRoot',
+        'WINDIR',
+        'TEMP',
+        'TMP',
+        'TMPDIR',
+        'HOME',
+        'USERPROFILE',
+        'DISPLAY',
+        'XAUTHORITY',
+        'LANG',
+        'LC_ALL'
+    ];
+    const environment = {};
+    for (const key of keys) {
+        const value = process.env[key];
+        if (value !== undefined)
+            environment[key] = value;
+    }
+    return environment;
+}
+function boundedText(value) {
+    const bytes = Buffer.from(value);
+    return bytes.length <= MAX_TEXT_BYTES
+        ? value
+        : `${bytes.subarray(0, MAX_TEXT_BYTES).toString('utf8')}\n[truncated]`;
+}

package/dist/connector.js

@@ -92,6 +92,7 @@ import { probeBubblewrap } from './service/conversation-hosting-capability-servi
 import { ConversationHostingLifecycleService } from './service/conversation-hosting-lifecycle-service.js';
 import { ConversationHostingEnablementService } from './service/conversation-hosting-enablement-service.js';
 import { ComputerUseEnablementService } from './service/computer-use-enablement-service.js';
+import { NodeConfigMutations } from './service/node-config-mutations.js';
 import { safeErrorCode } from './util/safe-error.js';
 import { RuntimeCredentialControlService } from './service/runtime-credential-control-service.js';
 import { MarAgentRuntimeModelFactory } from './runner/mar-agent/runtime-model-factory.js';
@@ -256,6 +257,7 @@ export class NodeConnector {
     marAgentRunController;
     computerUseProvider;
     computerUseEnablement;
+    configMutations = new NodeConfigMutations();
     managedComputerUseRuntime;
     openCodeRunController;
     claudeRunController;
@@ -549,6 +551,7 @@ export class NodeConnector {
         });
         this.managedComputerUseRuntime = new ManagedComputerUseRuntime(() => this.config, this.configPath);
         this.computerUseEnablement = new ComputerUseEnablementService({
+            mutations: this.configMutations,
             config: () => this.config,
             setConfig: (config) => (this.config = config),
             configPath: this.configPath,
@@ -1187,7 +1190,7 @@ export class NodeConnector {
         this.controlMessages = new NodeControlMessageService({
             config: () => this.config,
             register: async (nodeId, credential, payload) => {
-                await this.connectionLifecycle.register(nodeId, credential);
+                await this.configMutations.run(() => this.connectionLifecycle.register(nodeId, credential));
                 this.mailNotificationControl.setFeatures(payload);
                 this.usageOutbox?.connected(payload);
                 for (const change of this.pendingSessionGroups.values())
@@ -1214,9 +1217,9 @@ export class NodeConnector {
             },
             connected: (payload) => {
                 this.usageOutbox?.connected(payload);
+                this.connectionLifecycle.connected();
                 for (const change of this.pendingSessionGroups.values())
                     this.send('session.group.changed', change);
-                this.connectionLifecycle.connected();
                 this.mailNotificationControl.setFeatures(payload);
             },
             close: (code, reason) => this.controlChannel.close(code, reason),
@@ -1481,6 +1484,7 @@ export class NodeConnector {
         this.operationRouter.registerAll(this.marAgentModelTransportTests.operations());
         this.operationRouter.registerAll(this.chatgptLogins.operations());
         this.operationRouter.registerAll(new ConversationHostingEnablementService({
+            mutations: this.configMutations,
             config: () => this.config,
             setConfig: (config) => (this.config = config),
             configPath: this.configPath,

package/dist/control-outbound-scheduler.js

@@ -42,6 +42,9 @@ export class ControlOutboundScheduler {
         this.scheduleExpiry();
         this.schedule();
     }
+    resume() {
+        this.schedule();
+    }
     reset() {
         this.high.length = 0;
         this.normal.length = 0;

package/dist/hosting/hosted-conversation-node-service.js

@@ -936,7 +936,7 @@ function modelSummary(model, index) {
         defaultReasoningEffort: resolveMarAgentDefaultReasoningEffort(model.defaultReasoningEffort, model.reasoningEfforts),
         titleGeneration: model.titleGeneration,
         codeMode: model.codeMode,
-        ...(model.fastMode === true ? { fastMode: true } : {}),
+        ...(model.serviceTier === undefined ? {} : { serviceTier: model.serviceTier }),
         hostedWebSearch: model.hostedWebSearch,
         ...(model.responsesTransport === undefined
             ? {}

package/dist/mcp/naming.js

@@ -14,7 +14,7 @@ export const NODE_MCP = {
         name: 'mar_notification',
         tools: { send: 'send_notification', email: 'send_email_notification' }
     },
-    computer: { name: 'mar_computer', tools: { exec: 'exec' } },
+    computer: { name: 'mar_computer', tools: { exec: 'exec', wait: 'wait' } },
     channel: { name: 'mar_channel', tools: { reply: 'reply' } }
 };
 const { version } = createRequire(import.meta.url)('../../package.json');
@@ -25,6 +25,11 @@ export const NODE_COMPUTER_TOOL_NAME = [
     NODE_MCP.computer.name,
     NODE_MCP.computer.tools.exec
 ].join('__');
+export const NODE_COMPUTER_WAIT_TOOL_NAME = [
+    'mcp',
+    NODE_MCP.computer.name,
+    NODE_MCP.computer.tools.wait
+].join('__');
 const reservedNames = new Set(Object.values(NODE_MCP).map(({ name }) => name));
 export function mcpNameAlias(value) {
     return value.replace(/[^a-zA-Z0-9_-]/gu, '_').slice(0, 64);

package/dist/runner/mar-agent/computer-use-skill.js

@@ -1,10 +1,10 @@
-import { NODE_COMPUTER_TOOL_NAME } from '../../mcp/naming.js';
+import { NODE_COMPUTER_TOOL_NAME, NODE_COMPUTER_WAIT_TOOL_NAME } from '../../mcp/naming.js';
 export const computerUseHostSkill = {
     name: 'computer-use',
     description: 'Use when the user asks to operate or verify a real desktop GUI through ' +
         NODE_COMPUTER_TOOL_NAME +
         '. Load before the first desktop action.',
-    requiredTools: [NODE_COMPUTER_TOOL_NAME],
+    requiredTools: [NODE_COMPUTER_TOOL_NAME, NODE_COMPUTER_WAIT_TOOL_NAME],
     load: async () => computerUseSkill()
 };
 export function computerUseSkill() {
@@ -25,11 +25,20 @@ Use \`${NODE_COMPUTER_TOOL_NAME}\` only for user-authorized interaction with app
 - The runtime provides \`pyautogui\`, \`time\`, \`display(image)\`, \`log(value)\`, and \`paste_text(text)\`. Use these directly; do not import or install another desktop automation stack.
 - Keep each script focused and bounded, but prefer one coherent call over several one-action calls when the sequence is deterministic. Use short waits only for expected transitions.
 - Once repeated controls and their geometry are established, batch safe repetitive interactions such as filling several known fields or placing several known items. Do not spend a separate observe-act cycle on every identical row, item, or dialog.
+- For drawing, confirm the canvas, focus, and tool, then make a small test stroke. Combine known geometry into complete strokes or bounded batches; stop and observe at visual decision points. Confirm the format and path before saving. If the user requested real GUI drawing, do not substitute a generated file for that interaction.
+- Keep PyAutoGUI's FAILSAFE enabled. Adjust input timing only when the target application needs it; if a script temporarily changes library settings, restore those settings in a finally block so the warm namespace is not polluted.
+- The desktop lease coordinates MAR callers, not human input isolation. Tell the user: do not operate the same desktop while automation is active.
 - Do not issue sleep-only calls. Wait for an expected transition inside the action that caused it, then use the Runtime's automatic final screenshot to inspect the result.
 - Use PyAutoGUI for clicks, hotkeys, control keys, and compatible ASCII typing. Use \`paste_text\` for Unicode or longer literal text.
 - Do not assume a click, keypress, or paste can be rolled back. Avoid broad destructive shortcuts unless the user explicitly requested their effect.
 - The Runtime already returns a final primary-display screenshot. Call \`display()\` only for an additional image that is materially useful; do not duplicate the automatic final screenshot.
 
+### Overlap independent work safely
+- For a long bounded script, optionally set \`yieldMs\` to return early with a \`taskId\`. Omit it to wait synchronously. Early return changes responsiveness, not mouse speed or the execution timeout.
+- While \`RUNNING\` or \`STOPPING\`, prepare coordinates or do other work that cannot affect the desktop, focus, target application, or files it is using. Do not start another desktop script, observation, or input through another tool; the desktop is not safe for concurrent human input.
+- Call \`${NODE_COMPUTER_WAIT_TOOL_NAME}\` with that taskId and \`action: "poll"\` to obtain the final result and screenshot before claiming completion. A wait timeout or interrupted wait does not stop the task. Use \`action: "cancel"\` to stop and drain it; \`STOPPING\` is not a completed cancellation.
+- Tasks belong to this Execution and are stopped when it ends. Repeated wait/cancel reads the current terminal result without replay; a newly accepted exec replaces it. After \`OUTCOME_UNKNOWN\`, observe again and never automatically replay the script.
+
 ### Verify and recover
 - Verify at decision boundaries and once after the requested result is complete. Intermediate screenshots are unnecessary when a deterministic sequence completed without an error.
 - Pass the latest \`observationId\` when acting on observed coordinates. If the observation is stale, observe again rather than guessing.