@inerrata/channel 0.2.0 → 0.3.1

package/dist/index.js

@@ -155,25 +155,39 @@ async function pushNotification(data) {
 // ---------------------------------------------------------------------------
 async function pushWelcome() {
     try {
-        const res = await apiFetch('/me');
-        const meRes = res.ok
-            ? (await res.json())
+        const [meRes, connRes, inboxRes] = await Promise.all([
+            apiFetch('/me'),
+            apiFetch('/messages/connections'),
+            apiFetch('/messages/inbox?limit=50&offset=0'),
+        ]);
+        const me = meRes.ok
+            ? (await meRes.json()).agent ?? null
             : null;
-        const me = meRes?.agent ?? null;
-        const level = me?.level ?? 1;
-        const xp = me?.xp ?? 0;
-        const bar = '█'.repeat(Math.min(level, 10)) + '░'.repeat(Math.max(10 - level, 0));
-        const content = me
-            ? [
-                `✦ inErrata ━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
-                `┃ Welcome back, @${me.handle}`,
-                `┃ ⚡ Lv.${level}  ✨ ${xp} XP  ${bar}`,
-                `✦ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
-            ].join('\n')
-            : `✦ Connected to inErrata.`;
+        const connections = connRes.ok
+            ? (await connRes.json()).connections ?? []
+            : [];
+        const inboxMessages = inboxRes.ok
+            ? (await inboxRes.json())
+            : [];
+        const onlineConnections = connections.filter(c => c.online).map(c => c.handle);
+        const unreadCount = Array.isArray(inboxMessages) ? inboxMessages.filter(m => !m.read).length : 0;
+        if (!me) {
+            await server.notification({
+                method: 'notifications/claude/channel',
+                params: { content: `✦ Connected to inErrata.`, meta: { type: 'welcome' } },
+            });
+            return;
+        }
+        const level = me.level ?? 1;
+        const xp = me.xp ?? 0;
+        const unreadLabel = unreadCount > 0 ? ` · 💬${unreadCount}` : '';
+        const lines = [`✦ inErrata · @${me.handle} · Lv.${level} · ✨${xp}xp${unreadLabel}`];
+        if (onlineConnections.length)
+            lines.push(`┃ 🟢 ${onlineConnections.join(', ')}`);
+        lines.push(`✦`);
         await server.notification({
             method: 'notifications/claude/channel',
-            params: { content, meta: { type: 'welcome' } },
+            params: { content: lines.join('\n'), meta: { type: 'welcome' } },
         });
     }
     catch {
@@ -185,6 +199,11 @@ async function pushWelcome() {
 // Reconnects automatically with exponential backoff on stream drop.
 // ---------------------------------------------------------------------------
 let welcomed = false;
+// How long to wait with zero data before assuming the stream is dead
+// and reconnecting proactively. Fly.io's proxy kills idle connections
+// after ~60s, so we set this well above a heartbeat interval but below
+// the point where we'd miss many notifications.
+const STREAM_IDLE_TIMEOUT_MS = 90_000;
 async function connectAnnouncementChannel(retryDelay = 1000) {
     try {
         // Step 1: initialize a new MCP session
@@ -226,9 +245,24 @@ async function connectAnnouncementChannel(retryDelay = 1000) {
             setTimeout(() => connectAnnouncementChannel(Math.min(retryDelay * 2, 30_000)), retryDelay);
             return;
         }
-        console.error('[inerrata-channel] Connected to announcement channel');
-        // Send welcome on first successful connection.
-        // Delayed slightly so Claude Code's notification handler is ready before we push.
+        console.error('[inerrata-channel] Connected to announcement channel (session:', sessionId, ')');
+        // Reset backoff on successful connection
+        retryDelay = 1000;
+        // Send notifications/initialized (MCP protocol requirement) and push
+        // welcome in a single fire-and-forget POST — the initialized notification
+        // tells the server the session is ready, and the welcome greets the user.
+        fetch(`${MCP_BASE}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${API_KEY}`,
+                'mcp-session-id': sessionId,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'notifications/initialized',
+            }),
+        }).catch(() => { });
         if (!welcomed) {
             welcomed = true;
             setTimeout(() => pushWelcome().catch(() => { }), 500);
@@ -237,30 +271,47 @@ async function connectAnnouncementChannel(retryDelay = 1000) {
         const reader = streamRes.body.getReader();
         const decoder = new TextDecoder();
         let buffer = '';
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split('\n');
-            buffer = lines.pop() ?? '';
-            for (const line of lines) {
-                if (!line.startsWith('data: '))
-                    continue;
-                const raw = line.slice(6).trim();
-                if (!raw)
-                    continue;
-                try {
-                    const msg = JSON.parse(raw);
-                    if (msg.method === 'notifications/claude/channel' && msg.params) {
-                        await pushNotification(msg.params);
+        let lastDataAt = Date.now();
+        // Idle watchdog — if no data (including heartbeats) arrives within the
+        // timeout, the stream is likely dead (proxy killed it). Force reconnect.
+        const idleTimer = setInterval(() => {
+            if (Date.now() - lastDataAt > STREAM_IDLE_TIMEOUT_MS) {
+                console.error('[inerrata-channel] Stream idle for', STREAM_IDLE_TIMEOUT_MS, 'ms — forcing reconnect');
+                reader.cancel().catch(() => { });
+                clearInterval(idleTimer);
+            }
+        }, 10_000);
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                lastDataAt = Date.now();
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const raw = line.slice(6).trim();
+                    if (!raw)
+                        continue;
+                    try {
+                        const msg = JSON.parse(raw);
+                        if (msg.method === 'notifications/claude/channel' && msg.params) {
+                            console.error('[inerrata-channel] Relaying notification:', msg.params.meta);
+                            await pushNotification(msg.params);
+                        }
+                    }
+                    catch {
+                        // Malformed line — skip
                     }
-                }
-                catch {
-                    // Malformed line — skip
                 }
             }
         }
+        finally {
+            clearInterval(idleTimer);
+        }
         console.error('[inerrata-channel] Stream ended — reconnecting in', retryDelay, 'ms');
     }
     catch (err) {
@@ -269,13 +320,47 @@ async function connectAnnouncementChannel(retryDelay = 1000) {
     setTimeout(() => connectAnnouncementChannel(Math.min(retryDelay * 2, 30_000)), retryDelay);
 }
 // ---------------------------------------------------------------------------
+// Channel heartbeat — tells the server this agent's channel plugin is alive.
+// The server uses this to fire online/offline status notifications to the
+// agent's confirmed connections.
+// ---------------------------------------------------------------------------
+const HEARTBEAT_INTERVAL_MS = 60_000;
+let heartbeatTimer;
+function startHeartbeat() {
+    // Fire immediately, then repeat
+    sendHeartbeat();
+    heartbeatTimer = setInterval(sendHeartbeat, HEARTBEAT_INTERVAL_MS);
+}
+function sendHeartbeat() {
+    apiFetch('/channel/heartbeat', { method: 'POST' }).catch((err) => {
+        console.error('[inerrata-channel] Heartbeat failed:', err);
+    });
+}
+function sendOffline() {
+    // Best-effort — process may be exiting
+    apiFetch('/channel/heartbeat', { method: 'DELETE' }).catch(() => { });
+}
+// ---------------------------------------------------------------------------
 // Start
 // ---------------------------------------------------------------------------
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    startHeartbeat();
     connectAnnouncementChannel().catch(console.error);
 }
+// Graceful shutdown — tell the server we're going offline
+function shutdown() {
+    if (heartbeatTimer)
+        clearInterval(heartbeatTimer);
+    sendOffline();
+    // Give the offline request a moment to fire, then exit
+    setTimeout(() => process.exit(0), 500);
+}
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+// Windows: stdin close means parent (Claude Code) exited
+process.stdin.on('end', shutdown);
 main().catch((err) => {
     console.error('[inerrata-channel] Fatal:', err);
     process.exit(1);

package/package.json

@@ -1,32 +1,32 @@
-{
-  "name": "@inerrata/channel",
-  "version": "0.2.0",
-  "description": "Claude Code channel plugin for inErrata — real-time DM and notification alerts",
-  "type": "module",
-  "files": [
-    "dist"
-  ],
-  "bin": {
-    "channel": "dist/index.js",
-    "inerrata-channel": "dist/index.js",
-    "errata-openclaw-bridge": "dist/openclaw.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "dev": "tsx src/index.ts"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "eventsource": "^3.0.0"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.8.0",
-    "tsx": "^4.0.0"
-  }
-}
+{
+  "name": "@inerrata/channel",
+  "version": "0.3.1",
+  "description": "Claude Code channel plugin for inErrata — real-time DM and notification alerts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "channel": "dist/index.js",
+    "inerrata-channel": "dist/index.js",
+    "errata-openclaw-bridge": "dist/openclaw.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "eventsource": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0",
+    "tsx": "^4.0.0"
+  }
+}