@myagentroam/node 0.11.38 → 0.11.39

package/dist/computer-use/contracts.js

@@ -0,0 +1,8 @@
+export class ComputerUseError extends Error {
+    code;
+    constructor(code, message, options = {}) {
+        super(message, options);
+        this.name = 'ComputerUseError';
+        this.code = code;
+    }
+}

package/dist/{runner/mar-agent/computer-use-indicator.js → computer-use/indicator.js}

@@ -3,7 +3,8 @@ 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 { terminateProcessTree } from '../process-tree.js';
+import { ComputerUseError } from './contracts.js';
 const START_TIMEOUT_MS = 5_000;
 const STOP_TIMEOUT_MS = 2_000;
 /** A non-activating, pointer-transparent primary-display control marker. */
@@ -11,11 +12,14 @@ export class ComputerUseControlIndicator {
     child;
     directory;
     #closed = false;
+    #closePromise;
     #lostError;
+    #exited;
     lost;
     constructor(child, directory) {
         this.child = child;
         this.directory = directory;
+        this.#exited = new Promise((resolveExit) => child.once('close', () => resolveExit()));
         this.lost = new Promise((resolveLost) => {
             child.once('exit', (code, signal) => {
                 if (this.#closed)
@@ -28,28 +32,53 @@ export class ComputerUseControlIndicator {
     static async show(runtimeExecutable) {
         const directory = await mkdtemp(resolve(tmpdir(), 'mar-computer-use-indicator-'));
         const script = resolve(directory, 'indicator.py');
-        await writeFile(script, PYTHON_INDICATOR_SOURCE, { encoding: 'utf8', mode: 0o600 });
-        const child = spawn(runtimeExecutable, ['-u', script], {
-            cwd: directory,
-            env: indicatorEnvironment(),
-            stdio: ['pipe', 'pipe', 'pipe'],
-            windowsHide: true,
-            detached: process.platform !== 'win32'
-        });
+        let child;
+        try {
+            await writeFile(script, PYTHON_INDICATOR_SOURCE, { encoding: 'utf8', mode: 0o600 });
+            child = spawn(runtimeExecutable, ['-u', script], {
+                cwd: directory,
+                env: indicatorEnvironment(),
+                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 indicator startup cleanup failed.', {
+                    cause: new AggregateError([error, cleanup])
+                });
+            }
+            throw error;
+        }
         const indicator = new ComputerUseControlIndicator(child, directory);
         try {
             await waitUntilVisible(child);
             return indicator;
         }
         catch (error) {
-            await indicator.close();
+            try {
+                await indicator.close();
+            }
+            catch (cleanup) {
+                throw new ComputerUseError('COMPUTER_CLEANUP_FAILED', 'Computer Use indicator startup and cleanup failed.', { cause: new AggregateError([error, cleanup]) });
+            }
             throw error;
         }
     }
-    async close() {
-        if (this.#closed)
-            return;
+    close() {
+        if (this.#closePromise !== undefined)
+            return this.#closePromise;
         this.#closed = true;
+        this.#closePromise = this.#close().catch((error) => {
+            throw new ComputerUseError('COMPUTER_CLEANUP_FAILED', 'Computer Use indicator cleanup failed.', { cause: error });
+        });
+        return this.#closePromise;
+    }
+    async #close() {
         this.child.stdin.end();
         if (this.child.exitCode === null && this.child.signalCode === null) {
             await terminateProcessTree(this.child).catch(() => {
@@ -60,17 +89,27 @@ export class ComputerUseControlIndicator {
                     // The process may have exited between the status check and termination.
                 }
             });
-            if (!(await waitForExit(this.child, STOP_TIMEOUT_MS))) {
-                try {
-                    this.child.kill('SIGKILL');
-                }
-                catch {
-                    // The process may have exited before the fallback signal.
-                }
-                await waitForExit(this.child, STOP_TIMEOUT_MS);
+        }
+        if (!(await this.#waitForClose(STOP_TIMEOUT_MS))) {
+            try {
+                this.child.kill('SIGKILL');
             }
+            catch {
+                // The process may have exited before the fallback signal.
+            }
+            if (!(await this.#waitForClose(STOP_TIMEOUT_MS)))
+                throw new ComputerUseError('COMPUTER_CLEANUP_FAILED', 'Computer Use indicator did not exit.');
         }
-        await rm(this.directory, { recursive: true, force: true }).catch(() => undefined);
+        await rm(this.directory, { recursive: true, force: true });
+    }
+    #waitForClose(timeoutMs) {
+        return new Promise((resolveWait) => {
+            const timer = setTimeout(() => resolveWait(false), timeoutMs);
+            void this.#exited.then(() => {
+                clearTimeout(timer);
+                resolveWait(true);
+            });
+        });
     }
     assertActive() {
         if (this.#lostError !== undefined)
@@ -79,22 +118,6 @@ export class ComputerUseControlIndicator {
             throw new Error('Computer Use control indicator is no longer active.');
     }
 }
-async function waitForExit(child, timeoutMs) {
-    if (child.exitCode !== null || child.signalCode !== null)
-        return true;
-    return await new Promise((resolveExit) => {
-        const timer = setTimeout(() => finish(false), timeoutMs);
-        const exit = () => finish(true);
-        const finish = (exited) => {
-            clearTimeout(timer);
-            child.off('exit', exit);
-            resolveExit(exited);
-        };
-        child.once('exit', exit);
-        if (child.exitCode !== null || child.signalCode !== null)
-            finish(true);
-    });
-}
 async function waitUntilVisible(child) {
     const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
     try {

package/dist/computer-use/probe.js

@@ -0,0 +1,95 @@
+import { spawn } from 'node:child_process';
+import { access } from 'node:fs/promises';
+import { terminateProcessTree } from '../process-tree.js';
+import { PYTHON_PROBE_SOURCE } from './probe-source.js';
+export async function probeComputerUse(configuration) {
+    const platform = platformName();
+    const base = {
+        platform,
+        backend: 'PYAUTOGUI',
+        runtimeExecutable: configuration.runtimeExecutable,
+        supportsScreenshot: false,
+        supportsInput: false,
+        supportsUnicodePaste: false,
+        supportsPrimaryDisplay: false
+    };
+    if (!configuration.enabled)
+        return { ...base, available: false, reasonCode: 'COMPUTER_USE_DISABLED' };
+    if (process.platform === 'linux' && (!process.env['DISPLAY'] || process.env['WAYLAND_DISPLAY']))
+        return { ...base, available: false, reasonCode: 'COMPUTER_DESKTOP_UNSUPPORTED' };
+    try {
+        await access(configuration.runtimeExecutable);
+        const result = await runProbe(configuration.runtimeExecutable);
+        if (result === undefined)
+            return { ...base, available: false, reasonCode: 'COMPUTER_RUNTIME_UNAVAILABLE' };
+        return { ...base, ...result, available: result.reasonCode === null };
+    }
+    catch {
+        return { ...base, available: false, reasonCode: 'COMPUTER_RUNTIME_UNAVAILABLE' };
+    }
+}
+async function runProbe(executable) {
+    const child = spawn(executable, ['-c', PYTHON_PROBE_SOURCE], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true
+    });
+    let stdout = '';
+    let overflow = false;
+    child.stdout.on('data', (chunk) => {
+        if (stdout.length + chunk.length > 4096)
+            overflow = true;
+        if (!overflow)
+            stdout += chunk.toString('utf8');
+    });
+    child.stderr.resume();
+    return await new Promise((resolveProbe) => {
+        const timeout = setTimeout(() => {
+            void terminateProcessTree(child).finally(() => resolveProbe(undefined));
+        }, 10_000);
+        child.once('close', (code) => {
+            clearTimeout(timeout);
+            if (code !== 0 || overflow)
+                return resolveProbe(undefined);
+            try {
+                const value = JSON.parse(stdout);
+                if (value === null ||
+                    typeof value !== 'object' ||
+                    typeof value.supportsScreenshot !== 'boolean' ||
+                    typeof value.supportsInput !== 'boolean' ||
+                    typeof value.supportsUnicodePaste !== 'boolean' ||
+                    typeof value.supportsPrimaryDisplay !== 'boolean')
+                    return resolveProbe(undefined);
+                const reasonCode = value.reasonCode === 'COMPUTER_DESKTOP_UNSUPPORTED'
+                    ? value.reasonCode
+                    : !value.supportsScreenshot || !value.supportsPrimaryDisplay
+                        ? 'COMPUTER_RUNTIME_UNAVAILABLE'
+                        : !value.supportsInput
+                            ? 'COMPUTER_INPUT_PERMISSION_DENIED'
+                            : !value.supportsUnicodePaste
+                                ? 'COMPUTER_RUNTIME_UNAVAILABLE'
+                                : null;
+                resolveProbe({
+                    supportsScreenshot: value.supportsScreenshot,
+                    supportsInput: value.supportsInput,
+                    supportsUnicodePaste: value.supportsUnicodePaste,
+                    supportsPrimaryDisplay: value.supportsPrimaryDisplay,
+                    reasonCode
+                });
+            }
+            catch {
+                resolveProbe(undefined);
+            }
+        });
+        child.once('error', () => {
+            clearTimeout(timeout);
+            resolveProbe(undefined);
+        });
+    });
+}
+function platformName() {
+    if (process.platform === 'win32')
+        return 'windows';
+    if (process.platform === 'darwin')
+        return 'macos';
+    return 'linux';
+}

package/dist/computer-use/provider.js

@@ -0,0 +1,159 @@
+import { ComputerUseError } from './contracts.js';
+import { ComputerUseControlIndicator } from './indicator.js';
+import { probeComputerUse } from './probe.js';
+import { ComputerUseDesktopLeaseService, ComputerUseSessionResources } from './session.js';
+export class ComputerUseProvider {
+    configuration;
+    #lease;
+    #probe;
+    #showControlIndicator;
+    #sessions = new Map();
+    #pendingBinds = new Map();
+    #supportKey;
+    #supportPromise;
+    #disposed = false;
+    #resetPromise;
+    #resetFailure;
+    constructor(configuration, options = {}) {
+        this.configuration = configuration;
+        this.#lease = options.lease ?? new ComputerUseDesktopLeaseService();
+        this.#probe = options.probe ?? probeComputerUse;
+        this.#showControlIndicator = options.showControlIndicator ?? ComputerUseControlIndicator.show;
+    }
+    support() {
+        const configuration = this.#configuration();
+        return configuration === undefined
+            ? probeComputerUse({ enabled: false, runtimeExecutable: '' })
+            : this.#support(configuration);
+    }
+    async bind(input) {
+        if (this.#disposed || this.#resetPromise !== undefined || this.#resetFailure !== undefined)
+            throw new ComputerUseError('COMPUTER_UNAVAILABLE', 'Computer Use provider is closed.');
+        const token = { released: false };
+        const pending = this.#pendingBinds.get(input.sessionId) ?? new Set();
+        pending.add(token);
+        this.#pendingBinds.set(input.sessionId, pending);
+        try {
+            const configuration = this.#configuration();
+            if (configuration?.enabled !== true ||
+                !input.enabled ||
+                input.mode !== 'run' ||
+                !input.modelSupportsImages)
+                return undefined;
+            const support = await this.#support(configuration);
+            if (!support.available)
+                return undefined;
+            this.#assertBindingAvailable(token);
+            let retained = this.#sessions.get(input.sessionId);
+            if (retained !== undefined &&
+                retained.runtimeExecutable !== configuration.runtimeExecutable) {
+                await this.#destroySession(input.sessionId, retained);
+                this.#assertBindingAvailable(token);
+                retained = undefined;
+            }
+            const entry = retained ?? {
+                runtimeExecutable: configuration.runtimeExecutable,
+                session: new ComputerUseSessionResources(configuration.runtimeExecutable, this.#lease, this.#showControlIndicator, async () => {
+                    const current = await this.#probe(configuration);
+                    if (!current.available)
+                        throw new ComputerUseError(current.reasonCode ?? 'COMPUTER_UNAVAILABLE', 'The interactive desktop is no longer available.');
+                })
+            };
+            if (retained === undefined)
+                this.#sessions.set(input.sessionId, entry);
+            entry.session.attach(input.runId, input.signal);
+            let closed = false;
+            let closing;
+            const close = () => {
+                if (closing !== undefined)
+                    return closing;
+                closed = true;
+                closing = entry.session.detach(input.runId);
+                return closing;
+            };
+            entry.session.setBindingClose(close);
+            return {
+                call: (executionInput, signal) => {
+                    if (closed || this.#sessions.get(input.sessionId) !== entry)
+                        return Promise.reject(new ComputerUseError('COMPUTER_UNAVAILABLE', 'Computer Use binding is closed.'));
+                    return entry.session.call(executionInput, signal);
+                },
+                wait: (waitInput, signal) => {
+                    if (closed || this.#sessions.get(input.sessionId) !== entry)
+                        return Promise.reject(new ComputerUseError('COMPUTER_UNAVAILABLE', 'Computer Use binding is closed.'));
+                    return entry.session.wait(waitInput, signal);
+                },
+                close
+            };
+        }
+        finally {
+            pending.delete(token);
+            if (pending.size === 0)
+                this.#pendingBinds.delete(input.sessionId);
+        }
+    }
+    async releaseSession(sessionId) {
+        for (const token of this.#pendingBinds.get(sessionId) ?? [])
+            token.released = true;
+        const entry = this.#sessions.get(sessionId);
+        if (entry !== undefined)
+            await this.#destroySession(sessionId, entry);
+    }
+    reset() {
+        if (this.#resetPromise !== undefined)
+            return this.#resetPromise;
+        if (this.#resetFailure !== undefined)
+            return Promise.reject(this.#resetFailure);
+        this.#supportKey = undefined;
+        this.#supportPromise = undefined;
+        for (const pending of this.#pendingBinds.values())
+            for (const token of pending)
+                token.released = true;
+        const reset = (async () => {
+            const results = await Promise.allSettled([...this.#sessions.entries()].map(([sessionId, entry]) => this.#destroySession(sessionId, entry)));
+            const failures = results.filter((result) => result.status === 'rejected');
+            if (failures.length > 0)
+                throw new ComputerUseError('COMPUTER_CLEANUP_FAILED', 'Computer Use cleanup failed.', {
+                    cause: new AggregateError(failures.map((failure) => failure.reason))
+                });
+        })();
+        this.#resetPromise = reset;
+        void reset.then(() => {
+            this.#resetPromise = undefined;
+        }, (error) => {
+            this.#resetFailure =
+                error instanceof Error
+                    ? error
+                    : new Error('Computer Use cleanup failed.', { cause: error });
+            this.#resetPromise = undefined;
+        });
+        return reset;
+    }
+    async dispose() {
+        this.#disposed = true;
+        await this.reset();
+    }
+    #configuration() {
+        return typeof this.configuration === 'function' ? this.configuration() : this.configuration;
+    }
+    #assertBindingAvailable(token) {
+        if (!this.#disposed && !token.released)
+            return;
+        throw new ComputerUseError('COMPUTER_UNAVAILABLE', 'Computer Use Session resources were released while binding.');
+    }
+    #support(configuration) {
+        const key = `${configuration.enabled}:${configuration.runtimeExecutable}`;
+        if (this.#supportKey !== key) {
+            this.#supportKey = key;
+            this.#supportPromise = this.#probe(configuration);
+        }
+        return this.#supportPromise;
+    }
+    async #destroySession(sessionId, entry) {
+        if (this.#sessions.get(sessionId) !== entry)
+            return;
+        await entry.session.close();
+        if (this.#sessions.get(sessionId) === entry)
+            this.#sessions.delete(sessionId);
+    }
+}