@rome-os/node-core 0.1.0

package/dist/daemon-rpc.d.ts

@@ -0,0 +1,34 @@
+import WebSocket from "ws";
+import { type DaemonStatus } from "./daemon-protocol.js";
+export declare class DaemonVersionError extends Error {
+    constructor();
+}
+export declare class DaemonRequestError extends Error {
+    readonly code = "unknown_outcome";
+    constructor();
+}
+export declare class RpcError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+export interface DaemonState {
+    token: string;
+    port: number;
+    pid: number;
+    protocolVersion?: number;
+}
+export declare class RpcConnection {
+    readonly socket: WebSocket;
+    private nextId;
+    private pending;
+    onNotification?: (method: string, params: unknown) => void;
+    onClose?: () => void;
+    constructor(socket: WebSocket);
+    get open(): boolean;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+    close(): void;
+}
+export declare function connectRpc(state: DaemonState, signal?: AbortSignal): Promise<{
+    rpc: RpcConnection;
+    status: DaemonStatus;
+}>;

package/dist/daemon-rpc.js

@@ -0,0 +1,171 @@
+import WebSocket from "ws";
+import { isRecord } from "./actions.js";
+import { DAEMON_PROTOCOL_VERSION, 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.");
+    }
+}
+export class DaemonRequestError extends Error {
+    code = "unknown_outcome";
+    constructor() {
+        super("Caller daemon connection failed. Execution outcome may be unknown; do not automatically retry.");
+    }
+}
+export class RpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export class RpcConnection {
+    socket;
+    nextId = 0;
+    pending = new Map();
+    onNotification;
+    onClose;
+    constructor(socket) {
+        this.socket = socket;
+        let alive = true;
+        const heartbeat = setInterval(() => {
+            if (!this.open)
+                return;
+            if (!alive) {
+                socket.terminate();
+                return;
+            }
+            alive = false;
+            socket.ping();
+        }, 30_000);
+        heartbeat.unref();
+        socket.on("pong", () => {
+            alive = true;
+        });
+        socket.on("error", () => socket.terminate());
+        socket.on("close", () => {
+            clearInterval(heartbeat);
+            for (const request of this.pending.values())
+                request.reject(new DaemonRequestError());
+            this.pending.clear();
+            this.onClose?.();
+        });
+        socket.on("message", (data, binary) => {
+            let message;
+            try {
+                message = JSON.parse(data.toString());
+            }
+            catch {
+                this.close();
+                return;
+            }
+            if (binary || !isRecord(message) || message.jsonrpc !== "2.0") {
+                this.close();
+                return;
+            }
+            if (typeof message.method === "string" && !Object.hasOwn(message, "id")) {
+                this.onNotification?.(message.method, message.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);
+            else if (!Object.hasOwn(message, "result") &&
+                isRecord(message.error) &&
+                Number.isInteger(message.error.code) &&
+                typeof message.error.message === "string")
+                pending.reject(new RpcError(Number(message.error.code), message.error.message));
+            else
+                pending.reject(new DaemonRequestError());
+        });
+    }
+    get open() {
+        return this.socket.readyState === WebSocket.OPEN;
+    }
+    request(method, params = {}, timeoutMs = 85_000) {
+        if (!this.open)
+            return Promise.reject(new DaemonRequestError());
+        const id = String(++this.nextId);
+        const text = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+        return new Promise((resolve, reject) => {
+            const finish = (error, value) => {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                if (error)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            const timer = setTimeout(() => finish(new DaemonRequestError()), timeoutMs);
+            this.pending.set(id, {
+                resolve: (value) => finish(undefined, value),
+                reject: (error) => finish(error),
+            });
+            try {
+                this.socket.send(text, (error) => {
+                    if (error)
+                        finish(new DaemonRequestError());
+                });
+            }
+            catch {
+                finish(new DaemonRequestError());
+            }
+        });
+    }
+    close() {
+        this.socket.terminate();
+    }
+}
+export async function connectRpc(state, signal) {
+    signal?.throwIfAborted();
+    const socket = new WebSocket(`ws://127.0.0.1:${state.port}/rpc`, {
+        headers: { authorization: `Bearer ${state.token}` },
+        handshakeTimeout: 1500,
+        perMessageDeflate: false,
+        followRedirects: false,
+    });
+    const rpc = new RpcConnection(socket);
+    const abort = () => rpc.close();
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+        await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                socket.off("open", opened);
+                socket.off("close", failed);
+                socket.off("error", failed);
+            };
+            const opened = () => {
+                cleanup();
+                resolve();
+            };
+            const failed = () => {
+                cleanup();
+                reject(new DaemonRequestError());
+            };
+            socket.once("open", opened);
+            socket.once("close", failed);
+            socket.once("error", failed);
+            if (signal?.aborted)
+                abort();
+        });
+        const value = await rpc.request("daemon.hello", { protocolVersion: DAEMON_PROTOCOL_VERSION }, 1500);
+        if (isRecord(value) && value.protocolVersion !== DAEMON_PROTOCOL_VERSION)
+            throw new DaemonVersionError();
+        const status = parseDaemonStatus(value);
+        if (!status || status.pid !== state.pid)
+            throw new DaemonRequestError();
+        signal?.throwIfAborted();
+        return { rpc, status };
+    }
+    catch (error) {
+        rpc.close();
+        if (error instanceof RpcError && error.code === -32002)
+            throw new DaemonVersionError();
+        throw error;
+    }
+    finally {
+        signal?.removeEventListener("abort", abort);
+    }
+}

package/dist/daemon.d.ts

@@ -0,0 +1,2 @@
+import { type NodeConfig } from "./local.js";
+export declare function serveDaemon(config: NodeConfig, signal: AbortSignal): Promise<void>;

package/dist/daemon.js

@@ -0,0 +1,235 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import WebSocket, { WebSocketServer } from "ws";
+import { 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 { DeviceStatusReader } from "./devices-status.js";
+import { RpcError } from "./daemon-rpc.js";
+export async function serveDaemon(config, signal) {
+    if (signal.aborted)
+        return;
+    const credential = await readCallerCredential(config);
+    const peers = new Set();
+    const state = {
+        port: config.port,
+        pid: process.pid,
+        protocolVersion: DAEMON_PROTOCOL_VERSION,
+        token: `romenode_${randomBytes(32).toString("base64url")}`,
+    };
+    let closing = false;
+    const connector = new DeviceConnector({
+        credential,
+        onStatus: () => {
+            deviceStatus.invalidate();
+            for (const peer of peers)
+                if (peer.subscribed)
+                    notify(peer);
+        },
+    });
+    const deviceStatus = new DeviceStatusReader(connector);
+    const snapshot = () => ({
+        pid: state.pid,
+        protocolVersion: DAEMON_PROTOCOL_VERSION,
+        connection: connector.getStatus(),
+    });
+    function authorized(req) {
+        const actual = Buffer.from(req.headers.authorization ?? "");
+        const expected = Buffer.from(`Bearer ${state.token}`);
+        return actual.length === expected.length && timingSafeEqual(actual, expected);
+    }
+    const server = createServer((req, res) => {
+        res.writeHead(authorized(req) ? 426 : 401, { "cache-control": "no-store" }).end();
+    });
+    server.headersTimeout = 10_000;
+    const sockets = new WebSocketServer({ noServer: true, perMessageDeflate: false });
+    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");
+            return;
+        }
+        sockets.handleUpgrade(req, socket, head, (socket) => sockets.emit("connection", socket));
+    });
+    function send(peer, value) {
+        if (peer.socket.readyState !== WebSocket.OPEN)
+            return;
+        peer.socket.send(JSON.stringify(value), (error) => {
+            if (error)
+                peer.socket.terminate();
+        });
+    }
+    function notify(peer) {
+        if (peer.socket.bufferedAmount > 1024 * 1024) {
+            peer.socket.terminate();
+            return;
+        }
+        send(peer, { jsonrpc: "2.0", method: "events.connection", params: snapshot() });
+    }
+    const close = () => {
+        if (closing)
+            return;
+        closing = true;
+        connector.stop();
+        for (const peer of peers)
+            peer.socket.close(1001, "daemon stopped");
+        server.close();
+        sockets.close();
+        const timer = setTimeout(() => {
+            for (const peer of peers)
+                peer.socket.terminate();
+            server.closeAllConnections();
+        }, 1000);
+        timer.unref();
+    };
+    function error(id, code, message) {
+        return { jsonrpc: "2.0", id, error: { code, message } };
+    }
+    async function dispatch(peer, value) {
+        if (!isRecord(value) ||
+            value.jsonrpc !== "2.0" ||
+            typeof value.method !== "string" ||
+            (Object.hasOwn(value, "id") &&
+                typeof value.id !== "string" &&
+                typeof value.id !== "number" &&
+                value.id !== null))
+            return error(null, -32600, "Invalid Request");
+        const hasId = Object.hasOwn(value, "id");
+        const id = value.id;
+        if (hasId && id !== null && peer.pending.has(id)) {
+            peer.socket.close(1008, "duplicate request ID");
+            return;
+        }
+        if (hasId && id !== null)
+            peer.pending.add(id);
+        try {
+            if (closing)
+                throw new RpcError(-32000, "The caller daemon is stopping.");
+            const params = Object.hasOwn(value, "params") ? value.params : {};
+            if (!isRecord(params))
+                throw new RpcError(-32602, "Invalid params");
+            let result;
+            if (value.method === "daemon.hello") {
+                if (params.protocolVersion !== DAEMON_PROTOCOL_VERSION)
+                    throw new RpcError(-32002, "Incompatible daemon protocol.");
+                peer.ready = true;
+                result = snapshot();
+            }
+            else {
+                if (!peer.ready)
+                    throw new RpcError(-32001, "Complete the daemon handshake first.");
+                switch (value.method) {
+                    case "daemon.status":
+                        result = snapshot();
+                        break;
+                    case "daemon.stop":
+                        result = { stopped: true };
+                        setImmediate(close);
+                        break;
+                    case "devices.status":
+                        result = await deviceStatus.read();
+                        break;
+                    case "devices.list":
+                        result = await connector.list();
+                        break;
+                    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 ?? {});
+                        break;
+                    case "events.subscribe":
+                    case "events.unsubscribe":
+                        if (params.topic !== "connection")
+                            throw new RpcError(-32602, "Unknown event topic.");
+                        peer.subscribed = value.method === "events.subscribe";
+                        if (peer.subscribed)
+                            notify(peer);
+                        result = { subscribed: peer.subscribed };
+                        break;
+                    default:
+                        throw new RpcError(-32601, "Method not found");
+                }
+            }
+            return hasId ? { jsonrpc: "2.0", id, result } : undefined;
+        }
+        catch (cause) {
+            if (!hasId)
+                return;
+            return cause instanceof RpcError
+                ? error(id, cause.code, cause.message)
+                : error(id, -32000, "The device service is unavailable.");
+        }
+        finally {
+            if (hasId && id !== null)
+                peer.pending.delete(id);
+        }
+    }
+    sockets.on("connection", (socket) => {
+        const peer = { socket, ready: false, subscribed: false, alive: true, pending: new Set() };
+        peers.add(peer);
+        socket.on("error", () => socket.terminate());
+        socket.on("close", () => peers.delete(peer));
+        socket.on("pong", () => {
+            peer.alive = true;
+        });
+        socket.on("message", (data, binary) => {
+            let request;
+            try {
+                request = JSON.parse(data.toString());
+            }
+            catch {
+                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);
+                    if (responses.length)
+                        send(peer, responses);
+                }
+                else {
+                    const response = await dispatch(peer, request);
+                    if (response !== undefined)
+                        send(peer, response);
+                }
+            })().catch(() => socket.terminate());
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(state.port, "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const heartbeat = setInterval(() => {
+        for (const peer of peers) {
+            if (!peer.alive) {
+                peer.socket.terminate();
+                continue;
+            }
+            peer.alive = false;
+            if (peer.socket.readyState === WebSocket.OPEN)
+                peer.socket.ping();
+        }
+    }, 30_000);
+    heartbeat.unref();
+    const finished = new Promise((resolve) => server.once("close", resolve));
+    signal.addEventListener("abort", close, { once: true });
+    try {
+        await writePrivateJson(daemonStatePath(config), state);
+        if (signal.aborted)
+            close();
+        await finished;
+    }
+    finally {
+        close();
+        clearInterval(heartbeat);
+        signal.removeEventListener("abort", close);
+    }
+}

package/dist/devices-status.d.ts

@@ -0,0 +1,23 @@
+import type { ConnectionStatus } from "./client.js";
+import type { DeviceConnector } from "./connector.js";
+export interface DeviceStatus {
+    id: string;
+    name: string;
+    platform: string | null;
+    status: "connected" | "not_connected" | "unknown" | "revoked";
+}
+export interface DevicesStatus {
+    connection: ConnectionStatus;
+    checkedAt: string;
+    devices: DeviceStatus[];
+}
+export declare class DeviceStatusReader {
+    private connector;
+    private cached?;
+    private pending?;
+    private generation;
+    constructor(connector: Pick<DeviceConnector, "list" | "run" | "getStatus">);
+    invalidate(): void;
+    read(): Promise<DevicesStatus>;
+    private check;
+}

package/dist/devices-status.js

@@ -0,0 +1,68 @@
+import { isRecord } from "./actions.js";
+export class DeviceStatusReader {
+    connector;
+    cached;
+    pending;
+    generation = 0;
+    constructor(connector) {
+        this.connector = connector;
+    }
+    invalidate() {
+        this.generation++;
+        this.cached = undefined;
+    }
+    async read() {
+        if (this.cached && Date.now() - Date.parse(this.cached.checkedAt) < 10_000)
+            return this.cached;
+        if (this.pending)
+            return this.pending;
+        const generation = this.generation;
+        this.pending = this.check()
+            .then((snapshot) => {
+            if (generation === this.generation)
+                this.cached = snapshot;
+            return snapshot;
+        })
+            .finally(() => {
+            this.pending = undefined;
+        });
+        return this.pending;
+    }
+    async check() {
+        const list = await this.connector.list();
+        if (!isRecord(list) || !Array.isArray(list.items))
+            throw new Error("Invalid device list");
+        const devices = list.items.map((item) => {
+            if (!isRecord(item) || typeof item.id !== "string")
+                throw new Error("Invalid device record");
+            return {
+                id: item.id,
+                name: typeof item.device_name === "string" ? item.device_name : item.id,
+                platform: typeof item.platform === "string" ? item.platform : null,
+                status: item.revoked_at ? "revoked" : "unknown",
+            };
+        });
+        const deadline = Date.now() + 15_000;
+        let next = 0;
+        await Promise.all(Array.from({ length: Math.min(4, devices.length) }, async () => {
+            while (next < devices.length && Date.now() < deadline) {
+                const device = devices[next++];
+                if (device.status === "revoked")
+                    continue;
+                const response = await this.connector.run(device.id, "system.info", {}, 3000);
+                device.status = response.ok
+                    ? "connected"
+                    : response.error.code === "target_unavailable"
+                        ? "not_connected"
+                        : "unknown";
+            }
+        }));
+        const connection = this.connector.getStatus();
+        if (connection !== "online") {
+            for (const device of devices)
+                if (device.status !== "revoked")
+                    device.status = "unknown";
+        }
+        return { connection, checkedAt: new Date().toISOString(), devices };
+    }
+}

package/dist/executor.d.ts

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

package/dist/executor.js

@@ -0,0 +1,105 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { actionError, isRecord } from "./actions.js";
+export function createExecutor(name, send, secrets = []) {
+    const children = new Set();
+    let generation = 0;
+    const handlers = {
+        "system.info": async () => ({
+            type: "response",
+            ok: true,
+            result: {
+                name,
+                platform: platform() === "darwin" ? "macos" : platform() === "win32" ? "windows" : platform(),
+                actions: ["system.info", "exec"],
+            },
+        }),
+        exec: async (input) => {
+            if (!isRecord(input) ||
+                typeof input.command !== "string" ||
+                !input.command ||
+                input.command.includes("\0") ||
+                (input.args !== undefined &&
+                    (!Array.isArray(input.args) ||
+                        !input.args.every((arg) => typeof arg === "string" && !arg.includes("\0")))) ||
+                (input.cwd !== undefined && (typeof input.cwd !== "string" || input.cwd.includes("\0"))))
+                return actionError("invalid_args", "exec requires command, optional string args[], and optional cwd.");
+            if (children.size >= 8)
+                return actionError("busy", "The computer is already running eight programs.");
+            const command = input.command;
+            const args = (input.args ?? []);
+            const cwd = input.cwd;
+            return new Promise((resolve) => {
+                const environment = Object.fromEntries(Object.entries(process.env).filter(([key]) => !/^(?:ROME_.*(?:TOKEN|SECRET|CREDENTIAL)|NODE_OPTIONS)$/i.test(key)));
+                let child;
+                try {
+                    child = spawn(command, args, {
+                        cwd,
+                        env: environment,
+                        shell: false,
+                        windowsHide: true,
+                        stdio: ["ignore", "pipe", "pipe"],
+                    });
+                }
+                catch {
+                    resolve(actionError("exec_failed", "Could not start the program."));
+                    return;
+                }
+                children.add(child);
+                const output = { stdout: [], stderr: [] };
+                for (const stream of ["stdout", "stderr"]) {
+                    child[stream]?.on("data", (chunk) => {
+                        output[stream].push(chunk);
+                    });
+                }
+                child.once("error", () => {
+                    children.delete(child);
+                    resolve(actionError("exec_failed", "Could not start the program. Check the executable and working directory."));
+                });
+                child.once("close", (exitCode, signal) => {
+                    children.delete(child);
+                    const redact = (chunks) => secrets.reduce((text, secret) => text.replaceAll(secret, "[redacted]"), Buffer.concat(chunks).toString("utf8"));
+                    resolve({
+                        type: "response",
+                        ok: true,
+                        result: {
+                            exitCode,
+                            signal,
+                            stdout: redact(output.stdout),
+                            stderr: redact(output.stderr),
+                            truncated: { stdout: false, stderr: false },
+                        },
+                    });
+                });
+            });
+        },
+    };
+    return {
+        async receive(message) {
+            const request = message.payload;
+            if (!isRecord(request) || request.type !== "request" || typeof request.action !== "string")
+                return;
+            const current = generation;
+            const handler = Object.hasOwn(handlers, request.action)
+                ? handlers[request.action]
+                : undefined;
+            const payload = handler
+                ? await handler(request.args).catch(() => actionError("exec_failed", "The action failed."))
+                : actionError("unsupported_action", "The computer does not support this action.");
+            const reply = { id: message.id, to: message.from, payload };
+            if (current === generation)
+                send(reply);
+        },
+        disconnect() {
+            generation++;
+            for (const child of children) {
+                child.kill("SIGTERM");
+                const timer = setTimeout(() => {
+                    if (child.exitCode === null && child.signalCode === null)
+                        child.kill("SIGKILL");
+                }, 1000);
+                timer.unref();
+            }
+        },
+    };
+}

package/dist/gateway-url.d.ts

@@ -0,0 +1 @@
+export declare function parseGatewayUrl(value: string): URL;

package/dist/gateway-url.js

@@ -0,0 +1,11 @@
+export function parseGatewayUrl(value) {
+    const url = new URL(value);
+    if (url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        (url.protocol !== "wss:" &&
+            !(url.protocol === "ws:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))))
+        throw new Error("Use a credential-free WSS URL. WS is allowed only on loopback.");
+    return url;
+}

package/dist/host.d.ts

@@ -0,0 +1,3 @@
+export { connectHost, defaultDeviceName, type HostCredential, type HostEvent, type HostOptions, } from "./connect.js";
+export { loginDevice, type DeviceSession } from "./login.js";
+export { createFileCredentialStore, type CredentialStore } from "./storage.js";

package/dist/host.js

@@ -0,0 +1,3 @@
+export { connectHost, defaultDeviceName, } from "./connect.js";
+export { loginDevice } from "./login.js";
+export { createFileCredentialStore } from "./storage.js";

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { connectGateway, type GatewayClientOptions, type ConnectionStatus, type ClientSocket, } from "./client.js";
+export { MAX_MESSAGE_BYTES, byteLength, validId, type GatewayMessage, type InboundEnvelope, type OutboundEnvelope, } from "./protocol.js";
+export { CloudError, cloudOrigin, cloudRequest, gatewayConfig } from "./cloud.js";
+export { actionError, isRecord, parseResponse, type ActionResponse, type ActionRequest, } from "./actions.js";