@myagentroam/node 0.13.11 → 0.13.12

package/dist/remote-desktop/x11-topology-source.js

@@ -0,0 +1,205 @@
+import { spawn } from 'node:child_process';
+import { isAbsolute } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { z } from 'zod';
+import { RemoteDesktopError } from './desktop-error.js';
+const coordinate = z.number().int().min(-0x80000000).max(0x7fffffff);
+const dimension = z.number().int().min(1).max(65535);
+const identifier = z.number().int().min(1).max(0xffffffff);
+const outputSchema = z
+    .object({
+    id: identifier,
+    name: z.string().min(1).max(256),
+    x: coordinate,
+    y: coordinate,
+    width: dimension,
+    height: dimension,
+    rotation: z.number().int().min(1).max(63),
+    transform: z.array(coordinate).length(9)
+})
+    .strict();
+const snapshotSchema = z
+    .object({
+    type: z.literal('snapshot'),
+    width: dimension,
+    height: dimension,
+    monitors: z
+        .array(z
+        .object({
+        id: identifier,
+        name: z.string().min(1).max(256),
+        primary: z.boolean(),
+        x: coordinate,
+        y: coordinate,
+        width: dimension,
+        height: dimension,
+        mmWidth: z.number().int().min(0).max(0x7fffffff),
+        mmHeight: z.number().int().min(0).max(0x7fffffff),
+        outputs: z.array(outputSchema).min(1).max(64)
+    })
+        .strict())
+        .min(1)
+        .max(64)
+})
+    .strict();
+const eventSchema = z.discriminatedUnion('type', [
+    snapshotSchema,
+    z
+        .object({
+        type: z.literal('invalidated'),
+        resetOutput: identifier.optional(),
+        resetAll: z.literal(true).optional()
+    })
+        .strict()
+]);
+const maxLineBytes = 256 * 1024;
+/** Owns one native XRandR subscription, not the X11 session or any control lease. */
+export class X11TopologySource {
+    child;
+    options;
+    #exit;
+    #initial;
+    #resolveInitial;
+    #rejectInitial;
+    #line = Buffer.alloc(0);
+    #waitingSnapshot = true;
+    #ready = false;
+    #stopping = false;
+    #failed = false;
+    #stopPromise;
+    constructor(child, options) {
+        this.child = child;
+        this.options = options;
+        this.#initial = new Promise((resolve, reject) => {
+            this.#resolveInitial = resolve;
+            this.#rejectInitial = reject;
+        });
+        this.#exit = new Promise((resolve) => child.once('close', () => {
+            this.#fail();
+            resolve();
+        }));
+        child.on('error', () => this.#fail());
+        child.stdout.on('error', () => this.#fail());
+        child.stdout.on('end', () => this.#fail());
+        child.stdout.on('close', () => this.#fail());
+        child.stdin.on('error', () => this.#fail());
+        child.stderr.resume();
+        child.stdout.on('data', (chunk) => this.#receive(chunk));
+    }
+    static async start(options, signal) {
+        if (process.platform !== 'linux' ||
+            !isAbsolute(options.binaryPath) ||
+            !isAbsolute(options.xAuthority) ||
+            !options.display ||
+            signal.aborted)
+            throw new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE');
+        let child;
+        try {
+            child = spawn(options.binaryPath, [], {
+                env: { PATH: '/usr/bin:/bin', DISPLAY: options.display, XAUTHORITY: options.xAuthority },
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+        }
+        catch {
+            throw new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE');
+        }
+        const source = new X11TopologySource(child, options);
+        const deadline = AbortSignal.any([signal, AbortSignal.timeout(10_000)]);
+        const abort = () => source.#fail();
+        deadline.addEventListener('abort', abort, { once: true });
+        if (deadline.aborted)
+            abort();
+        try {
+            await source.#initial;
+            if (source.#failed)
+                throw new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE');
+            return source;
+        }
+        catch {
+            await source.stop();
+            throw new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE');
+        }
+        finally {
+            deadline.removeEventListener('abort', abort);
+        }
+    }
+    stop() {
+        if (this.#stopPromise)
+            return this.#stopPromise;
+        this.#stopping = true;
+        this.child.stdin.end();
+        this.#stopPromise = (async () => {
+            if (await Promise.race([
+                this.#exit.then(() => false),
+                delay(5_000, undefined, { ref: false }).then(() => true)
+            ])) {
+                this.child.kill('SIGKILL');
+                if (await Promise.race([
+                    this.#exit.then(() => false),
+                    delay(5_000, undefined, { ref: false }).then(() => true)
+                ]))
+                    throw new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE');
+            }
+        })();
+        return this.#stopPromise;
+    }
+    #receive(chunk) {
+        if (this.#failed || this.#stopping)
+            return;
+        let offset = 0;
+        while (offset < chunk.length && !this.#failed && !this.#stopping) {
+            const newline = chunk.indexOf(10, offset);
+            const end = newline < 0 ? chunk.length : newline;
+            if (this.#line.length + end - offset > maxLineBytes)
+                return this.#fail();
+            this.#line = Buffer.concat([this.#line, chunk.subarray(offset, end)]);
+            if (newline < 0)
+                return;
+            try {
+                const text = new TextDecoder('utf-8', { fatal: true }).decode(this.#line);
+                const event = eventSchema.parse(JSON.parse(text));
+                this.#line = Buffer.alloc(0);
+                if (event.type === 'invalidated') {
+                    if (this.#waitingSnapshot)
+                        return this.#fail();
+                    this.#waitingSnapshot = true;
+                    this.options.onInvalidated({
+                        ...(event.resetOutput === undefined ? {} : { resetOutput: event.resetOutput }),
+                        ...(event.resetAll === undefined ? {} : { resetAll: event.resetAll })
+                    });
+                }
+                else {
+                    if (!this.#waitingSnapshot)
+                        return this.#fail();
+                    this.#waitingSnapshot = false;
+                    this.options.onSnapshot(event);
+                    if (!this.#ready) {
+                        this.#ready = true;
+                        this.#resolveInitial();
+                    }
+                }
+            }
+            catch {
+                this.#fail();
+            }
+            offset = newline + 1;
+        }
+    }
+    #fail() {
+        if (this.#failed || this.#stopping)
+            return;
+        this.#failed = true;
+        try {
+            if (!this.#ready)
+                this.#rejectInitial(new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE'));
+            else
+                this.options.onUnavailable();
+        }
+        catch {
+            // A consumer failure must not prevent the owned native process stopping.
+        }
+        finally {
+            void this.stop().catch(() => { });
+        }
+    }
+}

package/dist/remote-desktop/x11-topology.js

@@ -0,0 +1,88 @@
+import { randomUUID } from 'node:crypto';
+import { RemoteDesktopError } from './desktop-error.js';
+/** Tracks layout and display identities for one X11 session, independently of VNC processes. */
+export class X11Topology {
+    desktopGeneration;
+    #identities = new Map();
+    #revision = 0;
+    #layout;
+    constructor(desktopGeneration) {
+        this.desktopGeneration = desktopGeneration;
+        if (!desktopGeneration)
+            throw new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE');
+    }
+    /** The owner must fence attachments on every invalidation before accepting a new layout. */
+    invalidate(event) {
+        this.#layout = undefined;
+        if (event.resetAll)
+            this.#identities.clear();
+        if (event.resetOutput !== undefined) {
+            for (const [key, identity] of this.#identities) {
+                if (identity.outputs.includes(event.resetOutput))
+                    this.#identities.delete(key);
+            }
+        }
+    }
+    /** Lost subscriptions cannot prove which monitor identities survived. */
+    unavailable() {
+        this.invalidate({ resetAll: true });
+    }
+    accept(snapshot) {
+        if (this.#layout)
+            throw new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE');
+        const monitors = [...snapshot.monitors].sort((a, b) => a.id - b.id);
+        if (new Set(monitors.map((monitor) => monitor.id)).size !== monitors.length ||
+            monitors.filter((monitor) => monitor.primary).length > 1 ||
+            (monitors.length > 1 && !monitors.some((monitor) => monitor.primary)) ||
+            monitors.some((monitor) => monitor.x < 0 ||
+                monitor.y < 0 ||
+                monitor.x + monitor.width > snapshot.width ||
+                monitor.y + monitor.height > snapshot.height ||
+                new Set(monitor.outputs.map((output) => output.id)).size !== monitor.outputs.length))
+            throw new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE');
+        const active = new Set(monitors.map((monitor) => monitor.id));
+        for (const key of this.#identities.keys())
+            if (!active.has(key))
+                this.#identities.delete(key);
+        const displays = monitors.map((monitor) => {
+            const outputs = monitor.outputs.map((output) => output.id).sort((a, b) => a - b);
+            let identity = this.#identities.get(monitor.id);
+            if (!identity ||
+                identity.outputs.length !== outputs.length ||
+                identity.outputs.some((output, index) => output !== outputs[index])) {
+                identity = { displayId: randomUUID(), outputs };
+                this.#identities.set(monitor.id, identity);
+            }
+            const bounds = { x: monitor.x, y: monitor.y, width: monitor.width, height: monitor.height };
+            return {
+                displayId: identity.displayId,
+                name: monitor.name,
+                primary: monitor.primary || monitors.length === 1,
+                nativeBounds: bounds,
+                framebufferBounds: { ...bounds },
+                nativeToFramebuffer: [1, 0, 0, 1, 0, 0]
+            };
+        });
+        // A notification may hide a transient change even when the new snapshot
+        // matches the old one. Never let grants from before that fence revive.
+        this.#revision++;
+        this.#layout = {
+            desktopGeneration: this.desktopGeneration,
+            topologyRevision: this.#revision,
+            framebuffer: { width: snapshot.width, height: snapshot.height },
+            displays
+        };
+        return structuredClone(this.#layout);
+    }
+    describe() {
+        if (!this.#layout)
+            throw new RemoteDesktopError('DESKTOP_TOPOLOGY_UNAVAILABLE');
+        return structuredClone(this.#layout);
+    }
+    /** A mismatch must end the attachment, never adapt input using stale geometry. */
+    matchesFramebuffer(width, height) {
+        return (!!this.#layout &&
+            this.#layout.framebuffer.width === width &&
+            this.#layout.framebuffer.height === height);
+    }
+}

package/dist/ripgrep-binary.js

@@ -1,5 +1,6 @@
 import { dirname, resolve } from 'node:path';
 import { createRequire } from 'node:module';
+import { managedBinariesPlatformDirectory } from './managed-binaries.js';
 export const BUNDLED_RIPGREP_VERSION = '15.1.0';
 const TARGETS = {
     'linux-x64': ['linux-x64', 'rg'],
@@ -18,7 +19,10 @@ export function bundledRipgrepPath(platform = process.platform, architecture = p
     const target = TARGETS[`${platform}-${architecture}`];
     if (target === undefined)
         throw new Error('RIPGREP_PLATFORM_UNSUPPORTED');
-    return resolve(bundledRipgrepDirectory(packageRoot), ...target);
+    const directory = packageRoot === undefined
+        ? resolve(managedBinariesPlatformDirectory(platform, architecture), 'vendor/ripgrep')
+        : bundledRipgrepDirectory(packageRoot);
+    return resolve(directory, ...target);
 }
 export function prependBundledRipgrepToPath(environment, executable, platform = process.platform) {
     const key = platform === 'win32' ? 'Path' : 'PATH';

package/dist/service/node-control-channel.js

@@ -7,6 +7,7 @@ const MAX_PREAUTH_BYTES = 8 * 1024 * 1024;
 export class NodeControlChannel {
     options;
     socket;
+    inboundMuted = false;
     authenticated = false;
     preauthFrames = 0;
     preauthBytes = 0;
@@ -25,6 +26,7 @@ export class NodeControlChannel {
                     this.socket.readyState === WebSocket.CONNECTING)))
             return;
         this.options.onConnecting(this.attempts);
+        this.inboundMuted = false;
         const socket = new WebSocket(nodeConnectEndpoint(config.serverUrl));
         this.socket = socket;
         socket.once('open', () => {
@@ -40,7 +42,7 @@ export class NodeControlChannel {
                 socket.close(4000, 'NODE_CREDENTIAL_MISSING');
         });
         socket.on('message', (raw) => {
-            if (this.socket === socket)
+            if (this.socket === socket && !this.inboundMuted)
                 this.options.onMessage(raw.toString());
         });
         socket.once('close', (code, reason) => {
@@ -61,6 +63,10 @@ export class NodeControlChannel {
     connected() {
         return this.authenticated && this.socket?.readyState === WebSocket.OPEN;
     }
+    /** Stop admitting new work while allowing final owned cleanup events to be sent. */
+    muteInbound() {
+        this.inboundMuted = true;
+    }
     connection() {
         return this.socket;
     }

package/dist/service/node-control-message-service.js

@@ -55,6 +55,17 @@ export class NodeControlMessageService {
         if (envelope.type.startsWith('terminal.direct.') &&
             this.options.handleTerminalDirect?.(envelope) === true)
             return;
+        if (envelope.type === 'desktop.ready') {
+            if (this.options.handleDesktopDirect?.(envelope) !== true)
+                this.options.handleDesktopRelay?.(envelope);
+            return;
+        }
+        if (envelope.type.startsWith('desktop.direct.') &&
+            this.options.handleDesktopDirect?.(envelope) === true)
+            return;
+        if (envelope.type.startsWith('desktop.relay.') &&
+            this.options.handleDesktopRelay?.(envelope) === true)
+            return;
         if (envelope.type === 'usage.ack') {
             this.options.usageAck?.(envelope.payload);
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.13.11",
+  "version": "0.13.12",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/myagentroam/mar.git",
@@ -37,7 +37,7 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.233",
     "@modelcontextprotocol/sdk": "1.32.0",
-    "@myagentroam/binaries": "0.10.2",
+    "@myagentroam/binaries": "0.10.3",
     "@opencode-ai/sdk": "1.18.20",
     "minimatch": "^10.2.6",
     "node-datachannel": "0.33.4",
@@ -49,14 +49,14 @@
     "turndown-plugin-gfm": "^1.0.2",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.13.11",
-    "@myagentroam/protocol": "0.13.11"
+    "@myagentroam/agent": "0.13.12",
+    "@myagentroam/protocol": "0.13.12"
   },
   "devDependencies": {
     "@types/turndown": "^5.0.6",
     "@types/ws": "^8.18.1",
-    "@myagentroam/marctl": "0.13.11",
-    "@myagentroam/code-navigation": "0.11.1"
+    "@myagentroam/code-navigation": "0.11.1",
+    "@myagentroam/marctl": "0.13.12"
   },
   "exports": {
     "./config": {