@hypercli.com/sdk 2026.3.13-1

package/dist/gateway.js

@@ -0,0 +1,1306 @@
+/**
+ * OpenClaw Gateway WebSocket Client
+ *
+ * Connects to an agent's OpenClaw gateway over WebSocket for real-time
+ * configuration, chat, session management, and file operations.
+ *
+ * Protocol: OpenClaw Gateway v3
+ */
+import { getPublicKeyAsync, signAsync, utils as edUtils } from "@noble/ed25519";
+class GatewayRequestError extends Error {
+    gatewayCode;
+    details;
+    constructor(error) {
+        super(error.message);
+        this.name = "GatewayRequestError";
+        this.gatewayCode = error.code;
+        this.details = error.details;
+    }
+}
+const PROTOCOL_VERSION = 3;
+const DEFAULT_TIMEOUT = 15_000;
+const CHAT_TIMEOUT = 120_000;
+const RECONNECT_CLOSE_CODE = 4008;
+const DEFAULT_CLIENT_ID = "openclaw-control-ui";
+const DEFAULT_CLIENT_MODE = "webchat";
+const DEFAULT_CLIENT_VERSION = "@hypercli/sdk";
+const DEFAULT_CAPS = ["tool-events"];
+const CONNECT_TIMER_MS = 750;
+const INITIAL_BACKOFF_MS = 800;
+const MAX_BACKOFF_MS = 15_000;
+const BACKOFF_MULTIPLIER = 1.7;
+const OPERATOR_ROLE = "operator";
+const OPERATOR_SCOPES = ["operator.admin", "operator.approvals", "operator.pairing"];
+const STORAGE_KEY = "openclaw.device.auth.v1";
+const CONNECT_ERROR_PAIRING_REQUIRED = "PAIRING_REQUIRED";
+const CONNECT_ERROR_DEVICE_TOKEN_MISMATCH = "AUTH_DEVICE_TOKEN_MISMATCH";
+const VALID_CLIENT_IDS = new Set([
+    "webchat-ui",
+    "openclaw-control-ui",
+    "webchat",
+    "cli",
+    "gateway-client",
+    "openclaw-macos",
+    "openclaw-ios",
+    "openclaw-android",
+    "node-host",
+    "test",
+    "fingerprint",
+    "openclaw-probe",
+]);
+const VALID_CLIENT_MODES = new Set([
+    "webchat",
+    "cli",
+    "ui",
+    "backend",
+    "node",
+    "probe",
+    "test",
+]);
+let memoryDeviceAuthStore = null;
+function makeId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+        const random = Math.random() * 16 | 0;
+        return (char === "x" ? random : (random & 0x3) | 0x8).toString(16);
+    });
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function splitConfigPath(path) {
+    return path
+        .split(".")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .flatMap((part) => part.endsWith("[]") && part !== "[]"
+        ? [part.slice(0, -2), "[]"]
+        : [part]);
+}
+export function normalizeOpenClawConfigSchemaNode(value) {
+    const schema = asRecord(value) ?? {};
+    const oneOf = Array.isArray(schema.oneOf) ? schema.oneOf : [];
+    const anyOf = Array.isArray(schema.anyOf) ? schema.anyOf : [];
+    const union = [...oneOf, ...anyOf];
+    if (union.length === 0)
+        return schema;
+    const primary = union.find((entry) => {
+        const obj = asRecord(entry);
+        if (!obj)
+            return false;
+        const t = obj.type;
+        if (typeof t === "string")
+            return t !== "null";
+        if (Array.isArray(t))
+            return t.some((v) => v !== "null");
+        return true;
+    });
+    return asRecord(primary) ?? schema;
+}
+export function describeOpenClawConfigNode(value) {
+    const schema = normalizeOpenClawConfigSchemaNode(value);
+    const rawType = schema.type;
+    const type = Array.isArray(rawType)
+        ? rawType.find((entry) => entry !== "null")
+        : (typeof rawType === "string" ? rawType : undefined);
+    const rawProperties = asRecord(schema.properties) ?? {};
+    const properties = {};
+    for (const [key, child] of Object.entries(rawProperties)) {
+        const childSchema = asRecord(child);
+        if (childSchema) {
+            properties[key] = childSchema;
+        }
+    }
+    const additionalPropertySchema = asRecord(schema.additionalProperties);
+    const additionalProperties = schema.additionalProperties === true || Boolean(additionalPropertySchema);
+    return {
+        schema,
+        type,
+        properties,
+        additionalProperties,
+        additionalPropertySchema,
+        isDynamicMap: (type === "object" || Object.keys(properties).length > 0 || additionalProperties) &&
+            additionalProperties,
+    };
+}
+export function createOpenClawConfigValue(value) {
+    const descriptor = describeOpenClawConfigNode(value);
+    switch (descriptor.type) {
+        case "object":
+            return {};
+        case "array":
+            return [];
+        case "boolean":
+            return false;
+        case "number":
+        case "integer":
+            return 0;
+        default:
+            return "";
+    }
+}
+export function normalizeOpenClawConfigSchema(value) {
+    const raw = asRecord(value);
+    if (!raw)
+        return null;
+    const wrappedSchema = asRecord(raw.schema);
+    const uiHints = asRecord(raw.uiHints) ?? {};
+    const normalized = {
+        schema: wrappedSchema ?? raw,
+        uiHints: uiHints,
+    };
+    if (typeof raw.version === "string") {
+        normalized.version = raw.version;
+    }
+    if (typeof raw.generatedAt === "string") {
+        normalized.generatedAt = raw.generatedAt;
+    }
+    return normalized;
+}
+export function resolveOpenClawConfigUiHint(source, path) {
+    if (!path.trim())
+        return null;
+    const sourceRecord = asRecord(source);
+    const uiHints = sourceRecord && asRecord(sourceRecord.uiHints)
+        ? sourceRecord.uiHints
+        : sourceRecord;
+    if (!uiHints || typeof uiHints !== "object")
+        return null;
+    const targetParts = splitConfigPath(path);
+    let best = null;
+    for (const [hintPath, hint] of Object.entries(uiHints)) {
+        const hintParts = splitConfigPath(hintPath);
+        if (hintParts.length !== targetParts.length)
+            continue;
+        let wildcardCount = 0;
+        let matches = true;
+        for (let index = 0; index < hintParts.length; index += 1) {
+            const hintPart = hintParts[index];
+            const targetPart = targetParts[index];
+            if (hintPart === targetPart)
+                continue;
+            if (hintPart === "*" || hintPart === "[]") {
+                wildcardCount += 1;
+                continue;
+            }
+            matches = false;
+            break;
+        }
+        if (!matches)
+            continue;
+        if (!best || wildcardCount < best.wildcardCount) {
+            best = { path: hintPath, hint, wildcardCount };
+        }
+    }
+    return best ? { path: best.path, hint: best.hint } : null;
+}
+function normalizeClientId(value) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized && VALID_CLIENT_IDS.has(normalized) ? normalized : DEFAULT_CLIENT_ID;
+}
+function normalizeClientMode(value) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized && VALID_CLIENT_MODES.has(normalized) ? normalized : DEFAULT_CLIENT_MODE;
+}
+function getNavigatorLike() {
+    const maybeNavigator = globalThis.navigator;
+    return maybeNavigator ?? null;
+}
+function resolvePlatform(value) {
+    const normalized = value?.trim();
+    if (normalized)
+        return normalized;
+    const browserNavigator = getNavigatorLike();
+    if (browserNavigator?.platform)
+        return browserNavigator.platform;
+    if (typeof process !== "undefined" && process.platform)
+        return process.platform;
+    return "web";
+}
+function inferBrowserName(userAgent) {
+    const ua = userAgent ?? "";
+    if (!ua)
+        return null;
+    if (/Firefox\//i.test(ua))
+        return "Firefox";
+    if (/Edg\//i.test(ua))
+        return "Edge";
+    if (/Chrome\//i.test(ua) && !/Edg\//i.test(ua))
+        return "Chrome";
+    if (/Safari\//i.test(ua) && !/Chrome\//i.test(ua))
+        return "Safari";
+    return null;
+}
+function inferPlatformName(platform) {
+    const normalized = platform.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (normalized.includes("mac"))
+        return "macOS";
+    if (normalized.includes("win"))
+        return "Windows";
+    if (normalized.includes("linux"))
+        return "Linux";
+    if (normalized.includes("iphone") || normalized.includes("ipad") || normalized.includes("ios")) {
+        return "iOS";
+    }
+    if (normalized.includes("android"))
+        return "Android";
+    return platform.trim();
+}
+function resolveBrowserHost() {
+    const browserWindow = globalThis.window;
+    const hostname = browserWindow?.location?.hostname?.trim();
+    return hostname || null;
+}
+function resolveClientDisplayName(value, platform) {
+    const provided = value?.trim();
+    if (provided)
+        return provided;
+    const browserName = inferBrowserName(resolveUserAgent());
+    const platformName = inferPlatformName(platform);
+    const host = resolveBrowserHost();
+    const details = [browserName, platformName ? `on ${platformName}` : null]
+        .filter(Boolean)
+        .join(" ");
+    if (details && host) {
+        return `Hyper Agent Web (${details}, ${host})`;
+    }
+    if (details) {
+        return `Hyper Agent Web (${details})`;
+    }
+    if (host) {
+        return `Hyper Agent Web (${host})`;
+    }
+    return "Hyper Agent Web";
+}
+function normalizeScopes(scopes) {
+    if (!Array.isArray(scopes)) {
+        return [];
+    }
+    const unique = new Set();
+    for (const scope of scopes) {
+        const normalized = scope.trim();
+        if (normalized)
+            unique.add(normalized);
+    }
+    return [...unique].sort();
+}
+function getStorage() {
+    const storage = globalThis.localStorage;
+    return storage ?? null;
+}
+function readDeviceAuthStore() {
+    const storage = getStorage();
+    if (!storage) {
+        return memoryDeviceAuthStore;
+    }
+    try {
+        const raw = storage.getItem(STORAGE_KEY);
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        return parsed?.version === 1 && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeDeviceAuthStore(store) {
+    const normalized = {
+        version: 1,
+        ...(store.deviceId ? { deviceId: store.deviceId } : {}),
+        ...(store.publicKey ? { publicKey: store.publicKey } : {}),
+        ...(store.privateKey ? { privateKey: store.privateKey } : {}),
+        ...(typeof store.createdAtMs === "number" ? { createdAtMs: store.createdAtMs } : {}),
+        ...(store.tokens ? { tokens: store.tokens } : {}),
+        ...(store.pendingPairings ? { pendingPairings: store.pendingPairings } : {}),
+    };
+    const storage = getStorage();
+    if (!storage) {
+        memoryDeviceAuthStore = normalized;
+        return;
+    }
+    try {
+        storage.setItem(STORAGE_KEY, JSON.stringify(normalized));
+    }
+    catch {
+        memoryDeviceAuthStore = normalized;
+    }
+}
+function storageScopeKey(scope, role) {
+    return `${scope.trim()}|${role.trim()}`;
+}
+function loadStoredDeviceToken(deviceId, scope, role) {
+    const store = readDeviceAuthStore();
+    if (!store || store.deviceId !== deviceId || !store.tokens)
+        return null;
+    const entry = store.tokens[storageScopeKey(scope, role)];
+    return entry && typeof entry.token === "string" ? entry : null;
+}
+function storeStoredDeviceToken(params) {
+    const role = params.role.trim();
+    const key = storageScopeKey(params.scope, role);
+    const existing = readDeviceAuthStore();
+    const next = {
+        version: 1,
+        ...(existing?.deviceId ? { deviceId: existing.deviceId } : {}),
+        ...(existing?.publicKey ? { publicKey: existing.publicKey } : {}),
+        ...(existing?.privateKey ? { privateKey: existing.privateKey } : {}),
+        ...(typeof existing?.createdAtMs === "number" ? { createdAtMs: existing.createdAtMs } : {}),
+        ...(existing?.pendingPairings ? { pendingPairings: existing.pendingPairings } : {}),
+        tokens: {
+            ...(existing?.tokens ?? {}),
+            [key]: {
+                token: params.token,
+                role,
+                scopes: normalizeScopes(params.scopes),
+                updatedAtMs: Date.now(),
+                ...(params.gatewayUrl ? { gatewayUrl: params.gatewayUrl } : {}),
+            },
+        },
+    };
+    if (!next.deviceId) {
+        next.deviceId = params.deviceId;
+    }
+    writeDeviceAuthStore(next);
+    return next.tokens?.[key];
+}
+function clearStoredDeviceToken(deviceId, scope, role) {
+    const store = readDeviceAuthStore();
+    if (!store || store.deviceId !== deviceId || !store.tokens)
+        return;
+    const key = storageScopeKey(scope, role);
+    if (!store.tokens[key])
+        return;
+    const nextTokens = { ...store.tokens };
+    delete nextTokens[key];
+    writeDeviceAuthStore({
+        version: 1,
+        ...(store.deviceId ? { deviceId: store.deviceId } : {}),
+        ...(store.publicKey ? { publicKey: store.publicKey } : {}),
+        ...(store.privateKey ? { privateKey: store.privateKey } : {}),
+        ...(typeof store.createdAtMs === "number" ? { createdAtMs: store.createdAtMs } : {}),
+        ...(store.pendingPairings ? { pendingPairings: store.pendingPairings } : {}),
+        tokens: nextTokens,
+    });
+}
+function pairingStoreKey(scope, role) {
+    return storageScopeKey(scope, role);
+}
+function loadPendingPairing(scope, role) {
+    const store = readDeviceAuthStore();
+    const key = pairingStoreKey(scope, role);
+    return store?.pendingPairings?.[key] ?? null;
+}
+function storePendingPairing(pairing, scope) {
+    const existing = readDeviceAuthStore();
+    const key = pairingStoreKey(scope, pairing.role);
+    writeDeviceAuthStore({
+        version: 1,
+        ...(existing?.deviceId ? { deviceId: existing.deviceId } : {}),
+        ...(existing?.publicKey ? { publicKey: existing.publicKey } : {}),
+        ...(existing?.privateKey ? { privateKey: existing.privateKey } : {}),
+        ...(typeof existing?.createdAtMs === "number" ? { createdAtMs: existing.createdAtMs } : {}),
+        ...(existing?.tokens ? { tokens: existing.tokens } : {}),
+        pendingPairings: {
+            ...(existing?.pendingPairings ?? {}),
+            [key]: pairing,
+        },
+    });
+    return pairing;
+}
+function clearPendingPairing(scope, role) {
+    const store = readDeviceAuthStore();
+    if (!store?.pendingPairings)
+        return;
+    const key = pairingStoreKey(scope, role);
+    if (!store.pendingPairings[key])
+        return;
+    const nextPendingPairings = { ...store.pendingPairings };
+    delete nextPendingPairings[key];
+    writeDeviceAuthStore({
+        version: 1,
+        ...(store.deviceId ? { deviceId: store.deviceId } : {}),
+        ...(store.publicKey ? { publicKey: store.publicKey } : {}),
+        ...(store.privateKey ? { privateKey: store.privateKey } : {}),
+        ...(typeof store.createdAtMs === "number" ? { createdAtMs: store.createdAtMs } : {}),
+        ...(store.tokens ? { tokens: store.tokens } : {}),
+        ...(Object.keys(nextPendingPairings).length > 0 ? { pendingPairings: nextPendingPairings } : {}),
+    });
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes, (value) => value.toString(16).padStart(2, "0")).join("");
+}
+function bytesToBase64Url(bytes) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes)
+            .toString("base64")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=+$/g, "");
+    }
+    const encoder = globalThis;
+    if (typeof encoder.btoa !== "function") {
+        throw new Error("base64 encoder unavailable");
+    }
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return encoder
+        .btoa(binary)
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/g, "");
+}
+function base64UrlToBytes(value) {
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+    if (typeof Buffer !== "undefined") {
+        return new Uint8Array(Buffer.from(padded, "base64"));
+    }
+    const decoder = globalThis;
+    if (typeof decoder.atob !== "function") {
+        throw new Error("base64 decoder unavailable");
+    }
+    const binary = decoder.atob(padded);
+    const output = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        output[index] = binary.charCodeAt(index);
+    }
+    return output;
+}
+async function sha256Hex(bytes) {
+    if (!globalThis.crypto?.subtle) {
+        throw new Error("crypto.subtle is required for device auth");
+    }
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+    return bytesToHex(new Uint8Array(digest));
+}
+async function loadOrCreateDeviceIdentity() {
+    const store = readDeviceAuthStore();
+    if (store?.version === 1 &&
+        typeof store.deviceId === "string" &&
+        typeof store.publicKey === "string" &&
+        typeof store.privateKey === "string") {
+        const derivedId = await sha256Hex(base64UrlToBytes(store.publicKey));
+        if (derivedId !== store.deviceId) {
+            writeDeviceAuthStore({
+                ...store,
+                version: 1,
+                deviceId: derivedId,
+            });
+            return {
+                deviceId: derivedId,
+                publicKey: store.publicKey,
+                privateKey: store.privateKey,
+                createdAtMs: store.createdAtMs,
+            };
+        }
+        return {
+            deviceId: store.deviceId,
+            publicKey: store.publicKey,
+            privateKey: store.privateKey,
+            createdAtMs: store.createdAtMs,
+        };
+    }
+    const privateKeyBytes = edUtils.randomSecretKey();
+    const publicKeyBytes = await getPublicKeyAsync(privateKeyBytes);
+    const deviceId = await sha256Hex(publicKeyBytes);
+    const identity = {
+        deviceId,
+        publicKey: bytesToBase64Url(publicKeyBytes),
+        privateKey: bytesToBase64Url(privateKeyBytes),
+        createdAtMs: Date.now(),
+    };
+    writeDeviceAuthStore({
+        version: 1,
+        ...identity,
+        ...(store?.tokens ? { tokens: store.tokens } : {}),
+    });
+    return identity;
+}
+async function signDevicePayload(privateKey, payload) {
+    const signature = await signAsync(new TextEncoder().encode(payload), base64UrlToBytes(privateKey));
+    return bytesToBase64Url(signature);
+}
+function buildDeviceAuthPayload(params) {
+    return [
+        "v2",
+        params.deviceId,
+        params.clientId,
+        params.clientMode,
+        params.role,
+        params.scopes.join(","),
+        String(params.signedAtMs),
+        params.token ?? "",
+        params.nonce,
+    ].join("|");
+}
+function toCloseError(error) {
+    if (error instanceof GatewayRequestError) {
+        return {
+            code: error.gatewayCode,
+            message: error.message,
+            details: error.details,
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            code: "UNAVAILABLE",
+            message: error.message,
+        };
+    }
+    return null;
+}
+function readConnectErrorCode(error) {
+    if (!(error instanceof GatewayRequestError))
+        return null;
+    const details = error.details;
+    if (!details || typeof details !== "object" || Array.isArray(details))
+        return null;
+    const code = details.code;
+    return typeof code === "string" && code.trim() ? code.trim() : null;
+}
+function readConnectPairingRequestId(error) {
+    if (!(error instanceof GatewayRequestError))
+        return null;
+    const details = error.details;
+    if (!details || typeof details !== "object" || Array.isArray(details))
+        return null;
+    const requestId = details.requestId;
+    return typeof requestId === "string" && requestId.trim() ? requestId.trim() : null;
+}
+function isSocketOpen(ws) {
+    return Boolean(ws && ws.readyState === 1);
+}
+function resolveUserAgent() {
+    return getNavigatorLike()?.userAgent;
+}
+function resolveLocale() {
+    return getNavigatorLike()?.language;
+}
+export class GatewayClient {
+    url;
+    token;
+    gatewayToken;
+    deploymentId;
+    apiKey;
+    apiBase;
+    autoApprovePairing;
+    clientId;
+    clientMode;
+    clientDisplayName;
+    clientVersion;
+    clientPlatform;
+    clientInstanceId;
+    caps;
+    origin;
+    defaultTimeout;
+    ws = null;
+    pending = new Map();
+    eventHandlers = new Set();
+    connected = false;
+    closed = false;
+    reconnectTimer = null;
+    connectTimer = null;
+    backoffMs = INITIAL_BACKOFF_MS;
+    connectNonce = null;
+    connectSent = false;
+    pendingConnectError = null;
+    pairingState = null;
+    autoApproveAttemptedRequestIds = new Set();
+    lastSeq = null;
+    connectPromise = null;
+    resolveConnectPromise = null;
+    rejectConnectPromise = null;
+    _version = null;
+    _protocol = null;
+    onDisconnect = null;
+    constructor(options) {
+        this.url = options.url;
+        this.token = options.token?.trim() || undefined;
+        this.gatewayToken = options.gatewayToken?.trim() || undefined;
+        this.deploymentId = options.deploymentId?.trim() || undefined;
+        this.apiKey = options.apiKey?.trim() || undefined;
+        this.apiBase = options.apiBase?.trim().replace(/\/$/, "") || undefined;
+        this.autoApprovePairing = options.autoApprovePairing === true;
+        this.clientId = normalizeClientId(options.clientId);
+        this.clientMode = normalizeClientMode(options.clientMode);
+        this.clientVersion = options.clientVersion?.trim() || DEFAULT_CLIENT_VERSION;
+        this.clientPlatform = resolvePlatform(options.platform);
+        this.clientDisplayName = resolveClientDisplayName(options.clientDisplayName, this.clientPlatform);
+        this.clientInstanceId = options.instanceId?.trim() || makeId();
+        this.caps = Array.isArray(options.caps)
+            ? options.caps.map((cap) => cap.trim()).filter(Boolean)
+            : [...DEFAULT_CAPS];
+        this.origin = options.origin ?? "https://hypercli.com";
+        this.defaultTimeout = options.timeout ?? DEFAULT_TIMEOUT;
+        this.onHello = options.onHello;
+        this.onClose = options.onClose;
+        this.onGap = options.onGap;
+        this.onPairing = options.onPairing;
+        this.pairingState = loadPendingPairing(this.storageScope(), OPERATOR_ROLE);
+    }
+    onHello;
+    onClose;
+    onGap;
+    onPairing;
+    get version() {
+        return this._version;
+    }
+    get protocol() {
+        return this._protocol;
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    get pendingPairing() {
+        return this.pairingState;
+    }
+    storageScope() {
+        return this.deploymentId || this.url;
+    }
+    /** Subscribe to server-sent events */
+    onEvent(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    /** Connect and keep reconnecting until stopped */
+    connect() {
+        return this.start();
+    }
+    start() {
+        this.closed = false;
+        if (this.connected) {
+            return Promise.resolve();
+        }
+        if (!this.connectPromise) {
+            this.connectPromise = new Promise((resolve, reject) => {
+                this.resolveConnectPromise = resolve;
+                this.rejectConnectPromise = reject;
+            });
+        }
+        this.openSocket();
+        return this.connectPromise;
+    }
+    /** Close permanently and stop reconnecting */
+    close() {
+        this.stop();
+    }
+    stop() {
+        this.closed = true;
+        this.connected = false;
+        this.connectSent = false;
+        this.connectNonce = null;
+        this.pendingConnectError = null;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.connectTimer) {
+            clearTimeout(this.connectTimer);
+            this.connectTimer = null;
+        }
+        const ws = this.ws;
+        this.ws = null;
+        if (ws) {
+            ws.close();
+        }
+        this.flushPending(new Error("gateway client stopped"));
+        if (this.rejectConnectPromise) {
+            this.rejectConnectPromise(new Error("gateway client stopped"));
+        }
+        this.connectPromise = null;
+        this.resolveConnectPromise = null;
+        this.rejectConnectPromise = null;
+    }
+    updatePairingState(pairing) {
+        this.pairingState = pairing;
+        if (pairing) {
+            storePendingPairing(pairing, this.storageScope());
+        }
+        else {
+            clearPendingPairing(this.storageScope(), OPERATOR_ROLE);
+        }
+        this.onPairing?.(pairing);
+    }
+    canAutoApprovePairing() {
+        return Boolean(this.autoApprovePairing &&
+            this.deploymentId &&
+            this.apiKey &&
+            this.apiBase &&
+            typeof fetch === "function");
+    }
+    async approvePairingRequest(requestId) {
+        if (!this.canAutoApprovePairing()) {
+            throw new Error("autoApprovePairing requires deploymentId, apiKey, apiBase, and fetch()");
+        }
+        const response = await fetch(`${this.apiBase}/deployments/${encodeURIComponent(this.deploymentId)}/exec`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                command: `openclaw devices approve ${requestId}`,
+                timeout: 30,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Pairing approval failed: ${response.status} ${errorText}`);
+        }
+        const payload = await response.json();
+        if ((payload.exitCode ?? payload.exit_code ?? 1) !== 0) {
+            throw new Error(payload.stderr?.trim() || payload.stdout?.trim() || "pairing approval command failed");
+        }
+    }
+    openSocket() {
+        if (this.closed || this.ws)
+            return;
+        if (typeof WebSocket === "undefined") {
+            throw new Error("WebSocket is not available in this environment");
+        }
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        const wsUrl = this.token
+            ? `${this.url}${this.url.includes("?") ? "&" : "?"}token=${encodeURIComponent(this.token)}`
+            : this.url;
+        const ws = new WebSocket(wsUrl);
+        this.ws = ws;
+        ws.onopen = () => {
+            this.queueConnect();
+        };
+        ws.onmessage = (event) => {
+            this.handleMessage(String(event.data ?? ""));
+        };
+        ws.onerror = () => {
+            // Close handling covers retries and surfaced errors.
+        };
+        ws.onclose = (event) => {
+            this.handleClose(ws, event.code ?? 1006, String(event.reason ?? ""));
+        };
+    }
+    queueConnect() {
+        this.connectNonce = null;
+        this.connectSent = false;
+        if (this.connectTimer) {
+            clearTimeout(this.connectTimer);
+        }
+        this.connectTimer = setTimeout(() => {
+            if (!this.ws || !isSocketOpen(this.ws) || this.closed || this.connectSent) {
+                return;
+            }
+            if (!this.connectNonce) {
+                this.pendingConnectError = {
+                    code: "CONNECT_CHALLENGE_TIMEOUT",
+                    message: "gateway connect challenge timeout",
+                };
+                this.ws.close(RECONNECT_CLOSE_CODE, "connect challenge timeout");
+            }
+        }, CONNECT_TIMER_MS);
+    }
+    scheduleReconnect() {
+        if (this.closed || this.reconnectTimer) {
+            return;
+        }
+        const delay = this.backoffMs;
+        this.backoffMs = Math.min(this.backoffMs * BACKOFF_MULTIPLIER, MAX_BACKOFF_MS);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.openSocket();
+        }, delay);
+    }
+    flushPending(error) {
+        for (const [, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    handleClose(ws, code, reason) {
+        if (this.ws !== ws) {
+            return;
+        }
+        this.ws = null;
+        this.connected = false;
+        this.connectSent = false;
+        this.connectNonce = null;
+        if (this.connectTimer) {
+            clearTimeout(this.connectTimer);
+            this.connectTimer = null;
+        }
+        const error = this.pendingConnectError;
+        this.pendingConnectError = null;
+        this.flushPending(new Error(`gateway closed (${code}): ${reason || "no reason"}`));
+        this.onClose?.({ code, reason, error });
+        if (!this.closed) {
+            this.onDisconnect?.();
+            this.scheduleReconnect();
+        }
+    }
+    async sendConnect() {
+        if (this.connectSent || !this.ws || !isSocketOpen(this.ws)) {
+            return;
+        }
+        const nonce = this.connectNonce?.trim() ?? "";
+        if (!nonce) {
+            this.pendingConnectError = {
+                code: "DEVICE_AUTH_NONCE_REQUIRED",
+                message: "gateway connect challenge missing nonce",
+            };
+            this.ws.close(RECONNECT_CLOSE_CODE, "connect challenge missing nonce");
+            return;
+        }
+        this.connectSent = true;
+        if (this.connectTimer) {
+            clearTimeout(this.connectTimer);
+            this.connectTimer = null;
+        }
+        let identity = null;
+        try {
+            identity = await loadOrCreateDeviceIdentity();
+            const storedDeviceToken = loadStoredDeviceToken(identity.deviceId, this.storageScope(), OPERATOR_ROLE)?.token;
+            const authToken = storedDeviceToken ?? this.gatewayToken;
+            const signedAtMs = Date.now();
+            const payload = buildDeviceAuthPayload({
+                deviceId: identity.deviceId,
+                clientId: this.clientId,
+                clientMode: this.clientMode,
+                role: OPERATOR_ROLE,
+                scopes: OPERATOR_SCOPES,
+                signedAtMs,
+                token: authToken ?? null,
+                nonce,
+            });
+            const signature = await signDevicePayload(identity.privateKey, payload);
+            const params = {
+                minProtocol: PROTOCOL_VERSION,
+                maxProtocol: PROTOCOL_VERSION,
+                client: {
+                    id: this.clientId,
+                    ...(this.clientDisplayName ? { displayName: this.clientDisplayName } : {}),
+                    version: this.clientVersion,
+                    platform: this.clientPlatform,
+                    mode: this.clientMode,
+                    ...(this.clientInstanceId ? { instanceId: this.clientInstanceId } : {}),
+                },
+                role: OPERATOR_ROLE,
+                scopes: [...OPERATOR_SCOPES],
+                device: {
+                    id: identity.deviceId,
+                    publicKey: identity.publicKey,
+                    signature,
+                    signedAt: signedAtMs,
+                    nonce,
+                },
+                caps: this.caps,
+                ...(authToken
+                    ? {
+                        auth: {
+                            ...(authToken ? { token: authToken } : {}),
+                        },
+                    }
+                    : {}),
+                ...(resolveUserAgent() ? { userAgent: resolveUserAgent() } : {}),
+                ...(resolveLocale() ? { locale: resolveLocale() } : {}),
+            };
+            const hello = await this.sendRawRequest("connect", params, this.defaultTimeout, true);
+            if (hello?.auth?.deviceToken) {
+                storeStoredDeviceToken({
+                    deviceId: identity.deviceId,
+                    scope: this.storageScope(),
+                    gatewayUrl: this.url,
+                    role: hello.auth.role ?? OPERATOR_ROLE,
+                    token: hello.auth.deviceToken,
+                    scopes: hello.auth.scopes ?? [],
+                });
+            }
+            this._version = hello?.server?.version ?? hello?.version ?? null;
+            this._protocol = hello?.protocol ?? null;
+            this.connected = true;
+            this.pendingConnectError = null;
+            this.backoffMs = INITIAL_BACKOFF_MS;
+            this.updatePairingState(null);
+            if (this.resolveConnectPromise) {
+                this.resolveConnectPromise();
+            }
+            this.connectPromise = null;
+            this.resolveConnectPromise = null;
+            this.rejectConnectPromise = null;
+            this.onHello?.(hello);
+        }
+        catch (error) {
+            this.pendingConnectError = toCloseError(error);
+            const detailCode = readConnectErrorCode(error);
+            const requestId = readConnectPairingRequestId(error);
+            if (identity &&
+                (detailCode === CONNECT_ERROR_PAIRING_REQUIRED ||
+                    detailCode === CONNECT_ERROR_DEVICE_TOKEN_MISMATCH)) {
+                clearStoredDeviceToken(identity.deviceId, this.storageScope(), OPERATOR_ROLE);
+            }
+            if (detailCode === CONNECT_ERROR_PAIRING_REQUIRED && requestId) {
+                this.updatePairingState({
+                    requestId,
+                    role: OPERATOR_ROLE,
+                    gatewayUrl: this.url,
+                    ...(identity ? { deviceId: identity.deviceId } : {}),
+                    status: "pending",
+                    updatedAtMs: Date.now(),
+                });
+                if (this.canAutoApprovePairing() && !this.autoApproveAttemptedRequestIds.has(requestId)) {
+                    this.autoApproveAttemptedRequestIds.add(requestId);
+                    try {
+                        this.updatePairingState({
+                            requestId,
+                            role: OPERATOR_ROLE,
+                            gatewayUrl: this.url,
+                            ...(identity ? { deviceId: identity.deviceId } : {}),
+                            status: "approving",
+                            updatedAtMs: Date.now(),
+                        });
+                        await this.approvePairingRequest(requestId);
+                        this.updatePairingState({
+                            requestId,
+                            role: OPERATOR_ROLE,
+                            gatewayUrl: this.url,
+                            ...(identity ? { deviceId: identity.deviceId } : {}),
+                            status: "approved",
+                            updatedAtMs: Date.now(),
+                        });
+                        this.pendingConnectError = {
+                            code: "PAIRING_APPROVED",
+                            message: "Pairing approved, reconnecting",
+                        };
+                    }
+                    catch (approvalError) {
+                        this.pendingConnectError = toCloseError(approvalError);
+                        this.updatePairingState({
+                            requestId,
+                            role: OPERATOR_ROLE,
+                            gatewayUrl: this.url,
+                            ...(identity ? { deviceId: identity.deviceId } : {}),
+                            status: "failed",
+                            updatedAtMs: Date.now(),
+                            error: approvalError instanceof Error ? approvalError.message : String(approvalError),
+                        });
+                    }
+                }
+            }
+            if (this.ws) {
+                this.ws.close(RECONNECT_CLOSE_CODE, "connect failed");
+            }
+        }
+    }
+    handleMessage(raw) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (message.type === "event") {
+            const gatewayEvent = message;
+            if (gatewayEvent.event === "connect.challenge") {
+                const nonce = gatewayEvent.payload && typeof gatewayEvent.payload.nonce === "string"
+                    ? gatewayEvent.payload.nonce.trim()
+                    : "";
+                if (!nonce) {
+                    this.pendingConnectError = {
+                        code: "DEVICE_AUTH_NONCE_REQUIRED",
+                        message: "gateway connect challenge missing nonce",
+                    };
+                    this.ws?.close(RECONNECT_CLOSE_CODE, "connect challenge missing nonce");
+                    return;
+                }
+                this.connectNonce = nonce;
+                void this.sendConnect();
+                return;
+            }
+            if (typeof gatewayEvent.seq === "number") {
+                if (this.lastSeq !== null && gatewayEvent.seq > this.lastSeq + 1) {
+                    this.onGap?.({ expected: this.lastSeq + 1, received: gatewayEvent.seq });
+                }
+                this.lastSeq = gatewayEvent.seq;
+            }
+            for (const handler of this.eventHandlers) {
+                try {
+                    handler(gatewayEvent);
+                }
+                catch {
+                    // Event handlers are isolated from the socket lifecycle.
+                }
+            }
+            return;
+        }
+        if (message.type !== "res") {
+            return;
+        }
+        const pending = this.pending.get(message.id);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(message.id);
+        clearTimeout(pending.timer);
+        if (message.ok) {
+            pending.resolve(message.payload);
+            return;
+        }
+        pending.reject(new GatewayRequestError({
+            code: message.error?.code ?? "UNAVAILABLE",
+            message: message.error?.message ?? "gateway request failed",
+            details: message.error?.details,
+        }));
+    }
+    sendRawRequest(method, params = {}, timeout = this.defaultTimeout, allowBeforeHello = false) {
+        if (!this.ws || !isSocketOpen(this.ws)) {
+            return Promise.reject(new Error("gateway not connected"));
+        }
+        if (!allowBeforeHello && !this.connected) {
+            return Promise.reject(new Error("gateway not connected"));
+        }
+        const id = makeId();
+        const request = { type: "req", id, method, params };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`RPC timeout: ${method}`));
+            }, timeout);
+            this.pending.set(id, { resolve, reject, timer });
+            this.ws?.send(JSON.stringify(request));
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // RPC
+    // ---------------------------------------------------------------------------
+    rpc(method, params = {}, timeout) {
+        return this.sendRawRequest(method, params, timeout ?? this.defaultTimeout);
+    }
+    request(method, params = {}, timeout) {
+        return this.rpc(method, params, timeout);
+    }
+    // ---------------------------------------------------------------------------
+    // Config
+    // ---------------------------------------------------------------------------
+    async configGet() {
+        const res = await this.rpc("config.get");
+        if (res?.parsed)
+            return res.parsed;
+        if (res?.raw) {
+            try {
+                return JSON.parse(res.raw);
+            }
+            catch {
+                // Fall through to the raw payload.
+            }
+        }
+        return res?.config ?? res ?? {};
+    }
+    async configSchema() {
+        const res = await this.rpc("config.schema");
+        return normalizeOpenClawConfigSchema(res) ?? { schema: {}, uiHints: {} };
+    }
+    async configPatch(patch) {
+        await this.rpc("config.patch", { patch });
+    }
+    async configSet(config) {
+        await this.rpc("config.set", { config });
+    }
+    async modelsList() {
+        const res = await this.rpc("models.list");
+        return res?.models ?? res ?? [];
+    }
+    // ---------------------------------------------------------------------------
+    // Sessions
+    // ---------------------------------------------------------------------------
+    async sessionsList() {
+        const res = await this.rpc("sessions.list");
+        return res?.sessions ?? res ?? [];
+    }
+    async sessionsPreview(sessionKey, limit = 20) {
+        const res = await this.rpc("sessions.preview", { sessionKey, limit });
+        return res?.messages ?? res ?? [];
+    }
+    async chatHistory(sessionKey, limit = 50) {
+        const params = { limit };
+        if (sessionKey)
+            params.sessionKey = sessionKey;
+        const res = await this.rpc("chat.history", params);
+        return res?.messages ?? res ?? [];
+    }
+    async chatAbort(sessionKey) {
+        const params = {};
+        if (sessionKey)
+            params.sessionKey = sessionKey;
+        await this.rpc("chat.abort", params);
+    }
+    async sendChat(message, sessionKey = "main", agentId, attachments) {
+        const params = {
+            message,
+            sessionKey,
+            idempotencyKey: makeId(),
+        };
+        if (agentId)
+            params.agentId = agentId;
+        if (attachments && attachments.length > 0)
+            params.attachments = attachments;
+        return this.rpc("chat.send", params, CHAT_TIMEOUT);
+    }
+    async sessionsReset(sessionKey) {
+        await this.rpc("sessions.reset", { sessionKey });
+    }
+    // ---------------------------------------------------------------------------
+    // Chat (streaming via events)
+    // ---------------------------------------------------------------------------
+    async *chatSend(message, sessionKey) {
+        if (!this.connected || !this.ws) {
+            throw new Error("Not connected");
+        }
+        const id = makeId();
+        const req = {
+            type: "req",
+            id,
+            method: "chat.send",
+            params: {
+                message,
+                sessionKey,
+                idempotencyKey: makeId(),
+            },
+        };
+        const events = [];
+        let resolveWait = null;
+        let done = false;
+        let error = null;
+        // Temporary event handler for chat events
+        const handler = (evt) => {
+            if (evt.event?.startsWith("chat.")) {
+                const payload = evt.payload ?? {};
+                if (evt.event === "chat.content") {
+                    events.push({ type: "content", text: payload.text ?? "" });
+                }
+                else if (evt.event === "chat.thinking") {
+                    events.push({ type: "thinking", text: payload.text ?? "" });
+                }
+                else if (evt.event === "chat.tool_call") {
+                    events.push({ type: "tool_call", data: payload });
+                }
+                else if (evt.event === "chat.tool_result") {
+                    events.push({ type: "tool_result", data: payload });
+                }
+                else if (evt.event === "chat.done") {
+                    events.push({ type: "done" });
+                    done = true;
+                }
+                else if (evt.event === "chat.error") {
+                    events.push({ type: "error", text: payload.message ?? "Unknown error" });
+                    done = true;
+                }
+                resolveWait?.();
+            }
+        };
+        this.eventHandlers.add(handler);
+        // Also listen for the RPC response
+        const timer = setTimeout(() => {
+            this.pending.delete(id);
+            error = new Error("Chat timeout");
+            done = true;
+            resolveWait?.();
+        }, CHAT_TIMEOUT);
+        this.pending.set(id, {
+            resolve: () => {
+                clearTimeout(timer);
+                done = true;
+                resolveWait?.();
+            },
+            reject: (rejection) => {
+                clearTimeout(timer);
+                error = rejection instanceof Error ? rejection : new Error(String(rejection));
+                done = true;
+                resolveWait?.();
+            },
+            timer,
+        });
+        this.ws.send(JSON.stringify(req));
+        try {
+            while (!done || events.length > 0) {
+                if (events.length > 0) {
+                    yield events.shift();
+                }
+                else if (!done) {
+                    await new Promise((resolve) => {
+                        resolveWait = resolve;
+                    });
+                    resolveWait = null;
+                }
+            }
+            if (error)
+                throw error;
+        }
+        finally {
+            clearTimeout(timer);
+            this.eventHandlers.delete(handler);
+            this.pending.delete(id);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Files (agent workspace files)
+    // ---------------------------------------------------------------------------
+    async filesList(agentId = "main") {
+        const res = await this.rpc("agents.files.list", { agentId });
+        return res?.files ?? [];
+    }
+    async fileGet(agentId, name) {
+        const res = await this.rpc("agents.files.get", { agentId, name });
+        return res?.content ?? "";
+    }
+    async fileSet(agentId, name, content) {
+        await this.rpc("agents.files.set", { agentId, name, content });
+    }
+    // ---------------------------------------------------------------------------
+    // Agents
+    // ---------------------------------------------------------------------------
+    async agentsList() {
+        const res = await this.rpc("agents.list");
+        const agents = res?.agents ?? res ?? [];
+        return Array.isArray(agents)
+            ? agents.map((agent) => ({ ...agent, id: agent?.agentId ?? agent?.id }))
+            : [];
+    }
+    // ---------------------------------------------------------------------------
+    // Cron
+    // ---------------------------------------------------------------------------
+    async cronList() {
+        const res = await this.rpc("cron.list");
+        return res?.jobs ?? res ?? [];
+    }
+    async cronAdd(job) {
+        return this.rpc("cron.add", { job });
+    }
+    async cronRemove(jobId) {
+        await this.rpc("cron.remove", { jobId });
+    }
+    async execApprove(execId) {
+        await this.rpc("exec.approve", { execId });
+    }
+    async execDeny(execId) {
+        await this.rpc("exec.deny", { execId });
+    }
+    // ---------------------------------------------------------------------------
+    // Status
+    // ---------------------------------------------------------------------------
+    async status() {
+        return this.rpc("status");
+    }
+}
+//# sourceMappingURL=gateway.js.map