@grknbyk/agent-wire 0.6.0 → 0.6.1

package/README.md

@@ -316,7 +316,7 @@ a 0.4 agent cannot verify each other. Upgrade both ends together.
 ## Development
 
 ```bash
-npm test       # 53 tests, no network
+npm test       # 60 tests, no network
 npm run bench  # medians over a synthetic 20k-message log
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@grknbyk/agent-wire",
-    "version": "0.6.0",
+    "version": "0.6.1",
     "description": "Let AI coding agents message each other through a shared Slack channel, over MCP.",
     "type": "module",
     "license": "MIT",

package/src/mcp.mjs

@@ -10,7 +10,7 @@ import { dirname, join } from 'node:path';
 import { activeChannels, channelMode, findChannel, loadConfig, paths, pollableChannels } from './config.mjs';
 import { DEFAULT_COUNT, appendMessages, archive, findByTs, markRead, readCursor, selectMessages, writeCursor } from './inbox.mjs';
 import { FINGERPRINT_CHARS, listPeers, signMessage } from './identity.mjs';
-import { listMembers, pollChannel, postMessage, slackClient, uploadFile } from './slack.mjs';
+import { CHANNEL_CONCURRENCY, listMembers, mapLimit, pollChannel, postMessage, slackClient, uploadFile } from './slack.mjs';
 import { MAX_HOPS, TEXT_MAX, formatMessage, mintNonce, renderEnvelope } from './protocol.mjs';
 
 const POLL_EVERY_MS = 5000;
@@ -134,18 +134,26 @@ function claimsPoll() {
     return true;
 }
 
+// The channels are fetched together and written afterwards, in order. Awaiting
+// one channel before starting the next spent a round trip per channel on data
+// that has nothing to do with the previous answer. Writing afterwards also means
+// no two channels interleave a read-modify-write of the same log.
+//
+// A channel that throws is caught here rather than at the caller, so one broken
+// channel costs its own messages instead of everybody else's.
 export async function pollOnce(config) {
     const client = slackClient(config.bot_token);
+    const channels = pollableChannels(config);
+    const polled = await mapLimit(channels, CHANNEL_CONCURRENCY, (channel) =>
+        pollChannel(client, channel, { since: readCursor(channel.id), myNickname: config.nickname })
+            .catch((error) => ({ ok: false, reason: error.message, items: [] })));
+
     let added = 0;
-    for (const channel of pollableChannels(config)) {
-        const result = await pollChannel(client, channel, {
-            since: readCursor(channel.id),
-            myNickname: config.nickname,
-        });
+    for (const [index, result] of polled.entries()) {
         if (!result.ok) continue;
 
         added += appendMessages(result.items);
-        if (result.newest) writeCursor(channel.id, result.newest);
+        if (result.newest) writeCursor(channels[index].id, result.newest);
     }
     return added;
 }

package/src/slack.mjs

@@ -24,6 +24,34 @@ const NAME_MAX_CHARS = 80;
 // message says why it was left there.
 const DOWNLOAD_MAX_BYTES = 20 * 1024 * 1024;
 
+// How many requests of one kind may be in flight. Slack rate-limits per method,
+// so these are per loop rather than one global number: history is Tier 3, the
+// user lookup is Tier 4, and a download is not an API call at all but does hold
+// a whole file in memory while it lands.
+export const CHANNEL_CONCURRENCY = 4;
+const USER_CONCURRENCY = 8;
+const DOWNLOAD_CONCURRENCY = 3;
+
+// Node has no bounded Promise.all, and both ends of the choice are wrong here:
+// awaiting in a loop costs one round trip per item, and an unbounded Promise.all
+// throws two hundred requests at a rate limiter. The workers pull from one shared
+// cursor rather than taking a slice each, so a slow reply cannot leave the others
+// queued behind it.
+export async function mapLimit(items, limit, run) {
+    const results = new Array(items.length);
+    let next = 0;
+
+    const worker = async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await run(items[index], index);
+        }
+    };
+
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}
+
 // conversations.* reject a JSON body and chat.postMessage needs one for metadata,
 // so the client speaks both and the caller picks per method. The token rides along
 // because downloading a file is a plain fetch, not an API call.
@@ -165,12 +193,8 @@ async function downloadAttachment(client, file) {
 }
 
 async function downloadAll(client, files) {
-    const saved = [];
-    for (const file of files ?? []) {
-        const result = await downloadAttachment(client, file);
-        if (result) saved.push(result);
-    }
-    return saved;
+    const saved = await mapLimit(files ?? [], DOWNLOAD_CONCURRENCY, (file) => downloadAttachment(client, file));
+    return saved.filter(Boolean);
 }
 
 async function downloadById(client, fileId) {
@@ -191,13 +215,15 @@ async function resolveUserNames(client, userIds) {
     const missing = [...new Set(userIds)].filter((userId) => !known[userId]);
     if (missing.length === 0) return userIds.map((userId) => known[userId]);
 
-    const found = { ...known };
-    for (const userId of missing) {
+    const resolved = await mapLimit(missing, USER_CONCURRENCY, async (userId) => {
         const result = await client.form('users.info', { user: userId });
-        found[userId] = result.ok
+        return result.ok
             ? (result.user.profile?.display_name || result.user.real_name || userId)
             : userId;
-    }
+    });
+
+    const found = { ...known };
+    missing.forEach((userId, index) => { found[userId] = resolved[index]; });
     writeJson(paths.users, found);
     return userIds.map((userId) => found[userId]);
 }