gopherhole_openclaw_a2a 0.1.2

package/dist/src/connection.js

@@ -0,0 +1,513 @@
+/**
+ * A2A Connection Manager
+ * Handles WebSocket connections to other agents and the bridge
+ */
+import WebSocket from 'ws';
+import { v4 as uuidv4 } from 'uuid';
+export class A2AConnectionManager {
+    connections = new Map();
+    pendingRequests = new Map();
+    reconnectTimers = new Map();
+    messageHandler = null;
+    config;
+    agentId;
+    constructor(config) {
+        this.config = config;
+        this.agentId = config.agentId ?? 'clawdbot';
+    }
+    setMessageHandler(handler) {
+        this.messageHandler = handler;
+    }
+    async start() {
+        // Connect to direct agents
+        if (this.config.agents) {
+            for (const agent of this.config.agents) {
+                await this.connectToAgent(agent.id, agent.url, agent.name);
+            }
+        }
+        // Connect to bridge if configured
+        if (this.config.bridgeUrl) {
+            await this.connectToAgent('bridge', this.config.bridgeUrl, 'A2A Bridge');
+        }
+        // Connect to GopherHole if configured
+        if (this.config.gopherhole?.enabled && this.config.gopherhole?.apiKey) {
+            await this.connectToGopherHole();
+        }
+    }
+    async connectToGopherHole() {
+        const gphConfig = this.config.gopherhole;
+        const hubUrl = gphConfig.hubUrl || 'wss://gopherhole.helixdata.workers.dev/ws';
+        const conn = {
+            id: 'gopherhole',
+            name: 'GopherHole Hub',
+            url: hubUrl,
+            ws: null,
+            connected: false,
+            reconnectAttempts: 0,
+        };
+        try {
+            await this.establishGopherHoleConnection(conn, gphConfig.apiKey);
+            this.connections.set('gopherhole', conn);
+            console.log(`[a2a] Connected to GopherHole Hub`);
+        }
+        catch (err) {
+            console.error(`[a2a] Failed to connect to GopherHole:`, err.message);
+            this.connections.set('gopherhole', conn);
+            this.scheduleReconnect('gopherhole');
+        }
+    }
+    async establishGopherHoleConnection(conn, apiKey) {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(conn.url);
+            const timeout = setTimeout(() => {
+                ws.terminate();
+                reject(new Error('GopherHole connection timeout'));
+            }, 10000);
+            ws.on('open', () => {
+                console.log('[a2a] GopherHole connected, authenticating...');
+                ws.send(JSON.stringify({ type: 'auth', token: apiKey }));
+            });
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.type === 'auth_ok' || msg.type === 'welcome') {
+                        clearTimeout(timeout);
+                        conn.ws = ws;
+                        conn.connected = true;
+                        conn.reconnectAttempts = 0;
+                        conn.lastPingAt = Date.now();
+                        console.log(`[a2a] GopherHole authenticated as ${msg.agentId}`);
+                        resolve();
+                    }
+                    else if (msg.type === 'auth_error') {
+                        clearTimeout(timeout);
+                        reject(new Error(msg.error || 'GopherHole auth failed'));
+                    }
+                    else if (msg.type === 'message') {
+                        // Incoming message from another agent via GopherHole
+                        console.log(`[a2a] Received GopherHole message: taskId=${msg.taskId}, from=${msg.from}`);
+                        const a2aMsg = {
+                            type: 'message',
+                            taskId: msg.taskId || `gph-${Date.now()}`,
+                            from: msg.from,
+                            content: msg.payload,
+                        };
+                        this.handleMessage('gopherhole', a2aMsg);
+                    }
+                    else if (msg.jsonrpc === '2.0' && msg.result) {
+                        // JSON-RPC response - task status (may be immediate success/failure)
+                        const requestId = msg.id;
+                        const taskId = msg.result?.id;
+                        const state = msg.result?.status?.state;
+                        console.log(`[a2a] GopherHole JSON-RPC response: requestId=${requestId}, taskId=${taskId}, state=${state}`);
+                        // Handle terminal states immediately (use requestId - that's what we stored)
+                        if (state === 'completed' || state === 'failed') {
+                            this.resolveGopherHoleTask(requestId, msg.result);
+                            return;
+                        }
+                        // For 'working'/'submitted', map taskId for future task_update events
+                        if (taskId && requestId && taskId !== requestId) {
+                            const pending = this.pendingRequests.get(requestId);
+                            if (pending) {
+                                this.pendingRequests.set(taskId, pending);
+                                this.pendingRequests.delete(requestId);
+                                console.log(`[a2a] Mapped taskId ${taskId} from requestId ${requestId}`);
+                            }
+                        }
+                    }
+                    else if (msg.jsonrpc === '2.0' && msg.error) {
+                        // JSON-RPC error response
+                        const requestId = msg.id;
+                        console.log(`[a2a] GopherHole JSON-RPC error: id=${requestId}, error=${msg.error?.message}`);
+                        const pending = this.pendingRequests.get(requestId);
+                        if (pending) {
+                            clearTimeout(pending.timeout);
+                            this.pendingRequests.delete(requestId);
+                            pending.reject(new Error(msg.error?.message || 'RPC error'));
+                        }
+                    }
+                    else if (msg.type === 'task_update') {
+                        // Task update event - nested under msg.task
+                        const task = msg.task || msg;
+                        const taskId = task.id || task.taskId;
+                        const state = task.status?.state;
+                        console.log(`[a2a] GopherHole task_update: taskId=${taskId}, state=${state}`);
+                        if (state === 'completed' || state === 'failed') {
+                            this.resolveGopherHoleTask(taskId, task);
+                        }
+                    }
+                    else if (msg.type === 'error') {
+                        // Error response (e.g., AGENT_NOT_FOUND)
+                        const taskId = msg.taskId;
+                        console.log(`[a2a] GopherHole error: code=${msg.code}, message=${msg.message}, taskId=${taskId}`);
+                        if (taskId) {
+                            const pending = this.pendingRequests.get(taskId);
+                            if (pending) {
+                                clearTimeout(pending.timeout);
+                                this.pendingRequests.delete(taskId);
+                                pending.reject(new Error(msg.message || msg.code || 'Unknown error'));
+                            }
+                        }
+                    }
+                    else {
+                        // Unhandled message type - log for debugging
+                        console.log(`[a2a] Unhandled GopherHole message: ${JSON.stringify(msg).slice(0, 500)}`);
+                    }
+                }
+                catch (err) {
+                    console.error(`[a2a] Failed to parse GopherHole message:`, err);
+                }
+            });
+            ws.on('close', (code, reason) => {
+                conn.connected = false;
+                conn.ws = null;
+                console.log(`[a2a] Disconnected from GopherHole: ${code} ${reason?.toString()}`);
+                this.scheduleReconnect('gopherhole');
+            });
+            ws.on('error', (err) => {
+                clearTimeout(timeout);
+                console.error(`[a2a] GopherHole WebSocket error:`, err.message);
+                if (!conn.connected) {
+                    reject(err);
+                }
+            });
+        });
+    }
+    async stop() {
+        // Clear all reconnect timers
+        for (const timer of this.reconnectTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.reconnectTimers.clear();
+        // Clear pending requests
+        for (const pending of this.pendingRequests.values()) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Connection closing'));
+        }
+        this.pendingRequests.clear();
+        // Close all connections
+        for (const conn of this.connections.values()) {
+            if (conn.ws && conn.ws.readyState === WebSocket.OPEN) {
+                conn.ws.close(1000, 'Shutting down');
+            }
+        }
+        this.connections.clear();
+    }
+    async connectToAgent(id, url, name) {
+        const conn = {
+            id,
+            name: name ?? id,
+            url,
+            ws: null,
+            connected: false,
+            reconnectAttempts: 0,
+        };
+        try {
+            await this.establishConnection(conn);
+            this.connections.set(id, conn);
+            console.log(`[a2a] Connected to agent: ${conn.name} (${id})`);
+        }
+        catch (err) {
+            console.error(`[a2a] Failed to connect to ${id}:`, err.message);
+            this.connections.set(id, conn);
+            this.scheduleReconnect(id);
+        }
+    }
+    async establishConnection(conn) {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(conn.url);
+            const timeout = setTimeout(() => {
+                ws.terminate();
+                reject(new Error('Connection timeout'));
+            }, 10000);
+            ws.on('open', () => {
+                clearTimeout(timeout);
+                conn.ws = ws;
+                conn.connected = true;
+                conn.reconnectAttempts = 0;
+                conn.lastPingAt = Date.now();
+                // Send agent card announcement
+                this.sendAgentAnnounce(conn);
+                resolve();
+            });
+            ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    this.handleMessage(conn.id, message);
+                }
+                catch (err) {
+                    console.error(`[a2a] Failed to parse message from ${conn.id}:`, err);
+                }
+            });
+            ws.on('close', (code, reason) => {
+                conn.connected = false;
+                conn.ws = null;
+                console.log(`[a2a] Disconnected from ${conn.id}: ${code} ${reason?.toString()}`);
+                this.scheduleReconnect(conn.id);
+            });
+            ws.on('error', (err) => {
+                clearTimeout(timeout);
+                console.error(`[a2a] WebSocket error for ${conn.id}:`, err.message);
+                reject(err);
+            });
+            ws.on('ping', () => {
+                conn.lastPingAt = Date.now();
+                ws.pong();
+            });
+        });
+    }
+    sendAgentAnnounce(conn) {
+        if (!conn.ws || !conn.connected)
+            return;
+        // Announce ourselves to the agent/bridge
+        const announce = {
+            type: 'announce',
+            agent: {
+                id: this.agentId,
+                name: this.config.agentName ?? 'Clawdbot',
+                description: 'Clawdbot AI assistant',
+                skills: ['chat', 'tasks', 'tools'],
+            },
+        };
+        conn.ws.send(JSON.stringify(announce));
+    }
+    scheduleReconnect(agentId) {
+        if (this.reconnectTimers.has(agentId))
+            return;
+        const conn = this.connections.get(agentId);
+        if (!conn)
+            return;
+        // Exponential backoff: 5s, 10s, 20s, 40s, max 60s
+        const baseDelay = this.config.reconnectIntervalMs ?? 5000;
+        const delay = Math.min(baseDelay * Math.pow(2, conn.reconnectAttempts), 60000);
+        conn.reconnectAttempts++;
+        console.log(`[a2a] Scheduling reconnect to ${agentId} in ${delay}ms`);
+        const timer = setTimeout(async () => {
+            this.reconnectTimers.delete(agentId);
+            if (!conn.connected) {
+                try {
+                    // Use GopherHole auth flow for gopherhole connection
+                    if (agentId === 'gopherhole' && this.config.gopherhole?.apiKey) {
+                        await this.establishGopherHoleConnection(conn, this.config.gopherhole.apiKey);
+                    }
+                    else {
+                        await this.establishConnection(conn);
+                    }
+                    console.log(`[a2a] Reconnected to ${agentId}`);
+                }
+                catch {
+                    this.scheduleReconnect(agentId);
+                }
+            }
+        }, delay);
+        this.reconnectTimers.set(agentId, timer);
+    }
+    handleMessage(agentId, message) {
+        // Handle responses to our requests
+        if (message.type === 'response' || message.status === 'completed' || message.status === 'failed') {
+            const pending = this.pendingRequests.get(message.taskId);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingRequests.delete(message.taskId);
+                if (message.status === 'failed' || message.error) {
+                    pending.reject(new Error(message.error ?? 'Task failed'));
+                }
+                else {
+                    const text = message.content?.parts
+                        ?.filter((p) => p.kind === 'text')
+                        .map((p) => p.text)
+                        .join('\n') ?? '';
+                    pending.resolve({
+                        text,
+                        status: message.status ?? 'completed',
+                        from: message.from,
+                    });
+                }
+                return;
+            }
+        }
+        // Route to message handler for incoming messages
+        if (this.messageHandler) {
+            this.messageHandler(agentId, message).catch((err) => {
+                console.error(`[a2a] Error handling message from ${agentId}:`, err);
+            });
+        }
+    }
+    /**
+     * Resolve a GopherHole task response - extract text from artifacts
+     */
+    resolveGopherHoleTask(taskId, taskData) {
+        const pending = this.pendingRequests.get(taskId);
+        if (!pending) {
+            console.log(`[a2a] No pending request for taskId ${taskId}`);
+            return;
+        }
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(taskId);
+        const status = taskData.status;
+        if (status?.state === 'failed') {
+            pending.reject(new Error(status.message ?? 'Task failed'));
+            return;
+        }
+        // Extract text from artifacts (GopherHole puts responses in artifacts, not history!)
+        let text = '';
+        const artifacts = taskData.artifacts;
+        if (artifacts?.length) {
+            // Get text from all artifacts
+            text = artifacts
+                .flatMap((artifact) => artifact.parts ?? [])
+                .filter((part) => part.kind === 'text' && part.text)
+                .map((part) => part.text)
+                .join('\n');
+        }
+        console.log(`[a2a] Resolved task ${taskId}: ${text.slice(0, 100)}...`);
+        pending.resolve({
+            text,
+            status: status?.state ?? 'completed',
+            from: 'gopherhole',
+        });
+    }
+    /**
+     * Send a message to another agent and wait for response
+     */
+    async sendMessage(agentId, text, contextId) {
+        const conn = this.connections.get(agentId);
+        if (!conn) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        if (!conn.connected || !conn.ws) {
+            throw new Error(`Agent ${agentId} not connected`);
+        }
+        const taskId = uuidv4();
+        const timeoutMs = this.config.requestTimeoutMs ?? 60000; // 60s default
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(taskId);
+                reject(new Error(`Request timeout after ${timeoutMs / 1000}s - agent may be offline`));
+            }, timeoutMs);
+            this.pendingRequests.set(taskId, {
+                taskId,
+                resolve,
+                reject,
+                timeout,
+                startedAt: Date.now(),
+            });
+            const msg = {
+                type: 'message',
+                taskId,
+                contextId,
+                from: this.agentId,
+                content: {
+                    parts: [{ kind: 'text', text }],
+                },
+            };
+            conn.ws.send(JSON.stringify(msg));
+        });
+    }
+    /**
+     * Send a response to an incoming message
+     */
+    sendResponse(agentId, taskId, text, contextId) {
+        const conn = this.connections.get(agentId);
+        if (!conn?.ws || !conn.connected) {
+            console.warn(`[a2a] Cannot send response - ${agentId} not connected`);
+            return;
+        }
+        const response = {
+            type: 'response',
+            taskId,
+            contextId,
+            from: this.agentId,
+            content: {
+                parts: [{ kind: 'text', text }],
+            },
+            status: 'completed',
+        };
+        conn.ws.send(JSON.stringify(response));
+    }
+    /**
+     * Send a response to an agent via GopherHole (for replying to incoming messages)
+     */
+    sendResponseViaGopherHole(targetAgentId, taskId, text, contextId) {
+        const gphConn = this.connections.get('gopherhole');
+        if (!gphConn?.connected || !gphConn.ws) {
+            console.warn(`[a2a] Cannot send GopherHole response - not connected`);
+            return;
+        }
+        // GopherHole task_response format (completes the original task)
+        const msg = {
+            type: 'task_response',
+            taskId,
+            to: targetAgentId,
+            status: { state: 'completed' },
+            artifact: {
+                artifactId: `response-${Date.now()}`,
+                mimeType: 'text/plain',
+                parts: [{ kind: 'text', text }],
+            },
+            lastChunk: true,
+        };
+        console.log(`[a2a] Sending response to ${targetAgentId} via GopherHole: taskId=${taskId}, msg=${JSON.stringify(msg)}`);
+        gphConn.ws.send(JSON.stringify(msg));
+    }
+    /**
+     * Send a message to a remote agent via GopherHole
+     * Note: targetAgentId must be the actual agent ID (e.g., "agent-70153299")
+     */
+    async sendViaGopherHole(targetAgentId, text, contextId) {
+        const gphConn = this.connections.get('gopherhole');
+        if (!gphConn?.connected || !gphConn.ws) {
+            throw new Error('GopherHole not connected');
+        }
+        const taskId = uuidv4();
+        const timeoutMs = this.config.requestTimeoutMs ?? 60000; // 60s default
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(taskId);
+                reject(new Error(`GopherHole request timeout after ${timeoutMs / 1000}s - target agent may be offline`));
+            }, timeoutMs);
+            this.pendingRequests.set(taskId, {
+                taskId,
+                resolve,
+                reject,
+                timeout,
+                startedAt: Date.now(),
+            });
+            // GopherHole WebSocket message format
+            const msg = {
+                type: 'message',
+                id: taskId,
+                to: targetAgentId,
+                payload: {
+                    parts: [{ kind: 'text', text }],
+                    ...(contextId ? { contextId } : {}),
+                },
+            };
+            console.log(`[a2a] Sending to ${targetAgentId} via GopherHole: taskId=${taskId}`);
+            gphConn.ws.send(JSON.stringify(msg));
+        });
+    }
+    /**
+     * Check if GopherHole is connected
+     */
+    isGopherHoleConnected() {
+        return this.connections.get('gopherhole')?.connected ?? false;
+    }
+    /**
+     * List connected agents
+     */
+    listAgents() {
+        return Array.from(this.connections.values()).map((c) => ({
+            id: c.id,
+            name: c.name,
+            connected: c.connected,
+        }));
+    }
+    /**
+     * Check if an agent is connected
+     */
+    isConnected(agentId) {
+        const conn = this.connections.get(agentId);
+        return conn?.connected ?? false;
+    }
+}

package/dist/src/gateway-client.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Gateway WebSocket Client
+ * Sends messages to the Clawdbot gateway via its WebSocket protocol
+ *
+ * chat.send is non-blocking - it returns a runId immediately and
+ * streams the response via chat events. We accumulate deltas and
+ * resolve when we get state: "final".
+ */
+export declare function connectToGateway(port?: number): Promise<void>;
+export declare function callGateway(method: string, params: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;
+/**
+ * Send a chat message and wait for the full response.
+ * chat.send is non-blocking - returns runId immediately, response streams via events.
+ */
+export declare function sendChatMessage(sessionKey: string, message: string, timeoutMs?: number): Promise<{
+    text: string;
+}>;
+export declare function disconnectFromGateway(): void;