@rome-os/node-core 0.1.1 → 0.1.3

package/dist/daemon.js

@@ -1,13 +1,78 @@
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
+import { createRequire } from "node:module";
+import { join } from "node:path";
 import WebSocket, { WebSocketServer } from "ws";
-import { isRecord } from "./actions.js";
+import { actionError, isRecord } from "./actions.js";
+import { ObserveStore, QueryError } from "./observe.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";
+const PRUNE_INTERVAL_MS = 60 * 60 * 1000;
+const { version: NODE_CORE_VERSION } = createRequire(import.meta.url)("../package.json");
+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 };
+}
+function byteCount(value) {
+    return typeof value === "string" ? Buffer.byteLength(value) : 0;
+}
+function actionStart(deviceId, action, args, mode, stdinBytes = 0) {
+    const exec = action === "exec" && isRecord(args) && typeof args.command === "string";
+    let text = null;
+    if (!exec)
+        try {
+            text = JSON.stringify(args ?? {});
+        }
+        catch { }
+    return {
+        direction: "out",
+        peer: deviceId.toLowerCase(),
+        action,
+        mode,
+        command: exec ? args.command : null,
+        args: exec ? (Array.isArray(args.args) ? args.args.map(String) : []) : text,
+        cwd: exec && typeof args.cwd === "string" ? args.cwd : null,
+        stdinBytes,
+    };
+}
+function actionEnd(response, stdoutBytes) {
+    if (!response.ok) {
+        const code = response.error.code;
+        return {
+            outcome: code === "unknown_outcome" ? "unknown_outcome" : code === "canceled" ? "aborted" : "error",
+            errorCode: code,
+        };
+    }
+    const result = isRecord(response.result) ? response.result : {};
+    return {
+        outcome: "ok",
+        exitCode: Number.isSafeInteger(result.exitCode) ? result.exitCode : null,
+        signal: typeof result.signal === "string" ? result.signal : null,
+        stdoutBytes: stdoutBytes ?? byteCount(result.stdout),
+        stderrBytes: byteCount(result.stderr),
+    };
+}
+function logQuery(params) {
+    if (params.kind !== "actions")
+        throw new RpcError(-32602, "log.query requires kind actions.");
+    return params;
+}
 export async function serveDaemon(config, signal) {
     if (signal.aborted)
         return;
@@ -19,14 +84,37 @@ export async function serveDaemon(config, signal) {
         protocolVersion: DAEMON_PROTOCOL_VERSION,
         token: `romenode_${randomBytes(32).toString("base64url")}`,
     };
+    const startedAt = Date.now();
     let closing = false;
+    const store = new ObserveStore({
+        path: join(config.directory, "observe.db"),
+        secrets: [credential.token, state.token],
+    });
+    const caller = {
+        connection: "stopped",
+        since: startedAt,
+        onlineOnce: false,
+        reconnects: 0,
+        running: 0,
+    };
     const connector = new DeviceConnector({
         credential,
-        onStatus: () => {
+        onStatus: (status) => {
             deviceStatus.invalidate();
             for (const peer of peers)
                 if (peer.subscribed)
                     notify(peer);
+            if (status === caller.connection)
+                return;
+            const at = Date.now();
+            caller.connection = status;
+            caller.since = at;
+            if (status === "online") {
+                if (caller.onlineOnce)
+                    caller.reconnects++;
+                caller.onlineOnce = true;
+            }
+            broadcast({ type: "connection", role: "caller", status, at });
         },
     });
     const deviceStatus = new DeviceStatusReader(connector);
@@ -35,6 +123,39 @@ export async function serveDaemon(config, signal) {
         protocolVersion: DAEMON_PROTOCOL_VERSION,
         connection: connector.getStatus(),
     });
+    const nodeStatus = () => ({
+        version: NODE_CORE_VERSION,
+        startedAt,
+        roles: {
+            caller: {
+                auth: caller.connection === "revoked" ? "revoked" : "authorized",
+                connection: caller.connection,
+                since: caller.since,
+                reconnects: caller.reconnects,
+                running: caller.running,
+            },
+        },
+    });
+    async function observed(start, work, end) {
+        if (!start)
+            return work();
+        caller.running++;
+        const row = store.startAction(start);
+        if (row)
+            broadcast({ type: "action", id: row.id, phase: "start", row });
+        let ended = { outcome: "error", errorCode: "daemon_error" };
+        try {
+            const value = await work();
+            ended = end(value);
+            return value;
+        }
+        finally {
+            caller.running--;
+            const done = row && store.endAction(row.id, ended);
+            if (done)
+                broadcast({ type: "action", id: done.id, phase: "end", row: done });
+        }
+    }
     function authorized(req) {
         const actual = Buffer.from(req.headers.authorization ?? "");
         const expected = Buffer.from(`Bearer ${state.token}`);
@@ -44,7 +165,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 +185,50 @@ 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) {
+        emit(peer, "events.connection", snapshot());
+    }
+    function broadcast(event) {
+        for (const peer of peers)
+            if (peer.observing)
+                emit(peer, "events.node", event);
+    }
+    function emit(peer, method, params) {
+        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, params });
+        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)
@@ -83,10 +246,52 @@ export async function serveDaemon(config, signal) {
         }, 1000);
         timer.unref();
     };
+    async function copyFile(peer, id, request) {
+        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)
+                return canceled();
+            const info = await connector.run(request.deviceId, "system.info", {});
+            if (controller.signal.aborted)
+                return canceled();
+            if (!info.ok)
+                return info;
+            if (!isRecord(info.result) || info.result.transferVersion !== TRANSFER_VERSION)
+                return actionError("unsupported_device", "The device runs a rome-node version without file transfers. Update rome-node on that device.");
+            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 },
+                    });
+                },
+            });
+            return { type: "response", ok: true, result: summary };
+        }
+        catch (cause) {
+            if (!(cause instanceof TransferError))
+                throw cause;
+            return actionError(cause.code, cause.message);
+        }
+        finally {
+            peer.copies.delete(controller);
+        }
+    }
     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 +299,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 +314,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.");
@@ -127,6 +335,29 @@ export async function serveDaemon(config, signal) {
                         result = { stopped: true };
                         setImmediate(close);
                         break;
+                    case "node.status":
+                        result = nodeStatus();
+                        break;
+                    case "log.query":
+                        try {
+                            result = store.query(logQuery(params));
+                        }
+                        catch (cause) {
+                            if (cause instanceof QueryError)
+                                throw new RpcError(-32602, cause.message);
+                            throw cause;
+                        }
+                        break;
+                    case "log.stats":
+                        try {
+                            result = store.stats(params);
+                        }
+                        catch (cause) {
+                            if (cause instanceof QueryError)
+                                throw new RpcError(-32602, cause.message);
+                            throw cause;
+                        }
+                        break;
                     case "devices.status":
                         result = await deviceStatus.read();
                         break;
@@ -136,29 +367,83 @@ export async function serveDaemon(config, signal) {
                     case "devices.run":
                         if (typeof params.deviceId !== "string" || typeof params.action !== "string")
                             throw new RpcError(-32602, "A device ID and action are required.");
-                        result = await connector.run(params.deviceId, params.action, params.args ?? {});
+                        {
+                            const { deviceId, action } = params;
+                            const args = params.args ?? {};
+                            result = await observed(action === "system.info" ? null : actionStart(deviceId, action, args, "json"), () => connector.run(deviceId, action, args), (response) => actionEnd(response));
+                        }
+                        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 { deviceId, action } = params;
+                        const args = params.args ?? {};
+                        const stdin = input ?? new Uint8Array();
+                        const reply = await observed(actionStart(deviceId, action, args, "binary", stdin.byteLength), () => connector.runBinary(deviceId, action, args, stdin), ({ response, body }) => actionEnd(response, body.byteLength));
+                        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.");
+                        result = await observed({
+                            direction: "out",
+                            peer: request.deviceId,
+                            action: "copy",
+                            mode: "copy",
+                            transfer: {
+                                direction: request.direction,
+                                localPath: request.localPath,
+                                remotePath: request.remotePath,
+                            },
+                        }, () => copyFile(peer, id, request), (response) => {
+                            const summary = response.ok && isRecord(response.result) ? response.result : {};
+                            return {
+                                ...actionEnd(response),
+                                transferBytes: typeof summary.bytes === "number" ? summary.bytes : null,
+                                sha256: typeof summary.sha256 === "string" ? summary.sha256 : null,
+                            };
+                        });
+                        break;
+                    }
                     case "events.subscribe":
-                    case "events.unsubscribe":
-                        if (params.topic !== "connection")
+                    case "events.unsubscribe": {
+                        const on = value.method === "events.subscribe";
+                        if (params.topic === "connection") {
+                            peer.subscribed = on;
+                            if (on)
+                                notify(peer);
+                        }
+                        else if (params.topic === "node") {
+                            peer.observing = on;
+                            if (on)
+                                emit(peer, "events.node", {
+                                    type: "snapshot",
+                                    status: nodeStatus(),
+                                    running: store.running(),
+                                });
+                        }
+                        else
                             throw new RpcError(-32602, "Unknown event topic.");
-                        peer.subscribed = value.method === "events.subscribe";
-                        if (peer.subscribed)
-                            notify(peer);
-                        result = { subscribed: peer.subscribed };
+                        result = { subscribed: on };
                         break;
+                    }
                     default:
                         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 +451,42 @@ 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,
+            observing: 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 +495,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());
         });
@@ -207,6 +518,9 @@ export async function serveDaemon(config, signal) {
             resolve();
         });
     });
+    store.open();
+    const pruner = setInterval(() => store.prune(), PRUNE_INTERVAL_MS);
+    pruner.unref();
     const heartbeat = setInterval(() => {
         for (const peer of peers) {
             if (!peer.alive) {
@@ -230,6 +544,8 @@ export async function serveDaemon(config, signal) {
     finally {
         close();
         clearInterval(heartbeat);
+        clearInterval(pruner);
+        store.close();
         signal.removeEventListener("abort", close);
     }
 }

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;
 };