@rome-os/node 0.1.0 → 0.1.2

package/README.md

@@ -8,8 +8,9 @@ Build an installation archive from this repository:
 
 ```sh
 pnpm --filter @rome-os/node build
+pnpm --filter @rome-os/node-core pack --pack-destination /tmp
 pnpm --filter @rome-os/node pack --pack-destination /tmp
-npm install -g /tmp/rome-os-node-0.1.0.tgz
+npm install -g /tmp/rome-os-node-core-0.1.0.tgz /tmp/rome-os-node-0.1.0.tgz
 ```
 
 On the target computer:
@@ -22,7 +23,27 @@ Open the printed authorization URL in a browser on that computer and approve it.
 The browser callback uses a temporary loopback listener. A remote browser needs
 a tunnel to that listener. Ctrl+C disconnects and preserves the credential.
 
-On the caller, configure a previously issued communication token through stdin:
+Over SSH or on a headless computer, use device authorization:
+
+```sh
+rome-node connect --device-code --name "Remote Linux" --cloud https://romeos.cc
+```
+
+Open the printed URL on another device and approve the displayed user code.
+The CLI prints the expiry and waits for approval without a callback listener or SSH tunnel.
+Ctrl+C cancels the authorization. Both modes reuse stored credentials when valid.
+
+Rome instances prepare caller authorization automatically at startup and after
+Cloud enrollment. In a server environment that supplies `ROME_INSTANCE_TOKEN`, run:
+
+```sh
+rome-node auth --server --cloud https://romeos.cc
+```
+
+This exchanges the Instance Token with Cloud and stores only the communication
+token. Existing caller credentials are reused. The CLI does not read Rome's database.
+
+For manual caller configuration, pass an issued communication token through stdin:
 
 ```sh
 rome-node auth --cloud https://romeos.cc < /path/to/private-token-file
@@ -49,10 +70,21 @@ Gateway connection. `rome-node daemon status` reports its PID, and
 daemon before changing credentials. `rome-node daemon serve` runs in the
 foreground for diagnosis. Set `ROME_NODE_CONFIG_DIR` to isolate configurations.
 
+`rome-node watch` subscribes to caller connection changes and prints one JSON
+event per line. It starts the daemon if needed and begins with a snapshot.
+After a connection loss it waits for the daemon and subscribes again; it does
+not restart a stopped daemon. Ctrl+C closes only the watcher. These events
+report the caller's Gateway connection, not remote device presence.
+
 Commands print JSON to stdout and diagnostics to stderr. Errors and nonzero
-remote exit codes produce a nonzero local exit status. An authorized device is
+remote exit codes produce a nonzero local exit status. Output is collected in memory
+and returned in full after program exit. Action message limits follow the WebSocket library and infrastructure.
+The local daemon disconnects event observers that exceed its send-buffer limit. A lost response reports
+`unknown_outcome`. Never automatically retry an unknown outcome.
+An authorized device is
 not necessarily online. Use `describe` to query its current platform and actions.
 
-The package exports the Gateway client, socket adapter, and action response
-contract for other clients. See [the device architecture and operating guide](../../docs/rome-node.md)
+The CLI uses [`@rome-os/node-core`](../rome-node-core/README.md) for authorization,
+its shared caller daemon, and the computer host. The package also re-exports
+the Gateway client, socket adapter, and action response contract for compatibility. See [the device architecture and operating guide](../../docs/rome-node.md)
 for credential boundaries, file operations, output limits, and disconnection behavior.

package/dist/entry.js

@@ -1,12 +1,26 @@
 import { parseArgs } from "node:util";
-import { connectComputer, defaultDeviceName } from "./connect.js";
-import { isRecord, parseResponse } from "./actions.js";
-import { callerCredentialPath } from "./local.js";
-import { writePrivateJson } from "./storage.js";
-import { cloudOrigin, gatewayConfig } from "./cloud.js";
-import { callDaemon, daemonStatus, serveDaemon, startDaemon, stopDaemon } from "./daemon.js";
-import { validId } from "./protocol.js";
+import { join } from "node:path";
+import { isRecord, cloudOrigin, validId } from "@rome-os/node-core";
+import { authorizeServer, configureCaller } from "@rome-os/node-core/auth";
+import { createNodeClient, CallerConfigurationError, DeviceActionError, nodeConfigFromEnvironment, readOptionalCallerCredential, daemonStatus, startDaemon, stopDaemon, } from "@rome-os/node-core/client";
 import { commandHelp } from "./help.js";
+async function withShutdown(run) {
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+        await run(controller.signal);
+    }
+    catch (error) {
+        if (!controller.signal.aborted)
+            throw error;
+    }
+    finally {
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+    }
+}
 async function main() {
     const { values, positionals } = parseArgs({
         allowPositionals: true,
@@ -16,6 +30,8 @@ async function main() {
             cloud: { type: "string" },
             name: { type: "string" },
             args: { type: "string" },
+            server: { type: "boolean" },
+            "device-code": { type: "boolean" },
         },
     });
     if (values.help || positionals.length === 0 || positionals[0] === "help") {
@@ -23,10 +39,28 @@ async function main() {
         process.stdout.write(commandHelp(explicitTopic ? positionals.slice(1) : positionals, explicitTopic));
         return;
     }
+    const config = nodeConfigFromEnvironment(process.env);
+    if (values.server && !(positionals[0] === "auth" && positionals.length === 1))
+        throw new Error("--server is only supported by rome-node auth.");
+    if (values["device-code"] && !(positionals[0] === "connect" && positionals.length === 1))
+        throw new Error("--device-code is only supported by rome-node connect.");
+    if (positionals[0] === "auth" && positionals[1] === "status" && positionals.length === 2) {
+        const credential = await readOptionalCallerCredential(config);
+        process.stdout.write(`${JSON.stringify(credential ? { configured: true, cloudUrl: credential.cloudUrl } : { configured: false })}\n`);
+        return;
+    }
     if (positionals[0] === "auth" && positionals.length === 1) {
+        const cloudUrl = cloudOrigin(values.cloud ?? "https://romeos.cc");
+        if (values.server) {
+            await authorizeServer(cloudUrl, process.env.ROME_INSTANCE_TOKEN, config, () => {
+                process.stderr.write("Rome Cloud is temporarily unavailable. Retrying server authorization.\n");
+            });
+            process.stdout.write(`${JSON.stringify({ configured: true })}\n`);
+            return;
+        }
         if (process.stdin.isTTY)
             throw new Error("Pass the communication token through stdin, not command arguments.");
-        if (await daemonStatus())
+        if (await daemonStatus(config))
             throw new Error("Stop the CLI daemon before changing credentials: rome-node daemon stop");
         const chunks = [];
         let size = 0;
@@ -38,11 +72,7 @@ async function main() {
             chunks.push(buffer);
         }
         const token = Buffer.concat(chunks).toString("utf8").trim();
-        if (!/^romedev_[A-Za-z0-9_-]{43}$/.test(token))
-            throw new Error("Invalid communication token.");
-        const cloudUrl = cloudOrigin(values.cloud ?? "https://romeos.cc");
-        await gatewayConfig(cloudUrl, token);
-        await writePrivateJson(callerCredentialPath(), { cloudUrl, token });
+        await configureCaller(cloudUrl, token, config);
         process.stdout.write(`${JSON.stringify({ configured: true })}\n`);
         return;
     }
@@ -51,36 +81,75 @@ async function main() {
             throw new Error("Invalid daemon command.");
         const operation = positionals[1] ?? "start";
         if (operation === "serve") {
-            await serveDaemon();
+            const { serveDaemon } = await import("@rome-os/node-core/daemon");
+            await withShutdown((signal) => serveDaemon(config, signal));
             return;
         }
         if (operation === "stop") {
-            await stopDaemon();
+            await stopDaemon(config);
             process.stdout.write(`${JSON.stringify({ running: false })}\n`);
             return;
         }
         if (operation !== "start" && operation !== "status")
             throw new Error("Unknown daemon command.");
-        const state = operation === "start" ? await startDaemon() : await daemonStatus();
+        const state = operation === "start" ? await startDaemon(config) : await daemonStatus(config);
         process.stdout.write(`${JSON.stringify(state ? { running: true, pid: state.pid } : { running: false })}\n`);
         return;
     }
+    if (positionals[0] === "watch" && positionals.length === 1) {
+        await withShutdown(async (signal) => {
+            const client = createNodeClient(config);
+            let finish;
+            const stopped = new Promise((resolve) => {
+                finish = resolve;
+            });
+            const stop = () => {
+                client.disconnect();
+                finish();
+            };
+            signal.addEventListener("abort", stop, { once: true });
+            try {
+                if (signal.aborted)
+                    return;
+                await client.subscribe("connection", (event) => process.stdout.write(`${JSON.stringify(event)}\n`));
+                await stopped;
+            }
+            finally {
+                signal.removeEventListener("abort", stop);
+                client.disconnect();
+            }
+        });
+        return;
+    }
     if (positionals[0] === "connect" && positionals.length === 1) {
-        const controller = new AbortController();
-        const stop = () => controller.abort();
-        process.once("SIGINT", stop);
-        process.once("SIGTERM", stop);
-        try {
-            await connectComputer(values.cloud ?? "https://romeos.cc", values.name ?? defaultDeviceName(), controller.signal);
-        }
-        catch (error) {
-            if (!controller.signal.aborted)
-                throw error;
-        }
-        finally {
-            process.removeListener("SIGINT", stop);
-            process.removeListener("SIGTERM", stop);
-        }
+        const { connectHost, defaultDeviceName, loginDevice, loginDeviceCode, createFileCredentialStore, } = await import("@rome-os/node-core/host");
+        const name = values.name ?? defaultDeviceName();
+        await withShutdown((signal) => connectHost({
+            cloudUrl: values.cloud ?? "https://romeos.cc",
+            name,
+            signal,
+            credentials: createFileCredentialStore(join(config.directory, "credential.json")),
+            authorize: (origin, deviceName, abort) => values["device-code"]
+                ? loginDeviceCode(origin, deviceName, abort, (prompt) => {
+                    process.stderr.write(`Open this URL in a browser on another device:\n${prompt.verificationUri}\n` +
+                        `User code: ${prompt.userCode}\n` +
+                        `Or open: ${prompt.verificationUriComplete}\n` +
+                        `Expires in ${prompt.expiresIn} seconds. Waiting for approval. Ctrl+C cancels.\n`);
+                })
+                : loginDevice(origin, deviceName, abort, (url) => {
+                    process.stderr.write(`Open this URL in your browser to authorize ${deviceName}:\n${url}\n`);
+                }),
+            onEvent: (event) => {
+                if (event.type === "authorization_required")
+                    process.stderr.write("While connect is running, Rome instances in your account can execute programs and read or change files as your OS user.\n");
+                else if (event.type === "retrying")
+                    process.stderr.write("Rome Cloud is unavailable; keeping credentials and retrying.\n");
+                else if (event.type === "device")
+                    process.stderr.write(`Device: ${event.name}\nDevice ID: ${event.deviceId}\n`);
+                else
+                    process.stderr.write(`Connection: ${event.status}\n`);
+            },
+        }));
         return;
     }
     if (positionals[0] !== "device")
@@ -102,26 +171,42 @@ async function main() {
             throw new Error("--args must contain valid JSON.");
         }
     }
-    const response = await callDaemon(listing ? "/devices" : "/run", listing
-        ? undefined
-        : { deviceId, action: command === "describe" ? "system.info" : action, args });
-    const body = await response.json();
-    if (listing && response.ok && isRecord(body) && Array.isArray(body.items)) {
-        process.stdout.write(`${JSON.stringify({ items: body.items })}\n`);
-        return;
+    const client = createNodeClient(config);
+    try {
+        if (listing) {
+            process.stdout.write(`${JSON.stringify(await client.listDevices())}\n`);
+            return;
+        }
+        const result = command === "describe"
+            ? await client.describe(deviceId)
+            : await client.run(deviceId, action, args);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        if (!result.ok ||
+            (isRecord(result.result) &&
+                Object.hasOwn(result.result, "exitCode") &&
+                result.result.exitCode !== 0))
+            process.exitCode = 1;
+    }
+    finally {
+        client.disconnect();
     }
-    const result = parseResponse(body);
-    if (!result)
-        throw new Error("Invalid response from the CLI daemon.");
-    process.stdout.write(`${JSON.stringify(result)}\n`);
-    if (!result.ok ||
-        !response.ok ||
-        (isRecord(result.result) &&
-            Object.hasOwn(result.result, "exitCode") &&
-            result.result.exitCode !== 0))
-        process.exitCode = 1;
 }
 main().catch((error) => {
+    if (error instanceof DeviceActionError) {
+        process.stdout.write(`${JSON.stringify(error.response)}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (error instanceof CallerConfigurationError) {
+        const messages = {
+            not_configured: "Configure a communication token with rome-node auth --cloud <origin> using stdin first.",
+            daemon_running: "Stop the CLI daemon before changing credentials: rome-node daemon stop",
+            instance_token_required: "Server authorization requires ROME_INSTANCE_TOKEN in the environment.",
+        };
+        process.stderr.write(`${messages[error.code]}\n`);
+        process.exitCode = 1;
+        return;
+    }
     process.stderr.write(`${error instanceof Error ? error.message : "Rome Node failed."}\n`);
     process.exitCode = 1;
 });

package/dist/help.js

@@ -6,10 +6,12 @@ Usage:
 
 Commands:
   connect          Keep this computer online as a remote executor.
-  auth             Configure the caller's communication token through stdin.
+  auth             Configure caller authorization through stdin or server mode.
+  auth status      Report local caller configuration without revealing the token.
   device           List authorized devices (they may be offline).
   device describe  Query a device's platform and supported actions.
   device run       Execute an action on a device.
+  watch            Stream caller connection snapshots and changes as JSON lines.
   daemon           Manage the caller's background connection.
 
 Agent workflow:
@@ -23,36 +25,72 @@ Use -h or --help on any command. No arguments also prints this overview.
 Set ROME_NODE_CONFIG_DIR to use a separate configuration directory.
 `;
 const commands = {
-    connect: `Usage: rome-node connect [--cloud <origin>] [--name <name>]
+    watch: `Usage: rome-node watch
+
+Subscribe to caller connection state as newline-delimited JSON.
+Starts the daemon if needed, but does not open its Gateway connection.
+Each connected event includes {transport:"connected",daemon:{pid,protocolVersion,connection}}.
+Local disconnection emits {transport:"disconnected",daemon:null,reason:"connection_lost"}.
+The daemon connection and its Gateway connection are separate states.
+
+Reconnection restores the subscription and emits a fresh snapshot, not missed history.
+A watcher does not restart an explicitly stopped daemon. Another command can start it.
+Ctrl+C exits the watcher without stopping the daemon or remote operations.
+These events do not indicate whether individual remote devices are online.
+`,
+    connect: `Usage: rome-node connect [--device-code] [--cloud <origin>] [--name <name>]
 
 Run this on the computer that will execute programs.
 Open the printed browser URL and approve access when authorization is needed.
+By default, the browser returns to a loopback listener on this computer.
+Use --device-code over SSH or on a headless computer to approve from another device.
+This mode prints a URL and user code without opening a browser or callback listener.
+Stored credentials are reused in either mode. SSH is not detected automatically.
 The process stays in the foreground. Ctrl+C disconnects and preserves authorization.
 Programs run as the OS user who starts connect.
 
 Options:
   --cloud <origin>  Cloud origin (default: https://romeos.cc).
   --name <name>     Name for browser authorization (default: computer hostname).
+  --device-code     Authorize from another device without a callback or SSH tunnel.
 
 Example:
   rome-node connect --name "My computer"
+  rome-node connect --device-code --name "Remote Linux" --cloud https://romeos.cc
 `,
-    auth: `Usage: rome-node auth [--cloud <origin>] < token-file
+    auth: `Usage:
+  rome-node auth [--cloud <origin>] < token-file
+  rome-node auth --server [--cloud <origin>]
 
 Read an issued communication token (romedev_...) from stdin, validate it with
-Cloud, and save it privately for device commands. An Instance Token must first
-be exchanged through Cloud. This command does not perform that exchange.
+Cloud, and save it privately for device commands.
 Stop a running caller daemon before changing credentials.
 
+With --server, reuse existing caller credentials for this Cloud origin. If missing,
+read ROME_INSTANCE_TOKEN from the environment, exchange it with Cloud, and save
+only the communication token. This does not start a daemon or read Rome's database.
+Transient Cloud failures get up to three attempts with delays of one and five seconds.
+An issued token is reused across validation retries. Existing credentials for
+another Cloud origin are preserved and require manual configuration.
+
 Options:
   --cloud <origin>  Cloud origin (default: https://romeos.cc).
+  --server          Authorize using ROME_INSTANCE_TOKEN from the environment.
 
 Example:
   rome-node daemon stop
   rome-node auth --cloud https://romeos.cc < /path/to/private-token-file
+  rome-node auth --server --cloud https://romeos.cc
 
 Output: {"configured":true}
-Pass tokens through stdin. Never put them in command arguments or print them.
+Pass communication tokens through stdin. Never put tokens in command arguments or print them.
+`,
+    "auth status": `Usage: rome-node auth status
+
+Report local caller configuration without contacting Cloud or starting the daemon.
+Output: {"configured":true,"cloudUrl":"https://romeos.cc"} or {"configured":false}.
+This checks the local credential format, not its validity at Cloud.
+The token is never printed.
 `,
     device: `Usage:
   rome-node device
@@ -112,8 +150,9 @@ Output:
 Check exec's exitCode even when ok is true. The local exit status is 1 for
 action failures, nonzero remote exit codes, or signal termination, otherwise 0.
 Local setup and argument errors print diagnostics to stderr and exit 1.
-Each output stream retains at most 48 KiB, with further truncation to fit a frame.
-Check truncated before treating output or file contents as complete.
+Output is collected in memory and returned in full after program exit.
+The CLI does not truncate output or impose message or send-buffer size limits.
+Transport limits still apply. Connection loss returns unknown_outcome.
 
 The caller waits up to 60 seconds for a response. unknown_outcome means execution
 may have started or completed. A local timeout does not cancel the remote program.

package/dist/index.d.ts

@@ -1,5 +1,2 @@
-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";
-export { createNodeSocket } from "./socket.js";
+export * from "@rome-os/node-core";
+export { createNodeSocket } from "@rome-os/node-core/socket";

package/dist/index.js

@@ -1,5 +1,2 @@
-export { connectGateway, } from "./client.js";
-export { MAX_MESSAGE_BYTES, byteLength, validId, } from "./protocol.js";
-export { CloudError, cloudOrigin, cloudRequest, gatewayConfig } from "./cloud.js";
-export { actionError, isRecord, parseResponse, } from "./actions.js";
-export { createNodeSocket } from "./socket.js";
+export * from "@rome-os/node-core";
+export { createNodeSocket } from "@rome-os/node-core/socket";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rome-os/node",
-  "version": "0.1.0",
-  "description": "Rome device protocol, Gateway client, and remote computer CLI",
+  "version": "0.1.2",
+  "description": "Standalone CLI for Rome remote devices",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -22,21 +22,22 @@
     }
   },
   "dependencies": {
-    "ws": "^8.18.0"
+    "@rome-os/node-core": "^0.1.1"
   },
   "devDependencies": {
     "@rstest/core": "^0.11.11",
     "@types/node": "25.2.3",
     "@types/ws": "^8.18.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "ws": "^8.18.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rome-os/rome.git",
-    "directory": "packages/rome-node"
+    "directory": "packages/rome-node-cli"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "pnpm --filter @rome-os/node-core build && node -e \"require('node:fs').rmSync('dist', {recursive:true, force:true})\" && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "pnpm build && ../../scripts/test-env.sh rstest"
   }

package/dist/actions.d.ts

@@ -1,20 +0,0 @@
-export interface ActionRequest {
-    type: "request";
-    action: string;
-    args: unknown;
-}
-export type ActionResponse = {
-    type: "response";
-    ok: true;
-    result: unknown;
-} | {
-    type: "response";
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-    };
-};
-export declare function actionError(code: string, message: string): ActionResponse;
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function parseResponse(value: unknown): ActionResponse | null;

package/dist/actions.js

@@ -1,18 +0,0 @@
-export function actionError(code, message) {
-    return { type: "response", ok: false, error: { code, message } };
-}
-export function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-export function parseResponse(value) {
-    if (!isRecord(value) || value.type !== "response")
-        return null;
-    if (value.ok === true && Object.hasOwn(value, "result"))
-        return { type: "response", ok: true, result: value.result };
-    if (value.ok === false &&
-        isRecord(value.error) &&
-        typeof value.error.code === "string" &&
-        typeof value.error.message === "string")
-        return actionError(value.error.code, value.error.message);
-    return null;
-}

package/dist/client.d.ts

@@ -1,29 +0,0 @@
-import { type GatewayMessage, type OutboundEnvelope } from "./protocol.js";
-export interface ClientSocket {
-    readyState: number;
-    bufferedAmount: number;
-    send(data: string): void;
-    close(code?: number, reason?: string): void;
-    addEventListener(type: "open", listener: () => void): void;
-    addEventListener(type: "message", listener: (event: {
-        data: unknown;
-    }) => void): void;
-    addEventListener(type: "close", listener: (event: {
-        code: number;
-    }) => void): void;
-    addEventListener(type: "error", listener: () => void): void;
-}
-export type ConnectionStatus = "connecting" | "online" | "retrying" | "revoked" | "superseded" | "stopped";
-export interface GatewayClientOptions {
-    gatewayUrl: string;
-    deviceToken: string;
-    createSocket(url: string, authorization: string): ClientSocket;
-    onMessage(message: GatewayMessage): void;
-    onStatus?(status: ConnectionStatus): void;
-    random?(): number;
-    beforeConnect?(): Promise<string | null>;
-}
-export declare function connectGateway(options: GatewayClientOptions): {
-    send(envelope: OutboundEnvelope): boolean;
-    stop(): void;
-};