@tjamescouch/agentchat 0.1.0

package/fly.toml

@@ -0,0 +1,21 @@
+# fly.toml app configuration file generated for agentchat-server on 2026-02-02T19:57:15-07:00
+#
+# See https://fly.io/docs/reference/configuration/ for information about how to use this file.
+#
+
+app = 'agentchat-server'
+primary_region = 'sjc'
+
+[build]
+
+[http_service]
+  internal_port = 6667
+  force_https = true
+  auto_stop_machines = 'off'
+  auto_start_machines = false
+  min_machines_running = 1
+  processes = ['app']
+
+[[vm]]
+  size = 'shared-cpu-1x'
+  memory = '256mb'

package/lib/client.js

@@ -0,0 +1,362 @@
+/**
+ * AgentChat Client
+ * Connect to agentchat servers from Node.js or CLI
+ */
+
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+import {
+  ClientMessageType,
+  ServerMessageType,
+  createMessage,
+  serialize,
+  parse
+} from './protocol.js';
+import { Identity } from './identity.js';
+
+export class AgentChatClient extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.server = options.server;
+    this.name = options.name || `agent-${Date.now()}`;
+    this.pubkey = options.pubkey || null;
+
+    // Identity support
+    this.identityPath = options.identity || null;
+    this._identity = null;
+
+    this.ws = null;
+    this.agentId = null;
+    this.connected = false;
+    this.channels = new Set();
+
+    this._pendingRequests = new Map();
+    this._requestId = 0;
+  }
+
+  /**
+   * Load identity from file
+   */
+  async _loadIdentity() {
+    if (this.identityPath) {
+      try {
+        this._identity = await Identity.load(this.identityPath);
+        this.name = this._identity.name;
+        this.pubkey = this._identity.pubkey;
+      } catch (err) {
+        throw new Error(`Failed to load identity from ${this.identityPath}: ${err.message}`);
+      }
+    }
+  }
+  
+  /**
+   * Connect to the server and identify
+   */
+  async connect() {
+    // Load identity if path provided
+    await this._loadIdentity();
+
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.server);
+      
+      this.ws.on('open', () => {
+        // Send identify
+        this._send({
+          type: ClientMessageType.IDENTIFY,
+          name: this.name,
+          pubkey: this.pubkey
+        });
+      });
+      
+      this.ws.on('message', (data) => {
+        this._handleMessage(data.toString());
+      });
+      
+      this.ws.on('close', () => {
+        this.connected = false;
+        this.emit('disconnect');
+      });
+      
+      this.ws.on('error', (err) => {
+        this.emit('error', err);
+        if (!this.connected) {
+          reject(err);
+        }
+      });
+      
+      // Wait for WELCOME
+      this.once('welcome', (info) => {
+        this.connected = true;
+        this.agentId = info.agent_id;
+        resolve(info);
+      });
+      
+      // Handle connection error
+      this.once('error', (err) => {
+        if (!this.connected) {
+          reject(err);
+        }
+      });
+    });
+  }
+  
+  /**
+   * Disconnect from server
+   */
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  
+  /**
+   * Join a channel
+   */
+  async join(channel) {
+    this._send({
+      type: ClientMessageType.JOIN,
+      channel
+    });
+    
+    return new Promise((resolve, reject) => {
+      const onJoined = (msg) => {
+        if (msg.channel === channel) {
+          this.removeListener('error', onError);
+          this.channels.add(channel);
+          resolve(msg);
+        }
+      };
+      
+      const onError = (msg) => {
+        this.removeListener('joined', onJoined);
+        reject(new Error(msg.message));
+      };
+      
+      this.once('joined', onJoined);
+      this.once('error', onError);
+    });
+  }
+  
+  /**
+   * Leave a channel
+   */
+  async leave(channel) {
+    this._send({
+      type: ClientMessageType.LEAVE,
+      channel
+    });
+    this.channels.delete(channel);
+  }
+  
+  /**
+   * Send a message to a channel or agent
+   */
+  async send(to, content) {
+    const msg = {
+      type: ClientMessageType.MSG,
+      to,
+      content
+    };
+
+    // Sign message if identity available
+    if (this._identity && this._identity.privkey) {
+      msg.ts = Date.now();
+      const dataToSign = JSON.stringify({
+        to: msg.to,
+        content: msg.content,
+        ts: msg.ts
+      });
+      msg.sig = this._identity.sign(dataToSign);
+    }
+
+    this._send(msg);
+  }
+  
+  /**
+   * Send a direct message (alias for send with @target)
+   */
+  async dm(agent, content) {
+    const target = agent.startsWith('@') ? agent : `@${agent}`;
+    return this.send(target, content);
+  }
+  
+  /**
+   * List available channels
+   */
+  async listChannels() {
+    this._send({
+      type: ClientMessageType.LIST_CHANNELS
+    });
+    
+    return new Promise((resolve) => {
+      this.once('channels', (msg) => {
+        resolve(msg.list);
+      });
+    });
+  }
+  
+  /**
+   * List agents in a channel
+   */
+  async listAgents(channel) {
+    this._send({
+      type: ClientMessageType.LIST_AGENTS,
+      channel
+    });
+    
+    return new Promise((resolve) => {
+      this.once('agents', (msg) => {
+        resolve(msg.list);
+      });
+    });
+  }
+  
+  /**
+   * Create a new channel
+   */
+  async createChannel(channel, inviteOnly = false) {
+    this._send({
+      type: ClientMessageType.CREATE_CHANNEL,
+      channel,
+      invite_only: inviteOnly
+    });
+    
+    return new Promise((resolve, reject) => {
+      const onJoined = (msg) => {
+        if (msg.channel === channel) {
+          this.removeListener('error', onError);
+          this.channels.add(channel);
+          resolve(msg);
+        }
+      };
+      
+      const onError = (msg) => {
+        this.removeListener('joined', onJoined);
+        reject(new Error(msg.message));
+      };
+      
+      this.once('joined', onJoined);
+      this.once('error', onError);
+    });
+  }
+  
+  /**
+   * Invite an agent to a channel
+   */
+  async invite(channel, agent) {
+    const target = agent.startsWith('@') ? agent : `@${agent}`;
+    this._send({
+      type: ClientMessageType.INVITE,
+      channel,
+      agent: target
+    });
+  }
+  
+  /**
+   * Send ping to server
+   */
+  ping() {
+    this._send({ type: ClientMessageType.PING });
+  }
+  
+  _send(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(serialize(msg));
+    }
+  }
+  
+  _handleMessage(data) {
+    let msg;
+    try {
+      msg = parse(data);
+    } catch (e) {
+      this.emit('error', { message: 'Invalid JSON from server' });
+      return;
+    }
+    
+    // Emit raw message
+    this.emit('raw', msg);
+    
+    // Handle by type
+    switch (msg.type) {
+      case ServerMessageType.WELCOME:
+        this.emit('welcome', msg);
+        break;
+        
+      case ServerMessageType.MSG:
+        this.emit('message', msg);
+        break;
+        
+      case ServerMessageType.JOINED:
+        this.emit('joined', msg);
+        break;
+        
+      case ServerMessageType.LEFT:
+        this.emit('left', msg);
+        break;
+        
+      case ServerMessageType.AGENT_JOINED:
+        this.emit('agent_joined', msg);
+        break;
+        
+      case ServerMessageType.AGENT_LEFT:
+        this.emit('agent_left', msg);
+        break;
+        
+      case ServerMessageType.CHANNELS:
+        this.emit('channels', msg);
+        break;
+        
+      case ServerMessageType.AGENTS:
+        this.emit('agents', msg);
+        break;
+        
+      case ServerMessageType.ERROR:
+        this.emit('error', msg);
+        break;
+        
+      case ServerMessageType.PONG:
+        this.emit('pong', msg);
+        break;
+    }
+  }
+}
+
+/**
+ * Quick send - connect, send message, disconnect
+ */
+export async function quickSend(server, name, to, content, identityPath = null) {
+  const client = new AgentChatClient({ server, name, identity: identityPath });
+  await client.connect();
+
+  // Join channel if needed
+  if (to.startsWith('#')) {
+    await client.join(to);
+  }
+
+  await client.send(to, content);
+
+  // Small delay to ensure message is sent
+  await new Promise(r => setTimeout(r, 100));
+
+  client.disconnect();
+}
+
+/**
+ * Listen mode - connect, join channels, stream messages
+ */
+export async function listen(server, name, channels, callback, identityPath = null) {
+  const client = new AgentChatClient({ server, name, identity: identityPath });
+  await client.connect();
+
+  for (const channel of channels) {
+    await client.join(channel);
+  }
+
+  client.on('message', callback);
+  client.on('agent_joined', callback);
+  client.on('agent_left', callback);
+
+  return client;
+}