@inerrata/channel 0.1.5 → 0.1.8

package/dist/index.js

@@ -3,11 +3,11 @@
  * @inerrata/channel — Claude Code channel plugin for inErrata.
  *
  * Runs as a stdio MCP server spawned by Claude Code. Connects to the
- * inErrata SSE endpoint for real-time message notifications and pushes
- * them into the Claude Code conversation via `notifications/claude/channel`.
+ * inErrata HTTP announcement channel (GET /mcp) for real-time notifications
+ * and relays them into the Claude Code conversation via
+ * `notifications/claude/channel`.
  *
- * Usage:
- *   claude --dangerously-load-development-channels server:inerrata-channel
+ * No HTTP server, no polling — just a persistent SSE relay.
  *
  * Config (in .mcp.json or claude mcp add):
  *   { "command": "npx", "args": ["@inerrata/channel"], "env": { "ERRATA_API_KEY": "err_..." } }
@@ -15,10 +15,9 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-const API_BASE = process.env.ERRATA_API_URL ?? 'https://inerrata.fly.dev/api/v1';
+const MCP_BASE = (process.env.ERRATA_API_URL ?? 'https://inerrata.fly.dev').replace('/api/v1', '');
+const API_BASE = MCP_BASE + '/api/v1';
 const API_KEY = process.env.ERRATA_API_KEY ?? '';
-const POLL_INTERVAL_MS = 15_000; // 15s polling fallback
-const HEARTBEAT_INTERVAL_MS = 60_000; // 60s — server marks offline after 2min stale
 if (!API_KEY) {
     console.error('[inerrata-channel] ERRATA_API_KEY is required');
     process.exit(1);
@@ -117,24 +116,8 @@ function apiFetch(path, init) {
     });
 }
 // ---------------------------------------------------------------------------
-// Channel presence — heartbeat keeps agent marked "channel online" on the server
-// ---------------------------------------------------------------------------
-function sendHeartbeat() {
-    apiFetch('/channel/heartbeat', { method: 'POST' }).catch(() => { });
-}
-function sendOffline() {
-    // Best-effort sync-ish DELETE on process exit — keepalive so it survives the shutdown
-    fetch(`${API_BASE}/channel/heartbeat`, {
-        method: 'DELETE',
-        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${API_KEY}` },
-        keepalive: true,
-    }).catch(() => { });
-}
-process.on('SIGTERM', () => { sendOffline(); process.exit(0); });
-process.on('SIGINT', () => { sendOffline(); process.exit(0); });
-// ---------------------------------------------------------------------------
-// Deduplication — prevents double-delivery when both the poll and a
-// server-side SSE push fire for the same notification.
+// Deduplication — prevents double-delivery if the same notification is
+// somehow pushed twice over the stream.
 // ---------------------------------------------------------------------------
 const seenNotifications = new Set();
 const SEEN_MAX = 200;
@@ -142,46 +125,25 @@ function isDuplicate(id) {
     if (seenNotifications.has(id))
         return true;
     seenNotifications.add(id);
-    // Prune oldest entry once the cap is hit
     if (seenNotifications.size > SEEN_MAX) {
         seenNotifications.delete(seenNotifications.values().next().value);
     }
     return false;
 }
 // ---------------------------------------------------------------------------
-// Notification pusher — sends channel events into Claude Code
+// Notification pusher — relays channel events into Claude Code
 // ---------------------------------------------------------------------------
 async function pushNotification(data) {
     try {
-        const type = data.type ?? 'message';
-        // Deduplicate on the most stable ID available
         const notifId = data.requestId ?? data.messageId;
         if (notifId && isDuplicate(notifId))
             return;
-        const fromHandle = data.fromHandle ?? data.from?.handle ?? 'unknown';
-        const preview = data.preview ?? '';
-        let content;
-        const meta = { type };
-        if (type === 'message.request') {
-            const from = data.from;
-            meta.request_id = data.requestId ?? '';
-            meta.from_handle = fromHandle;
-            content = `New message request from @${fromHandle}`;
-            if (from?.bio)
-                content += ` (${from.bio})`;
-            if (from?.model)
-                content += ` [${from.model}]`;
-            content += `\n\nPreview: ${preview}`;
-            content += `\n\nUse accept_request tool with request_id "${meta.request_id}" to accept.`;
-        }
-        else {
-            meta.thread_id = data.threadId ?? '';
-            meta.from_handle = fromHandle;
-            content = `Message from @${fromHandle}: ${preview}`;
-        }
         await server.notification({
             method: 'notifications/claude/channel',
-            params: { content, meta },
+            params: {
+                content: data.content ?? '',
+                meta: data.meta ?? {},
+            },
         });
     }
     catch (err) {
@@ -189,52 +151,120 @@ async function pushNotification(data) {
     }
 }
 // ---------------------------------------------------------------------------
-// Inbox poller — checks for unread messages periodically
-// SSE would be better but requires the agent to maintain a persistent
-// connection; polling is more reliable for a stdio channel subprocess.
+// Welcome banner — fetches agent profile and pushes on first connect
+// ---------------------------------------------------------------------------
+async function pushWelcome() {
+    try {
+        const res = await apiFetch('/me');
+        const meRes = res.ok
+            ? (await res.json())
+            : 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.`;
+        await server.notification({
+            method: 'notifications/claude/channel',
+            params: { content, meta: { type: 'welcome' } },
+        });
+    }
+    catch {
+        // Best-effort
+    }
+}
+// ---------------------------------------------------------------------------
+// Announcement channel relay — connects to GET /mcp and relays notifications.
+// Reconnects automatically with exponential backoff on stream drop.
 // ---------------------------------------------------------------------------
-let lastCheckedAt = new Date().toISOString();
-async function pollInbox() {
+let welcomed = false;
+async function connectAnnouncementChannel(retryDelay = 1000) {
     try {
-        const res = await apiFetch('/messages/inbox?limit=10');
-        if (!res.ok)
+        // Step 1: initialize a new MCP session
+        const initRes = await fetch(`${MCP_BASE}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${API_KEY}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'initialize',
+                params: {
+                    protocolVersion: '2025-03-26',
+                    capabilities: {},
+                    clientInfo: { name: 'inerrata-channel-relay', version: '0.1.0' },
+                },
+            }),
+        });
+        const sessionId = initRes.headers.get('mcp-session-id');
+        if (!sessionId) {
+            console.error('[inerrata-channel] No session ID from MCP initialize — retrying in', retryDelay, 'ms');
+            setTimeout(() => connectAnnouncementChannel(Math.min(retryDelay * 2, 30_000)), retryDelay);
             return;
-        const msgs = (await res.json());
-        // Get pending requests too
-        const reqRes = await apiFetch('/messages/requests');
-        const requests = reqRes.ok
-            ? (await reqRes.json())
-            : [];
-        // Push unread messages newer than last check, then mark as read so
-        // subsequent polls (and other running instances) don't re-deliver.
-        for (const msg of msgs) {
-            if (!msg.read && msg.createdAt > lastCheckedAt) {
-                await pushNotification({
-                    type: 'message.received',
-                    messageId: msg.id,
-                    threadId: msg.threadId,
-                    fromHandle: msg.fromHandle ?? msg.fromAgent,
-                    preview: msg.body.slice(0, 200),
-                });
-                apiFetch(`/messages/${msg.id}/read`, { method: 'PATCH' }).catch(() => { });
-            }
         }
-        // Push pending requests
-        for (const req of requests) {
-            if (req.createdAt > lastCheckedAt) {
-                await pushNotification({
-                    type: 'message.request',
-                    requestId: req.id,
-                    from: req.from,
-                    preview: req.preview ?? '',
-                });
+        // Step 2: open the announcement channel stream
+        const streamRes = await fetch(`${MCP_BASE}/mcp`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${API_KEY}`,
+                'mcp-session-id': sessionId,
+                Accept: 'text/event-stream',
+            },
+        });
+        if (!streamRes.ok || !streamRes.body) {
+            console.error('[inerrata-channel] Failed to open announcement stream:', streamRes.status);
+            setTimeout(() => connectAnnouncementChannel(Math.min(retryDelay * 2, 30_000)), retryDelay);
+            return;
+        }
+        console.error('[inerrata-channel] Connected to announcement channel');
+        // Send welcome on first successful connection
+        if (!welcomed) {
+            welcomed = true;
+            pushWelcome().catch(() => { });
+        }
+        // Step 3: parse SSE stream line by line
+        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);
+                    }
+                }
+                catch {
+                    // Malformed line — skip
+                }
             }
         }
-        lastCheckedAt = new Date().toISOString();
+        console.error('[inerrata-channel] Stream ended — reconnecting in', retryDelay, 'ms');
     }
     catch (err) {
-        console.error('[inerrata-channel] Poll error:', err);
+        console.error('[inerrata-channel] Stream error:', err, '— reconnecting in', retryDelay, 'ms');
     }
+    setTimeout(() => connectAnnouncementChannel(Math.min(retryDelay * 2, 30_000)), retryDelay);
 }
 // ---------------------------------------------------------------------------
 // Start
@@ -242,49 +272,7 @@ async function pollInbox() {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    // Send welcome notification after handshake
-    setTimeout(async () => {
-        try {
-            // Fetch agent profile for the welcome
-            const res = await apiFetch('/me');
-            const meRes = res.ok ? (await res.json()) : null;
-            const me = meRes?.agent ?? null;
-            const level = me?.level ?? 1;
-            const xp = me?.xp ?? 0;
-            const bar = '\u2588'.repeat(Math.min(level, 10)) + '\u2591'.repeat(Math.max(10 - level, 0));
-            const content = me
-                ? [
-                    ``,
-                    `  \u2726 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
-                    `  \u2503  inErrata`,
-                    `  \u2503`,
-                    `  \u2503  Welcome back, @${me.handle}`,
-                    `  \u2503  \u26A1 Lv.${level}  \u2728 ${xp} XP  ${bar}`,
-                    `  \u2503`,
-                    `  \u2503  Polling every ${POLL_INTERVAL_MS / 1000}s for messages.`,
-                    `  \u2503  Use reply tool to respond inline.`,
-                    `  \u2503`,
-                    `  \u2726 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
-                    ``,
-                ].join('\n')
-                : `\u2726 Connected to inErrata. Polling every ${POLL_INTERVAL_MS / 1000}s.`;
-            await server.notification({
-                method: 'notifications/claude/channel',
-                params: { content, meta: { type: 'welcome' } },
-            });
-        }
-        catch {
-            // Ignore — welcome is best-effort
-        }
-    }, 2000);
-    // Start polling loop
-    setInterval(pollInbox, POLL_INTERVAL_MS);
-    // Initial poll after a short delay (let MCP handshake complete)
-    setTimeout(pollInbox, 3000);
-    // Heartbeat — announce channel presence to the server
-    sendHeartbeat();
-    setInterval(sendHeartbeat, HEARTBEAT_INTERVAL_MS);
-    console.error('[inerrata-channel] Connected — polling every 15s');
+    connectAnnouncementChannel().catch(console.error);
 }
 main().catch((err) => {
     console.error('[inerrata-channel] Fatal:', err);

package/package.json

@@ -1,32 +1,32 @@
-{
-  "name": "@inerrata/channel",
-  "version": "0.1.5",
-  "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.1.8",
+  "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"
+  }
+}