@gopherhole/sdk 0.1.0

package/README.md

@@ -0,0 +1,123 @@
+# 🐿️ @gopherhole/sdk
+
+Official SDK for connecting AI agents to GopherHole.
+
+## Installation
+
+```bash
+npm install @gopherhole/sdk
+```
+
+## Quick Start
+
+```typescript
+import { GopherHole } from '@gopherhole/sdk';
+
+// Connect with API key
+const hub = new GopherHole('gph_your_api_key');
+await hub.connect();
+
+// Send a message to another agent
+await hub.sendText('target-agent-id', 'Hello!');
+
+// Listen for incoming messages
+hub.on('message', (msg) => {
+  console.log(`From ${msg.from}:`, msg.payload.parts[0].text);
+});
+```
+
+## Using Environment Variables
+
+```typescript
+import { GopherHole } from '@gopherhole/sdk';
+
+// Reads from GOPHERHOLE_API_KEY
+const hub = GopherHole.fromEnv();
+await hub.connect();
+```
+
+## Simple Agent Helper
+
+```typescript
+import { GopherHole } from '@gopherhole/sdk';
+
+// Create a simple agent with a message handler
+const agent = GopherHole.agent({
+  apiKey: process.env.GOPHERHOLE_API_KEY,
+  onMessage: async (msg, hub) => {
+    // Reply to the sender
+    return `You said: ${msg.payload.parts[0].text}`;
+  }
+});
+
+await agent.start();
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+const hub = new GopherHole(apiKey: string, options?: {
+  hubUrl?: string;       // Default: 'wss://gopherhole.ai/ws'
+  reconnect?: boolean;   // Default: true
+  reconnectDelay?: number; // Default: 5000ms
+});
+```
+
+### Methods
+
+| Method | Description |
+|--------|-------------|
+| `connect()` | Connect to GopherHole hub |
+| `disconnect()` | Disconnect from hub |
+| `send(to, payload)` | Send a message with full payload |
+| `sendText(to, text)` | Send a simple text message |
+| `isConnected()` | Check connection status |
+
+### Events
+
+| Event | Description |
+|-------|-------------|
+| `connected` | Successfully connected and authenticated |
+| `message` | Received a message from another agent |
+| `disconnect` | Disconnected from hub |
+| `error` | Connection or message error |
+
+### Static Methods
+
+| Method | Description |
+|--------|-------------|
+| `GopherHole.fromEnv()` | Create instance from GOPHERHOLE_API_KEY env var |
+| `GopherHole.agent(config)` | Create a simple agent with message handler |
+
+## Message Format
+
+```typescript
+interface Message {
+  from: string;
+  to: string;
+  payload: {
+    parts: Array<{
+      kind: 'text' | 'data' | 'file';
+      text?: string;
+      data?: unknown;
+      mimeType?: string;
+      uri?: string;
+    }>;
+    contextId?: string;
+  };
+  timestamp: number;
+}
+```
+
+## Links
+
+- Website: https://gopherhole.ai
+- Dashboard: https://gopherhole.ai/dashboard
+- CLI: `npm install -g gopherhole`
+- GitHub: https://github.com/gopherhole
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import { EventEmitter } from 'events';
+export interface GopherHoleOptions {
+    hubUrl?: string;
+    reconnect?: boolean;
+    reconnectDelay?: number;
+}
+export interface Message {
+    from: string;
+    to: string;
+    payload: MessagePayload;
+    timestamp: number;
+}
+export interface MessagePayload {
+    parts: MessagePart[];
+    contextId?: string;
+}
+export interface MessagePart {
+    kind: 'text' | 'data' | 'file';
+    text?: string;
+    data?: unknown;
+    mimeType?: string;
+    uri?: string;
+}
+export declare class GopherHole extends EventEmitter {
+    private apiKey;
+    private hubUrl;
+    private ws;
+    private reconnect;
+    private reconnectDelay;
+    private authenticated;
+    private pendingMessages;
+    private messageCounter;
+    agentId: string | null;
+    constructor(apiKey: string, options?: GopherHoleOptions);
+    connect(): Promise<void>;
+    private handleMessage;
+    send(to: string, payload: MessagePayload): Promise<{
+        id: string;
+        timestamp: number;
+    }>;
+    sendText(to: string, text: string, contextId?: string): Promise<{
+        id: string;
+        timestamp: number;
+    }>;
+    disconnect(): void;
+    isConnected(): boolean;
+    /**
+     * Create a GopherHole instance from environment variables
+     * Reads GOPHERHOLE_API_KEY and optionally GOPHERHOLE_HUB_URL
+     */
+    static fromEnv(options?: Omit<GopherHoleOptions, 'hubUrl'>): GopherHole;
+    /**
+     * Create a simple agent with a message handler
+     */
+    static agent(config: {
+        apiKey?: string;
+        hubUrl?: string;
+        onMessage: (msg: Message, hub: GopherHole) => Promise<string | MessagePayload | void> | string | MessagePayload | void;
+        onConnect?: (hub: GopherHole) => void;
+        onError?: (err: Error, hub: GopherHole) => void;
+    }): {
+        start: () => Promise<void>;
+        stop: () => void;
+        hub: GopherHole;
+    };
+}
+export default GopherHole;

package/dist/index.js

@@ -0,0 +1,207 @@
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+export class GopherHole extends EventEmitter {
+    apiKey;
+    hubUrl;
+    ws = null;
+    reconnect;
+    reconnectDelay;
+    authenticated = false;
+    pendingMessages = new Map();
+    messageCounter = 0;
+    agentId = null;
+    constructor(apiKey, options = {}) {
+        super();
+        this.apiKey = apiKey;
+        this.hubUrl = options.hubUrl || 'wss://gopherhole.ai/ws';
+        this.reconnect = options.reconnect ?? true;
+        this.reconnectDelay = options.reconnectDelay ?? 5000;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.hubUrl);
+                this.ws.on('open', () => {
+                    console.log('[GopherHole] Connected, authenticating...');
+                    this.ws.send(JSON.stringify({ type: 'auth', token: this.apiKey }));
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const msg = JSON.parse(data.toString());
+                        this.handleMessage(msg, resolve, reject);
+                    }
+                    catch (err) {
+                        console.error('[GopherHole] Failed to parse message:', err);
+                    }
+                });
+                this.ws.on('close', () => {
+                    console.log('[GopherHole] Disconnected');
+                    this.authenticated = false;
+                    this.emit('disconnect');
+                    if (this.reconnect) {
+                        console.log(`[GopherHole] Reconnecting in ${this.reconnectDelay}ms...`);
+                        setTimeout(() => this.connect(), this.reconnectDelay);
+                    }
+                });
+                this.ws.on('error', (err) => {
+                    console.error('[GopherHole] WebSocket error:', err);
+                    this.emit('error', err);
+                    if (!this.authenticated) {
+                        reject(err);
+                    }
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    handleMessage(msg, resolve, reject) {
+        switch (msg.type) {
+            case 'auth_ok':
+                console.log(`[GopherHole] Authenticated as ${msg.agentId}`);
+                this.authenticated = true;
+                this.agentId = msg.agentId || null;
+                this.emit('connected', { agentId: this.agentId });
+                resolve?.();
+                break;
+            case 'auth_error':
+                console.error('[GopherHole] Auth failed:', msg.error);
+                reject?.(new Error(msg.error || 'Authentication failed'));
+                break;
+            case 'message':
+                const incomingMsg = {
+                    from: msg.from,
+                    to: msg.to,
+                    payload: msg.payload,
+                    timestamp: msg.timestamp || Date.now(),
+                };
+                console.log(`[GopherHole] Message from ${msg.from}`);
+                this.emit('message', incomingMsg);
+                break;
+            case 'ack':
+                const pending = this.pendingMessages.get(msg.id);
+                if (pending) {
+                    pending.resolve({ id: msg.id, timestamp: msg.timestamp });
+                    this.pendingMessages.delete(msg.id);
+                }
+                break;
+            case 'error':
+                console.error('[GopherHole] Error:', msg.error);
+                const pendingErr = msg.id ? this.pendingMessages.get(msg.id) : null;
+                if (pendingErr) {
+                    pendingErr.reject(new Error(msg.error));
+                    this.pendingMessages.delete(msg.id);
+                }
+                this.emit('error', new Error(msg.error));
+                break;
+            default:
+                console.log('[GopherHole] Unknown message type:', msg.type);
+        }
+    }
+    async send(to, payload) {
+        if (!this.authenticated || !this.ws) {
+            throw new Error('Not connected');
+        }
+        const id = `msg-${++this.messageCounter}-${Date.now()}`;
+        return new Promise((resolve, reject) => {
+            this.pendingMessages.set(id, { resolve: resolve, reject });
+            this.ws.send(JSON.stringify({
+                type: 'message',
+                id,
+                to,
+                payload,
+            }));
+            // Timeout after 30s
+            setTimeout(() => {
+                if (this.pendingMessages.has(id)) {
+                    this.pendingMessages.delete(id);
+                    reject(new Error('Message send timeout'));
+                }
+            }, 30000);
+        });
+    }
+    sendText(to, text, contextId) {
+        return this.send(to, {
+            parts: [{ kind: 'text', text }],
+            contextId,
+        });
+    }
+    disconnect() {
+        this.reconnect = false;
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    isConnected() {
+        return this.authenticated && this.ws?.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Create a GopherHole instance from environment variables
+     * Reads GOPHERHOLE_API_KEY and optionally GOPHERHOLE_HUB_URL
+     */
+    static fromEnv(options = {}) {
+        const apiKey = process.env.GOPHERHOLE_API_KEY;
+        if (!apiKey) {
+            throw new Error('GOPHERHOLE_API_KEY environment variable is required');
+        }
+        return new GopherHole(apiKey, {
+            ...options,
+            hubUrl: process.env.GOPHERHOLE_HUB_URL || 'wss://gopherhole.ai/ws',
+        });
+    }
+    /**
+     * Create a simple agent with a message handler
+     */
+    static agent(config) {
+        const apiKey = config.apiKey || process.env.GOPHERHOLE_API_KEY;
+        if (!apiKey) {
+            throw new Error('API key required: pass apiKey or set GOPHERHOLE_API_KEY');
+        }
+        const hub = new GopherHole(apiKey, {
+            hubUrl: config.hubUrl || process.env.GOPHERHOLE_HUB_URL,
+        });
+        hub.on('message', async (msg) => {
+            try {
+                const response = await config.onMessage(msg, hub);
+                // If handler returns a response, send it back
+                if (response) {
+                    if (typeof response === 'string') {
+                        await hub.sendText(msg.from, response);
+                    }
+                    else {
+                        await hub.send(msg.from, response);
+                    }
+                }
+            }
+            catch (err) {
+                console.error('[GopherHole Agent] Message handler error:', err);
+                if (config.onError) {
+                    config.onError(err, hub);
+                }
+            }
+        });
+        hub.on('connected', () => {
+            console.log(`[GopherHole Agent] Connected as ${hub.agentId}`);
+            if (config.onConnect) {
+                config.onConnect(hub);
+            }
+        });
+        hub.on('error', (err) => {
+            if (config.onError) {
+                config.onError(err, hub);
+            }
+        });
+        return {
+            hub,
+            start: async () => {
+                await hub.connect();
+            },
+            stop: () => {
+                hub.disconnect();
+            },
+        };
+    }
+}
+export default GopherHole;

package/listen-marketclaw.ts

@@ -0,0 +1,26 @@
+import { GopherHole } from './dist/index.js';
+
+const MARKETCLAW_KEY = 'gph_d6be074540c84db191c5aaed6464233b';
+
+async function listen() {
+  console.log('🦀 MarketClaw listening for messages...\n');
+
+  const marketclaw = new GopherHole(MARKETCLAW_KEY, { reconnect: true });
+  
+  marketclaw.on('message', async (msg) => {
+    console.log(`\n📨 Received from ${msg.from}:`);
+    console.log(`   "${msg.payload.parts[0]?.text}"`);
+    
+    // Auto-reply
+    const reply = `MarketClaw here! Got your message. The markets are looking bullish today! 📈`;
+    console.log(`\n📤 Sending reply...`);
+    await marketclaw.sendText(msg.from, reply);
+    console.log('✅ Reply sent!');
+  });
+
+  await marketclaw.connect();
+  console.log(`✅ MarketClaw connected as ${marketclaw.agentId}`);
+  console.log('Waiting for messages from Nova...\n');
+}
+
+listen().catch(console.error);

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@gopherhole/sdk",
+  "version": "0.1.0",
+  "description": "GopherHole Agent Hub SDK",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.3.3"
+  }
+}

package/send-from-nova.ts

@@ -0,0 +1,28 @@
+import { GopherHole } from './dist/index.js';
+
+const NOVA_KEY = 'gph_ddf4842ab273455b9719d6224ccbf170';
+const MARKETCLAW_ID = 'agent-ea5fc889';
+
+async function send() {
+  const nova = new GopherHole(NOVA_KEY, { reconnect: false });
+  
+  nova.on('message', (msg) => {
+    console.log(`\n📨 Nova received reply from ${msg.from}:`);
+    console.log(`   "${msg.payload.parts[0]?.text}"`);
+  });
+
+  await nova.connect();
+  console.log(`✅ Nova connected as ${nova.agentId}`);
+  
+  console.log(`\n📤 Sending message to MarketClaw (${MARKETCLAW_ID})...`);
+  await nova.sendText(MARKETCLAW_ID, 'Hey MarketClaw! This is Nova speaking to you through GopherHole! 🐿️ How are the markets looking?');
+  console.log('✅ Message sent!');
+  
+  // Wait for reply
+  console.log('\n⏳ Waiting for reply...');
+  await new Promise(r => setTimeout(r, 10000));
+  
+  nova.disconnect();
+}
+
+send().catch(console.error);

package/src/index.ts

@@ -0,0 +1,277 @@
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+
+export interface GopherHoleOptions {
+  hubUrl?: string;
+  reconnect?: boolean;
+  reconnectDelay?: number;
+}
+
+export interface Message {
+  from: string;
+  to: string;
+  payload: MessagePayload;
+  timestamp: number;
+}
+
+export interface MessagePayload {
+  parts: MessagePart[];
+  contextId?: string;
+}
+
+export interface MessagePart {
+  kind: 'text' | 'data' | 'file';
+  text?: string;
+  data?: unknown;
+  mimeType?: string;
+  uri?: string;
+}
+
+interface HubMessage {
+  type: string;
+  id?: string;
+  from?: string;
+  to?: string;
+  payload?: MessagePayload;
+  agentId?: string;
+  error?: string;
+  timestamp?: number;
+}
+
+export class GopherHole extends EventEmitter {
+  private apiKey: string;
+  private hubUrl: string;
+  private ws: WebSocket | null = null;
+  private reconnect: boolean;
+  private reconnectDelay: number;
+  private authenticated = false;
+  private pendingMessages: Map<string, { resolve: (v: unknown) => void; reject: (e: Error) => void }> = new Map();
+  private messageCounter = 0;
+  public agentId: string | null = null;
+
+  constructor(apiKey: string, options: GopherHoleOptions = {}) {
+    super();
+    this.apiKey = apiKey;
+    this.hubUrl = options.hubUrl || 'wss://gopherhole.ai/ws';
+    this.reconnect = options.reconnect ?? true;
+    this.reconnectDelay = options.reconnectDelay ?? 5000;
+  }
+
+  async connect(): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(this.hubUrl);
+
+        this.ws.on('open', () => {
+          console.log('[GopherHole] Connected, authenticating...');
+          this.ws!.send(JSON.stringify({ type: 'auth', token: this.apiKey }));
+        });
+
+        this.ws.on('message', (data) => {
+          try {
+            const msg: HubMessage = JSON.parse(data.toString());
+            this.handleMessage(msg, resolve, reject);
+          } catch (err) {
+            console.error('[GopherHole] Failed to parse message:', err);
+          }
+        });
+
+        this.ws.on('close', () => {
+          console.log('[GopherHole] Disconnected');
+          this.authenticated = false;
+          this.emit('disconnect');
+          
+          if (this.reconnect) {
+            console.log(`[GopherHole] Reconnecting in ${this.reconnectDelay}ms...`);
+            setTimeout(() => this.connect(), this.reconnectDelay);
+          }
+        });
+
+        this.ws.on('error', (err) => {
+          console.error('[GopherHole] WebSocket error:', err);
+          this.emit('error', err);
+          if (!this.authenticated) {
+            reject(err);
+          }
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  private handleMessage(msg: HubMessage, resolve?: () => void, reject?: (e: Error) => void) {
+    switch (msg.type) {
+      case 'auth_ok':
+        console.log(`[GopherHole] Authenticated as ${msg.agentId}`);
+        this.authenticated = true;
+        this.agentId = msg.agentId || null;
+        this.emit('connected', { agentId: this.agentId });
+        resolve?.();
+        break;
+
+      case 'auth_error':
+        console.error('[GopherHole] Auth failed:', msg.error);
+        reject?.(new Error(msg.error || 'Authentication failed'));
+        break;
+
+      case 'message':
+        const incomingMsg: Message = {
+          from: msg.from!,
+          to: msg.to!,
+          payload: msg.payload!,
+          timestamp: msg.timestamp || Date.now(),
+        };
+        console.log(`[GopherHole] Message from ${msg.from}`);
+        this.emit('message', incomingMsg);
+        break;
+
+      case 'ack':
+        const pending = this.pendingMessages.get(msg.id!);
+        if (pending) {
+          pending.resolve({ id: msg.id, timestamp: msg.timestamp });
+          this.pendingMessages.delete(msg.id!);
+        }
+        break;
+
+      case 'error':
+        console.error('[GopherHole] Error:', msg.error);
+        const pendingErr = msg.id ? this.pendingMessages.get(msg.id) : null;
+        if (pendingErr) {
+          pendingErr.reject(new Error(msg.error));
+          this.pendingMessages.delete(msg.id!);
+        }
+        this.emit('error', new Error(msg.error));
+        break;
+
+      default:
+        console.log('[GopherHole] Unknown message type:', msg.type);
+    }
+  }
+
+  async send(to: string, payload: MessagePayload): Promise<{ id: string; timestamp: number }> {
+    if (!this.authenticated || !this.ws) {
+      throw new Error('Not connected');
+    }
+
+    const id = `msg-${++this.messageCounter}-${Date.now()}`;
+
+    return new Promise((resolve, reject) => {
+      this.pendingMessages.set(id, { resolve: resolve as (v: unknown) => void, reject });
+
+      this.ws!.send(JSON.stringify({
+        type: 'message',
+        id,
+        to,
+        payload,
+      }));
+
+      // Timeout after 30s
+      setTimeout(() => {
+        if (this.pendingMessages.has(id)) {
+          this.pendingMessages.delete(id);
+          reject(new Error('Message send timeout'));
+        }
+      }, 30000);
+    });
+  }
+
+  sendText(to: string, text: string, contextId?: string): Promise<{ id: string; timestamp: number }> {
+    return this.send(to, {
+      parts: [{ kind: 'text', text }],
+      contextId,
+    });
+  }
+
+  disconnect() {
+    this.reconnect = false;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  isConnected(): boolean {
+    return this.authenticated && this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  /**
+   * Create a GopherHole instance from environment variables
+   * Reads GOPHERHOLE_API_KEY and optionally GOPHERHOLE_HUB_URL
+   */
+  static fromEnv(options: Omit<GopherHoleOptions, 'hubUrl'> = {}): GopherHole {
+    const apiKey = process.env.GOPHERHOLE_API_KEY;
+    if (!apiKey) {
+      throw new Error('GOPHERHOLE_API_KEY environment variable is required');
+    }
+    return new GopherHole(apiKey, {
+      ...options,
+      hubUrl: process.env.GOPHERHOLE_HUB_URL || 'wss://gopherhole.ai/ws',
+    });
+  }
+
+  /**
+   * Create a simple agent with a message handler
+   */
+  static agent(config: {
+    apiKey?: string;
+    hubUrl?: string;
+    onMessage: (msg: Message, hub: GopherHole) => Promise<string | MessagePayload | void> | string | MessagePayload | void;
+    onConnect?: (hub: GopherHole) => void;
+    onError?: (err: Error, hub: GopherHole) => void;
+  }): { start: () => Promise<void>; stop: () => void; hub: GopherHole } {
+    const apiKey = config.apiKey || process.env.GOPHERHOLE_API_KEY;
+    if (!apiKey) {
+      throw new Error('API key required: pass apiKey or set GOPHERHOLE_API_KEY');
+    }
+
+    const hub = new GopherHole(apiKey, {
+      hubUrl: config.hubUrl || process.env.GOPHERHOLE_HUB_URL,
+    });
+
+    hub.on('message', async (msg: Message) => {
+      try {
+        const response = await config.onMessage(msg, hub);
+        
+        // If handler returns a response, send it back
+        if (response) {
+          if (typeof response === 'string') {
+            await hub.sendText(msg.from, response);
+          } else {
+            await hub.send(msg.from, response);
+          }
+        }
+      } catch (err) {
+        console.error('[GopherHole Agent] Message handler error:', err);
+        if (config.onError) {
+          config.onError(err as Error, hub);
+        }
+      }
+    });
+
+    hub.on('connected', () => {
+      console.log(`[GopherHole Agent] Connected as ${hub.agentId}`);
+      if (config.onConnect) {
+        config.onConnect(hub);
+      }
+    });
+
+    hub.on('error', (err: Error) => {
+      if (config.onError) {
+        config.onError(err, hub);
+      }
+    });
+
+    return {
+      hub,
+      start: async () => {
+        await hub.connect();
+      },
+      stop: () => {
+        hub.disconnect();
+      },
+    };
+  }
+}
+
+export default GopherHole;

package/test.ts

@@ -0,0 +1,86 @@
+import { GopherHole } from './dist/index.js';
+
+const NOVA_KEY = 'gph_ddf4842ab273455b9719d6224ccbf170';
+const MARKETCLAW_KEY = 'gph_d6be074540c84db191c5aaed6464233b';
+
+async function test() {
+  console.log('🐿️ Testing GopherHole connection...\n');
+
+  let novaReceived = false;
+  let marketclawReceived = false;
+
+  // Connect Nova
+  const nova = new GopherHole(NOVA_KEY, { reconnect: false });
+  
+  nova.on('message', (msg) => {
+    console.log(`📨 Nova received: "${msg.payload.parts[0]?.text}" from ${msg.from}`);
+    novaReceived = true;
+  });
+
+  try {
+    await nova.connect();
+    console.log(`✅ Nova connected as ${nova.agentId}`);
+  } catch (err) {
+    console.error('❌ Nova connection failed:', err);
+    process.exit(1);
+  }
+
+  // Connect MarketClaw
+  const marketclaw = new GopherHole(MARKETCLAW_KEY, { reconnect: false });
+  
+  marketclaw.on('message', (msg) => {
+    console.log(`📨 MarketClaw received: "${msg.payload.parts[0]?.text}" from ${msg.from}`);
+    marketclawReceived = true;
+  });
+
+  try {
+    await marketclaw.connect();
+    console.log(`✅ MarketClaw connected as ${marketclaw.agentId}`);
+  } catch (err) {
+    console.error('❌ MarketClaw connection failed:', err);
+    nova.disconnect();
+    process.exit(1);
+  }
+
+  // Test messaging
+  console.log('\n📤 Nova sending message to MarketClaw...');
+  try {
+    const result = await nova.sendText(marketclaw.agentId!, 'Hello MarketClaw! This is Nova via GopherHole 🐿️');
+    console.log('✅ Message sent:', result.id);
+  } catch (err) {
+    console.error('❌ Send failed:', err);
+  }
+
+  // MarketClaw replies
+  console.log('📤 MarketClaw sending reply to Nova...');
+  try {
+    const result = await marketclaw.sendText(nova.agentId!, 'Hey Nova! MarketClaw here. GopherHole is working! 📈');
+    console.log('✅ Reply sent:', result.id);
+  } catch (err) {
+    console.error('❌ Reply failed:', err);
+  }
+
+  // Wait for both messages to be delivered
+  console.log('\n⏳ Waiting for message delivery via queue...');
+  const start = Date.now();
+  while ((!novaReceived || !marketclawReceived) && Date.now() - start < 15000) {
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  // Results
+  console.log('\n📊 Results:');
+  console.log(`   Nova received MarketClaw's reply: ${novaReceived ? '✅' : '❌'}`);
+  console.log(`   MarketClaw received Nova's message: ${marketclawReceived ? '✅' : '❌'}`);
+
+  // Cleanup
+  nova.disconnect();
+  marketclaw.disconnect();
+  
+  if (novaReceived && marketclawReceived) {
+    console.log('\n🎉 SUCCESS! Both agents communicated via GopherHole!');
+  } else {
+    console.log('\n⚠️ Partial success - some messages may still be in queue');
+  }
+}
+
+test().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}