@myagentroam/node 0.9.94 → 0.9.96

package/dist/computer-use-runtime-version.js

@@ -0,0 +1 @@
+export const computerUseRuntimeVersion = '0.9.95';

package/dist/computer-use-runtime.js

@@ -0,0 +1,330 @@
+import { execFile } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { access, cp, lstat, mkdir, readFile, readdir, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, relative, resolve, sep } from 'node:path';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { computerUseRuntimeExecutable, nodeDataDirectory } from './config.js';
+import { computerUseRuntimeVersion } from './computer-use-runtime-version.js';
+const manifestSchema = z
+    .object({
+    formatVersion: z.literal(1),
+    runtimeVersion: z.string().trim().min(1).max(128),
+    platform: z.enum(['win32', 'darwin', 'linux']),
+    architecture: z.enum(['x64', 'arm64']),
+    executable: z.string().trim().min(1).max(512),
+    files: z
+        .array(z
+        .object({
+        path: z.string().trim().min(1).max(512),
+        size: z.number().int().nonnegative(),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/u)
+    })
+        .strict())
+        .min(1)
+})
+    .strict();
+// Only Windows x64 and Linux x64 are published initially because maintainers do not
+// currently have native build environments for the other platform/architecture targets.
+const runtimePackages = {
+    'win32-x64': {
+        name: '@myagentroam/computer-runtime-win32-x64',
+        version: computerUseRuntimeVersion
+    },
+    'linux-x64': {
+        name: '@myagentroam/computer-runtime-linux-x64',
+        version: computerUseRuntimeVersion
+    }
+};
+const execFileAsync = promisify(execFile);
+const installLockTimeoutMs = 620_000;
+const installLockPollMs = 100;
+export class ComputerUseRuntimeError extends Error {
+    code;
+    constructor(code, options = {}) {
+        super(code, options);
+        this.code = code;
+        this.name = 'ComputerUseRuntimeError';
+    }
+}
+export class ManagedComputerUseRuntime {
+    config;
+    configPath;
+    platform;
+    architecture;
+    installRuntimePackage;
+    #ensurePromise;
+    constructor(config, configPath, platform = process.platform, architecture = process.arch, installRuntimePackage = defaultRuntimePackageInstaller) {
+        this.config = config;
+        this.configPath = configPath;
+        this.platform = platform;
+        this.architecture = architecture;
+        this.installRuntimePackage = installRuntimePackage;
+    }
+    ensure() {
+        this.#ensurePromise ??= this.#ensure().finally(() => {
+            this.#ensurePromise = undefined;
+        });
+        return this.#ensurePromise;
+    }
+    async #ensure() {
+        const config = this.config();
+        if (config === undefined)
+            throw new ComputerUseRuntimeError('NODE_CONFIG_UNAVAILABLE');
+        if (config.computerUse?.runtimeExecutable !== undefined) {
+            const executable = computerUseRuntimeExecutable(config, this.configPath, this.platform);
+            if (executable === undefined)
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MISSING');
+            await access(executable).catch((cause) => {
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MISSING', { cause });
+            });
+            return executable;
+        }
+        const runtimePackage = runtimePackages[`${this.platform}-${this.architecture}`];
+        if (runtimePackage === undefined)
+            throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_PLATFORM_UNSUPPORTED');
+        const runtimeRoot = resolve(nodeDataDirectory(config, this.configPath), 'computer-use', 'runtime');
+        await mkdir(runtimeRoot, { recursive: true });
+        const current = resolve(runtimeRoot, `${runtimePackage.version}-${this.platform}-${this.architecture}`);
+        const currentExecutable = await this.#currentExecutable(current, runtimePackage.version);
+        if (currentExecutable !== undefined)
+            return currentExecutable;
+        return this.#withInstallLock(runtimeRoot, async () => {
+            const lockedCurrent = await this.#currentExecutable(current, runtimePackage.version);
+            if (lockedCurrent !== undefined)
+                return lockedCurrent;
+            const packageStaging = resolve(runtimeRoot, `.package-${randomUUID()}`);
+            const staging = resolve(runtimeRoot, `.staging-${randomUUID()}`);
+            try {
+                const packageRoot = await this.installRuntimePackage(runtimePackage, packageStaging);
+                await this.#verifyPackageMetadata(packageRoot, runtimePackage);
+                const source = resolve(packageRoot, 'runtime');
+                const manifest = await this.#readManifest(source);
+                if (manifest.runtimeVersion !== runtimePackage.version ||
+                    manifest.platform !== this.platform ||
+                    manifest.architecture !== this.architecture)
+                    throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID');
+                await this.#verify(source, manifest);
+                await cp(source, staging, { recursive: true, errorOnExist: true, force: false });
+                await this.#verify(staging, manifest);
+                await rm(current, { recursive: true, force: true });
+                try {
+                    await rename(staging, current);
+                }
+                catch (error) {
+                    if (!(await this.#currentExecutable(current, runtimePackage.version)))
+                        throw error;
+                }
+                return resolve(current, manifest.executable);
+            }
+            catch (cause) {
+                await rm(staging, { recursive: true, force: true });
+                if (cause instanceof ComputerUseRuntimeError)
+                    throw cause;
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_INSTALL_FAILED', { cause });
+            }
+            finally {
+                await rm(packageStaging, { recursive: true, force: true });
+            }
+        });
+    }
+    async #currentExecutable(directory, runtimeVersion) {
+        try {
+            const manifest = await this.#readManifest(directory);
+            if (manifest.runtimeVersion !== runtimeVersion ||
+                manifest.platform !== this.platform ||
+                manifest.architecture !== this.architecture)
+                return undefined;
+            await this.#verify(directory, manifest);
+            return resolve(directory, manifest.executable);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async #readManifest(directory) {
+        try {
+            const path = resolve(directory, 'manifest.json');
+            if (!(await lstat(path)).isFile())
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID');
+            return manifestSchema.parse(JSON.parse(await readFile(path, 'utf8')));
+        }
+        catch (cause) {
+            if (cause instanceof ComputerUseRuntimeError)
+                throw cause;
+            throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID', { cause });
+        }
+    }
+    async #verify(directory, manifest) {
+        if (!(await lstat(directory)).isDirectory())
+            throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID');
+        const root = await realpath(directory);
+        const paths = new Set();
+        for (const file of manifest.files) {
+            const path = safeRuntimePath(directory, file.path);
+            if (paths.has(path))
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID');
+            paths.add(path);
+            const fileStat = await lstat(path).catch((cause) => {
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MISSING', { cause });
+            });
+            if (!fileStat.isFile() || !isWithin(root, await realpath(path)))
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID');
+            const bytes = await readFile(path).catch((cause) => {
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MISSING', { cause });
+            });
+            if (bytes.byteLength !== file.size ||
+                createHash('sha256').update(bytes).digest('hex') !== file.sha256)
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_INTEGRITY_FAILED');
+        }
+        const actualPaths = new Set((await regularRuntimeFiles(directory))
+            .filter((path) => relative(directory, path).split(sep).join('/') !== 'manifest.json')
+            .map((path) => resolve(path)));
+        if (actualPaths.size !== paths.size || [...actualPaths].some((path) => !paths.has(path)))
+            throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID');
+        const executable = safeRuntimePath(directory, manifest.executable);
+        if (!paths.has(executable) || !(await stat(executable)).isFile())
+            throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID');
+        if (this.platform !== 'win32')
+            await access(executable, constants.X_OK).catch((cause) => {
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_INTEGRITY_FAILED', { cause });
+            });
+    }
+    async #verifyPackageMetadata(packageRoot, runtimePackage) {
+        try {
+            const path = resolve(packageRoot, 'package.json');
+            if (!(await lstat(path)).isFile())
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_PACKAGE_INVALID');
+            const metadata = z
+                .object({ name: z.string(), version: z.string() })
+                .passthrough()
+                .parse(JSON.parse(await readFile(path, 'utf8')));
+            if (metadata.name !== runtimePackage.name || metadata.version !== runtimePackage.version)
+                throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_PACKAGE_INVALID');
+        }
+        catch (cause) {
+            if (cause instanceof ComputerUseRuntimeError)
+                throw cause;
+            throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_PACKAGE_INVALID', { cause });
+        }
+    }
+    async #withInstallLock(runtimeRoot, operation) {
+        const lock = resolve(runtimeRoot, '.install-lock');
+        const owner = resolve(lock, 'owner.json');
+        const deadline = Date.now() + installLockTimeoutMs;
+        for (;;) {
+            try {
+                await mkdir(lock);
+                await writeFile(owner, JSON.stringify({ pid: process.pid, id: randomUUID() }), {
+                    flag: 'wx'
+                });
+                break;
+            }
+            catch (cause) {
+                if (!isAlreadyExists(cause))
+                    throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_INSTALL_FAILED', { cause });
+                if (!(await lockOwnerIsAlive(owner, lock))) {
+                    await rm(lock, { recursive: true, force: true });
+                    continue;
+                }
+                if (Date.now() >= deadline)
+                    throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_INSTALL_FAILED', {
+                        cause: new Error('COMPUTER_RUNTIME_INSTALL_LOCK_TIMEOUT')
+                    });
+                await delay(installLockPollMs);
+            }
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            await rm(lock, { recursive: true, force: true });
+        }
+    }
+}
+async function defaultRuntimePackageInstaller(runtimePackage, destination) {
+    const npmRoot = dirname(createRequire(import.meta.url).resolve('npm/package.json'));
+    const npmCli = resolve(npmRoot, 'bin/npm-cli.js');
+    await mkdir(destination, { recursive: true });
+    await execFileAsync(process.execPath, [
+        npmCli,
+        'install',
+        `${runtimePackage.name}@${runtimePackage.version}`,
+        '--prefix',
+        destination,
+        '--ignore-scripts',
+        '--no-audit',
+        '--no-fund',
+        '--package-lock=false',
+        '--omit=dev',
+        '--loglevel=error'
+    ], {
+        env: { ...process.env, NPM_CONFIG_UPDATE_NOTIFIER: 'false' },
+        timeout: 600_000,
+        maxBuffer: 1024 * 1024
+    });
+    return resolve(destination, 'node_modules', '@myagentroam', runtimePackage.name.split('/')[1]);
+}
+function safeRuntimePath(root, path) {
+    const target = resolve(root, path);
+    const suffix = relative(root, target);
+    if (suffix.length === 0 ||
+        suffix === '..' ||
+        suffix.startsWith(`..${sep}`) ||
+        resolve(root, suffix) !== target)
+        throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID');
+    return target;
+}
+function isMissing(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
+}
+function isAlreadyExists(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'EEXIST');
+}
+function isWithin(root, target) {
+    const suffix = relative(root, target);
+    return suffix === '' || (suffix !== '..' && !suffix.startsWith(`..${sep}`));
+}
+async function regularRuntimeFiles(directory) {
+    const output = [];
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const path = resolve(directory, entry.name);
+        if (entry.isDirectory())
+            output.push(...(await regularRuntimeFiles(path)));
+        else if (entry.isFile())
+            output.push(path);
+        else
+            throw new ComputerUseRuntimeError('COMPUTER_RUNTIME_MANIFEST_INVALID');
+    }
+    return output;
+}
+async function lockOwnerIsAlive(ownerPath, lockPath) {
+    try {
+        const owner = z
+            .object({ pid: z.number().int().positive() })
+            .passthrough()
+            .parse(JSON.parse(await readFile(ownerPath, 'utf8')));
+        try {
+            process.kill(owner.pid, 0);
+            return true;
+        }
+        catch (cause) {
+            return !(cause instanceof Error &&
+                'code' in cause &&
+                cause.code === 'ESRCH');
+        }
+    }
+    catch {
+        try {
+            return Date.now() - (await stat(lockPath)).mtimeMs < 5_000;
+        }
+        catch {
+            return true;
+        }
+    }
+}
+function delay(milliseconds) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}

package/dist/config.js

@@ -1,6 +1,7 @@
 import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, relative, resolve, sep, win32 } from 'node:path';
+import { computerUseRuntimeVersion } from './computer-use-runtime-version.js';
 export function nodeConfigPath() {
     return resolve(process.env['MAR_NODE_CONFIG'] ?? 'data/mar-node.json');
 }
@@ -27,6 +28,7 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
         : defaultAllowedRoots();
     const conversationHosting = parseConversationHosting(input['conversationHosting']);
     const directTransfer = parseDirectTransfer(input['directTransfer']);
+    const computerUse = parseComputerUse(input['computerUse']);
     return {
         serverUrl: parsed.serverUrl,
         allowedRoots,
@@ -35,7 +37,8 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
         ...(registrationToken === undefined ? {} : { registrationToken }),
         ...(dataDirectory === undefined ? {} : { dataDirectory }),
         ...(conversationHosting === undefined ? {} : { conversationHosting }),
-        ...(directTransfer === undefined ? {} : { directTransfer })
+        ...(directTransfer === undefined ? {} : { directTransfer }),
+        ...(computerUse === undefined ? {} : { computerUse })
     };
 }
 export function directTransferUdpPortRange(config) {
@@ -57,6 +60,16 @@ export function nodeDataDirectory(config, configPath = nodeConfigPath()) {
         return resolve(dirname(configPath), config.dataDirectory);
     return resolve(dirname(configPath));
 }
+export function computerUseRuntimeExecutable(config, configPath = nodeConfigPath(), platform = process.platform, architecture = process.arch) {
+    if (config.computerUse?.enabled !== true)
+        return undefined;
+    if (config.computerUse.runtimeExecutable !== undefined)
+        return resolve(dirname(configPath), config.computerUse.runtimeExecutable);
+    const runtimeRoot = resolve(nodeDataDirectory(config, configPath), 'computer-use', 'runtime', `${computerUseRuntimeVersion}-${platform}-${architecture}`);
+    return platform === 'win32'
+        ? resolve(runtimeRoot, 'python.exe')
+        : resolve(runtimeRoot, 'bin', 'python3');
+}
 export function hostedConversationStorePath(config, configPath = nodeConfigPath()) {
     const hosting = config.conversationHosting;
     if (hosting?.enabled !== true)
@@ -129,6 +142,27 @@ function parseDirectTransfer(value) {
         udpPortRangeEnd: end
     };
 }
+function parseComputerUse(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'object' ||
+        value === null ||
+        Array.isArray(value) ||
+        typeof value['enabled'] !== 'boolean' ||
+        Object.keys(value).some((key) => key !== 'enabled' && key !== 'runtimeExecutable'))
+        throw new Error('NODE_CONFIG_INVALID');
+    const input = value;
+    const runtimeExecutable = input['runtimeExecutable'];
+    if (runtimeExecutable !== undefined &&
+        (typeof runtimeExecutable !== 'string' ||
+            runtimeExecutable.length === 0 ||
+            runtimeExecutable.trim() !== runtimeExecutable))
+        throw new Error('NODE_CONFIG_INVALID');
+    return {
+        enabled: input['enabled'],
+        ...(runtimeExecutable === undefined ? {} : { runtimeExecutable })
+    };
+}
 function validStoreDirectory(value) {
     if (typeof value !== 'string' || value.trim() !== value || value.length === 0)
         return false;

package/dist/connector.js

@@ -1,6 +1,6 @@
 import { dirname, resolve } from 'node:path';
 import { createEnvelope, directNodeCommandSchema } from '@myagentroam/protocol';
-import { hostedConversationStorePath, loadNodeConfig, directTransferUdpPortRange, nodeDataDirectory, nodeDatabasePath } from './config.js';
+import { hostedConversationStorePath, loadNodeConfig, computerUseRuntimeExecutable, directTransferUdpPortRange, nodeDataDirectory, nodeDatabasePath } from './config.js';
 import { NodeMetrics, nodeLog } from './operational.js';
 import { assertLocalSqlitePath } from './storage.js';
 import { detectCapabilitiesAsync, unavailableCapabilities } from './capabilities.js';
@@ -20,6 +20,8 @@ import { RunnerRegistry } from './runner/runner-registry.js';
 import { OpenCodeRunner } from './runner/opencode-runner.js';
 import { MarAgentRunner } from './runner/mar-agent-runner.js';
 import { MarAgentManagedRunController } from './runner/mar-agent/managed-run-controller.js';
+import { PyAutoGuiComputerUseProvider } from './runner/mar-agent/computer-use.js';
+import { ManagedComputerUseRuntime } from './computer-use-runtime.js';
 import { OpenCodeManagedRunController } from './runner/opencode/managed-run-controller.js';
 import { NodeOperationRouter } from './connector/node-operation-router.js';
 import { SkillNodeOperationService } from './service/skill-node-operation-service.js';
@@ -85,6 +87,7 @@ import { MarAgentHostedConversationRuntime } from './runner/mar-agent/hosted-con
 import { conversationHostingCapability, probeBubblewrap } from './service/conversation-hosting-capability-service.js';
 import { ConversationHostingMaintenanceService } from './service/conversation-hosting-maintenance-service.js';
 import { ConversationHostingEnablementService } from './service/conversation-hosting-enablement-service.js';
+import { ComputerUseEnablementService } from './service/computer-use-enablement-service.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';
@@ -210,6 +213,9 @@ export class NodeConnector {
     openCodeClient;
     marAgentClient;
     marAgentRunController;
+    computerUseProvider;
+    computerUseEnablement;
+    managedComputerUseRuntime;
     openCodeRunController;
     claudeRunController;
     runners;
@@ -262,7 +268,7 @@ export class NodeConnector {
     terminalManager;
     upgradeCoordinator;
     workspaceState = new WorkspaceDomainState();
-    workspaceWatchService = new WorkspaceWatchService(this.workspaceState, (workspaceId) => this.workspaceSessionService.ensureWatch(workspaceId), (workspaceId) => this.workspaceSessionService.stopWatch(workspaceId), (workspaceId) => this.workspaceWorkbenchService?.clearWorkspace(workspaceId));
+    workspaceWatchService = new WorkspaceWatchService(this.workspaceState, (workspaceId) => this.workspaceSessionService.ensureWatch(workspaceId), (workspaceId) => this.workspaceSessionService.stopWatch(workspaceId), (workspaceId) => this.workspaceWorkbenchService?.releaseWorkspace(workspaceId));
     workspaceSessionService = new WorkspaceSessionService(this.workspaceState, {
         discover: (workspaceId) => this.discoverWorkspaceSessions(workspaceId),
         listPage: (workspaceId) => this.executeNodeOperation('session.list', { workspaceId, limit: 20 }),
@@ -274,9 +280,13 @@ export class NodeConnector {
             waitMs
         })
     });
-    workspaceFileService = new WorkspaceFileService(this.workspaceState, () => this.config?.allowedRoots ?? [], (workspaceId) => this.workspaceCoordinator.invalidate(workspaceId));
+    workspaceFileService = new WorkspaceFileService(this.workspaceState, () => this.config?.allowedRoots ?? [], (workspaceId) => {
+        this.workspaceWorkbenchService?.invalidateWorkspaceFiles(workspaceId);
+        this.workspaceCoordinator.invalidate(workspaceId);
+    });
     workspaceUploadService = new WorkspaceUploadService(this.workspaceState, (workspaceId) => {
         this.workspaceFileService.dispose(workspaceId);
+        this.workspaceWorkbenchService?.invalidateWorkspaceFiles(workspaceId);
         this.workspaceCoordinator.invalidate(workspaceId);
     });
     directTransferService;
@@ -443,10 +453,10 @@ export class NodeConnector {
         const detect = options.capabilityDetector ?? detectCapabilitiesAsync;
         this.capabilityDetector = async () => {
             const capabilities = await detect();
-            return this.projectConversationHostingCapability({
+            return this.projectComputerUseCapability(await this.projectConversationHostingCapability({
                 ...capabilities,
                 metadata: upgradeMetadata(capabilities.metadata, this.upgradeCoordinator.snapshot())
-            });
+            }));
         };
         this.reconnect = options.reconnect ?? true;
         this.fakeRunner =
@@ -493,6 +503,25 @@ export class NodeConnector {
         this.openCodeClient = new OpenCodeRunner(options.openCodeClient);
         this.marAgentClient = new MarAgentRunner();
         this.marAgentClient.setGeneratedImageRegistrar((session, images) => this.runAttachmentService.registerNative(session, images));
+        this.computerUseProvider = new PyAutoGuiComputerUseProvider(() => {
+            if (this.config?.computerUse?.enabled !== true)
+                return undefined;
+            const runtimeExecutable = computerUseRuntimeExecutable(this.config, this.configPath);
+            return runtimeExecutable === undefined ? undefined : { enabled: true, runtimeExecutable };
+        });
+        this.managedComputerUseRuntime = new ManagedComputerUseRuntime(() => this.config, this.configPath);
+        this.computerUseEnablement = new ComputerUseEnablementService({
+            config: () => this.config,
+            setConfig: (config) => (this.config = config),
+            configPath: this.configPath,
+            provider: this.computerUseProvider,
+            prepareRuntime: () => this.managedComputerUseRuntime.ensure(),
+            publish: (capability) => {
+                this.capabilities = { ...this.capabilities, computerUse: capability };
+                this.send('capabilities', this.capabilities);
+            }
+        });
+        this.capabilities = this.projectComputerUseCapability(this.capabilities);
         this.marAgentRunController = new MarAgentManagedRunController(this.marAgentClient, {
             active: this.runState.active,
             adopt: (input) => this.runtime.adoptRun(input),
@@ -519,7 +548,8 @@ export class NodeConnector {
                     : this.marAgentClient.registerGeneratedImages(session, nativeSessionId, images);
             }
         }, {
-            modelFactory: this.marAgentRuntimeModels
+            modelFactory: this.marAgentRuntimeModels,
+            computerUse: this.computerUseProvider
         });
         this.marAgentClient.setSessionResourceReleaser((sessionId) => this.marAgentRunController.releaseSession(sessionId));
         this.openCodeRunController = new OpenCodeManagedRunController(this.openCodeClient, {
@@ -1173,7 +1203,10 @@ export class NodeConnector {
             metrics: this.metrics,
             heartbeatMs: HEARTBEAT_MS,
             refreshMs: CAPABILITY_REFRESH_MS,
-            onRegistered: () => this.initializeConversationHosting(),
+            onRegistered: async () => {
+                await this.initializeConversationHosting();
+                this.computerUseEnablement.initialize();
+            },
             onConnected: () => {
                 this.runtimeCredentials.connected();
                 this.recentRunProjectionService.publishSnapshot();
@@ -1213,6 +1246,7 @@ export class NodeConnector {
             listSessions: (workspaceId) => this.executeNodeOperation('session.list', { workspaceId, limit: 20 }),
             invalidate: (workspaceId) => {
                 this.workspaceFileService.dispose(workspaceId);
+                this.workspaceWorkbenchService.invalidateWorkspaceFiles(workspaceId);
                 this.workspaceCoordinator.invalidate(workspaceId);
             },
             nodeId: () => this.config?.nodeId ?? 'runtime-node',
@@ -1263,6 +1297,7 @@ export class NodeConnector {
             prepareForDisable: () => this.hostedConversationService?.prepareForDisable() ?? (() => { }),
             publishCapabilities: () => this.send('capabilities', this.capabilities)
         }).operations());
+        this.operationRouter.registerAll(this.computerUseEnablement.operations());
         this.operationRouter.registerAll(new SkillNodeOperationService(requireDatabase, () => {
             if (this.config === undefined)
                 throw new Error('NODE_CONFIG_UNAVAILABLE');
@@ -1393,6 +1428,12 @@ export class NodeConnector {
         }
         this.capabilities = await this.projectConversationHostingCapability(this.capabilities);
     }
+    projectComputerUseCapability(capabilities) {
+        return {
+            ...capabilities,
+            computerUse: this.computerUseEnablement.capability()
+        };
+    }
     async projectConversationHostingCapability(capabilities) {
         let storageReady = this.conversationHostingStorageReady;
         let storageFailureCode = this.conversationHostingFailureCode;
@@ -1422,6 +1463,7 @@ export class NodeConnector {
         this.database ??= new NodeDatabase(nodeDatabasePath(this.config, this.configPath), () => this.config?.nodeId ?? 'unregistered');
         this.database.closeRunningTerminalSessions();
         await this.initializeConversationHosting();
+        this.computerUseEnablement.initialize();
         this.directTransferService ??= this.createDirectTransferService();
         this.connectionLifecycle.start();
         this.controlChannel.connect();

package/dist/ctags-binary.js

@@ -0,0 +1,18 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const BUNDLED_CTAGS_VERSION = '6.2.1';
+const TARGETS = {
+    'linux-x64': ['linux-x64', 'ctags'],
+    'win32-x64': ['win32-x64', 'ctags.exe']
+};
+export function bundledCtagsDirectory(packageRoot) {
+    return packageRoot === undefined
+        ? resolve(dirname(fileURLToPath(import.meta.url)), '..', 'vendor/ctags')
+        : resolve(packageRoot, 'mar-node/vendor/ctags');
+}
+export function bundledCtagsPath(platform = process.platform, architecture = process.arch, packageRoot) {
+    const target = TARGETS[`${platform}-${architecture}`];
+    if (target === undefined)
+        throw new Error('CTAGS_PLATFORM_UNSUPPORTED');
+    return resolve(bundledCtagsDirectory(packageRoot), ...target);
+}