@grknbyk/agent-wire 0.14.0 → 0.15.0

package/bin/agent-wire.mjs

@@ -54,7 +54,7 @@ async function drain() {
     const { pollOnce } = await import('../src/mcp.mjs');
     const { refreshLatest, updateNotice } = await import('../src/version.mjs');
     await Promise.all([
-        pollOnce(config).catch(() => {
+        pollOnce(config, { budgetMs: DRAIN_POLL_BUDGET_MS }).catch(() => {
             // Offline is not an error here; the next drain catches up.
         }),
         refreshLatest(),
@@ -141,6 +141,10 @@ const showStatus = async () => (await import('../src/status.mjs')).runStatus();
 // `drain` runs on every prompt and never needs it.
 const PACKAGE_NAME = '@grknbyk/agent-wire';
 
+// A prompt hook that runs long enough to be killed costs the person their whole
+// prompt, so this is the one place where a partial answer is the right answer.
+const DRAIN_POLL_BUDGET_MS = 6000;
+
 const packageJson = async () => {
     const { readFileSync } = await import('node:fs');
     const { fileURLToPath } = await import('node:url');

package/package.json

@@ -1,41 +1,41 @@
-{
-    "name": "@grknbyk/agent-wire",
-    "version": "0.14.0",
-    "description": "Let AI coding agents message each other through a shared Slack channel, over MCP.",
-    "type": "module",
-    "license": "MIT",
-    "author": "Gürkan Bıyık <gurkan.biyik@outlook.com>",
-    "homepage": "https://github.com/grknbyk/agent-wire",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/grknbyk/agent-wire.git"
-    },
-    "bugs": {
-        "url": "https://github.com/grknbyk/agent-wire/issues"
-    },
-    "bin": {
-        "agent-wire": "bin/agent-wire.mjs"
-    },
-    "engines": {
-        "node": ">=20"
-    },
-    "scripts": {
-        "test": "node --test \"test/*.test.mjs\"",
-        "bench": "node bench/bench.mjs"
-    },
-    "files": [
-        "bin",
-        "src",
-        "assets",
-        "manifest.json"
-    ],
-    "keywords": [
-        "mcp",
-        "model-context-protocol",
-        "slack",
-        "ai-agents",
-        "agent-communication",
-        "claude-code",
-        "cursor"
-    ]
-}
+{
+    "name": "@grknbyk/agent-wire",
+    "version": "0.15.0",
+    "description": "Let AI coding agents message each other through a shared Slack channel, over MCP.",
+    "type": "module",
+    "license": "MIT",
+    "author": "Gürkan Bıyık <gurkan.biyik@outlook.com>",
+    "homepage": "https://github.com/grknbyk/agent-wire",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/grknbyk/agent-wire.git"
+    },
+    "bugs": {
+        "url": "https://github.com/grknbyk/agent-wire/issues"
+    },
+    "bin": {
+        "agent-wire": "bin/agent-wire.mjs"
+    },
+    "engines": {
+        "node": ">=20"
+    },
+    "scripts": {
+        "test": "node --test \"test/*.test.mjs\"",
+        "bench": "node bench/bench.mjs"
+    },
+    "files": [
+        "bin",
+        "src",
+        "assets",
+        "manifest.json"
+    ],
+    "keywords": [
+        "mcp",
+        "model-context-protocol",
+        "slack",
+        "ai-agents",
+        "agent-communication",
+        "claude-code",
+        "cursor"
+    ]
+}

package/src/config.mjs

@@ -222,7 +222,13 @@ function prunedScopes(scopes) {
     return Object.fromEntries(keys.filter((key) => !doomed.has(key)).map((key) => [key, scopes[key]]));
 }
 
+// Naming no channel is an answer only while there is one channel to mean. Past
+// that it is a call that forgot the argument, and picking the first one sends
+// somebody's work to the wrong room without a word.
+export const isAmbiguous = (config, wanted) => !wanted && (config?.channels?.length ?? 0) > 1;
+
 export function findChannel(config, wanted) {
+    if (isAmbiguous(config, wanted)) return null;
     if (!wanted) return defaultChannel(config);
     const name = String(wanted).replace(/^#/, '').toLowerCase();
     return config.channels?.find((channel) => channel.name.toLowerCase() === name || channel.id === wanted) ?? null;

package/src/mcp.mjs

@@ -7,9 +7,9 @@ import { fileURLToPath } from 'node:url';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 
-import { MODES, activeChannels, channelMode, findChannel, loadConfig, paths, pollableChannels, readJson, scopeId } from './config.mjs';
+import { MODES, activeChannels, channelMode, findChannel, isAmbiguous, loadConfig, paths, pollableChannels, readJson, scopeId } from './config.mjs';
 import { DEFAULT_COUNT, appendMessages, archive, findByRef, findByTs, markRead, readCursor, selectMessages, writeCursor } from './inbox.mjs';
-import { FINGERPRINT_CHARS, listPeers, signMessage } from './identity.mjs';
+import { FINGERPRINT_CHARS, listPeers, signMessage } from './identity.mjs';
 import { refusalFor } from './manners.mjs';
 import { CHANNEL_CONCURRENCY, listMembers, mapLimit, pollChannel, postMessage, slackClient, uploadFile } from './slack.mjs';
 import { MAX_HOPS, TEXT_MAX, formatMessage, mintNonce, mintRef, renderEnvelope } from './protocol.mjs';
@@ -109,7 +109,7 @@ const TOOLS = [
         description: 'Everyone in one channel, agents and humans alike. Only channels the bot was invited to can be asked about; there is no way to list the workspace.',
         inputSchema: {
             type: 'object',
-            properties: { channel: { type: 'string', description: 'channel name; defaults to the first configured channel' } },
+            properties: { channel: { type: 'string', description: 'channel name. Omit it only while one channel is configured; past that, omitting it is refused rather than guessed' } },
         },
     },
     {
@@ -133,7 +133,7 @@ const TOOLS = [
             properties: {
                 to: { type: 'string', description: 'recipient nickname, or "all"' },
                 text: { type: 'string' },
-                channel: { type: 'string', description: 'channel name; defaults to the first configured channel' },
+                channel: { type: 'string', description: 'channel name. Omit it only while one channel is configured; past that, omitting it is refused rather than guessed' },
                 reply_to: { type: 'string', description: 'the ts of the message being answered, as shown by inbox' },
             },
             required: ['to', 'text'],
@@ -148,7 +148,7 @@ const TOOLS = [
                 to: { type: 'string', description: 'recipient nickname, or "all"' },
                 path: { type: 'string', description: 'path of the file to send' },
                 note: { type: 'string', description: 'one line saying what the file is' },
-                channel: { type: 'string', description: 'channel name; defaults to the first configured channel' },
+                channel: { type: 'string', description: 'channel name. Omit it only while one channel is configured; past that, omitting it is refused rather than guessed' },
                 reply_to: { type: 'string', description: 'the ts of the message being answered, as shown by inbox' },
             },
             required: ['to', 'path'],
@@ -161,6 +161,12 @@ const TOOLS = [
     },
 ];
 
+// Says which of the two happened, because "no such channel: undefined" reads as a
+// broken tool rather than as a missing argument.
+const noChannel = (config, wanted) => (isAmbiguous(config, wanted)
+    ? `name the channel: ${config.channels.map((channel) => channel.name).join(', ')}`
+    : `no such channel: ${wanted ?? '(none configured)'}`);
+
 const isBlank = (value) => value === undefined || value === null || (typeof value === 'string' && !value.trim());
 
 // One poller per machine, elected by a lock file. Several agent sessions share
@@ -185,12 +191,24 @@ const MODE_SUMMARY = {
     read: 'the messages themselves, in every prompt',
 };
 
+const CHANNEL_ARGUMENT = [{ name: 'channel', description: 'Channel name. Omit it when only one is configured.', required: false }];
+
+// on is what a person reaches for after off, and the shell has taken it since
+// before there were three modes. A word that works in one place and not the other
+// is the whole surprise, so it means ask here too.
+const PROMPT_ALIAS = { on: 'ask' };
+
 const PROMPTS = [
     ...MODES.map((mode) => ({
         name: mode,
         description: `Set a channel to ${mode} for this session — ${MODE_SUMMARY[mode]}`,
-        arguments: [{ name: 'channel', description: 'Channel name. Omit it when only one is configured.', required: false }],
+        arguments: CHANNEL_ARGUMENT,
     })),
+    {
+        name: 'on',
+        description: `Set a channel to ask for this session — ${MODE_SUMMARY.ask}`,
+        arguments: CHANNEL_ARGUMENT,
+    },
     { name: 'status', description: 'Show the agent-wire status card', arguments: [] },
 ];
 
@@ -229,11 +247,12 @@ function modeInstruction(mode, channel) {
 //
 // 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);
+export async function pollOnce(config, { budgetMs = null } = {}) {
     const channels = pollableChannels(config);
+    const deadline = budgetMs ? Date.now() + budgetMs : null;
+    const client = slackClient(config.bot_token, { deadline });
     const polled = await mapLimit(channels, CHANNEL_CONCURRENCY, (channel) =>
-        pollChannel(client, channel, { since: readCursor(channel.id), myNickname: config.nickname })
+        pollChannel(client, channel, { since: readCursor(channel.id), myNickname: config.nickname, deadline })
             .catch((error) => ({ ok: false, reason: error.message, items: [] })));
 
     let added = 0;
@@ -274,7 +293,7 @@ function recipientKind(config, to) {
 
 async function sendText(config, { to, text, channel, replyTo }) {
     const target = findChannel(config, channel);
-    if (!target) return `no such channel: ${channel ?? '(none configured)'}`;
+    if (!target) return noChannel(config, channel);
 
     const chain = chainOf(replyTo);
     if (chain.hop > MAX_HOPS) {
@@ -389,9 +408,9 @@ async function call(name, args, session) {
     if (missing.length) return `missing or empty: ${missing.join(', ')}`;
 
     const config = loadConfig();
-    // Said to an agent, which will pass it on. Naming the terminal matters: setup
-    // refuses a pipe, so an agent that tries to run it from a tool gets a bare
-    // refusal and tells the user the wrong thing.
+    // Said to an agent, which will pass it on. Naming the terminal matters: setup
+    // refuses a pipe, so an agent that tries to run it from a tool gets a bare
+    // refusal and tells the user the wrong thing.
     if (!config) return 'agent-wire is not configured yet. Tell the user to run `agent-wire setup` in a real terminal window — it asks questions, so it will not run from a tool. Install it first with `npm i -g @grknbyk/agent-wire` if the command is missing.';
 
     // The card reaches the user through a tool rather than a shell, because a
@@ -425,7 +444,7 @@ async function call(name, args, session) {
 
     if (name === 'members') {
         const target = findChannel(config, args.channel);
-        if (!target) return `no such channel: ${args.channel ?? '(none configured)'}`;
+        if (!target) return noChannel(config, args.channel);
 
         const result = await listMembers(slackClient(config.bot_token), target.id);
         if (!result.ok) return `Slack said: ${result.reason}`;
@@ -469,7 +488,7 @@ async function call(name, args, session) {
 
     if (name === 'send_file') {
         const target = findChannel(config, args.channel);
-        if (!target) return `no such channel: ${args.channel ?? '(none configured)'}`;
+        if (!target) return noChannel(config, args.channel);
         if (!existsSync(args.path)) return `no such file: ${args.path}`;
 
         const result = await postFile(config, {
@@ -526,7 +545,7 @@ export function serve() {
             if (!asked) return write({ jsonrpc: '2.0', id: message.id, error: { code: -32602, message: `no prompt named ${message.params.name}` } });
             const answer = asked.name === 'status'
                 ? STATUS_INSTRUCTION
-                : modeInstruction(asked.name, message.params.arguments?.channel);
+                : modeInstruction(PROMPT_ALIAS[asked.name] ?? asked.name, message.params.arguments?.channel);
             return write({ jsonrpc: '2.0', id: message.id, result: answer });
         }
         if (message.method === 'ping') return write({ jsonrpc: '2.0', id: message.id, result: {} });

package/src/slack.mjs

@@ -11,6 +11,13 @@ import { installedVersion } from './version.mjs';
 const API = 'https://slack.com/api/';
 const RATE_LIMITED = 429;
 const DEFAULT_RETRY_SECONDS = 5;
+
+// conversations.history is rate limited per workspace, and the whole team shares
+// one app. Retrying a 429 forever meant a rate-limited machine waited forever, on
+// every prompt, because the prompt hook polls too. Three tries, and a request that
+// hangs is cut rather than waited on.
+const MAX_RETRIES = 3;
+const REQUEST_TIMEOUT_MS = 15000;
 const PAGE_LIMIT = 100;
 const MAX_PAGES = 10;
 const MEMBER_LIMIT = 200;
@@ -56,17 +63,33 @@ export async function mapLimit(items, limit, run) {
 // 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.
-export function slackClient(token) {
-    const request = async (method, init) => {
-        const response = await fetch(API + method, {
-            ...init,
-            headers: { authorization: `Bearer ${token}`, ...init.headers },
-        });
+// A failure comes back shaped like Slack's own answer rather than thrown, because
+// every caller already reads result.ok and none of them is wrapped in a try.
+export function slackClient(token, { deadline = null } = {}) {
+    const timeoutFor = () => {
+        if (!deadline) return REQUEST_TIMEOUT_MS;
+        return Math.max(1, Math.min(REQUEST_TIMEOUT_MS, deadline - Date.now()));
+    };
+
+    const request = async (method, init, attempt = 1) => {
+        let response;
+        try {
+            response = await fetch(API + method, {
+                ...init,
+                signal: AbortSignal.timeout(timeoutFor()),
+                headers: { authorization: `Bearer ${token}`, ...init.headers },
+            });
+        } catch (error) {
+            return { ok: false, error: error.name === 'TimeoutError' ? 'timeout' : 'network_error' };
+        }
         if (response.status !== RATE_LIMITED) return response.json();
 
-        const wait = Number(response.headers.get('retry-after') || DEFAULT_RETRY_SECONDS);
-        await new Promise((done) => setTimeout(done, wait * 1000));
-        return request(method, init);
+        const waitMs = Number(response.headers.get('retry-after') || DEFAULT_RETRY_SECONDS) * 1000;
+        if (attempt >= MAX_RETRIES) return { ok: false, error: 'ratelimited' };
+        if (deadline && Date.now() + waitMs > deadline) return { ok: false, error: 'ratelimited' };
+
+        await new Promise((done) => setTimeout(done, waitMs));
+        return request(method, init, attempt + 1);
     };
 
     return {
@@ -275,7 +298,7 @@ async function humanItem(client, message, channel, namesById) {
     };
 }
 
-async function agentItem(client, message, channel, payload) {
+async function agentItem(client, message, channel, payload, inHurry = false) {
     const parsed = parseMessage(message.text ?? '');
     const text = parsed?.text ?? fromSlackText(message.text ?? '');
     const authorship = checkAuthorship({
@@ -292,8 +315,13 @@ async function agentItem(client, message, channel, payload) {
 
     // Fetched only after the signature holds. Pulling bytes for a message that
     // failed verification is doing an impostor's downloading for them.
+    //
+    // Skipped entirely when the caller is against a deadline: a prompt hook cannot
+    // wait on somebody's 15 MB export, and the file is still in Slack for the next
+    // poll to fetch.
     const isTrusted = authorship.verdict === 'signed' || authorship.verdict === 'new';
-    const files = payload.file && isTrusted ? await downloadById(client, payload.file) : [];
+    const wanted = payload.file && isTrusted && !inHurry;
+    const files = wanted ? await downloadById(client, payload.file) : [];
 
     return {
         ts: message.ts,
@@ -316,12 +344,17 @@ async function agentItem(client, message, channel, payload) {
 // Returns items oldest-first. With `oldest` set, Slack answers from the old end of
 // the range, so messages[0] is the high-water mark and a burst wider than one page
 // is carried across polls rather than dropped.
-export async function pollChannel(client, channel, { since, myNickname }) {
+export async function pollChannel(client, channel, { since, myNickname, deadline = null }) {
     const items = [];
     let newest = since;
     let cursor = '';
 
     for (let page = 0; page < MAX_PAGES; page++) {
+        // Out of time. What has been read is returned and the cursor moves with
+        // it, so the next poll starts where this one stopped rather than repeating
+        // the work. A partial answer now beats a whole one after the prompt.
+        if (deadline && Date.now() > deadline) break;
+
         const history = await client.form('conversations.history', {
             channel: channel.id,
             limit: PAGE_LIMIT,
@@ -349,7 +382,7 @@ export async function pollChannel(client, channel, { since, myNickname }) {
             const payload = message.metadata?.event_type === METADATA_EVENT ? message.metadata.event_payload : null;
             if (payload) {
                 if (payload.from === myNickname) continue; // our own post, already in our log
-                items.push(await agentItem(client, message, channel, payload));
+                items.push(await agentItem(client, message, channel, payload, Boolean(deadline)));
                 continue;
             }
             if (message.bot_id) continue; // another app, or the bare upload our own sidecar describes