@rome-os/node-core 0.1.4 → 0.1.5

package/README.md

@@ -21,6 +21,8 @@ const client = createNodeClient(nodeConfigFromEnvironment(process.env));
 const status = await client.getConnectionStatus();
 const devices = await client.listDevices();
 const connections = await client.getDevicesStatus();
+await client.renameDevice("device-id", "Build server");
+await client.removeDevice("old-device-id");
 const info = await client.describe("device-id");
 const result = await client.run("device-id", "exec", {
   command: "git",
@@ -48,6 +50,13 @@ Gateway connection. `connection` describes the caller connection to Gateway,
 not the online state of remote devices. `listDevices()` returns authorized
 devices without asserting that they are online.
 
+`renameDevice(deviceId, name)` and `removeDevice(deviceId)` change the account's
+device list in Cloud and resolve with no value. A failure throws
+`DeviceActionError` with code `device_not_found`, `invalid_device_name`,
+`invalid_device_session`, or `cloud_unavailable`. `removeDevice` revokes the
+device first and throws `revocation_pending` while the Gateway has not confirmed
+the revocation. The device stays listed as revoked until a later call deletes it.
+
 `runBinary(deviceId, action, args?, body?)` resolves to `{ response, body }`.
 It sends `body` as input bytes in a binary frame. For `exec`, the input is the
 program's stdin and the reply `body` is its raw stdout. Neither side is JSON or
@@ -203,7 +212,7 @@ where `expiresIn` is in seconds. It returns a `DeviceSession` after approval and
 rejects on denial, expiry, cancellation, or a terminal error. It opens no browser
 or callback listener. The callback receives neither the device code nor the access token.
 
-The host exposes `system.info` and `exec`, in text envelopes and in binary frames.
+The host exposes `system.info`, `exec`, and the read-only `fs.list`, in text envelopes and in binary frames.
 It also accepts the internal file transfers that `copy()` uses. Programs run as the application's OS
 user. Connection loss terminates direct child processes on a best-effort basis.
 A local caller timeout does not cancel remote execution.

package/dist/cloud.d.ts

@@ -3,5 +3,5 @@ export declare class CloudError extends Error {
     constructor(code: string);
 }
 export declare function cloudOrigin(value: string): string;
-export declare function cloudRequest(origin: string, path: string, token: string, method?: string): Promise<unknown>;
+export declare function cloudRequest(origin: string, path: string, token: string, method?: string, json?: unknown): Promise<unknown>;
 export declare function gatewayConfig(origin: string, token: string): Promise<string>;

package/dist/cloud.js

@@ -1,11 +1,16 @@
 import { isRecord } from "./actions.js";
 import { parseGatewayUrl } from "./gateway-url.js";
+const messages = {
+    invalid_device_session: "Device authorization is invalid.",
+    device_not_found: "No device with this ID exists in the account.",
+    invalid_device_name: "Use a name of 1 to 80 characters without control characters.",
+    revocation_pending: "The device is revoked. Rome Cloud deletes it after the Gateway confirms the revocation. Remove it again later.",
+};
+const deviceErrors = new Set(["device_not_found", "invalid_device_name", "revocation_pending"]);
 export class CloudError extends Error {
     code;
     constructor(code) {
-        super(code === "invalid_device_session"
-            ? "Device authorization is invalid."
-            : "Rome Cloud is unavailable. Retry later.");
+        super(messages[code] ?? "Rome Cloud is unavailable. Retry later.");
         this.code = code;
     }
 }
@@ -21,12 +26,16 @@ export function cloudOrigin(value) {
         throw new Error("Use an HTTPS Cloud origin. HTTP is allowed only on loopback.");
     return url.origin;
 }
-export async function cloudRequest(origin, path, token, method = "GET") {
+export async function cloudRequest(origin, path, token, method = "GET", json) {
     let response;
     try {
         response = await fetch(new URL(path, cloudOrigin(origin)), {
             method,
-            headers: { Authorization: `Bearer ${token}` },
+            headers: {
+                Authorization: `Bearer ${token}`,
+                ...(json === undefined ? {} : { "content-type": "application/json" }),
+            },
+            body: json === undefined ? undefined : JSON.stringify(json),
             redirect: "error",
             signal: AbortSignal.timeout(10_000),
             cache: "no-store",
@@ -39,6 +48,8 @@ export async function cloudRequest(origin, path, token, method = "GET") {
     if (!response.ok) {
         if (response.status === 401 && isRecord(body) && body.error === "invalid_device_session")
             throw new CloudError("invalid_device_session");
+        if (isRecord(body) && typeof body.error === "string" && deviceErrors.has(body.error))
+            throw new CloudError(body.error);
         throw new CloudError("cloud_unavailable");
     }
     return body;

package/dist/connector.d.ts

@@ -22,6 +22,8 @@ export declare class DeviceConnector {
     private ensure;
     private initialize;
     list(): Promise<unknown>;
+    rename(deviceId: string, name: string): Promise<void>;
+    remove(deviceId: string): Promise<void>;
     private receive;
     private receiveFrame;
     private admit;

package/dist/connector.js

@@ -80,6 +80,22 @@ export class DeviceConnector {
             throw new CloudError("invalid_response");
         return { items: body.items };
     }
+    async rename(deviceId, name) {
+        if (this.stopped)
+            throw new Error("connector_stopped");
+        if (!isUuid(deviceId))
+            throw new CloudError("device_not_found");
+        const { cloudUrl, token } = this.options.credential;
+        await cloudRequest(cloudUrl, `/api/account/devices/${deviceId}`, token, "PATCH", { name });
+    }
+    async remove(deviceId) {
+        if (this.stopped)
+            throw new Error("connector_stopped");
+        if (!isUuid(deviceId))
+            throw new CloudError("device_not_found");
+        const { cloudUrl, token } = this.options.credential;
+        await cloudRequest(cloudUrl, `/api/account/devices/${deviceId}`, token, "DELETE");
+    }
     receive(message) {
         const pending = this.pending.get(message.id);
         if (!pending || pending.binary)

package/dist/daemon-client.d.ts

@@ -32,6 +32,8 @@ export declare function createNodeClient(config: NodeConfig, options?: NodeClien
     getConnectionStatus(): Promise<DaemonStatus | null>;
     getDevicesStatus(): Promise<DevicesStatus | null>;
     listDevices(): Promise<DeviceList>;
+    renameDevice: (deviceId: string, name: string) => Promise<void>;
+    removeDevice: (deviceId: string) => Promise<void>;
     run: (deviceId: string, action: string, args?: unknown) => Promise<ActionResponse>;
     runBinary: (deviceId: string, action: string, args?: unknown, body?: Uint8Array) => Promise<BinaryActionResult>;
     copy: (request: CopyRequest, options?: {

package/dist/daemon-client.js

@@ -146,6 +146,38 @@ export function createNodeClient(config, options = {}) {
             throw error;
         }
     }
+    async function manage(method, params) {
+        assertOpen();
+        let value;
+        try {
+            value = await call(method, params);
+        }
+        catch (error) {
+            if (error instanceof RpcError && error.code === -32601)
+                throw new DaemonVersionError();
+            if (error instanceof DaemonRequestError)
+                throw new DeviceActionError({
+                    type: "response",
+                    ok: false,
+                    error: { code: error.code, message: error.message },
+                });
+            if (error instanceof RpcError)
+                throw new DeviceActionError({
+                    type: "response",
+                    ok: false,
+                    error: {
+                        code: error.code === -32602 ? "invalid_request" : "cloud_unavailable",
+                        message: error.message,
+                    },
+                });
+            throw error;
+        }
+        const response = parseResponse(value);
+        if (!response)
+            throw new Error("Invalid device management response.");
+        if (!response.ok)
+            throw new DeviceActionError(response);
+    }
     async function runBinary(deviceId, action, args = {}, body = new Uint8Array()) {
         assertOpen();
         const empty = new Uint8Array();
@@ -281,6 +313,8 @@ export function createNodeClient(config, options = {}) {
                 throw new Error("Invalid device list response.");
             return body;
         },
+        renameDevice: (deviceId, name) => manage("devices.rename", { deviceId, name }),
+        removeDevice: (deviceId) => manage("devices.remove", { deviceId }),
         run,
         runBinary,
         copy,

package/dist/daemon.js

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import WebSocket, { WebSocketServer } from "ws";
 import { actionError, isRecord } from "./actions.js";
 import { ObserveStore, QueryError } from "./observe.js";
+import { CloudError } from "./cloud.js";
 import { DeviceConnector } from "./connector.js";
 import { daemonStatePath, readCallerCredential } from "./local.js";
 import { writePrivateJson } from "./storage.js";
@@ -364,6 +365,28 @@ export async function serveDaemon(config, signal) {
                     case "devices.list":
                         result = await connector.list();
                         break;
+                    case "devices.rename":
+                    case "devices.remove": {
+                        if (typeof params.deviceId !== "string" ||
+                            (value.method === "devices.rename" && typeof params.name !== "string"))
+                            throw new RpcError(-32602, "A device ID and, for rename, a name are required.");
+                        try {
+                            if (value.method === "devices.rename")
+                                await connector.rename(params.deviceId, params.name);
+                            else
+                                await connector.remove(params.deviceId);
+                            result = { type: "response", ok: true, result: {} };
+                        }
+                        catch (cause) {
+                            if (!(cause instanceof CloudError))
+                                throw cause;
+                            result = actionError(cause.code, cause.message);
+                        }
+                        finally {
+                            deviceStatus.invalidate();
+                        }
+                        break;
+                    }
                     case "devices.run":
                         if (typeof params.deviceId !== "string" || typeof params.action !== "string")
                             throw new RpcError(-32602, "A device ID and action are required.");

package/dist/executor.d.ts

@@ -1,5 +1,6 @@
 import { type Frame } from "./frame.js";
 import type { InboundEnvelope, OutboundEnvelope } from "./protocol.js";
+export declare const FS_LIST_LIMIT = 1000;
 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>;

package/dist/executor.js

@@ -1,5 +1,7 @@
 import { spawn } from "node:child_process";
-import { platform } from "node:os";
+import { readdir, realpath, stat } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { dirname, resolve } from "node:path";
 import { actionError, isRecord } from "./actions.js";
 import { decodeMeta, encodeMeta, FRAME_TYPE, frameFits, MAX_FRAME_BYTES, } from "./frame.js";
 import { parseTransferMessage, TRANSFER_VERSION, TransferHost } from "./transfer.js";
@@ -19,6 +21,57 @@ function execInput(input) {
         cwd: input.cwd,
     };
 }
+export const FS_LIST_LIMIT = 1000;
+const typeOrder = { dir: 0, symlink: 1, file: 2, other: 3 };
+function fsError(error) {
+    const code = isRecord(error) ? error.code : undefined;
+    if (code === "ENOENT")
+        return actionError("not_found", "The folder does not exist.");
+    if (code === "EACCES" || code === "EPERM")
+        return actionError("permission_denied", "The computer's user cannot read this folder.");
+    if (code === "ENOTDIR")
+        return actionError("not_a_directory", "The path is not a folder.");
+    return actionError("fs_failed", "Could not read the folder.");
+}
+async function listFolder(input) {
+    const raw = input === undefined || input === null ? {} : input;
+    if (!isRecord(raw) ||
+        (raw.path !== undefined &&
+            (typeof raw.path !== "string" || !raw.path || raw.path.includes("\0"))))
+        return actionError("invalid_args", "fs.list takes an optional non-empty string path.");
+    let path;
+    let entries;
+    try {
+        path = await realpath(resolve(homedir(), raw.path ?? "."));
+        if (!(await stat(path)).isDirectory())
+            return actionError("not_a_directory", "The path is not a folder.");
+        entries = (await readdir(path, { withFileTypes: true })).map((entry) => ({
+            name: entry.name,
+            type: entry.isDirectory()
+                ? "dir"
+                : entry.isFile()
+                    ? "file"
+                    : entry.isSymbolicLink()
+                        ? "symlink"
+                        : "other",
+        }));
+    }
+    catch (error) {
+        return fsError(error);
+    }
+    entries.sort((a, b) => typeOrder[a.type] - typeOrder[b.type] || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const parent = dirname(path);
+    return {
+        type: "response",
+        ok: true,
+        result: {
+            path,
+            parent: parent === path ? null : parent,
+            entries: entries.slice(0, FS_LIST_LIMIT),
+            truncated: entries.length > FS_LIST_LIMIT,
+        },
+    };
+}
 export function redactBytes(data, secrets) {
     for (const secret of secrets) {
         const needle = Buffer.from(secret);
@@ -39,7 +92,7 @@ export function createExecutor(name, send, secrets = [], sendFrame = () => false
         result: {
             name,
             platform: platform() === "darwin" ? "macos" : platform() === "win32" ? "windows" : platform(),
-            actions: ["system.info", "exec"],
+            actions: ["system.info", "exec", "fs.list"],
             frameVersion: 1,
             transferVersion: TRANSFER_VERSION,
         },
@@ -113,10 +166,12 @@ export function createExecutor(name, send, secrets = [], sendFrame = () => false
                 },
             };
         },
+        "fs.list": listFolder,
     };
     const empty = new Uint8Array();
     const frameHandlers = {
         "system.info": async () => ({ response: info(), body: empty }),
+        "fs.list": async (input) => ({ response: await listFolder(input), body: empty }),
         exec: async (input, body) => {
             const parsed = execInput(input);
             if (!parsed)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rome-os/node-core",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "JavaScript APIs for Rome device hosts and shared caller daemons",
   "license": "MIT",
   "type": "module",