@rome-os/node-core 0.1.1 → 0.1.3

package/dist/daemon-client.js

@@ -1,11 +1,14 @@
-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";
 export { daemonStatus, startDaemon, stopDaemon } from "./daemon-control.js";
 export { DaemonRequestError, DaemonVersionError } from "./daemon-rpc.js";
+export { openConsoleBridge, MAX_CONSOLE_MESSAGE_BYTES, } from "./console.js";
 export class DeviceActionError extends Error {
     response;
     code;
@@ -143,6 +146,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 +282,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 = 4;
+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 = 4;
+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;
 }>;

package/dist/daemon-rpc.js

@@ -1,6 +1,6 @@
 import WebSocket from "ws";
 import { isRecord } from "./actions.js";
-import { DAEMON_PROTOCOL_VERSION, parseDaemonStatus, } from "./daemon-protocol.js";
+import { DAEMON_PROTOCOL_VERSION, encodeBinaryMessage, MAX_LOCAL_MESSAGE_BYTES, parseBinaryMessage, parseDaemonStatus, } from "./daemon-protocol.js";
 export class DaemonVersionError extends Error {
     constructor() {
         super("The caller daemon uses an incompatible protocol. Stop it explicitly before restarting with this version.");
@@ -52,26 +52,47 @@ export class RpcConnection {
         });
         socket.on("message", (data, binary) => {
             let message;
-            try {
-                message = JSON.parse(data.toString());
+            let body = new Uint8Array();
+            if (binary) {
+                const parsed = parseBinaryMessage(Buffer.isBuffer(data)
+                    ? data
+                    : Array.isArray(data)
+                        ? Buffer.concat(data)
+                        : Buffer.from(data));
+                if (!parsed) {
+                    this.close();
+                    return;
+                }
+                ({ message, body } = parsed);
             }
-            catch {
-                this.close();
-                return;
+            else {
+                try {
+                    message = JSON.parse(data.toString());
+                }
+                catch {
+                    this.close();
+                    return;
+                }
             }
-            if (binary || !isRecord(message) || message.jsonrpc !== "2.0") {
+            if (!isRecord(message) || message.jsonrpc !== "2.0") {
                 this.close();
                 return;
             }
             if (typeof message.method === "string" && !Object.hasOwn(message, "id")) {
-                this.onNotification?.(message.method, message.params);
+                const params = message.params;
+                if (message.method === "events.transfer") {
+                    if (isRecord(params) && typeof params.requestId === "string")
+                        this.pending.get(params.requestId)?.progress?.(params);
+                    return;
+                }
+                this.onNotification?.(message.method, params);
                 return;
             }
             const pending = typeof message.id === "string" ? this.pending.get(message.id) : undefined;
             if (!pending)
                 return;
             if (Object.hasOwn(message, "result") && !Object.hasOwn(message, "error"))
-                pending.resolve(message.result);
+                pending.resolve(message.result, body);
             else if (!Object.hasOwn(message, "result") &&
                 isRecord(message.error) &&
                 Number.isInteger(message.error.code) &&
@@ -84,11 +105,18 @@ export class RpcConnection {
     get open() {
         return this.socket.readyState === WebSocket.OPEN;
     }
-    request(method, params = {}, timeoutMs = 85_000) {
+    async request(method, params = {}, timeoutMs = 85_000, progress) {
+        return (await this.submit(method, params, undefined, timeoutMs, progress)).result;
+    }
+    async requestBinary(method, params, body, timeoutMs = 85_000) {
+        return this.submit(method, params, body, timeoutMs);
+    }
+    submit(method, params, body, timeoutMs, progress) {
         if (!this.open)
             return Promise.reject(new DaemonRequestError());
         const id = String(++this.nextId);
-        const text = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+        const message = { jsonrpc: "2.0", id, method, params };
+        const data = body ? encodeBinaryMessage(message, body) : JSON.stringify(message);
         return new Promise((resolve, reject) => {
             const finish = (error, value) => {
                 clearTimeout(timer);
@@ -98,13 +126,16 @@ export class RpcConnection {
                 else
                     resolve(value);
             };
-            const timer = setTimeout(() => finish(new DaemonRequestError()), timeoutMs);
+            const timer = Number.isFinite(timeoutMs)
+                ? setTimeout(() => finish(new DaemonRequestError()), timeoutMs)
+                : undefined;
             this.pending.set(id, {
-                resolve: (value) => finish(undefined, value),
+                resolve: (result, body) => finish(undefined, { result, body }),
                 reject: (error) => finish(error),
+                progress,
             });
             try {
-                this.socket.send(text, (error) => {
+                this.socket.send(data, { binary: Boolean(body) }, (error) => {
                     if (error)
                         finish(new DaemonRequestError());
                 });
@@ -118,12 +149,13 @@ export class RpcConnection {
         this.socket.terminate();
     }
 }
-export async function connectRpc(state, signal) {
+export async function connectRpc(state, signal, protocolVersion = DAEMON_PROTOCOL_VERSION) {
     signal?.throwIfAborted();
     const socket = new WebSocket(`ws://127.0.0.1:${state.port}/rpc`, {
         headers: { authorization: `Bearer ${state.token}` },
         handshakeTimeout: 1500,
         perMessageDeflate: false,
+        maxPayload: MAX_LOCAL_MESSAGE_BYTES,
         followRedirects: false,
     });
     const rpc = new RpcConnection(socket);
@@ -150,8 +182,8 @@ export async function connectRpc(state, signal) {
             if (signal?.aborted)
                 abort();
         });
-        const value = await rpc.request("daemon.hello", { protocolVersion: DAEMON_PROTOCOL_VERSION }, 1500);
-        if (isRecord(value) && value.protocolVersion !== DAEMON_PROTOCOL_VERSION)
+        const value = await rpc.request("daemon.hello", { protocolVersion }, 1500);
+        if (isRecord(value) && value.protocolVersion !== protocolVersion)
             throw new DaemonVersionError();
         const status = parseDaemonStatus(value);
         if (!status || status.pid !== state.pid)