agent-relay 3.1.10 → 3.1.12

package/packages/openclaw/src/__tests__/ws-client.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, afterEach } from 'vitest';
 import { WebSocketServer, type WebSocket as WsType } from 'ws';
 
 // Mock spawn/manager and relaycast SDK to prevent side-effects from gateway.ts module load
@@ -42,6 +42,8 @@ vi.mock('node:fs/promises', () => ({
   readFile: vi.fn().mockResolvedValue('{"spawns":[]}'),
   writeFile: vi.fn().mockResolvedValue(undefined),
   mkdir: vi.fn().mockResolvedValue(undefined),
+  rename: vi.fn().mockResolvedValue(undefined),
+  chmod: vi.fn().mockResolvedValue(undefined),
 }));
 
 vi.mock('node:fs', () => ({
@@ -114,12 +116,14 @@ class MockOpenClawServer {
           if (this.acceptAuth) {
             ws.send(JSON.stringify({ type: 'res', id: 'connect-1', ok: true }));
           } else {
-            ws.send(JSON.stringify({
-              type: 'res',
-              id: 'connect-1',
-              ok: false,
-              error: { code: 'auth_failed', message: 'Invalid token' },
-            }));
+            ws.send(
+              JSON.stringify({
+                type: 'res',
+                id: 'connect-1',
+                ok: false,
+                error: { code: 'auth_failed', message: 'Invalid token' },
+              })
+            );
           }
           return;
         }
@@ -128,19 +132,23 @@ class MockOpenClawServer {
         if (msg.method === 'chat.send') {
           const respond = () => {
             if (this.chatOk) {
-              ws.send(JSON.stringify({
-                type: 'res',
-                id: msg.id,
-                ok: true,
-                payload: { runId: 'run-1', status: 'accepted' },
-              }));
+              ws.send(
+                JSON.stringify({
+                  type: 'res',
+                  id: msg.id,
+                  ok: true,
+                  payload: { runId: 'run-1', status: 'accepted' },
+                })
+              );
             } else {
-              ws.send(JSON.stringify({
-                type: 'res',
-                id: msg.id,
-                ok: false,
-                error: { code: 'rate_limited', message: 'Too many requests' },
-              }));
+              ws.send(
+                JSON.stringify({
+                  type: 'res',
+                  id: msg.id,
+                  ok: false,
+                  error: { code: 'rate_limited', message: 'Too many requests' },
+                })
+              );
             }
           };
 
@@ -308,11 +316,13 @@ describe('OpenClawGatewayClient', () => {
     origWss.removeAllListeners('connection');
     origWss.on('connection', (ws) => {
       // Send challenge
-      ws.send(JSON.stringify({
-        type: 'event',
-        event: 'connect.challenge',
-        payload: { nonce: 'nonce-1', ts: Date.now() },
-      }));
+      ws.send(
+        JSON.stringify({
+          type: 'event',
+          event: 'connect.challenge',
+          payload: { nonce: 'nonce-1', ts: Date.now() },
+        })
+      );
       ws.on('message', (data) => {
         const msg = JSON.parse(data.toString()) as Record<string, unknown>;
         if (msg.method === 'connect') {
@@ -354,11 +364,13 @@ describe('OpenClawGatewayClient', () => {
     origWss.on('connection', (ws) => {
       // Send garbage first, then a proper challenge
       ws.send('not json at all');
-      ws.send(JSON.stringify({
-        type: 'event',
-        event: 'connect.challenge',
-        payload: { nonce: 'nonce-2', ts: Date.now() },
-      }));
+      ws.send(
+        JSON.stringify({
+          type: 'event',
+          event: 'connect.challenge',
+          payload: { nonce: 'nonce-2', ts: Date.now() },
+        })
+      );
       ws.on('message', (data) => {
         const msg = JSON.parse(data.toString()) as Record<string, unknown>;
         if (msg.method === 'connect') {
@@ -380,22 +392,26 @@ describe('OpenClawGatewayClient', () => {
     origWss.on('connection', (ws) => {
       connectAttempts++;
       // Send challenge
-      ws.send(JSON.stringify({
-        type: 'event',
-        event: 'connect.challenge',
-        payload: { nonce: `nonce-fallback-${connectAttempts}`, ts: Date.now() },
-      }));
+      ws.send(
+        JSON.stringify({
+          type: 'event',
+          event: 'connect.challenge',
+          payload: { nonce: `nonce-fallback-${connectAttempts}`, ts: Date.now() },
+        })
+      );
       ws.on('message', (data) => {
         const msg = JSON.parse(data.toString()) as Record<string, unknown>;
         if (msg.method === 'connect') {
           if (connectAttempts === 1) {
             // First attempt: reject with signature invalid
-            ws.send(JSON.stringify({
-              type: 'res',
-              id: 'connect-1',
-              ok: false,
-              error: { code: 'auth_failed', message: 'device signature invalid' },
-            }));
+            ws.send(
+              JSON.stringify({
+                type: 'res',
+                id: 'connect-1',
+                ok: false,
+                error: { code: 'auth_failed', message: 'device signature invalid' },
+              })
+            );
           } else {
             // Second attempt (fallback): accept
             ws.send(JSON.stringify({ type: 'res', id: 'connect-1', ok: true }));
@@ -418,21 +434,25 @@ describe('OpenClawGatewayClient', () => {
     origWss.removeAllListeners('connection');
     origWss.on('connection', (ws) => {
       connectAttempts++;
-      ws.send(JSON.stringify({
-        type: 'event',
-        event: 'connect.challenge',
-        payload: { nonce: `nonce-nofallback-${connectAttempts}`, ts: Date.now() },
-      }));
+      ws.send(
+        JSON.stringify({
+          type: 'event',
+          event: 'connect.challenge',
+          payload: { nonce: `nonce-nofallback-${connectAttempts}`, ts: Date.now() },
+        })
+      );
       ws.on('message', (data) => {
         const msg = JSON.parse(data.toString()) as Record<string, unknown>;
         if (msg.method === 'connect') {
           // Always reject with signature invalid
-          ws.send(JSON.stringify({
-            type: 'res',
-            id: 'connect-1',
-            ok: false,
-            error: { code: 'auth_failed', message: 'device signature invalid' },
-          }));
+          ws.send(
+            JSON.stringify({
+              type: 'res',
+              id: 'connect-1',
+              ok: false,
+              error: { code: 'auth_failed', message: 'device signature invalid' },
+            })
+          );
         }
       });
     });

package/packages/openclaw/src/config.ts

@@ -5,6 +5,28 @@ import { existsSync, readFileSync } from 'node:fs';
 
 import type { GatewayConfig } from './types.js';
 
+function envValue(vars: Record<string, string>, key: string): string | undefined {
+  const processValue = process.env[key]?.trim();
+  if (processValue) return processValue;
+  const fileValue = vars[key]?.trim();
+  return fileValue ? fileValue : undefined;
+}
+
+function parseBooleanEnv(vars: Record<string, string>, key: string): boolean | undefined {
+  const value = envValue(vars, key);
+  if (!value) return undefined;
+  if (['1', 'true', 'yes', 'on'].includes(value.toLowerCase())) return true;
+  if (['0', 'false', 'no', 'off'].includes(value.toLowerCase())) return false;
+  return undefined;
+}
+
+function parseNumberEnv(vars: Record<string, string>, key: string): number | undefined {
+  const value = envValue(vars, key);
+  if (!value) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
 export interface OpenClawDetection {
   /** Whether OpenClaw is installed. */
   installed: boolean;
@@ -61,6 +83,15 @@ export function openclawHome(): string {
   return openclawHomePath;
 }
 
+/** Return the config filename for the resolved OpenClaw home (clawdbot.json or openclaw.json). */
+export function openclawConfigFilename(home?: string): string {
+  const dir = home ?? openclawHome();
+  if (hasValidConfig(dir, 'clawdbot.json')) return 'clawdbot.json';
+  if (hasValidConfig(dir, 'openclaw.json')) return 'openclaw.json';
+  // No existing config — infer from directory name
+  return dir.endsWith('.clawdbot') ? 'clawdbot.json' : 'openclaw.json';
+}
+
 /**
  * Detect whether OpenClaw is installed and return paths/config.
  */
@@ -138,6 +169,7 @@ export async function detectOpenClaw(): Promise<OpenClawDetection> {
  * Load the gateway config from ~/.openclaw/workspace/relaycast/.env.
  * Returns null if the file doesn't exist or can't be parsed.
  */
+// eslint-disable-next-line complexity
 export async function loadGatewayConfig(): Promise<GatewayConfig | null> {
   const detection = await detectOpenClaw();
   const envPath = join(detection.workspaceDir, 'relaycast', '.env');
@@ -163,25 +195,69 @@ export async function loadGatewayConfig(): Promise<GatewayConfig | null> {
       vars[trimmed.slice(0, eqIdx)] = value;
     }
 
-    const apiKey = vars['RELAY_API_KEY'];
-    const clawName = vars['RELAY_CLAW_NAME'];
+    const apiKey = envValue(vars, 'RELAY_API_KEY');
+    const clawName = envValue(vars, 'RELAY_CLAW_NAME');
+    const relayChannels = envValue(vars, 'RELAY_CHANNELS');
 
     if (!apiKey || !clawName) {
       return null;
     }
 
-    const portStr = vars['OPENCLAW_GATEWAY_PORT'];
-    const port = portStr ? Number(portStr) : undefined;
+    const port = parseNumberEnv(vars, 'OPENCLAW_GATEWAY_PORT');
+    const pollFallbackEnabled = parseBooleanEnv(vars, 'RELAY_TRANSPORT_POLL_FALLBACK_ENABLED');
+    const pollFallbackProbeWsEnabled = parseBooleanEnv(
+      vars,
+      'RELAY_TRANSPORT_POLL_FALLBACK_PROBE_WS_ENABLED'
+    );
+    const pollFallbackWsFailureThreshold = parseNumberEnv(
+      vars,
+      'RELAY_TRANSPORT_POLL_FALLBACK_WS_FAILURE_THRESHOLD'
+    );
+    const pollFallbackTimeoutSeconds = parseNumberEnv(vars, 'RELAY_TRANSPORT_POLL_FALLBACK_TIMEOUT_SECONDS');
+    const pollFallbackLimit = parseNumberEnv(vars, 'RELAY_TRANSPORT_POLL_FALLBACK_LIMIT');
+    const pollFallbackProbeWsIntervalMs = parseNumberEnv(
+      vars,
+      'RELAY_TRANSPORT_POLL_FALLBACK_PROBE_WS_INTERVAL_MS'
+    );
+    const pollFallbackProbeWsStableGraceMs = parseNumberEnv(
+      vars,
+      'RELAY_TRANSPORT_POLL_FALLBACK_PROBE_WS_STABLE_GRACE_MS'
+    );
+    const pollFallbackInitialCursor = envValue(vars, 'RELAY_TRANSPORT_POLL_FALLBACK_INITIAL_CURSOR');
+
+    const transport =
+      pollFallbackEnabled !== undefined ||
+      pollFallbackProbeWsEnabled !== undefined ||
+      pollFallbackWsFailureThreshold !== undefined ||
+      pollFallbackTimeoutSeconds !== undefined ||
+      pollFallbackLimit !== undefined ||
+      pollFallbackProbeWsIntervalMs !== undefined ||
+      pollFallbackProbeWsStableGraceMs !== undefined ||
+      pollFallbackInitialCursor !== undefined
+        ? {
+            pollFallback: {
+              enabled: pollFallbackEnabled,
+              wsFailureThreshold: pollFallbackWsFailureThreshold,
+              timeoutSeconds: pollFallbackTimeoutSeconds,
+              limit: pollFallbackLimit,
+              initialCursor: pollFallbackInitialCursor,
+              probeWs: {
+                enabled: pollFallbackProbeWsEnabled,
+                intervalMs: pollFallbackProbeWsIntervalMs,
+                stableGraceMs: pollFallbackProbeWsStableGraceMs,
+              },
+            },
+          }
+        : undefined;
 
     return {
       apiKey,
       clawName,
-      baseUrl: vars['RELAY_BASE_URL'] || 'https://api.relaycast.dev',
-      channels: vars['RELAY_CHANNELS']
-        ? vars['RELAY_CHANNELS'].split(',').map((c) => c.trim())
-        : ['general'],
-      openclawGatewayToken: vars['OPENCLAW_GATEWAY_TOKEN'] || process.env.OPENCLAW_GATEWAY_TOKEN,
+      baseUrl: envValue(vars, 'RELAY_BASE_URL') || 'https://api.relaycast.dev',
+      channels: relayChannels ? relayChannels.split(',').map((c) => c.trim()) : ['general'],
+      openclawGatewayToken: envValue(vars, 'OPENCLAW_GATEWAY_TOKEN'),
       openclawGatewayPort: Number.isFinite(port) ? port : undefined,
+      transport,
     };
   } catch {
     return null;
@@ -207,14 +283,47 @@ export async function saveGatewayConfig(config: GatewayConfig): Promise<void> {
 
   if (config.openclawGatewayToken) {
     lines.push(`OPENCLAW_GATEWAY_TOKEN=${config.openclawGatewayToken}`);
-    const masked = config.openclawGatewayToken.length > 12
-      ? config.openclawGatewayToken.slice(0, 8) + '...'
-      : '***';
+    const masked =
+      config.openclawGatewayToken.length > 12 ? config.openclawGatewayToken.slice(0, 8) + '...' : '***';
     console.log(`[config] Persisting OPENCLAW_GATEWAY_TOKEN (${masked})`);
   }
   if (config.openclawGatewayPort) {
     lines.push(`OPENCLAW_GATEWAY_PORT=${config.openclawGatewayPort}`);
   }
+  if (config.transport?.pollFallback?.enabled !== undefined) {
+    lines.push(`RELAY_TRANSPORT_POLL_FALLBACK_ENABLED=${config.transport.pollFallback.enabled}`);
+  }
+  if (config.transport?.pollFallback?.wsFailureThreshold !== undefined) {
+    lines.push(
+      `RELAY_TRANSPORT_POLL_FALLBACK_WS_FAILURE_THRESHOLD=${config.transport.pollFallback.wsFailureThreshold}`
+    );
+  }
+  if (config.transport?.pollFallback?.timeoutSeconds !== undefined) {
+    lines.push(
+      `RELAY_TRANSPORT_POLL_FALLBACK_TIMEOUT_SECONDS=${config.transport.pollFallback.timeoutSeconds}`
+    );
+  }
+  if (config.transport?.pollFallback?.limit !== undefined) {
+    lines.push(`RELAY_TRANSPORT_POLL_FALLBACK_LIMIT=${config.transport.pollFallback.limit}`);
+  }
+  if (config.transport?.pollFallback?.initialCursor) {
+    lines.push(`RELAY_TRANSPORT_POLL_FALLBACK_INITIAL_CURSOR=${config.transport.pollFallback.initialCursor}`);
+  }
+  if (config.transport?.pollFallback?.probeWs?.enabled !== undefined) {
+    lines.push(
+      `RELAY_TRANSPORT_POLL_FALLBACK_PROBE_WS_ENABLED=${config.transport.pollFallback.probeWs.enabled}`
+    );
+  }
+  if (config.transport?.pollFallback?.probeWs?.intervalMs !== undefined) {
+    lines.push(
+      `RELAY_TRANSPORT_POLL_FALLBACK_PROBE_WS_INTERVAL_MS=${config.transport.pollFallback.probeWs.intervalMs}`
+    );
+  }
+  if (config.transport?.pollFallback?.probeWs?.stableGraceMs !== undefined) {
+    lines.push(
+      `RELAY_TRANSPORT_POLL_FALLBACK_PROBE_WS_STABLE_GRACE_MS=${config.transport.pollFallback.probeWs.stableGraceMs}`
+    );
+  }
 
   lines.push('');
   const env = lines.join('\n');