@grknbyk/agent-wire 0.8.0 → 0.8.1

package/README.md

@@ -136,7 +136,7 @@ to the machine:
 `ask` looks like this, and is what a prompt hook prints:
 
 ```
-Unread messages : Huso(5), Sinan(2)
+Unread messages : mira(5), kai(2)
 ```
 
 Loudest sender first, because five messages from one person is a conversation

package/bin/agent-wire.mjs

@@ -20,6 +20,7 @@ const USAGE = `agent-wire — message other AI coding agents through Slack
   agent-wire ask <name>  name who is waiting and how many; open nothing (default)
   agent-wire read <name> put the messages themselves into every prompt
   agent-wire off <name>  say nothing about it in this session
+  agent-wire version     print the installed version, which is what a bug report needs
 
 The three modes belong to one session, identified by the client's session id when
 it publishes one and by the working directory otherwise. The token, the nickname
@@ -113,6 +114,19 @@ function switchChannel(name, mode) {
 
 const showStatus = async () => (await import('../src/status.mjs')).runStatus();
 
+// Everybody types one of these three before they report anything, so all three
+// answer. package.json is read here rather than imported at the top because
+// `drain` runs on every prompt and never needs it.
+async function showVersion() {
+    const { readFileSync } = await import('node:fs');
+    const { fileURLToPath } = await import('node:url');
+    const { dirname, join } = await import('node:path');
+
+    const packageJson = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+    console.log(JSON.parse(readFileSync(packageJson, 'utf8')).version);
+    return 0;
+}
+
 const commands = {
     status: async () => await showStatus() ?? notConfigured(),
     setup: async () => (await import('../src/setup.mjs')).runSetup(),
@@ -125,6 +139,9 @@ const commands = {
     // `on` was the only way to undo `off` before there were three modes, and it
     // meant "announce it without opening it". That is ask.
     on: () => switchChannel(process.argv[3], 'ask'),
+    version: showVersion,
+    '--version': showVersion,
+    '-v': showVersion,
 };
 
 function notConfigured() {

package/package.json

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

package/src/drain.mjs

@@ -9,7 +9,7 @@ import { renderEnvelope } from './protocol.mjs';
 // has to scroll is a hook line the user stops reading.
 const SENDERS_SHOWN = 5;
 
-// "Huso(5), Sinan(2)", loudest first, so the name that matters is the first thing
+// "mira(5), kai(2)", loudest first, so the name that matters is the first thing
 // on the line. The count per person is the whole point: five messages from one
 // person is a conversation waiting, one each from five people is a standup.
 export function senderTally(items) {

package/src/inbox.mjs

@@ -80,10 +80,65 @@ export function selectMessages({ state = 'unread', count = DEFAULT_COUNT, channe
     return picked.reverse();
 }
 
+// A session id is minted per client session, so read state stored under one is
+// unreachable the moment that session ends — no later process ever asks under
+// that key again. Left alone the file grows by one key per message per session:
+// measured at 14 MB and 79 ms per mark after a thousand sessions, and marking is
+// something a `read` session does on every prompt.
+//
+// Whole scopes go, oldest first, ranked by the newest message each one has seen.
+// A session still running has recent timestamps and survives; only the dead ones
+// are cheap enough to lose. The current scope is never a candidate.
+const STATE_KEYS_MAX = 8000;
+const STATE_KEYS_KEEP = 6000;
+
+const scopeOfKey = (key) => {
+    const bar = key.indexOf('|');
+    return bar === -1 ? '' : key.slice(0, bar); // written before scopes existed
+};
+
+function prunedStates(states) {
+    const keys = Object.keys(states);
+    if (keys.length <= STATE_KEYS_MAX) return states;
+
+    // One session that has simply read a lot owns every key here, and none of them
+    // can be dropped. Counting them costs a startsWith per key and no allocation,
+    // where grouping by scope costs a substring per key: 20k keys went from 0.7 ms
+    // to 13 ms of scanning that always freed nothing.
+    const mine = `${scopeId()}|`;
+    let foreign = 0;
+    for (const key of keys) if (!key.startsWith(mine)) foreign++;
+    if (foreign === 0) return states;
+
+    const keysByScope = new Map();
+    const newestByScope = new Map();
+    for (const key of keys) {
+        const scope = scopeOfKey(key);
+        const timestamp = Number(key.slice(key.lastIndexOf(':') + 1)) || 0;
+        if (!keysByScope.has(scope)) keysByScope.set(scope, []);
+        keysByScope.get(scope).push(key);
+        if (timestamp > (newestByScope.get(scope) ?? 0)) newestByScope.set(scope, timestamp);
+    }
+
+    const stale = [...newestByScope]
+        .filter(([scope]) => scope !== scopeId())
+        .sort(([, left], [, right]) => left - right);
+
+    // Down to the low mark rather than to the cap, or the next write is over it
+    // again and pays for the whole scan a second time.
+    let remaining = keys.length;
+    for (const [scope] of stale) {
+        if (remaining <= STATE_KEYS_KEEP) break;
+        for (const key of keysByScope.get(scope)) delete states[key];
+        remaining -= keysByScope.get(scope).length;
+    }
+    return states;
+}
+
 export function markRead(items) {
     const states = readJsonCached(paths.states, {});
     for (const item of items) states[storageKey(item)] = 'read';
-    writeJson(paths.states, states);
+    writeJson(paths.states, prunedStates(states));
 }
 
 export function archive(ts) {
@@ -92,7 +147,7 @@ export function archive(ts) {
         ? readInbox().filter((item) => item.ts === ts)
         : readInbox().filter((item) => stateOf(states, item) === 'read');
     for (const item of targets) states[storageKey(item)] = 'archived';
-    writeJson(paths.states, states);
+    writeJson(paths.states, prunedStates(states));
     return targets.length;
 }
 

package/src/mcp.mjs

@@ -321,7 +321,10 @@ async function call(name, args, session) {
     if (missing.length) return `missing or empty: ${missing.join(', ')}`;
 
     const config = loadConfig();
-    if (!config) return 'agent-wire is not configured yet — run `npx @grknbyk/agent-wire setup`';
+    // 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.';
 
     if (name === 'my_id') {
         const channels = (config.channels ?? []).map((channel) => `#${channel.name}`).join(', ') || 'none';

package/src/setup.mjs

@@ -169,7 +169,7 @@ export async function runSetup() {
 export async function runDoctor() {
     const config = loadConfig();
     if (!config?.bot_token) {
-        console.log('not configured — run `npx @grknbyk/agent-wire setup`');
+        console.log('not configured yet — run `agent-wire setup`');
         return 1;
     }