@tjamescouch/agentchat 0.18.1 → 0.18.2

package/lib/server/handlers/identity.js

@@ -0,0 +1,242 @@
+/**
+ * Identity Handlers
+ * Handles identify, verification request/response
+ */
+
+import crypto from 'crypto';
+import {
+  ServerMessageType,
+  ErrorCode,
+  createMessage,
+  createError,
+  generateAgentId,
+  generateVerifyId,
+  pubkeyToAgentId,
+} from '../../protocol.js';
+
+/**
+ * Handle IDENTIFY command
+ */
+export function handleIdentify(server, ws, msg) {
+  // Check if already identified
+  if (server.agents.has(ws)) {
+    server._send(ws, createError(ErrorCode.INVALID_MSG, 'Already identified'));
+    return;
+  }
+
+  let id;
+
+  // Use pubkey-derived stable ID if pubkey provided
+  if (msg.pubkey) {
+    // Check if this pubkey has connected before
+    const existingId = server.pubkeyToId.get(msg.pubkey);
+    if (existingId) {
+      // Returning agent - use their stable ID
+      id = existingId;
+    } else {
+      // New agent with pubkey - generate stable ID from pubkey
+      id = pubkeyToAgentId(msg.pubkey);
+      server.pubkeyToId.set(msg.pubkey, id);
+    }
+
+    // Check if this ID is currently in use by another connection
+    if (server.agentById.has(id)) {
+      // Kick the old connection instead of rejecting the new one
+      const oldWs = server.agentById.get(id);
+      server._log('identity-takeover', { id, reason: 'New connection with same identity' });
+      server._send(oldWs, createError(ErrorCode.INVALID_MSG, 'Disconnected: Another connection claimed this identity'));
+      server._handleDisconnect(oldWs);
+      oldWs.close(1000, 'Identity claimed by new connection');
+    }
+  } else {
+    // Ephemeral agent - generate random ID
+    id = generateAgentId();
+  }
+
+  const agent = {
+    id,
+    name: msg.name,
+    pubkey: msg.pubkey || null,
+    channels: new Set(),
+    connectedAt: Date.now(),
+    presence: 'online',
+    statusText: null
+  };
+
+  server.agents.set(ws, agent);
+  server.agentById.set(id, ws);
+
+  // Determine if this is a new or returning identity
+  const isReturning = msg.pubkey && server.pubkeyToId.has(msg.pubkey);
+  const isEphemeral = !msg.pubkey;
+
+  server._log('identify', {
+    id,
+    name: msg.name,
+    hasPubkey: !!msg.pubkey,
+    returning: isReturning,
+    ephemeral: isEphemeral,
+    ip: ws._realIp,
+    user_agent: ws._userAgent
+  });
+
+  server._send(ws, createMessage(ServerMessageType.WELCOME, {
+    agent_id: `@${id}`,
+    server: server.serverName
+  }));
+}
+
+/**
+ * Handle VERIFY_REQUEST command
+ */
+export function handleVerifyRequest(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  // Find target agent
+  const targetId = msg.target.slice(1);
+  const targetWs = server.agentById.get(targetId);
+
+  if (!targetWs) {
+    server._send(ws, createError(ErrorCode.AGENT_NOT_FOUND, `Agent ${msg.target} not found`));
+    return;
+  }
+
+  const targetAgent = server.agents.get(targetWs);
+
+  // Target must have a pubkey for verification
+  if (!targetAgent.pubkey) {
+    server._send(ws, createError(ErrorCode.NO_PUBKEY, `Agent ${msg.target} has no persistent identity`));
+    return;
+  }
+
+  // Create verification request
+  const requestId = generateVerifyId();
+  const expires = Date.now() + server.verificationTimeoutMs;
+
+  server.pendingVerifications.set(requestId, {
+    from: `@${agent.id}`,
+    fromWs: ws,
+    target: msg.target,
+    targetPubkey: targetAgent.pubkey,
+    nonce: msg.nonce,
+    expires
+  });
+
+  // Set timeout to clean up expired requests
+  setTimeout(() => {
+    const request = server.pendingVerifications.get(requestId);
+    if (request) {
+      server.pendingVerifications.delete(requestId);
+      // Notify requester of timeout
+      if (request.fromWs.readyState === 1) {
+        server._send(request.fromWs, createMessage(ServerMessageType.VERIFY_FAILED, {
+          request_id: requestId,
+          target: request.target,
+          reason: 'Verification timed out'
+        }));
+      }
+    }
+  }, server.verificationTimeoutMs);
+
+  server._log('verify_request', { id: requestId, from: agent.id, target: targetId });
+
+  // Forward to target agent
+  server._send(targetWs, createMessage(ServerMessageType.VERIFY_REQUEST, {
+    request_id: requestId,
+    from: `@${agent.id}`,
+    nonce: msg.nonce
+  }));
+
+  // Acknowledge to requester
+  server._send(ws, createMessage(ServerMessageType.VERIFY_REQUEST, {
+    request_id: requestId,
+    target: msg.target,
+    status: 'pending'
+  }));
+}
+
+/**
+ * Handle VERIFY_RESPONSE command
+ */
+export function handleVerifyResponse(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  // Must have identity to respond to verification
+  if (!agent.pubkey) {
+    server._send(ws, createError(ErrorCode.SIGNATURE_REQUIRED, 'Responding to verification requires persistent identity'));
+    return;
+  }
+
+  // Find the pending verification
+  const request = server.pendingVerifications.get(msg.request_id);
+  if (!request) {
+    server._send(ws, createError(ErrorCode.VERIFICATION_EXPIRED, 'Verification request not found or expired'));
+    return;
+  }
+
+  // Verify the responder is the target
+  if (request.target !== `@${agent.id}`) {
+    server._send(ws, createError(ErrorCode.INVALID_MSG, 'You are not the target of this verification'));
+    return;
+  }
+
+  // Verify the nonce matches
+  if (msg.nonce !== request.nonce) {
+    server._send(ws, createError(ErrorCode.INVALID_MSG, 'Nonce mismatch'));
+    return;
+  }
+
+  // Verify the signature
+  let verified = false;
+  try {
+    const keyObj = crypto.createPublicKey(request.targetPubkey);
+    verified = crypto.verify(
+      null,
+      Buffer.from(msg.nonce),
+      keyObj,
+      Buffer.from(msg.sig, 'base64')
+    );
+  } catch (err) {
+    server._log('verify_error', { request_id: msg.request_id, error: err.message });
+  }
+
+  // Clean up the pending request
+  server.pendingVerifications.delete(msg.request_id);
+
+  server._log('verify_response', {
+    request_id: msg.request_id,
+    from: agent.id,
+    verified
+  });
+
+  // Notify the original requester
+  if (request.fromWs.readyState === 1) {
+    if (verified) {
+      server._send(request.fromWs, createMessage(ServerMessageType.VERIFY_SUCCESS, {
+        request_id: msg.request_id,
+        agent: request.target,
+        pubkey: request.targetPubkey
+      }));
+    } else {
+      server._send(request.fromWs, createMessage(ServerMessageType.VERIFY_FAILED, {
+        request_id: msg.request_id,
+        target: request.target,
+        reason: 'Signature verification failed'
+      }));
+    }
+  }
+
+  // Notify the responder
+  server._send(ws, createMessage(verified ? ServerMessageType.VERIFY_SUCCESS : ServerMessageType.VERIFY_FAILED, {
+    request_id: msg.request_id,
+    verified
+  }));
+}

package/lib/server/handlers/index.js

@@ -0,0 +1,42 @@
+/**
+ * Server Handlers Index
+ * Exports all handler functions
+ */
+
+// Message handlers
+export {
+  handleMsg,
+  handleJoin,
+  handleLeave,
+  handleListChannels,
+  handleListAgents,
+  handleCreateChannel,
+  handleInvite,
+} from './message.js';
+
+// Proposal handlers
+export {
+  handleProposal,
+  handleAccept,
+  handleReject,
+  handleComplete,
+  handleDispute,
+} from './proposal.js';
+
+// Identity handlers
+export {
+  handleIdentify,
+  handleVerifyRequest,
+  handleVerifyResponse,
+} from './identity.js';
+
+// Skills handlers
+export {
+  handleRegisterSkills,
+  handleSearchSkills,
+} from './skills.js';
+
+// Presence handlers
+export {
+  handleSetPresence,
+} from './presence.js';

package/lib/server/handlers/message.js

@@ -0,0 +1,306 @@
+/**
+ * Message Handlers
+ * Handles message routing, join, leave, and channel operations
+ */
+
+import {
+  ServerMessageType,
+  ErrorCode,
+  createMessage,
+  createError,
+  isChannel,
+  isAgent,
+} from '../../protocol.js';
+
+/**
+ * Handle MSG command - route messages to channels or agents
+ */
+export function handleMsg(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  // Rate limiting: 1 message per second per agent
+  const now = Date.now();
+  const lastTime = server.lastMessageTime.get(ws) || 0;
+  if (now - lastTime < server.rateLimitMs) {
+    server._send(ws, createError(ErrorCode.RATE_LIMITED, 'Rate limit exceeded (max 1 message per second)'));
+    return;
+  }
+  server.lastMessageTime.set(ws, now);
+
+  const outMsg = createMessage(ServerMessageType.MSG, {
+    from: `@${agent.id}`,
+    to: msg.to,
+    content: msg.content,
+    ...(msg.sig && { sig: msg.sig })
+  });
+
+  if (isChannel(msg.to)) {
+    // Channel message
+    const channel = server.channels.get(msg.to);
+    if (!channel) {
+      server._send(ws, createError(ErrorCode.CHANNEL_NOT_FOUND, `Channel ${msg.to} not found`));
+      return;
+    }
+
+    if (!agent.channels.has(msg.to)) {
+      server._send(ws, createError(ErrorCode.NOT_INVITED, `Not a member of ${msg.to}`));
+      return;
+    }
+
+    // Broadcast to channel including sender
+    server._broadcast(msg.to, outMsg);
+
+    // Buffer the message for replay to future joiners
+    server._bufferMessage(msg.to, outMsg);
+
+    // Update channel activity timestamp (for idle detection)
+    server.channelLastActivity.set(msg.to, Date.now());
+
+  } else if (isAgent(msg.to)) {
+    // Direct message
+    const targetId = msg.to.slice(1);
+    const targetWs = server.agentById.get(targetId);
+
+    if (!targetWs) {
+      server._send(ws, createError(ErrorCode.AGENT_NOT_FOUND, `Agent ${msg.to} not found`));
+      return;
+    }
+
+    // Send to target
+    server._send(targetWs, outMsg);
+    // Echo back to sender
+    server._send(ws, outMsg);
+  }
+}
+
+/**
+ * Handle JOIN command - add agent to channel
+ */
+export function handleJoin(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  const channel = server.channels.get(msg.channel);
+  if (!channel) {
+    server._send(ws, createError(ErrorCode.CHANNEL_NOT_FOUND, `Channel ${msg.channel} not found`));
+    return;
+  }
+
+  // Check invite-only
+  if (channel.inviteOnly && !channel.invited.has(agent.id)) {
+    server._send(ws, createError(ErrorCode.NOT_INVITED, `Channel ${msg.channel} is invite-only`));
+    return;
+  }
+
+  // Add to channel
+  channel.agents.add(ws);
+  agent.channels.add(msg.channel);
+
+  server._log('join', { agent: agent.id, channel: msg.channel });
+
+  // Notify others
+  server._broadcast(msg.channel, createMessage(ServerMessageType.AGENT_JOINED, {
+    channel: msg.channel,
+    agent: `@${agent.id}`
+  }), ws);
+
+  // Send confirmation with agent list
+  const agentList = [];
+  for (const memberWs of channel.agents) {
+    const member = server.agents.get(memberWs);
+    if (member) agentList.push(`@${member.id}`);
+  }
+
+  server._send(ws, createMessage(ServerMessageType.JOINED, {
+    channel: msg.channel,
+    agents: agentList
+  }));
+
+  // Replay recent messages to the joining agent
+  server._replayMessages(ws, msg.channel);
+
+  // Send welcome prompt to the new joiner
+  server._send(ws, createMessage(ServerMessageType.MSG, {
+    from: '@server',
+    to: msg.channel,
+    content: `Welcome to ${msg.channel}, @${agent.id}! Say hello to introduce yourself and start collaborating with other agents.`
+  }));
+
+  // Prompt existing agents to engage with the new joiner (if there are others)
+  const otherAgents = [];
+  for (const memberWs of channel.agents) {
+    if (memberWs !== ws) {
+      const member = server.agents.get(memberWs);
+      if (member) otherAgents.push({ ws: memberWs, id: member.id });
+    }
+  }
+
+  if (otherAgents.length > 0) {
+    const welcomePrompt = createMessage(ServerMessageType.MSG, {
+      from: '@server',
+      to: msg.channel,
+      content: `Hey ${otherAgents.map(a => `@${a.id}`).join(', ')} - new agent @${agent.id} just joined! Say hi and share what you're working on.`
+    });
+
+    for (const other of otherAgents) {
+      server._send(other.ws, welcomePrompt);
+    }
+  }
+
+  // Update channel activity
+  server.channelLastActivity.set(msg.channel, Date.now());
+}
+
+/**
+ * Handle LEAVE command - remove agent from channel
+ */
+export function handleLeave(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  const channel = server.channels.get(msg.channel);
+  if (!channel) return;
+
+  channel.agents.delete(ws);
+  agent.channels.delete(msg.channel);
+
+  server._log('leave', { agent: agent.id, channel: msg.channel });
+
+  // Notify others
+  server._broadcast(msg.channel, createMessage(ServerMessageType.AGENT_LEFT, {
+    channel: msg.channel,
+    agent: `@${agent.id}`
+  }));
+
+  server._send(ws, createMessage(ServerMessageType.LEFT, {
+    channel: msg.channel
+  }));
+}
+
+/**
+ * Handle LIST_CHANNELS command
+ */
+export function handleListChannels(server, ws) {
+  const list = [];
+  for (const [name, channel] of server.channels) {
+    if (!channel.inviteOnly) {
+      list.push({
+        name,
+        agents: channel.agents.size
+      });
+    }
+  }
+
+  server._send(ws, createMessage(ServerMessageType.CHANNELS, { list }));
+}
+
+/**
+ * Handle LIST_AGENTS command
+ */
+export function handleListAgents(server, ws, msg) {
+  const channel = server.channels.get(msg.channel);
+  if (!channel) {
+    server._send(ws, createError(ErrorCode.CHANNEL_NOT_FOUND, `Channel ${msg.channel} not found`));
+    return;
+  }
+
+  const list = [];
+  for (const memberWs of channel.agents) {
+    const member = server.agents.get(memberWs);
+    if (member) {
+      list.push({
+        id: `@${member.id}`,
+        name: member.name,
+        presence: member.presence || 'online',
+        status_text: member.statusText || null
+      });
+    }
+  }
+
+  server._send(ws, createMessage(ServerMessageType.AGENTS, {
+    channel: msg.channel,
+    list
+  }));
+}
+
+/**
+ * Handle CREATE_CHANNEL command
+ */
+export function handleCreateChannel(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  if (server.channels.has(msg.channel)) {
+    server._send(ws, createError(ErrorCode.CHANNEL_EXISTS, `Channel ${msg.channel} already exists`));
+    return;
+  }
+
+  const channel = server._createChannel(msg.channel, msg.invite_only || false);
+
+  // Creator is automatically invited and joined
+  if (channel.inviteOnly) {
+    channel.invited.add(agent.id);
+  }
+
+  server._log('create_channel', { agent: agent.id, channel: msg.channel, inviteOnly: channel.inviteOnly });
+
+  // Auto-join creator
+  channel.agents.add(ws);
+  agent.channels.add(msg.channel);
+
+  server._send(ws, createMessage(ServerMessageType.JOINED, {
+    channel: msg.channel,
+    agents: [`@${agent.id}`]
+  }));
+}
+
+/**
+ * Handle INVITE command
+ */
+export function handleInvite(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  const channel = server.channels.get(msg.channel);
+  if (!channel) {
+    server._send(ws, createError(ErrorCode.CHANNEL_NOT_FOUND, `Channel ${msg.channel} not found`));
+    return;
+  }
+
+  // Must be a member to invite
+  if (!agent.channels.has(msg.channel)) {
+    server._send(ws, createError(ErrorCode.NOT_INVITED, `Not a member of ${msg.channel}`));
+    return;
+  }
+
+  const targetId = msg.agent.slice(1);
+  channel.invited.add(targetId);
+
+  server._log('invite', { agent: agent.id, target: targetId, channel: msg.channel });
+
+  // Notify target if connected
+  const targetWs = server.agentById.get(targetId);
+  if (targetWs) {
+    server._send(targetWs, createMessage(ServerMessageType.MSG, {
+      from: `@${agent.id}`,
+      to: msg.agent,
+      content: `You have been invited to ${msg.channel}`
+    }));
+  }
+}

package/lib/server/handlers/presence.js

@@ -0,0 +1,44 @@
+/**
+ * Presence Handlers
+ * Handles presence status updates
+ */
+
+import {
+  ServerMessageType,
+  ErrorCode,
+  createMessage,
+  createError,
+} from '../../protocol.js';
+
+/**
+ * Handle SET_PRESENCE command
+ */
+export function handleSetPresence(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  const oldPresence = agent.presence;
+  agent.presence = msg.status;
+  agent.statusText = msg.status_text || null;
+
+  server._log('presence_changed', {
+    agent: agent.id,
+    from: oldPresence,
+    to: msg.status,
+    statusText: agent.statusText
+  });
+
+  // Broadcast presence change to all channels the agent is in
+  const presenceMsg = createMessage(ServerMessageType.PRESENCE_CHANGED, {
+    agent_id: `@${agent.id}`,
+    presence: agent.presence,
+    status_text: agent.statusText
+  });
+
+  for (const channelName of agent.channels) {
+    server._broadcast(channelName, presenceMsg);
+  }
+}