@rome-os/node-core 0.1.0 → 0.1.2

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)

package/dist/daemon.js

@@ -1,13 +1,29 @@
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
 import WebSocket, { WebSocketServer } from "ws";
-import { isRecord } from "./actions.js";
+import { actionError, isRecord } from "./actions.js";
 import { DeviceConnector } from "./connector.js";
 import { daemonStatePath, readCallerCredential } from "./local.js";
 import { writePrivateJson } from "./storage.js";
-import { DAEMON_PROTOCOL_VERSION } from "./daemon-protocol.js";
+import { DAEMON_PROTOCOL_VERSION, encodeBinaryMessage, MAX_LOCAL_MESSAGE_BYTES, parseBinaryMessage, } from "./daemon-protocol.js";
 import { DeviceStatusReader } from "./devices-status.js";
 import { RpcError } from "./daemon-rpc.js";
+import { isAbsolute } from "node:path";
+import { isUuid } from "./frame.js";
+import { copyWithDevice, TRANSFER_VERSION, TransferError } from "./transfer.js";
+function copyRequest(params) {
+    const { direction, localPath, deviceId, remotePath } = params;
+    if ((direction !== "push" && direction !== "pull") ||
+        typeof localPath !== "string" ||
+        !isAbsolute(localPath) ||
+        localPath.includes("\0") ||
+        !isUuid(deviceId) ||
+        typeof remotePath !== "string" ||
+        !remotePath ||
+        remotePath.includes("\0"))
+        return null;
+    return { direction, localPath, deviceId: deviceId.toLowerCase(), remotePath };
+}
 export async function serveDaemon(config, signal) {
     if (signal.aborted)
         return;
@@ -44,7 +60,11 @@ export async function serveDaemon(config, signal) {
         res.writeHead(authorized(req) ? 426 : 401, { "cache-control": "no-store" }).end();
     });
     server.headersTimeout = 10_000;
-    const sockets = new WebSocketServer({ noServer: true, perMessageDeflate: false });
+    const sockets = new WebSocketServer({
+        noServer: true,
+        perMessageDeflate: false,
+        maxPayload: MAX_LOCAL_MESSAGE_BYTES,
+    });
     server.on("upgrade", (req, socket, head) => {
         if (closing || req.url !== "/rpc" || req.headers.origin || !authorized(req)) {
             socket.end("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
@@ -60,12 +80,46 @@ export async function serveDaemon(config, signal) {
                 peer.socket.terminate();
         });
     }
+    function deliver(peer, reply) {
+        if (!reply.body) {
+            send(peer, reply.message);
+            return;
+        }
+        if (peer.socket.readyState !== WebSocket.OPEN)
+            return;
+        let data = encodeBinaryMessage(reply.message, reply.body);
+        if (data.byteLength > MAX_LOCAL_MESSAGE_BYTES) {
+            const id = isRecord(reply.message) ? reply.message.id : null;
+            data = encodeBinaryMessage({
+                jsonrpc: "2.0",
+                id,
+                result: actionError("message_too_large", "The response exceeds the local message limit. The action may have completed."),
+            }, new Uint8Array());
+        }
+        peer.socket.send(data, { binary: true }, (error) => {
+            if (error)
+                peer.socket.terminate();
+        });
+    }
     function notify(peer) {
-        if (peer.socket.bufferedAmount > 1024 * 1024) {
+        if (peer.eventBytes > 1024 * 1024) {
             peer.socket.terminate();
             return;
         }
-        send(peer, { jsonrpc: "2.0", method: "events.connection", params: snapshot() });
+        if (peer.socket.readyState !== WebSocket.OPEN)
+            return;
+        const text = JSON.stringify({
+            jsonrpc: "2.0",
+            method: "events.connection",
+            params: snapshot(),
+        });
+        const size = Buffer.byteLength(text);
+        peer.eventBytes += size;
+        peer.socket.send(text, (error) => {
+            peer.eventBytes -= size;
+            if (error)
+                peer.socket.terminate();
+        });
     }
     const close = () => {
         if (closing)
@@ -86,7 +140,7 @@ export async function serveDaemon(config, signal) {
     function error(id, code, message) {
         return { jsonrpc: "2.0", id, error: { code, message } };
     }
-    async function dispatch(peer, value) {
+    async function dispatch(peer, value, input) {
         if (!isRecord(value) ||
             value.jsonrpc !== "2.0" ||
             typeof value.method !== "string" ||
@@ -94,7 +148,7 @@ export async function serveDaemon(config, signal) {
                 typeof value.id !== "string" &&
                 typeof value.id !== "number" &&
                 value.id !== null))
-            return error(null, -32600, "Invalid Request");
+            return { message: error(null, -32600, "Invalid Request") };
         const hasId = Object.hasOwn(value, "id");
         const id = value.id;
         if (hasId && id !== null && peer.pending.has(id)) {
@@ -109,7 +163,10 @@ export async function serveDaemon(config, signal) {
             const params = Object.hasOwn(value, "params") ? value.params : {};
             if (!isRecord(params))
                 throw new RpcError(-32602, "Invalid params");
+            if ((value.method === "devices.runBinary") !== Boolean(input))
+                throw new RpcError(-32600, "Only devices.runBinary uses binary messages, and it requires one.");
             let result;
+            let body;
             if (value.method === "daemon.hello") {
                 if (params.protocolVersion !== DAEMON_PROTOCOL_VERSION)
                     throw new RpcError(-32002, "Incompatible daemon protocol.");
@@ -138,6 +195,68 @@ export async function serveDaemon(config, signal) {
                             throw new RpcError(-32602, "A device ID and action are required.");
                         result = await connector.run(params.deviceId, params.action, params.args ?? {});
                         break;
+                    case "devices.runBinary": {
+                        if (typeof params.deviceId !== "string" || typeof params.action !== "string")
+                            throw new RpcError(-32602, "A device ID and action are required.");
+                        const reply = await connector.runBinary(params.deviceId, params.action, params.args ?? {}, input ?? new Uint8Array());
+                        result = reply.response;
+                        body = reply.body;
+                        break;
+                    }
+                    case "files.copy": {
+                        const request = copyRequest(params);
+                        if (!request)
+                            throw new RpcError(-32602, "files.copy requires direction push or pull, an absolute localPath, a device UUID, and remotePath.");
+                        const controller = new AbortController();
+                        peer.copies.add(controller);
+                        if (peer.socket.readyState !== WebSocket.OPEN)
+                            controller.abort();
+                        const canceled = () => actionError("canceled", "The client disconnected. The copy did not start.");
+                        let last = 0;
+                        try {
+                            if (controller.signal.aborted) {
+                                result = canceled();
+                                break;
+                            }
+                            const info = await connector.run(request.deviceId, "system.info", {});
+                            if (controller.signal.aborted) {
+                                result = canceled();
+                                break;
+                            }
+                            if (!info.ok) {
+                                result = info;
+                                break;
+                            }
+                            if (!isRecord(info.result) || info.result.transferVersion !== TRANSFER_VERSION) {
+                                result = actionError("unsupported_device", "The device runs a rome-node version without file transfers. Update rome-node on that device.");
+                                break;
+                            }
+                            const summary = await copyWithDevice((events) => connector.openChannel(request.deviceId, events), request, {
+                                signal: controller.signal,
+                                onProgress: ({ bytes, total }) => {
+                                    const now = Date.now();
+                                    if (now - last < 250 && bytes !== total)
+                                        return;
+                                    last = now;
+                                    send(peer, {
+                                        jsonrpc: "2.0",
+                                        method: "events.transfer",
+                                        params: { requestId: id, bytes, total },
+                                    });
+                                },
+                            });
+                            result = { type: "response", ok: true, result: summary };
+                        }
+                        catch (cause) {
+                            if (!(cause instanceof TransferError))
+                                throw cause;
+                            result = actionError(cause.code, cause.message);
+                        }
+                        finally {
+                            peer.copies.delete(controller);
+                        }
+                        break;
+                    }
                     case "events.subscribe":
                     case "events.unsubscribe":
                         if (params.topic !== "connection")
@@ -151,14 +270,16 @@ export async function serveDaemon(config, signal) {
                         throw new RpcError(-32601, "Method not found");
                 }
             }
-            return hasId ? { jsonrpc: "2.0", id, result } : undefined;
+            return hasId ? { message: { jsonrpc: "2.0", id, result }, body } : undefined;
         }
         catch (cause) {
             if (!hasId)
                 return;
-            return cause instanceof RpcError
-                ? error(id, cause.code, cause.message)
-                : error(id, -32000, "The device service is unavailable.");
+            return {
+                message: cause instanceof RpcError
+                    ? error(id, cause.code, cause.message)
+                    : error(id, -32000, "The device service is unavailable."),
+            };
         }
         finally {
             if (hasId && id !== null)
@@ -166,14 +287,41 @@ export async function serveDaemon(config, signal) {
         }
     }
     sockets.on("connection", (socket) => {
-        const peer = { socket, ready: false, subscribed: false, alive: true, pending: new Set() };
+        const peer = {
+            socket,
+            ready: false,
+            subscribed: false,
+            alive: true,
+            pending: new Set(),
+            eventBytes: 0,
+            copies: new Set(),
+        };
         peers.add(peer);
         socket.on("error", () => socket.terminate());
-        socket.on("close", () => peers.delete(peer));
+        socket.on("close", () => {
+            peers.delete(peer);
+            for (const copy of peer.copies)
+                copy.abort();
+        });
         socket.on("pong", () => {
             peer.alive = true;
         });
         socket.on("message", (data, binary) => {
+            if (binary) {
+                const parsed = parseBinaryMessage(Buffer.isBuffer(data)
+                    ? data
+                    : Array.isArray(data)
+                        ? Buffer.concat(data)
+                        : Buffer.from(data));
+                if (!parsed) {
+                    send(peer, error(null, -32600, "Invalid Request"));
+                    return;
+                }
+                void dispatch(peer, parsed.message, parsed.body)
+                    .then((reply) => reply && deliver(peer, reply))
+                    .catch(() => socket.terminate());
+                return;
+            }
             let request;
             try {
                 request = JSON.parse(data.toString());
@@ -182,20 +330,18 @@ export async function serveDaemon(config, signal) {
                 send(peer, error(null, -32700, "Parse error"));
                 return;
             }
-            if (binary) {
-                send(peer, error(null, -32600, "Invalid Request"));
-                return;
-            }
             void (async () => {
                 if (Array.isArray(request) && request.length > 0) {
-                    const responses = (await Promise.all(request.map((item) => dispatch(peer, item)))).filter((value) => value !== undefined);
+                    const responses = (await Promise.all(request.map((item) => dispatch(peer, item))))
+                        .filter((reply) => reply !== undefined)
+                        .map((reply) => reply.message);
                     if (responses.length)
                         send(peer, responses);
                 }
                 else {
-                    const response = await dispatch(peer, request);
-                    if (response !== undefined)
-                        send(peer, response);
+                    const reply = await dispatch(peer, request);
+                    if (reply !== undefined)
+                        send(peer, reply.message);
                 }
             })().catch(() => socket.terminate());
         });

package/dist/device-authorization.d.ts

@@ -0,0 +1,8 @@
+import { type DeviceSession } from "./device-session.js";
+export interface DeviceAuthorizationPrompt {
+    verificationUri: string;
+    verificationUriComplete: string;
+    userCode: string;
+    expiresIn: number;
+}
+export declare function loginDeviceCode(cloudUrl: string, name: string, signal: AbortSignal, onAuthorizationRequired: (prompt: DeviceAuthorizationPrompt) => void): Promise<DeviceSession>;

package/dist/device-authorization.js

@@ -0,0 +1,156 @@
+import { isRecord } from "./actions.js";
+import { cloudOrigin } from "./cloud.js";
+import { devicePlatform, deviceSessionFromToken } from "./device-session.js";
+class DeviceAuthorizationError extends Error {
+}
+class RetryableRequestError extends Error {
+}
+function seconds(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 2_147_483;
+}
+function verificationUrl(value, origin) {
+    if (typeof value !== "string")
+        throw new DeviceAuthorizationError("Invalid device authorization response.");
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new DeviceAuthorizationError("Invalid device authorization response.");
+    }
+    if (url.origin !== origin || url.username || url.password)
+        throw new DeviceAuthorizationError("Invalid device authorization response.");
+    return url.href;
+}
+async function post(origin, path, body, signal) {
+    let response;
+    try {
+        response = await fetch(new URL(path, origin), {
+            method: "POST",
+            body,
+            signal: AbortSignal.any([signal, AbortSignal.timeout(10_000)]),
+            redirect: "error",
+            cache: "no-store",
+        });
+    }
+    catch {
+        throw new RetryableRequestError();
+    }
+    if (response.status === 429 || response.status >= 500) {
+        await response.body?.cancel().catch(() => { });
+        throw new RetryableRequestError();
+    }
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new DeviceAuthorizationError("Invalid device authorization response.");
+        throw new RetryableRequestError();
+    }
+    return { response, result };
+}
+function wait(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        signal.throwIfAborted();
+        const abort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", abort);
+            resolve();
+        }, milliseconds);
+        signal.addEventListener("abort", abort, { once: true });
+    });
+}
+export async function loginDeviceCode(cloudUrl, name, signal, onAuthorizationRequired) {
+    const origin = cloudOrigin(cloudUrl);
+    const expiry = new AbortController();
+    const pollingSignal = AbortSignal.any([signal, expiry.signal]);
+    let timer;
+    try {
+        signal.throwIfAborted();
+        const { response, result } = await post(origin, "/oauth2/device_authorization", new URLSearchParams({
+            client_id: "rome-computer",
+            display_name: name,
+            platform: devicePlatform(),
+        }), signal);
+        if (!response.ok ||
+            !isRecord(result) ||
+            typeof result.device_code !== "string" ||
+            !result.device_code ||
+            typeof result.user_code !== "string" ||
+            !/^[A-Za-z0-9-]{1,64}$/.test(result.user_code) ||
+            !seconds(result.expires_in) ||
+            !seconds(result.interval))
+            throw new DeviceAuthorizationError("Invalid device authorization response.");
+        const prompt = {
+            verificationUri: verificationUrl(result.verification_uri, origin),
+            verificationUriComplete: verificationUrl(result.verification_uri_complete, origin),
+            userCode: result.user_code,
+            expiresIn: result.expires_in,
+        };
+        const deadline = Date.now() + result.expires_in * 1000;
+        timer = setTimeout(() => expiry.abort(), result.expires_in * 1000);
+        onAuthorizationRequired(prompt);
+        let interval = result.interval * 1000;
+        while (true) {
+            await wait(Math.min(interval, Math.max(0, deadline - Date.now())), pollingSignal);
+            if (Date.now() >= deadline)
+                expiry.abort();
+            pollingSignal.throwIfAborted();
+            let polled;
+            try {
+                polled = await post(origin, "/oauth2/token", new URLSearchParams({
+                    client_id: "rome-computer",
+                    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                    device_code: result.device_code,
+                }), pollingSignal);
+            }
+            catch (error) {
+                pollingSignal.throwIfAborted();
+                if (!(error instanceof RetryableRequestError))
+                    throw error;
+                interval = Math.max(interval, Math.min(interval * 2, 60_000));
+                continue;
+            }
+            const { response, result: token } = polled;
+            pollingSignal.throwIfAborted();
+            if (response.ok) {
+                const session = deviceSessionFromToken(token, origin);
+                if (!session)
+                    throw new DeviceAuthorizationError("Invalid token response.");
+                return session;
+            }
+            if (response.status === 400 && isRecord(token)) {
+                if (token.error === "authorization_pending")
+                    continue;
+                if (token.error === "slow_down") {
+                    interval += 5000;
+                    continue;
+                }
+                if (token.error === "access_denied")
+                    throw new DeviceAuthorizationError("Device authorization denied.");
+                if (token.error === "expired_token")
+                    throw new DeviceAuthorizationError("Device authorization expired.");
+                if (token.error === "invalid_grant")
+                    throw new DeviceAuthorizationError("Device authorization is invalid.");
+            }
+            throw new DeviceAuthorizationError("Device authorization rejected.");
+        }
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw new DeviceAuthorizationError("Authorization canceled.");
+        if (expiry.signal.aborted)
+            throw new DeviceAuthorizationError("Device authorization expired.");
+        if (error instanceof DeviceAuthorizationError)
+            throw error;
+        throw new DeviceAuthorizationError("Could not complete device authorization. Try connecting again.");
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/device-session.d.ts

@@ -0,0 +1,7 @@
+export interface DeviceSession {
+    cloudUrl: string;
+    token: string;
+    deviceId: string;
+}
+export declare function devicePlatform(): "macos" | "windows" | "linux";
+export declare function deviceSessionFromToken(body: unknown, origin: string): DeviceSession | null;

package/dist/device-session.js

@@ -0,0 +1,16 @@
+import { platform } from "node:os";
+import { isRecord } from "./actions.js";
+import { validId } from "./protocol.js";
+export function devicePlatform() {
+    const value = platform();
+    return value === "darwin" ? "macos" : value === "win32" ? "windows" : "linux";
+}
+export function deviceSessionFromToken(body, origin) {
+    if (!isRecord(body) ||
+        typeof body.access_token !== "string" ||
+        !/^romedev_[A-Za-z0-9_-]{43}$/.test(body.access_token) ||
+        body.token_type !== "Bearer" ||
+        !validId(body.device_id))
+        return null;
+    return { cloudUrl: origin, token: body.access_token, deviceId: body.device_id };
+}

package/dist/executor.d.ts

@@ -1,5 +1,8 @@
+import { type Frame } from "./frame.js";
 import type { InboundEnvelope, OutboundEnvelope } from "./protocol.js";
-export declare function createExecutor(name: string, send: (message: OutboundEnvelope) => boolean, secrets?: string[]): {
+export declare function redactBytes(data: Buffer, secrets: string[]): Buffer;
+export declare function createExecutor(name: string, send: (message: OutboundEnvelope) => boolean, secrets?: string[], sendFrame?: (frame: Frame) => boolean): {
     receive(message: InboundEnvelope): Promise<void>;
+    receiveFrame(frame: Frame): Promise<void>;
     disconnect(): void;
 };