@rome-os/node-core 0.1.1 → 0.1.2

package/README.md

@@ -27,6 +27,18 @@ const result = await client.run("device-id", "exec", {
   args: ["status"],
   cwd: "/workspace",
 });
+const { response, body } = await client.runBinary(
+  "device-id",
+  "exec",
+  { command: "gzip", args: ["-c"] },
+  input,
+);
+const copied = await client.copy({
+  direction: "push",
+  localPath: "/data/video.mp4",
+  deviceId: "device-id",
+  remotePath: "/tmp/video.mp4",
+});
 client.disconnect();
 ```
 
@@ -36,6 +48,27 @@ Gateway connection. `connection` describes the caller connection to Gateway,
 not the online state of remote devices. `listDevices()` returns authorized
 devices without asserting that they are online.
 
+`runBinary(deviceId, action, args?, body?)` resolves to `{ response, body }`.
+It sends `body` as input bytes in a binary frame. For `exec`, the input is the
+program's stdin and the reply `body` is its raw stdout. Neither side is JSON or
+base64 encoded. `response` is the same `ActionResponse` as `run()`, and the exec
+result has no `stdout` field. Failures have an empty `body`. The device ID must
+be a UUID. The request must fit in one 32 MiB Gateway frame, header and meta
+included. Larger input fails with `message_too_large` before anything is sent.
+Output that cannot fit fails with `output_too_large` after the program ran.
+A host version without binary frame support
+does not reply, and the call returns `unknown_outcome` after the wait limit.
+See [binary frames](../../docs/rome-node.md#binary-frames).
+
+`copy({ direction, localPath, deviceId, remotePath }, { onProgress? })` copies
+one file between the daemon's computer and a device. `direction` is `push` or
+`pull`, and `localPath` must be absolute. It resolves to `{ bytes, ms, sha256 }`
+after both sides verified the size and checksum. It throws `DeviceActionError`
+otherwise, and the destination stays unchanged. `onProgress` receives
+`{ bytes, total }` about four times per second. The copy has no total time limit
+and aborts after 60 seconds without progress or when the client disconnects.
+See [copying files](../../docs/rome-node.md#copying-files).
+
 `getDevicesStatus()` checks device reachability through read-only `system.info`
 requests through an existing daemon and returns `{ connection, checkedAt, devices }`.
 It returns `null` when no daemon runs and never starts or restarts one. Each device has
@@ -144,7 +177,8 @@ where `expiresIn` is in seconds. It returns a `DeviceSession` after approval and
 rejects on denial, expiry, cancellation, or a terminal error. It opens no browser
 or callback listener. The callback receives neither the device code nor the access token.
 
-The host exposes `system.info` and `exec`. Programs run as the application's OS
+The host exposes `system.info` and `exec`, in text envelopes and in binary frames.
+It also accepts the internal file transfers that `copy()` uses. Programs run as the application's OS
 user. Connection loss terminates direct child processes on a best-effort basis.
 A local caller timeout does not cancel remote execution.
 

package/dist/actions.d.ts

@@ -15,6 +15,10 @@ export type ActionResponse = {
         message: string;
     };
 };
+export interface BinaryActionResult {
+    response: ActionResponse;
+    body: Uint8Array;
+}
 export declare function actionError(code: string, message: string): ActionResponse;
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function parseResponse(value: unknown): ActionResponse | null;

package/dist/client.d.ts

@@ -1,7 +1,8 @@
+import { type Frame } from "./frame.js";
 import { type GatewayMessage, type OutboundEnvelope } from "./protocol.js";
 export interface ClientSocket {
     readyState: number;
-    send(data: string): void;
+    send(data: string | Uint8Array): void;
     close(code?: number, reason?: string): void;
     addEventListener(type: "open", listener: () => void): void;
     addEventListener(type: "message", listener: (event: {
@@ -18,11 +19,13 @@ export interface GatewayClientOptions {
     deviceToken: string;
     createSocket(url: string, authorization: string): ClientSocket;
     onMessage(message: GatewayMessage): void;
+    onFrame?(frame: Frame): void;
     onStatus?(status: ConnectionStatus): void;
     random?(): number;
     beforeConnect?(): Promise<string | null>;
 }
 export declare function connectGateway(options: GatewayClientOptions): {
     send(envelope: OutboundEnvelope): boolean;
+    sendFrame(frame: Frame): boolean;
     stop(): void;
 };

package/dist/client.js

@@ -1,3 +1,4 @@
+import { encodeFrame, FRAME_TYPE, frameFits, isUuid, parseFrame } from "./frame.js";
 import { parseGatewayUrl } from "./gateway-url.js";
 import { CLOSE, gatewayMessage, outboundEnvelope, } from "./protocol.js";
 export function connectGateway(options) {
@@ -76,8 +77,19 @@ export function connectGateway(options) {
             status("online");
         });
         current.addEventListener("message", ({ data }) => {
-            if (stopped || socket !== current || typeof data !== "string")
+            if (stopped || socket !== current)
                 return;
+            if (typeof data !== "string") {
+                const bytes = data instanceof Uint8Array
+                    ? data
+                    : data instanceof ArrayBuffer
+                        ? new Uint8Array(data)
+                        : null;
+                const frame = bytes && parseFrame(bytes);
+                if (frame)
+                    options.onFrame?.(frame);
+                return;
+            }
             let message;
             try {
                 message = gatewayMessage(JSON.parse(data));
@@ -116,6 +128,23 @@ export function connectGateway(options) {
                 return false;
             }
         },
+        sendFrame(frame) {
+            if (stopped || !socket || socket.readyState !== 1)
+                return false;
+            if (!frameFits(frame.meta.byteLength, frame.body.byteLength))
+                return false;
+            if (frame.type !== FRAME_TYPE.request && frame.type !== FRAME_TYPE.response)
+                return false;
+            if (!isUuid(frame.id) || !isUuid(frame.peer))
+                return false;
+            try {
+                socket.send(encodeFrame(frame));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
         stop() {
             stopped = true;
             clearTimeout(timer);

package/dist/connect.js

@@ -59,9 +59,7 @@ export async function connectHost(options) {
     const active = session;
     options.onEvent?.({ type: "device", name: active.name, deviceId: active.deviceId });
     await new Promise((resolve, reject) => {
-        const executor = createExecutor(active.name, (message) => connection.send(message), [
-            active.token,
-        ]);
+        const executor = createExecutor(active.name, (message) => connection.send(message), [active.token], (frame) => connection.sendFrame(frame));
         let finished = false;
         const finish = (error) => {
             if (finished)
@@ -94,6 +92,7 @@ export async function connectHost(options) {
                 if ("from" in message)
                     void executor.receive(message);
             },
+            onFrame: (frame) => void executor.receiveFrame(frame),
             onStatus: (status) => {
                 options.onEvent?.({ type: "connection", status });
                 if (status !== "online" && status !== "connecting")

package/dist/connector.d.ts

@@ -1,6 +1,7 @@
-import { type ActionResponse } from "./actions.js";
+import { type ActionResponse, type BinaryActionResult } from "./actions.js";
 import { connectGateway, type ConnectionStatus } from "./client.js";
 import type { CallerCredential } from "./local.js";
+import type { ChannelEvents, TransferChannel } from "./transfer.js";
 export interface DeviceConnectorOptions {
     credential: CallerCredential;
     connect?: typeof connectGateway;
@@ -15,12 +16,20 @@ export declare class DeviceConnector {
     private stopped;
     private pending;
     private ready;
+    private channels;
     constructor(options: DeviceConnectorOptions);
     getStatus(): ConnectionStatus;
     private ensure;
     private initialize;
     list(): Promise<unknown>;
     private receive;
+    private receiveFrame;
+    private admit;
+    private full;
     run(target: string, action: string, args: unknown, waitMs?: number): Promise<ActionResponse>;
+    runBinary(target: string, action: string, args: unknown, body: Uint8Array, waitMs?: number): Promise<BinaryActionResult>;
+    openChannel(target: string, events: ChannelEvents): Promise<(TransferChannel & {
+        id: string;
+    }) | ActionResponse>;
     stop(): void;
 }

package/dist/connector.js

@@ -2,8 +2,10 @@ import { randomUUID } from "node:crypto";
 import { actionError, isRecord, parseResponse, } from "./actions.js";
 import { connectGateway } from "./client.js";
 import { cloudRequest, CloudError, gatewayConfig } from "./cloud.js";
+import { decodeMeta, encodeMeta, FRAME_TYPE, frameFits, isUuid, MAX_FRAME_BYTES, } from "./frame.js";
 import { validId } from "./protocol.js";
 import { createNodeSocket } from "./socket.js";
+const MAX_PENDING = 128;
 export class DeviceConnector {
     options;
     connection;
@@ -12,6 +14,7 @@ export class DeviceConnector {
     stopped = false;
     pending = new Map();
     ready = new Set();
+    channels = new Map();
     constructor(options) {
         this.options = options;
     }
@@ -53,12 +56,15 @@ export class DeviceConnector {
                 }
             },
             onMessage: (message) => this.receive(message),
+            onFrame: (frame) => this.receiveFrame(frame),
             onStatus: (status) => {
                 this.status = status;
                 this.options.onStatus?.(status);
                 if (status !== "online") {
                     for (const pending of this.pending.values())
                         pending.finish(actionError("unknown_outcome", "The connection was lost. Execution may have occurred. Do not automatically retry."));
+                    for (const channel of [...this.channels.values()])
+                        channel.events.lost();
                 }
                 for (const wake of this.ready)
                     wake();
@@ -76,7 +82,7 @@ export class DeviceConnector {
     }
     receive(message) {
         const pending = this.pending.get(message.id);
-        if (!pending)
+        if (!pending || pending.binary)
             return;
         if ("type" in message) {
             pending.finish(actionError(message.code, "The Gateway could not forward the request."));
@@ -88,9 +94,34 @@ export class DeviceConnector {
         if (response)
             pending.finish(response);
     }
-    async run(target, action, args, waitMs = this.options.waitMs ?? 60_000) {
-        if (!validId(target) || !action || action.length > 128)
-            return actionError("invalid_request", "A device ID and action are required.");
+    receiveFrame(frame) {
+        const channel = this.channels.get(frame.id);
+        if (channel) {
+            if (frame.peer !== channel.target)
+                return;
+            if (frame.type === FRAME_TYPE.response)
+                channel.events.frame(decodeMeta(frame.meta), frame.body);
+            else if (frame.type === FRAME_TYPE.routeError) {
+                const meta = decodeMeta(frame.meta);
+                channel.events.frame(actionError(isRecord(meta) && typeof meta.code === "string" ? meta.code : "target_unavailable", "The Gateway could not forward the request."), new Uint8Array());
+            }
+            return;
+        }
+        const pending = this.pending.get(frame.id);
+        if (!pending?.binary || frame.peer !== pending.target)
+            return;
+        if (frame.type === FRAME_TYPE.routeError) {
+            const meta = decodeMeta(frame.meta);
+            pending.finish(actionError(isRecord(meta) && typeof meta.code === "string" ? meta.code : "target_unavailable", "The Gateway could not forward the request."));
+            return;
+        }
+        if (frame.type !== FRAME_TYPE.response)
+            return;
+        const response = parseResponse(decodeMeta(frame.meta));
+        if (response)
+            pending.finish(response, frame.body);
+    }
+    async admit() {
         try {
             await this.ensure();
         }
@@ -114,8 +145,19 @@ export class DeviceConnector {
             });
         if (this.status !== "online")
             return actionError("gateway_unavailable", "The device connection is offline. No operation was sent.");
-        if (this.pending.size >= 128)
-            return actionError("busy", "Too many device requests are pending.");
+        return null;
+    }
+    full() {
+        return this.pending.size + this.channels.size >= MAX_PENDING
+            ? actionError("busy", "Too many device requests are pending.")
+            : null;
+    }
+    async run(target, action, args, waitMs = this.options.waitMs ?? 60_000) {
+        if (!validId(target) || !action || action.length > 128)
+            return actionError("invalid_request", "A device ID and action are required.");
+        const refused = await this.admit();
+        if (refused)
+            return refused;
         const id = randomUUID();
         const envelope = {
             id,
@@ -128,6 +170,9 @@ export class DeviceConnector {
         catch {
             return actionError("invalid_request", "Action arguments must be JSON.");
         }
+        const busy = this.full();
+        if (busy)
+            return busy;
         return new Promise((resolve) => {
             const finish = (response) => {
                 clearTimeout(timer);
@@ -135,11 +180,88 @@ export class DeviceConnector {
                 resolve(response);
             };
             const timer = setTimeout(() => finish(actionError("unknown_outcome", "The local wait limit was reached. The remote program was not canceled. Do not automatically retry.")), waitMs);
-            this.pending.set(id, { target, finish });
+            this.pending.set(id, { target, binary: false, finish });
             if (!this.connection?.send(envelope))
                 finish(actionError("unknown_outcome", "The request could not be submitted reliably. Do not automatically retry."));
         });
     }
+    async runBinary(target, action, args, body, waitMs = this.options.waitMs ?? 60_000) {
+        const empty = new Uint8Array();
+        if (!isUuid(target) || !action || action.length > 128)
+            return {
+                response: actionError("invalid_request", "A device UUID and action are required."),
+                body: empty,
+            };
+        let meta;
+        try {
+            meta = encodeMeta({ type: "request", action, args });
+        }
+        catch {
+            return {
+                response: actionError("invalid_request", "Action arguments must be JSON."),
+                body: empty,
+            };
+        }
+        if (!frameFits(meta.byteLength, body.byteLength))
+            return {
+                response: actionError("message_too_large", `The input does not fit in one ${MAX_FRAME_BYTES / 1024 / 1024} MiB frame. Nothing was sent. Use rome-node cp for large files.`),
+                body: empty,
+            };
+        const refused = await this.admit();
+        if (refused)
+            return { response: refused, body: empty };
+        const busy = this.full();
+        if (busy)
+            return { response: busy, body: empty };
+        const id = randomUUID();
+        const peer = target.toLowerCase();
+        return new Promise((resolve) => {
+            const finish = (response, output = empty) => {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                resolve({ response, body: response.ok ? output : empty });
+            };
+            const timer = setTimeout(() => finish(actionError("unknown_outcome", "The local wait limit was reached. The remote program was not canceled. Do not automatically retry.")), waitMs);
+            this.pending.set(id, { target: peer, binary: true, finish });
+            if (!this.connection?.sendFrame({ type: FRAME_TYPE.request, id, peer, meta, body }))
+                finish(actionError("unknown_outcome", "The request could not be submitted reliably. Do not automatically retry."));
+        });
+    }
+    async openChannel(target, events) {
+        if (!isUuid(target))
+            return actionError("invalid_request", "A device UUID is required.");
+        const refused = await this.admit();
+        if (refused)
+            return refused;
+        const busy = this.full();
+        if (busy)
+            return busy;
+        const id = randomUUID();
+        const peer = target.toLowerCase();
+        this.channels.set(id, { target: peer, events });
+        return {
+            id,
+            send: (meta, body = new Uint8Array()) => {
+                if (!this.channels.has(id))
+                    return false;
+                try {
+                    return (this.connection?.sendFrame({
+                        type: FRAME_TYPE.request,
+                        id,
+                        peer,
+                        meta: encodeMeta(meta),
+                        body,
+                    }) ?? false);
+                }
+                catch {
+                    return false;
+                }
+            },
+            close: () => {
+                this.channels.delete(id);
+            },
+        };
+    }
     stop() {
         this.stopped = true;
         this.status = "stopped";

package/dist/daemon-client.d.ts

@@ -1,13 +1,13 @@
 import type { DevicesStatus } from "./devices-status.js";
-import { type ActionResponse } from "./actions.js";
-import { type DaemonStatus, type ConnectionEvent } from "./daemon-protocol.js";
+import { type ActionResponse, type BinaryActionResult } from "./actions.js";
+import { type DaemonStatus, type ConnectionEvent, type CopyProgress, type CopyRequest, type CopySummary } from "./daemon-protocol.js";
 import type { NodeConfig } from "./local.js";
 export { createNodeConfig, nodeConfigFromEnvironment, readOptionalCallerCredential, CallerConfigurationError, type NodeConfig, type CallerCredential, } from "./local.js";
 export { daemonStatus, startDaemon, stopDaemon } from "./daemon-control.js";
 export { DaemonRequestError, DaemonVersionError } from "./daemon-rpc.js";
-export type { DaemonStatus, ConnectionEvent } from "./daemon-protocol.js";
+export type { DaemonStatus, ConnectionEvent, CopyProgress, CopyRequest, CopySummary, } from "./daemon-protocol.js";
 export type { DevicesStatus, DeviceStatus } from "./devices-status.js";
-export type { ActionResponse } from "./actions.js";
+export type { ActionResponse, BinaryActionResult } from "./actions.js";
 export declare class DeviceActionError extends Error {
     readonly response: Extract<ActionResponse, {
         ok: false;
@@ -31,6 +31,10 @@ export declare function createNodeClient(config: NodeConfig, options?: NodeClien
     getDevicesStatus(): Promise<DevicesStatus | null>;
     listDevices(): Promise<DeviceList>;
     run: (deviceId: string, action: string, args?: unknown) => Promise<ActionResponse>;
+    runBinary: (deviceId: string, action: string, args?: unknown, body?: Uint8Array) => Promise<BinaryActionResult>;
+    copy: (request: CopyRequest, options?: {
+        onProgress?(progress: CopyProgress): void;
+    }) => Promise<CopySummary>;
     describe: (deviceId: string) => Promise<ActionResponse>;
     subscribe(topic: "connection", listener: (event: ConnectionEvent) => void): Promise<() => Promise<void>>;
     disconnect(): void;

package/dist/daemon-client.js

@@ -1,6 +1,8 @@
-import { actionError, isRecord, parseResponse } from "./actions.js";
+import { actionError, isRecord, parseResponse, } from "./actions.js";
 import { validId } from "./protocol.js";
-import { parseDaemonStatus } from "./daemon-protocol.js";
+import { encodeMeta, frameFits, isUuid, MAX_FRAME_BYTES } from "./frame.js";
+import { parseDaemonStatus, } from "./daemon-protocol.js";
+import { isAbsolute } from "node:path";
 import { DaemonRequestError, DaemonVersionError, RpcError, } from "./daemon-rpc.js";
 import { ensureDaemon, findDaemon } from "./daemon-control.js";
 export { createNodeConfig, nodeConfigFromEnvironment, readOptionalCallerCredential, CallerConfigurationError, } from "./local.js";
@@ -143,6 +145,86 @@ export function createNodeClient(config, options = {}) {
             throw error;
         }
     }
+    async function runBinary(deviceId, action, args = {}, body = new Uint8Array()) {
+        assertOpen();
+        const empty = new Uint8Array();
+        const failure = (code, message) => ({
+            response: actionError(code, message),
+            body: empty,
+        });
+        if (!isUuid(deviceId) || typeof action !== "string" || !action || action.length > 128)
+            return failure("invalid_request", "A device UUID and action are required.");
+        let params;
+        try {
+            params = JSON.parse(JSON.stringify({ deviceId, action, args }));
+        }
+        catch {
+            return failure("invalid_request", "Action arguments must be JSON.");
+        }
+        const meta = encodeMeta({ type: "request", action, args: params.args ?? {} });
+        if (!frameFits(meta.byteLength, body.byteLength))
+            return failure("message_too_large", `The input does not fit in one ${MAX_FRAME_BYTES / 1024 / 1024} MiB frame. Nothing was sent. Use rome-node cp for large files.`);
+        try {
+            const rpc = await connect(true);
+            assertOpen();
+            if (!rpc)
+                throw new DaemonRequestError();
+            const reply = await rpc.requestBinary("devices.runBinary", params, body);
+            const response = parseResponse(reply.result);
+            if (!response)
+                return failure("unknown_outcome", "The action response was invalid. Do not automatically retry.");
+            return { response, body: response.ok ? reply.body : empty };
+        }
+        catch (error) {
+            if (error instanceof DaemonRequestError)
+                return failure(error.code, error.message);
+            if (error instanceof RpcError)
+                return failure(error.code === -32602 ? "invalid_request" : "gateway_unavailable", error.message);
+            throw error;
+        }
+    }
+    async function copy(request, options = {}) {
+        assertOpen();
+        const failure = (code, message) => new DeviceActionError({ type: "response", ok: false, error: { code, message } });
+        if ((request.direction !== "push" && request.direction !== "pull") ||
+            typeof request.localPath !== "string" ||
+            !isAbsolute(request.localPath) ||
+            !isUuid(request.deviceId) ||
+            typeof request.remotePath !== "string" ||
+            !request.remotePath)
+            throw failure("invalid_request", "A copy needs direction push or pull, an absolute localPath, a device UUID, and remotePath.");
+        const { direction, localPath, deviceId, remotePath } = request;
+        let value;
+        try {
+            const rpc = await connect(true);
+            assertOpen();
+            if (!rpc)
+                throw new DaemonRequestError();
+            value = await rpc.request("files.copy", { direction, localPath, deviceId, remotePath }, Number.POSITIVE_INFINITY, (params) => {
+                if (typeof params.bytes === "number" && typeof params.total === "number")
+                    options.onProgress?.({ bytes: params.bytes, total: params.total });
+            });
+        }
+        catch (error) {
+            if (error instanceof DaemonRequestError)
+                throw failure(error.code, error.message);
+            if (error instanceof RpcError)
+                throw failure(error.code === -32602 ? "invalid_request" : "gateway_unavailable", error.message);
+            throw error;
+        }
+        const response = parseResponse(value);
+        if (!response)
+            throw failure("unknown_outcome", "The copy response was invalid. Run the copy again.");
+        if (!response.ok)
+            throw new DeviceActionError(response);
+        const summary = response.result;
+        if (!isRecord(summary) ||
+            typeof summary.bytes !== "number" ||
+            typeof summary.ms !== "number" ||
+            typeof summary.sha256 !== "string")
+            throw failure("unknown_outcome", "The copy response was invalid. Run the copy again.");
+        return { bytes: summary.bytes, ms: summary.ms, sha256: summary.sha256 };
+    }
     return {
         async getConnectionStatus() {
             const rpc = await connect(false);
@@ -199,6 +281,8 @@ export function createNodeClient(config, options = {}) {
             return body;
         },
         run,
+        runBinary,
+        copy,
         describe: (deviceId) => run(deviceId, "system.info"),
         async subscribe(topic, listener) {
             assertOpen();

package/dist/daemon-control.js

@@ -117,8 +117,19 @@ export async function stopDaemon(config) {
         if (legacy?.pid === state.pid) {
             await legacyRequest(state, "/stop");
         }
-        else
-            return;
+        else {
+            const older = typeof state.protocolVersion === "number"
+                ? await connectRpc(state, undefined, state.protocolVersion).catch(() => null)
+                : null;
+            if (!older)
+                return;
+            try {
+                await older.rpc.request("daemon.stop", {}, 5000);
+            }
+            finally {
+                older.rpc.close();
+            }
+        }
     }
     else {
         const found = await findDaemon(config);

package/dist/daemon-protocol.d.ts

@@ -1,5 +1,6 @@
 import type { ConnectionStatus } from "./client.js";
-export declare const DAEMON_PROTOCOL_VERSION = 2;
+export declare const DAEMON_PROTOCOL_VERSION = 3;
+export declare const MAX_LOCAL_MESSAGE_BYTES: number;
 export interface DaemonStatus {
     pid: number;
     protocolVersion: number;
@@ -14,3 +15,23 @@ export type ConnectionEvent = {
     daemon: null;
     reason: "connection_lost" | "incompatible";
 };
+export declare function encodeBinaryMessage(message: unknown, body: Uint8Array): Buffer;
+export declare function parseBinaryMessage(data: Buffer): {
+    message: unknown;
+    body: Uint8Array;
+} | null;
+export interface CopyRequest {
+    direction: "push" | "pull";
+    localPath: string;
+    deviceId: string;
+    remotePath: string;
+}
+export interface CopySummary {
+    bytes: number;
+    ms: number;
+    sha256: string;
+}
+export interface CopyProgress {
+    bytes: number;
+    total: number;
+}

package/dist/daemon-protocol.js

@@ -1,5 +1,6 @@
 import { isRecord } from "./actions.js";
-export const DAEMON_PROTOCOL_VERSION = 2;
+export const DAEMON_PROTOCOL_VERSION = 3;
+export const MAX_LOCAL_MESSAGE_BYTES = 64 * 1024 * 1024;
 export function parseDaemonStatus(value) {
     if (!isRecord(value) ||
         !Number.isSafeInteger(value.pid) ||
@@ -13,3 +14,23 @@ export function parseDaemonStatus(value) {
         connection: value.connection,
     };
 }
+export function encodeBinaryMessage(message, body) {
+    const json = Buffer.from(JSON.stringify(message));
+    const header = Buffer.alloc(4);
+    header.writeUInt32BE(json.byteLength);
+    return Buffer.concat([header, json, body]);
+}
+export function parseBinaryMessage(data) {
+    if (data.byteLength < 4)
+        return null;
+    const end = 4 + data.readUInt32BE(0);
+    if (end > data.byteLength)
+        return null;
+    try {
+        const message = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(data.subarray(4, end)));
+        return { message, body: data.subarray(end) };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/daemon-rpc.d.ts

@@ -25,10 +25,15 @@ export declare class RpcConnection {
     onClose?: () => void;
     constructor(socket: WebSocket);
     get open(): boolean;
-    request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+    request(method: string, params?: unknown, timeoutMs?: number, progress?: (params: Record<string, unknown>) => void): Promise<unknown>;
+    requestBinary(method: string, params: unknown, body: Uint8Array, timeoutMs?: number): Promise<{
+        result: unknown;
+        body: Uint8Array;
+    }>;
+    private submit;
     close(): void;
 }
-export declare function connectRpc(state: DaemonState, signal?: AbortSignal): Promise<{
+export declare function connectRpc(state: DaemonState, signal?: AbortSignal, protocolVersion?: number): Promise<{
     rpc: RpcConnection;
     status: DaemonStatus;
 }>;