@tjamescouch/agentchat-mcp 0.8.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tjamescouch/agentchat-mcp",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "MCP server for AgentChat - real-time AI agent communication",
   "main": "index.js",
   "type": "module",
@@ -27,7 +27,7 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@tjamescouch/agentchat": "^0.21.1",
+    "@tjamescouch/agentchat": "^0.22.1",
     "zod": "^3.25.0"
   },
   "peerDependencies": {

package/state.js

@@ -12,8 +12,25 @@ export let keepaliveInterval = null;
 // Message tracking - timestamp of last message we returned to the caller
 export let lastSeenTimestamp = 0;
 
+// Message buffer - captures messages between listen() calls
+const MAX_BUFFER_SIZE = 200;
+let messageBuffer = [];
+
 // Default server
-export const DEFAULT_SERVER_URL = 'wss://agentchat-server.fly.dev';
+export const DEFAULT_SERVER_URL = (() => {
+  const explicit = process.env.AGENTCHAT_URL;
+  if (explicit) {
+    const parsed = new URL(explicit);
+    const isLocal = parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1' || parsed.hostname === '::1';
+    if (!isLocal && process.env.AGENTCHAT_PUBLIC !== 'true') {
+      console.error(`ERROR: AGENTCHAT_URL points to remote host "${parsed.hostname}" but AGENTCHAT_PUBLIC is not set.`);
+      console.error('Set AGENTCHAT_PUBLIC=true to allow connections to non-localhost servers.');
+      process.exit(1);
+    }
+    return explicit;
+  }
+  return process.env.AGENTCHAT_PUBLIC === 'true' ? 'wss://agentchat-server.fly.dev' : 'ws://localhost:6667';
+})();
 
 // Keepalive settings
 export const KEEPALIVE_INTERVAL_MS = 30000;
@@ -69,3 +86,29 @@ export function resetLastSeen() {
 export function getLastSeen() {
   return lastSeenTimestamp;
 }
+
+/**
+ * Push a message into the buffer (called by persistent handler on client)
+ */
+export function bufferMessage(msg) {
+  messageBuffer.push(msg);
+  if (messageBuffer.length > MAX_BUFFER_SIZE) {
+    messageBuffer = messageBuffer.slice(-MAX_BUFFER_SIZE);
+  }
+}
+
+/**
+ * Drain all buffered messages and clear the buffer
+ */
+export function drainMessageBuffer() {
+  const messages = messageBuffer;
+  messageBuffer = [];
+  return messages;
+}
+
+/**
+ * Clear the message buffer (e.g., on reconnect)
+ */
+export function clearMessageBuffer() {
+  messageBuffer = [];
+}

package/tools/connect.js

@@ -10,7 +10,7 @@ import path from 'path';
 import {
   client, keepaliveInterval,
   setClient, setServerUrl, setKeepaliveInterval,
-  resetLastSeen,
+  resetLastSeen, clearMessageBuffer, bufferMessage,
   DEFAULT_SERVER_URL, KEEPALIVE_INTERVAL_MS
 } from '../state.js';
 
@@ -55,7 +55,7 @@ export function registerConnectTool(server) {
     'agentchat_connect',
     'Connect to an AgentChat server for real-time agent communication',
     {
-      server_url: z.string().optional().describe('WebSocket URL (default: wss://agentchat-server.fly.dev)'),
+      server_url: z.string().optional().describe('WebSocket URL (default: ws://localhost:6667, or wss://agentchat-server.fly.dev if AGENTCHAT_PUBLIC=true)'),
       name: z.string().optional().describe('Agent name for persistent identity. Creates .agentchat/identities/<name>.json. Omit for ephemeral identity.'),
       identity_path: z.string().optional().describe('Custom path to identity file (overrides name)'),
     },
@@ -132,8 +132,23 @@ export function registerConnectTool(server) {
         setClient(newClient);
         setServerUrl(actualServerUrl);
 
-        // Reset last seen timestamp on new connection
+        // Reset last seen timestamp and message buffer on new connection
         resetLastSeen();
+        clearMessageBuffer();
+
+        // Persistent message handler - buffers ALL messages between listen() calls
+        // This is the fix for the listen() message drop bug: messages that arrive
+        // while the agent is busy with other tools are captured here instead of lost.
+        newClient.on('message', (msg) => {
+          // Skip own messages, server noise, and replays
+          if (msg.from === newClient.agentId || msg.from === '@server' || msg.replay) return;
+          bufferMessage({
+            from: msg.from,
+            to: msg.to,
+            content: msg.content,
+            ts: msg.ts,
+          });
+        });
 
         // Start keepalive ping to prevent connection timeout
         const interval = setInterval(() => {

package/tools/listen.js

@@ -7,7 +7,8 @@ import { z } from 'zod';
 import fs from 'fs';
 import { getDaemonPaths } from '@tjamescouch/agentchat/lib/daemon.js';
 import { addJitter } from '@tjamescouch/agentchat/lib/jitter.js';
-import { client, getLastSeen, updateLastSeen } from '../state.js';
+import { ClientMessageType } from '@tjamescouch/agentchat/lib/protocol.js';
+import { client, getLastSeen, updateLastSeen, drainMessageBuffer } from '../state.js';
 
 // Timeouts - agent cannot override these
 const ENFORCED_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour when alone
@@ -32,14 +33,33 @@ export function registerListenTool(server) {
           };
         }
 
-        // Join channels
+        const startTime = Date.now();
+
+        // Collect replay messages during channel joins
+        // The server sends buffered messages with { replay: true } on join,
+        // so we must capture them before they're emitted and lost
+        const replayMessages = [];
+        const replayHandler = (msg) => {
+          if (msg.replay && msg.from !== client.agentId && msg.from !== '@server') {
+            replayMessages.push({
+              from: msg.from,
+              to: msg.to,
+              content: msg.content,
+              ts: msg.ts,
+            });
+          }
+        };
+        client.on('message', replayHandler);
+
+        // Join channels (replay messages arrive here)
         for (const channel of channels) {
           if (!client.channels.has(channel)) {
             await client.join(channel);
           }
         }
 
-        const startTime = Date.now();
+        // Done collecting replays
+        client.removeListener('message', replayHandler);
 
         // Check channel occupancy to determine timeout behavior
         let othersPresent = false;
@@ -61,9 +81,22 @@ export function registerListenTool(server) {
         }
         const lastSeen = getLastSeen();
 
-        // Check daemon inbox for missed messages first
+        // Set presence to 'listening' so other agents see we're active
+        const setPresence = (status) => {
+          client.sendRaw({ type: ClientMessageType.SET_PRESENCE, status });
+        };
+        setPresence('listening');
+
+        // Drain the persistent message buffer (messages captured between listen calls)
+        const buffered = drainMessageBuffer().filter(m => {
+          // Filter to relevant channels/DMs, skip already-seen messages
+          const isRelevant = channels.includes(m.to) || m.to === client.agentId;
+          return isRelevant && (!m.ts || m.ts > lastSeen);
+        });
+
+        // Start with buffered messages + replay messages captured during join
         const paths = getDaemonPaths('default');
-        let missedMessages = [];
+        let missedMessages = [...buffered, ...replayMessages];
 
         if (fs.existsSync(paths.inbox)) {
           try {
@@ -106,19 +139,33 @@ export function registerListenTool(server) {
           }
         }
 
-        // If we have missed messages, return them immediately
+        // If we have missed messages (from replay or inbox), return them immediately
         if (missedMessages.length > 0) {
+          // Deduplicate by timestamp + from (replay and inbox may overlap)
+          const seen = new Set();
+          missedMessages = missedMessages.filter((m) => {
+            const key = `${m.ts}:${m.from}`;
+            if (seen.has(key)) return false;
+            seen.add(key);
+            return true;
+          });
+
+          // Sort by timestamp ascending (oldest first)
+          missedMessages.sort((a, b) => a.ts - b.ts);
+
           // Update last seen to the newest message timestamp
           const newestTs = missedMessages[missedMessages.length - 1].ts;
           updateLastSeen(newestTs);
 
+          setPresence('online');
           return {
             content: [
               {
                 type: 'text',
                 text: JSON.stringify({
                   messages: missedMessages,
-                  from_inbox: true,
+                  from_inbox: replayMessages.length === 0,
+                  from_replay: replayMessages.length > 0,
                   elapsed_ms: Date.now() - startTime,
                 }),
               },
@@ -165,6 +212,7 @@ export function registerListenTool(server) {
           const cleanup = () => {
             client.removeListener('message', messageHandler);
             if (timeoutId) clearTimeout(timeoutId);
+            setPresence('online');
           };
 
           client.on('message', messageHandler);