@rome-os/node 0.1.0

package/dist/daemon.js

@@ -0,0 +1,208 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { setTimeout as delay } from "node:timers/promises";
+import { actionError, isRecord } from "./actions.js";
+import { DeviceConnector } from "./connector.js";
+import { configRoot, daemonPort, daemonStatePath, readCallerCredential } from "./local.js";
+import { MAX_MESSAGE_BYTES } from "./protocol.js";
+import { readPrivateJson, writePrivateJson } from "./storage.js";
+async function readDaemonState() {
+    const value = await readPrivateJson(daemonStatePath());
+    if (!isRecord(value) ||
+        typeof value.token !== "string" ||
+        !/^romenode_[A-Za-z0-9_-]{43}$/.test(value.token) ||
+        value.port !== daemonPort() ||
+        typeof value.pid !== "number" ||
+        !Number.isSafeInteger(value.pid) ||
+        value.pid <= 0)
+        return null;
+    return { token: value.token, port: daemonPort(), pid: value.pid };
+}
+async function request(state, path, body) {
+    return fetch(`http://127.0.0.1:${state.port}${path}`, {
+        method: body === undefined ? "GET" : "POST",
+        redirect: "error",
+        signal: AbortSignal.timeout(path === "/status" ? 1000 : 85_000),
+        headers: { authorization: `Bearer ${state.token}`, "content-type": "application/json" },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+}
+export async function daemonStatus() {
+    const state = await readDaemonState();
+    if (!state)
+        return null;
+    try {
+        const response = await request(state, "/status");
+        const value = await response.json();
+        return response.ok && isRecord(value) && value.pid === state.pid ? state : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function startDaemon() {
+    const current = await daemonStatus();
+    if (current)
+        return current;
+    await readCallerCredential();
+    const child = spawn(process.execPath, [process.argv[1], "daemon", "serve"], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: { ...process.env, ROME_NODE_CONFIG_DIR: configRoot() },
+    });
+    let failed = false;
+    child.on("error", () => {
+        failed = true;
+    });
+    child.unref();
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline && !failed) {
+        const state = await daemonStatus();
+        if (state)
+            return state;
+        await delay(50);
+    }
+    throw new Error("Could not start the CLI daemon. Run rome-node daemon serve to inspect the error. If its port is occupied, set ROME_NODE_DAEMON_PORT.");
+}
+export async function stopDaemon() {
+    const state = await daemonStatus();
+    if (!state)
+        return;
+    const response = await request(state, "/stop", {});
+    if (!response.ok)
+        throw new Error("Could not stop the CLI daemon.");
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        try {
+            const status = await request(state, "/status");
+            if (status.status === 401)
+                return;
+        }
+        catch {
+            return;
+        }
+        await delay(50);
+    }
+    throw new Error("The CLI daemon has not stopped yet.");
+}
+export async function callDaemon(path, body) {
+    const state = await startDaemon();
+    try {
+        return await request(state, path, body);
+    }
+    catch {
+        throw new Error("CLI daemon connection failed. Execution outcome may be unknown; do not automatically retry.");
+    }
+}
+function json(response, status, value) {
+    response.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" });
+    response.end(JSON.stringify(value));
+}
+async function readBody(request) {
+    let size = 0;
+    const chunks = [];
+    for await (const chunk of request) {
+        const buffer = Buffer.from(chunk);
+        size += buffer.length;
+        if (size > MAX_MESSAGE_BYTES)
+            throw new Error("message_too_large");
+        chunks.push(buffer);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+export async function serveDaemon() {
+    const credential = await readCallerCredential();
+    const connector = new DeviceConnector({ credential });
+    const state = {
+        port: daemonPort(),
+        pid: process.pid,
+        token: `romenode_${randomBytes(32).toString("base64url")}`,
+    };
+    let closing = false;
+    const server = createServer((req, res) => {
+        void handle(req, res).catch(() => {
+            if (!res.headersSent)
+                json(res, 503, actionError("gateway_unavailable", "The device service is unavailable."));
+            else
+                res.destroy();
+        });
+    });
+    server.requestTimeout = 10_000;
+    server.headersTimeout = 10_000;
+    const close = () => {
+        if (closing)
+            return;
+        closing = true;
+        connector.stop();
+        server.close();
+        server.closeIdleConnections();
+        const timer = setTimeout(() => server.closeAllConnections(), 1000);
+        timer.unref();
+    };
+    async function handle(req, res) {
+        const actual = Buffer.from(req.headers.authorization ?? "");
+        const expected = Buffer.from(`Bearer ${state.token}`);
+        if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
+            json(res, 401, actionError("unauthorized", "A CLI daemon credential is required."));
+            return;
+        }
+        if (closing) {
+            json(res, 503, actionError("daemon_stopped", "The CLI daemon is stopping."));
+        }
+        else if (req.method === "GET" && req.url === "/status") {
+            json(res, 200, { pid: state.pid });
+        }
+        else if (req.method === "POST" && req.url === "/stop") {
+            json(res, 200, { stopped: true });
+            close();
+        }
+        else if (req.method === "GET" && req.url === "/devices") {
+            json(res, 200, await connector.list());
+        }
+        else if (req.method === "POST" && req.url === "/run") {
+            if (Number(req.headers["content-length"]) > MAX_MESSAGE_BYTES) {
+                json(res, 413, actionError("message_too_large", "The request exceeds 128 KiB."));
+                req.resume();
+                return;
+            }
+            let body;
+            try {
+                body = await readBody(req);
+            }
+            catch (error) {
+                const tooLarge = error instanceof Error && error.message === "message_too_large";
+                json(res, tooLarge ? 413 : 400, actionError(tooLarge ? "message_too_large" : "invalid_request", "Invalid device request."));
+                return;
+            }
+            if (!isRecord(body) || typeof body.deviceId !== "string" || typeof body.action !== "string") {
+                json(res, 400, actionError("invalid_request", "A device ID and action are required."));
+                return;
+            }
+            json(res, 200, await connector.run(body.deviceId, body.action, body.args ?? {}));
+        }
+        else {
+            json(res, 404, actionError("not_found", "Unknown CLI daemon operation."));
+        }
+    }
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(state.port, "127.0.0.1", () => {
+            server.removeListener("error", reject);
+            resolve();
+        });
+    });
+    const finished = new Promise((resolve) => server.once("close", resolve));
+    process.once("SIGINT", close);
+    process.once("SIGTERM", close);
+    try {
+        await writePrivateJson(daemonStatePath(), state);
+        await finished;
+    }
+    finally {
+        close();
+        process.removeListener("SIGINT", close);
+        process.removeListener("SIGTERM", close);
+    }
+}

package/dist/entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entry.js

@@ -0,0 +1,127 @@
+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 { commandHelp } from "./help.js";
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        strict: true,
+        options: {
+            help: { type: "boolean", short: "h" },
+            cloud: { type: "string" },
+            name: { type: "string" },
+            args: { type: "string" },
+        },
+    });
+    if (values.help || positionals.length === 0 || positionals[0] === "help") {
+        const explicitTopic = positionals[0] === "help";
+        process.stdout.write(commandHelp(explicitTopic ? positionals.slice(1) : positionals, explicitTopic));
+        return;
+    }
+    if (positionals[0] === "auth" && positionals.length === 1) {
+        if (process.stdin.isTTY)
+            throw new Error("Pass the communication token through stdin, not command arguments.");
+        if (await daemonStatus())
+            throw new Error("Stop the CLI daemon before changing credentials: rome-node daemon stop");
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of process.stdin) {
+            const buffer = Buffer.from(chunk);
+            size += buffer.length;
+            if (size > 1024)
+                throw new Error("Invalid communication token.");
+            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 });
+        process.stdout.write(`${JSON.stringify({ configured: true })}\n`);
+        return;
+    }
+    if (positionals[0] === "daemon") {
+        if (positionals.length > 2)
+            throw new Error("Invalid daemon command.");
+        const operation = positionals[1] ?? "start";
+        if (operation === "serve") {
+            await serveDaemon();
+            return;
+        }
+        if (operation === "stop") {
+            await stopDaemon();
+            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();
+        process.stdout.write(`${JSON.stringify(state ? { running: true, pid: state.pid } : { running: false })}\n`);
+        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);
+        }
+        return;
+    }
+    if (positionals[0] !== "device")
+        throw new Error("Unknown command. Run rome-node --help.");
+    const [, command, deviceId, action] = positionals;
+    const listing = positionals.length === 1;
+    if (!listing &&
+        !(command === "describe" && positionals.length === 3) &&
+        !(command === "run" && positionals.length === 4))
+        throw new Error("Invalid device command. Run rome-node --help.");
+    if (!listing && !validId(deviceId))
+        throw new Error("Invalid device ID.");
+    let args = {};
+    if (values.args) {
+        try {
+            args = JSON.parse(values.args);
+        }
+        catch {
+            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 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) => {
+    process.stderr.write(`${error instanceof Error ? error.message : "Rome Node failed."}\n`);
+    process.exitCode = 1;
+});

package/dist/executor.d.ts

@@ -0,0 +1,5 @@
+import { type InboundEnvelope, type 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,121 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { actionError, isRecord } from "./actions.js";
+import { byteLength, MAX_MESSAGE_BYTES, } from "./protocol.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: Buffer.alloc(0), stderr: Buffer.alloc(0) };
+                const truncated = { stdout: false, stderr: false };
+                for (const stream of ["stdout", "stderr"]) {
+                    child[stream]?.on("data", (chunk) => {
+                        const remaining = 48 * 1024 - output[stream].length;
+                        if (chunk.length > remaining)
+                            truncated[stream] = true;
+                        output[stream] = Buffer.concat([output[stream], chunk.subarray(0, remaining)]);
+                    });
+                }
+                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 = (value) => secrets.reduce((text, secret) => text.replaceAll(secret, "[redacted]"), value.toString("utf8"));
+                    resolve({
+                        type: "response",
+                        ok: true,
+                        result: {
+                            exitCode,
+                            signal,
+                            stdout: redact(output.stdout),
+                            stderr: redact(output.stderr),
+                            truncated,
+                        },
+                    });
+                });
+            });
+        },
+    };
+    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 (payload.ok && isRecord(payload.result) && isRecord(payload.result.truncated)) {
+                const result = payload.result;
+                while (byteLength(JSON.stringify(reply)) > MAX_MESSAGE_BYTES) {
+                    for (const stream of ["stdout", "stderr"]) {
+                        if (typeof result[stream] === "string" && result[stream].length > 0) {
+                            result[stream] = result[stream].slice(0, Math.floor(result[stream].length * 0.75));
+                            result.truncated[stream] = true;
+                        }
+                    }
+                }
+            }
+            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/help.d.ts

@@ -0,0 +1 @@
+export declare function commandHelp(positionals: string[], explicitTopic: boolean): string;

package/dist/help.js

@@ -0,0 +1,156 @@
+const overview = `Rome Node — run programs on authorized remote computers.
+
+Usage:
+  rome-node help [command ...]
+  rome-node <command> --help
+
+Commands:
+  connect          Keep this computer online as a remote executor.
+  auth             Configure the caller's communication token through stdin.
+  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.
+  daemon           Manage the caller's background connection.
+
+Agent workflow:
+  1. Run rome-node device and choose a device ID from items.
+  2. Run rome-node device describe <device-id> to check its platform and actions.
+  3. Run rome-node help device run for argument formats and result handling.
+
+Device commands require caller auth and start the daemon automatically.
+Help works offline without credentials and does not start the daemon.
+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>]
+
+Run this on the computer that will execute programs.
+Open the printed browser URL and approve access when authorization is needed.
+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).
+
+Example:
+  rome-node connect --name "My computer"
+`,
+    auth: `Usage: rome-node auth [--cloud <origin>] < token-file
+
+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.
+Stop a running caller daemon before changing credentials.
+
+Options:
+  --cloud <origin>  Cloud origin (default: https://romeos.cc).
+
+Example:
+  rome-node daemon stop
+  rome-node auth --cloud https://romeos.cc < /path/to/private-token-file
+
+Output: {"configured":true}
+Pass tokens through stdin. Never put them in command arguments or print them.
+`,
+    device: `Usage:
+  rome-node device
+  rome-node device describe <device-id>
+  rome-node device run <device-id> <action> [--args <json>]
+
+With no subcommand, list authorized devices as {"items":[...]}.
+Use an item's id for subsequent commands. Listed devices may be offline.
+describe queries the target's current platform and actions through Gateway.
+run invokes one of those actions. The caller daemon starts automatically.
+
+Examples:
+  rome-node device
+  rome-node device describe <device-id>
+  rome-node help device run
+`,
+    "device describe": `Usage: rome-node device describe <device-id>
+
+Invoke system.info on an online target. Use an ID from rome-node device.
+The result includes name, platform, and actions. Platform-specific commands and
+paths must match the target computer, which may differ from the caller.
+
+Example result:
+  {"type":"response","ok":true,"result":{"name":"My computer","platform":"macos","actions":["system.info","exec"]}}
+
+Failures return {"type":"response","ok":false,"error":{"code":"...","message":"..."}}.
+The local exit status is 0 on success or 1 on failure.
+`,
+    "device run": `Usage: rome-node device run <device-id> <action> [--args <json>]
+
+Use an ID from rome-node device. Run device describe first to discover actions.
+--args is a JSON object for the action (default: {}).
+
+Computer actions:
+  system.info  No arguments. Returns name, platform, and actions.
+  exec         Run a program on the target computer.
+
+exec arguments:
+  command      Required nonempty executable name or path.
+  args         Optional array of string arguments (default: []).
+  cwd          Optional working directory on the target (default: executor cwd).
+
+Programs receive no interactive stdin. No shell is added automatically.
+Invoke a shell explicitly for pipelines, redirection, or shell builtins.
+Examples below use POSIX caller-shell quoting:
+  rome-node device run <device-id> system.info
+  rome-node device run <device-id> exec --args '{"command":"git","args":["status"],"cwd":"/workspace"}'
+  rome-node device run <device-id> exec --args '{"command":"cat","args":["/workspace/README.md"]}'
+  rome-node device run <device-id> exec --args '{"command":"sh","args":["-c","ls /workspace | head"]}'
+  rome-node device run <device-id> exec --args '{"command":"powershell.exe","args":["-NoProfile","-Command","Get-ChildItem -LiteralPath C:/Work"]}'
+
+Output:
+  Success: {"type":"response","ok":true,"result":{...}}
+  Failure: {"type":"response","ok":false,"error":{"code":"...","message":"..."}}
+  exec result: {exitCode, signal, stdout, stderr, truncated: {stdout, stderr}}
+
+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.
+
+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.
+Never automatically retry an unknown outcome. Requests are never replayed.
+`,
+    daemon: `Usage: rome-node daemon [start|status|stop|serve]
+
+  start   Start the background caller daemon if needed (default).
+  status  Report {"running":true,"pid":...} or {"running":false} without starting it.
+  stop    Close the daemon and its Gateway connection. Print {"running":false}.
+  serve   Run the daemon in the foreground for diagnosis. Ctrl+C stops it.
+
+Device commands start the daemon automatically and share its connection.
+start and serve require caller auth. A later device command restarts a stopped
+or crashed daemon. Interrupted operations are never replayed.
+Stop the daemon before changing credentials with rome-node auth.
+
+Environment:
+  ROME_NODE_CONFIG_DIR   Configuration directory shared by caller and daemon.
+  ROME_NODE_DAEMON_PORT  Override the derived loopback port (1024-65535).
+                        Use the same value for caller and daemon.
+`,
+};
+export function commandHelp(positionals, explicitTopic) {
+    if (positionals.length === 0)
+        return overview;
+    const topic = positionals.join(" ");
+    if (Object.hasOwn(commands, topic))
+        return commands[topic];
+    if (positionals[0] === "daemon" &&
+        positionals.length === 2 &&
+        ["start", "status", "stop", "serve"].includes(positionals[1]))
+        return commands.daemon;
+    if (!explicitTopic) {
+        const command = positionals.slice(0, 2).join(" ");
+        if (Object.hasOwn(commands, command))
+            return commands[command];
+    }
+    throw new Error(`Unknown help topic: ${topic}. Run rome-node help.`);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+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";

package/dist/index.js

@@ -0,0 +1,5 @@
+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";

package/dist/local.d.ts

@@ -0,0 +1,9 @@
+export declare function configRoot(): string;
+export declare const callerCredentialPath: () => string;
+export declare const daemonStatePath: () => string;
+export declare function daemonPort(): number;
+export interface CallerCredential {
+    cloudUrl: string;
+    token: string;
+}
+export declare function readCallerCredential(): Promise<CallerCredential>;