@nordbyte/nordrelay 0.3.1 → 0.4.0

package/dist/openclaw-auth.js

@@ -0,0 +1,27 @@
+import { OpenClawGatewayClient } from "./openclaw-gateway.js";
+export async function checkOpenClawAuthStatus(options) {
+    const client = new OpenClawGatewayClient({
+        url: options.gatewayUrl,
+        token: options.token,
+        password: options.password,
+        timeoutMs: 5_000,
+    });
+    try {
+        await client.health();
+        return {
+            authenticated: true,
+            method: options.token || options.password ? "api-key" : "cli",
+            detail: `OpenClaw Gateway reachable at ${options.gatewayUrl}`,
+        };
+    }
+    catch (error) {
+        return {
+            authenticated: false,
+            method: options.token || options.password ? "api-key" : "cli",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        client.close();
+    }
+}

package/dist/openclaw-cli.js

@@ -0,0 +1,19 @@
+import { findExecutableOnPath } from "./codex-cli.js";
+export function resolveOpenClawCli(env = process.env, explicitPath) {
+    const configuredPath = optionalString(explicitPath) ?? optionalString(env.OPENCLAW_CLI_PATH);
+    if (configuredPath) {
+        return { path: configuredPath, source: "env" };
+    }
+    const pathMatch = findExecutableOnPath("openclaw", env.PATH);
+    return pathMatch ? { path: pathMatch, source: "path" } : { source: "missing" };
+}
+export function describeOpenClawCli(resolution) {
+    if (resolution.path) {
+        return `${resolution.source} (${resolution.path})`;
+    }
+    return "missing";
+}
+function optionalString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}

package/dist/openclaw-gateway.js

@@ -0,0 +1,285 @@
+import { randomUUID } from "node:crypto";
+export class OpenClawGatewayClient {
+    options;
+    socket = null;
+    connected = false;
+    pending = new Map();
+    listeners = new Set();
+    timeoutMs;
+    constructor(options) {
+        this.options = options;
+        this.timeoutMs = options.timeoutMs ?? 15_000;
+    }
+    async connect() {
+        if (this.socket && this.connected) {
+            return {};
+        }
+        const WebSocketClass = this.options.webSocketFactory ?? getGlobalWebSocket();
+        const socket = new WebSocketClass(this.options.url);
+        this.socket = socket;
+        socket.addEventListener("message", (event) => this.handleMessage(event));
+        socket.addEventListener("close", () => this.rejectAll(new Error("OpenClaw Gateway connection closed")));
+        socket.addEventListener("error", () => this.rejectAll(new Error("OpenClaw Gateway connection failed")));
+        await waitForOpen(socket, this.timeoutMs);
+        const hello = await this.sendConnect();
+        this.connected = true;
+        return hello;
+    }
+    async health() {
+        await this.connect();
+        return this.request("health", {}, { timeoutMs: 10_000 }).catch(() => this.request("status", {}, { timeoutMs: 10_000 }));
+    }
+    async listSessions(params = {}) {
+        await this.connect();
+        return this.request("sessions.list", params, { timeoutMs: 10_000 });
+    }
+    async listModels(params = {}) {
+        await this.connect();
+        return this.request("models.list", params, { timeoutMs: 10_000 });
+    }
+    async runAgent(request, onEvent, signal) {
+        await this.connect();
+        const runState = { runId: null };
+        const off = this.onEvent((event) => {
+            if (eventMatchesRun(event, runState.runId, request.sessionId)) {
+                onEvent(event);
+            }
+        });
+        const abort = () => {
+            if (runState.runId) {
+                void this.cancelRun(runState.runId).catch(() => { });
+            }
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+        try {
+            const payload = await this.request("agent", buildAgentParams(request), {
+                expectFinal: true,
+                timeoutMs: 0,
+                onAccepted: (accepted) => {
+                    runState.runId = stringValue(accepted.runId) ?? stringValue(accepted.run_id) ?? stringValue(accepted.id);
+                    if (runState.runId) {
+                        request.onRunId?.(runState.runId);
+                    }
+                },
+            });
+            const text = extractOpenClawOutputText(payload);
+            return {
+                runId: runState.runId ?? stringValue(payload.runId) ?? stringValue(payload.run_id),
+                status: stringValue(payload.status) ?? "ok",
+                text,
+                usage: payload.usage,
+                payload,
+            };
+        }
+        finally {
+            signal?.removeEventListener("abort", abort);
+            off();
+        }
+    }
+    async cancelRun(runId) {
+        await this.connect();
+        await this.request("agent.cancel", { runId }, { timeoutMs: 5_000 }).catch(() => this.request("tasks.cancel", { runId }, { timeoutMs: 5_000 })).catch(() => { });
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    close() {
+        this.connected = false;
+        this.rejectAll(new Error("OpenClaw Gateway connection closed"));
+        this.socket?.close();
+        this.socket = null;
+    }
+    sendConnect() {
+        const params = {
+            client: {
+                name: this.options.clientName ?? "NordRelay",
+                deviceFamily: "nordrelay",
+            },
+            role: "operator",
+            subscribe: ["agent", "session.message", "session.tool", "sessions.changed", "health"],
+        };
+        const auth = {};
+        if (this.options.token)
+            auth.token = this.options.token;
+        if (this.options.password)
+            auth.password = this.options.password;
+        if (Object.keys(auth).length > 0) {
+            params.auth = auth;
+        }
+        return this.sendFrameAndWait("connect", "connect", params, { timeoutMs: this.timeoutMs });
+    }
+    request(method, params, options = {}) {
+        return this.sendFrameAndWait("req", method, params, options);
+    }
+    sendFrameAndWait(type, method, params, options = {}) {
+        const socket = this.socket;
+        if (!socket) {
+            return Promise.reject(new Error("OpenClaw Gateway is not connected"));
+        }
+        const id = randomUUID();
+        const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+        const frame = type === "connect"
+            ? { type, id, params }
+            : { type, id, method, params, idempotencyKey: randomUUID() };
+        return new Promise((resolve, reject) => {
+            const timeout = timeoutMs > 0
+                ? setTimeout(() => {
+                    this.pending.delete(id);
+                    reject(new Error(`OpenClaw Gateway ${method} timed out after ${timeoutMs}ms`));
+                }, timeoutMs)
+                : undefined;
+            if (timeout?.unref)
+                timeout.unref();
+            this.pending.set(id, {
+                method,
+                expectFinal: Boolean(options.expectFinal),
+                resolve,
+                reject,
+                onAccepted: options.onAccepted,
+                timeout,
+            });
+            socket.send(JSON.stringify(frame));
+        });
+    }
+    handleMessage(event) {
+        const data = event.data;
+        const raw = typeof data === "string" ? data : data instanceof Buffer ? data.toString("utf8") : String(data ?? "");
+        const frame = parseFrame(raw);
+        if (!frame) {
+            return;
+        }
+        if (frame.type === "event") {
+            for (const listener of this.listeners) {
+                try {
+                    listener(frame);
+                }
+                catch {
+                    this.listeners.delete(listener);
+                }
+            }
+            return;
+        }
+        const id = stringValue(frame.id);
+        if (!id) {
+            return;
+        }
+        const pending = this.pending.get(id);
+        if (!pending) {
+            return;
+        }
+        if (frame.ok === false || frame.error) {
+            this.pending.delete(id);
+            clearTimeout(pending.timeout);
+            pending.reject(new Error(formatGatewayError(frame.error ?? frame.payload ?? frame)));
+            return;
+        }
+        const payload = objectValue(frame.payload) ?? objectValue(frame.result) ?? frame;
+        const status = stringValue(payload.status);
+        if (pending.expectFinal && status === "accepted") {
+            pending.onAccepted?.(payload);
+            return;
+        }
+        this.pending.delete(id);
+        clearTimeout(pending.timeout);
+        pending.resolve(payload);
+    }
+    rejectAll(error) {
+        for (const [id, pending] of this.pending.entries()) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+            this.pending.delete(id);
+        }
+    }
+}
+export function extractOpenClawOutputText(payload) {
+    const object = objectValue(payload);
+    if (!object) {
+        return typeof payload === "string" && payload.trim() ? payload : null;
+    }
+    const direct = stringValue(object.text)
+        ?? stringValue(object.output)
+        ?? stringValue(object.summary)
+        ?? stringValue(object.message)
+        ?? stringValue(object.content);
+    if (direct) {
+        return direct;
+    }
+    const result = objectValue(object.result);
+    if (result) {
+        return extractOpenClawOutputText(result);
+    }
+    const payloads = Array.isArray(object.payloads) ? object.payloads : [];
+    const textParts = payloads
+        .map((entry) => stringValue(objectValue(entry)?.text) ?? stringValue(entry))
+        .filter((entry) => Boolean(entry));
+    return textParts.length > 0 ? textParts.join("\n\n") : null;
+}
+function buildAgentParams(request) {
+    return {
+        message: request.message,
+        sessionId: request.sessionId,
+        session_id: request.sessionId,
+        agent: request.agentId,
+        agentId: request.agentId,
+        model: request.model,
+        thinking: request.thinking,
+        workspace: request.workspace,
+        local: request.local,
+        deliver: request.deliver,
+        instructions: request.instructions,
+        attachments: request.attachments,
+    };
+}
+function eventMatchesRun(event, runId, sessionId) {
+    const payload = objectValue(event.payload) ?? event;
+    const eventRunId = stringValue(payload.runId) ?? stringValue(payload.run_id) ?? stringValue(payload.id);
+    const eventSessionId = stringValue(payload.sessionId) ?? stringValue(payload.session_id) ?? stringValue(payload.sessionKey);
+    if (runId && eventRunId) {
+        return eventRunId === runId;
+    }
+    return !eventSessionId || eventSessionId === sessionId;
+}
+function getGlobalWebSocket() {
+    const WebSocketClass = globalThis.WebSocket;
+    if (!WebSocketClass) {
+        throw new Error("OpenClaw Gateway requires a WebSocket-capable Node runtime.");
+    }
+    return WebSocketClass;
+}
+function waitForOpen(socket, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error(`OpenClaw Gateway connection timed out after ${timeoutMs}ms`)), timeoutMs);
+        timeout.unref?.();
+        socket.addEventListener("open", () => {
+            clearTimeout(timeout);
+            resolve();
+        }, { once: true });
+        socket.addEventListener("error", () => {
+            clearTimeout(timeout);
+            reject(new Error("OpenClaw Gateway connection failed"));
+        }, { once: true });
+    });
+}
+function parseFrame(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return objectValue(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+function formatGatewayError(value) {
+    const object = objectValue(value);
+    if (!object) {
+        return typeof value === "string" ? value : "OpenClaw Gateway request failed";
+    }
+    return stringValue(object.message) ?? stringValue(object.error) ?? JSON.stringify(object);
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}

package/dist/openclaw-launch.js

@@ -0,0 +1,65 @@
+import { createLaunchProfile } from "./codex-launch.js";
+export const OPENCLAW_LAUNCH_PROFILES = [
+    {
+        id: "default",
+        label: "Default",
+        behavior: "OpenClaw Gateway defaults",
+        unsafe: false,
+        local: false,
+        deliver: false,
+    },
+    {
+        id: "safe",
+        label: "Safe",
+        behavior: "non-destructive intent / Gateway defaults",
+        unsafe: false,
+        local: false,
+        deliver: false,
+        instructions: "Do not perform destructive operations. If a risky action is required, stop and explain the required approval.",
+    },
+    {
+        id: "readonly",
+        label: "Read Only",
+        behavior: "inspect-only intent / no file changes",
+        unsafe: false,
+        local: false,
+        deliver: false,
+        instructions: "Treat this run as read-only. Inspect, explain, and plan, but do not modify files or execute destructive commands.",
+    },
+    {
+        id: "local",
+        label: "Local",
+        behavior: "force OpenClaw embedded local run",
+        unsafe: false,
+        local: true,
+        deliver: false,
+    },
+    {
+        id: "deliver",
+        label: "Deliver",
+        behavior: "OpenClaw Gateway delivery enabled",
+        unsafe: false,
+        local: false,
+        deliver: true,
+    },
+];
+export function listOpenClawLaunchProfiles() {
+    return OPENCLAW_LAUNCH_PROFILES.map((profile) => ({
+        id: profile.id,
+        label: profile.label,
+        behavior: profile.behavior,
+        unsafe: profile.unsafe,
+    }));
+}
+export function findOpenClawLaunchProfile(profileId) {
+    const profile = OPENCLAW_LAUNCH_PROFILES.find((candidate) => candidate.id === profileId);
+    return profile ?? OPENCLAW_LAUNCH_PROFILES[0];
+}
+export function openClawProfileAsLaunchProfile(profile) {
+    return createLaunchProfile({
+        id: profile.id,
+        label: profile.label,
+        sandboxMode: profile.unsafe ? "danger-full-access" : "workspace-write",
+        approvalPolicy: "never",
+    });
+}