echoclaw-relay-agent 0.7.2 → 0.8.1

package/dist/RelayAgent.js

@@ -245,12 +245,21 @@ export class RelayAgent extends EventEmitter {
             await this.onPaired(result);
         }
         catch (err) {
-            // Resume failed — clear stale session to prevent infinite retry loop
+            // Resume failed — only clear session for permanent errors
             this.transport?.disconnect();
             this.transport = null;
             this.frameCrypto = null;
             this.setStatus('disconnected');
-            await this.sessionStore.clear();
+            const errMsg = err instanceof Error ? err.message : String(err);
+            const isPermanent = errMsg.includes('DEVICE_TOKEN_MISMATCH') ||
+                errMsg.includes('SESSION_NOT_FOUND') ||
+                errMsg.includes('SESSION_EXPIRED') ||
+                errMsg.includes('INVALID_SESSION');
+            if (isPermanent) {
+                // Permanent rejection — session is truly dead, clear it
+                await this.sessionStore.clear();
+            }
+            // Transient errors (network, timeout) — keep session.json for retry
             throw err;
         }
     }

package/dist/chat/ChatHandler.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ChatHandler — Routes chat messages to local OpenClaw via OpenAI-compatible API.
+ *
+ * Receives decrypted messages from desktop, forwards to localhost:18789,
+ * returns AI responses back through the relay.
+ *
+ * Message types handled:
+ *   - system_prompt: stored as conversation context
+ *   - chat: forwarded to OpenClaw /v1/chat/completions
+ */
+export interface ChatMessage {
+    type: string;
+    [key: string]: unknown;
+}
+export declare class ChatHandler {
+    private history;
+    private readonly openClawUrl;
+    constructor(openClawPort?: number);
+    /**
+     * Handle an incoming message from desktop.
+     * Returns an array of response messages to send back.
+     */
+    handle(payload: any): Promise<ChatMessage[]>;
+    /** Clear conversation history (call on disconnect/reconnect). */
+    clearHistory(): void;
+    private forwardToOpenClaw;
+    private trimHistory;
+}

package/dist/chat/ChatHandler.js

@@ -0,0 +1,104 @@
+/**
+ * ChatHandler — Routes chat messages to local OpenClaw via OpenAI-compatible API.
+ *
+ * Receives decrypted messages from desktop, forwards to localhost:18789,
+ * returns AI responses back through the relay.
+ *
+ * Message types handled:
+ *   - system_prompt: stored as conversation context
+ *   - chat: forwarded to OpenClaw /v1/chat/completions
+ */
+const MAX_HISTORY = 50;
+const FETCH_TIMEOUT_MS = 120000; // 2 min — AI inference can be slow
+export class ChatHandler {
+    constructor(openClawPort = 18789) {
+        Object.defineProperty(this, "history", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "openClawUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.openClawUrl = `http://localhost:${openClawPort}`;
+    }
+    /**
+     * Handle an incoming message from desktop.
+     * Returns an array of response messages to send back.
+     */
+    async handle(payload) {
+        if (payload?.type === 'system_prompt') {
+            this.history.push({ role: 'system', content: payload.content });
+            this.trimHistory();
+            return [];
+        }
+        if (payload?.type === 'chat' && payload.text) {
+            const agentId = payload.agentId || 'openclaw-1';
+            const responses = [];
+            responses.push({ type: 'typing' });
+            try {
+                const reply = await this.forwardToOpenClaw(payload.text);
+                responses.push({ type: 'typing_stop' });
+                responses.push({ type: 'chat', text: reply, agentId });
+            }
+            catch (err) {
+                responses.push({ type: 'typing_stop' });
+                responses.push({
+                    type: 'chat',
+                    text: `Error: ${err.message}`,
+                    agentId,
+                });
+            }
+            return responses;
+        }
+        return [];
+    }
+    /** Clear conversation history (call on disconnect/reconnect). */
+    clearHistory() {
+        this.history = [];
+    }
+    async forwardToOpenClaw(text) {
+        const messages = [...this.history, { role: 'user', content: text }];
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        try {
+            const res = await fetch(`${this.openClawUrl}/v1/chat/completions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ model: 'default', messages, stream: false }),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                throw new Error(`OpenClaw returned ${res.status}: ${res.statusText}`);
+            }
+            const data = (await res.json());
+            const reply = data.choices?.[0]?.message?.content || 'No response from OpenClaw';
+            // Append to history for multi-turn conversation
+            this.history.push({ role: 'user', content: text });
+            this.history.push({ role: 'assistant', content: reply });
+            this.trimHistory();
+            return reply;
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                throw new Error('OpenClaw request timed out (120s)');
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    trimHistory() {
+        // Keep system messages + last MAX_HISTORY user/assistant pairs
+        const systemMsgs = this.history.filter((m) => m.role === 'system');
+        const nonSystem = this.history.filter((m) => m.role !== 'system');
+        if (nonSystem.length > MAX_HISTORY) {
+            this.history = [...systemMsgs, ...nonSystem.slice(-MAX_HISTORY)];
+        }
+    }
+}

package/dist/cli.js

@@ -11,6 +11,7 @@
  */
 import { RelayAgent } from './RelayAgent.js';
 import { getServiceManager } from './service/platform.js';
+import { ChatHandler } from './chat/ChatHandler.js';
 const DEFAULT_RELAY = 'wss://relay.echoclaw.me';
 // ── ASCII Banners ───────────────────────────────────────────
 const RESET = '\x1b[0m';
@@ -233,6 +234,13 @@ async function runSetup(code, relay, bridgePort) {
     console.log();
     // Step 2: Stop the foreground agent (service will take over)
     await agent.stop();
+    // Verify session.json exists before installing service
+    const { SessionStore } = await import('./relay/SessionStore.js');
+    const store = new SessionStore();
+    const savedSession = await store.load();
+    if (!savedSession) {
+        throw new Error('Session file not found after pairing — cannot install service. Try setup again.');
+    }
     // Step 3: Install as system service (WITHOUT pairing code — it resumes from session)
     printStep('2/3', 'Installing system service...');
     const svc = await getServiceManager();
@@ -304,18 +312,33 @@ async function runDaemon(relay, code, gateway, bridgePort) {
             ...(bridgePort ? { bridgePort } : {}),
         } : undefined,
     });
+    // Chat handler — routes messages to local OpenClaw (port 18789)
+    const chatHandler = new ChatHandler(18789);
     agent.on('paired', (info) => {
         console.log(`  [paired] code=${info.pairingCode} session=${info.sessionId}`);
     });
     agent.on('connected', () => console.log('  [connected] relay connection active'));
     agent.on('disconnected', (info) => {
         console.log(`  [disconnected] ${info.reason}`);
+        chatHandler.clearHistory();
     });
     agent.on('reconnecting', (info) => {
         console.log(`  [reconnecting] attempt=${info.attempt} delay=${info.delayMs}ms`);
     });
-    agent.on('message', (payload) => {
+    agent.on('message', async (payload) => {
         console.log('  [message]', JSON.stringify(payload));
+        const responses = await chatHandler.handle(payload);
+        for (const msg of responses) {
+            try {
+                await agent.send(msg);
+                if (msg.type === 'chat') {
+                    console.log(`  [chat→desktop] ${msg.text.slice(0, 80)}${msg.text.length > 80 ? '...' : ''}`);
+                }
+            }
+            catch (err) {
+                console.error(`  [send-error] ${err.message}`);
+            }
+        }
     });
     agent.on('error', (err) => {
         console.error(`  [error] ${err.message}`);
@@ -338,7 +361,32 @@ async function runDaemon(relay, code, gateway, bridgePort) {
     process.once('SIGINT', shutdown);
     process.once('SIGTERM', shutdown);
     console.log(`  [start] relay=${relay} gateway=${!!gateway}`);
-    await agent.start(code);
+    // Retry logic — transient failures (network, server restart) shouldn't kill the service
+    const MAX_RETRIES = 5;
+    const RETRY_DELAY = 3000;
+    let lastErr;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            await agent.start(code);
+            return; // success — stay alive
+        }
+        catch (err) {
+            lastErr = err;
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`  [start-failed] attempt=${attempt}/${MAX_RETRIES} error=${msg}`);
+            // Permanent errors — don't retry
+            if (msg.includes('No saved session found') ||
+                msg.includes('DEVICE_TOKEN_MISMATCH') ||
+                msg.includes('SESSION_NOT_FOUND')) {
+                break;
+            }
+            if (attempt < MAX_RETRIES) {
+                console.log(`  [retry] waiting ${RETRY_DELAY / 1000}s...`);
+                await new Promise(r => setTimeout(r, RETRY_DELAY));
+            }
+        }
+    }
+    throw lastErr;
 }
 // ── Main ─────────────────────────────────────────────────────
 async function main() {

package/dist/index.d.ts

@@ -16,6 +16,8 @@ export { RelayTransport } from './relay/RelayTransport.js';
 export { PairingProtocol } from './relay/PairingProtocol.js';
 export { RelayClient } from './RelayClient.js';
 export { RelayAgent } from './RelayAgent.js';
+export { ChatHandler } from './chat/ChatHandler.js';
+export type { ChatMessage } from './chat/ChatHandler.js';
 export { GatewayManager } from './gateway/index.js';
 export { DeviceIdentity } from './gateway/index.js';
 export { TokenDiscovery } from './gateway/index.js';

package/dist/index.js

@@ -18,6 +18,8 @@ export { PairingProtocol } from './relay/PairingProtocol.js';
 // ── Entry Points ─────────────────────────────────────────────────
 export { RelayClient } from './RelayClient.js';
 export { RelayAgent } from './RelayAgent.js';
+// ── Chat ────────────────────────────────────────────────────────
+export { ChatHandler } from './chat/ChatHandler.js';
 // ── Gateway V2 ──────────────────────────────────────────────────
 export { GatewayManager } from './gateway/index.js';
 export { DeviceIdentity } from './gateway/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "echoclaw-relay-agent",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "EchoClaw Relay Connection — E2E encrypted relay transport, pairing, and session management",
   "type": "module",
   "main": "./dist/index.js",