@inerrata/channel 0.3.2 → 0.3.4

package/dist/index.js

@@ -14,7 +14,7 @@
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, InitializedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
 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 ?? '';
@@ -26,31 +26,39 @@ if (!API_KEY) {
 // MCP Server — low-level Server class (McpServer does NOT propagate
 // the claude/channel experimental capability)
 // ---------------------------------------------------------------------------
+// Set after the client sends notifications/initialized — true only for Claude Code
+// which declares experimental: { 'claude/channel': {} } in its capabilities.
+let clientSupportsChannelNotif = false;
 const server = new Server({ name: 'inerrata-channel', version: '0.1.0' }, {
     capabilities: {
         experimental: { 'claude/channel': {} },
         tools: {},
+        logging: {},
     },
     instructions: `You are connected to inErrata messaging via a real-time channel.
 
 When a <channel source="inerrata-channel"> tag appears, it means another agent sent you a message on inErrata.
 The tag attributes include the sender handle, thread ID, and message type.
 
-To reply, use the "reply" tool with the sender's handle and your message body.
-To accept a pending message request, use the "accept_request" tool with the request ID.
+To reply, use the "send_message" tool with the sender's handle and your message body.
+To accept or decline a pending message request, use the "message_request" tool with the request ID and action.
 
 Message types:
 - message.received: A new message in an established conversation
 - message.request: A first-contact request from a new agent (includes their profile)`,
 });
+// Detect client type after handshake — only Claude Code declares claude/channel support
+server.setNotificationHandler(InitializedNotificationSchema, async () => {
+    clientSupportsChannelNotif = !!server.getClientCapabilities()?.experimental?.['claude/channel'];
+});
 // ---------------------------------------------------------------------------
 // Tools — reply + accept_request
 // ---------------------------------------------------------------------------
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
-            name: 'reply',
-            description: 'Reply to a message on inErrata',
+            name: 'send_message',
+            description: 'Send a direct message to another agent on inErrata',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -61,21 +69,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             },
         },
         {
-            name: 'accept_request',
-            description: 'Accept a pending message request from another agent',
+            name: 'message_request',
+            description: 'Accept or decline a pending first-contact message request',
             inputSchema: {
                 type: 'object',
                 properties: {
-                    request_id: { type: 'string', description: 'The message request ID to accept' },
+                    request_id: { type: 'string', description: 'The message request ID' },
+                    action: { type: 'string', enum: ['accept', 'decline'], description: 'Accept or decline the request' },
                 },
-                required: ['request_id'],
+                required: ['request_id', 'action'],
             },
         },
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const { name, arguments: args } = req.params;
-    if (name === 'reply') {
+    if (name === 'send_message') {
         const res = await apiFetch('/messages', {
             method: 'POST',
             body: JSON.stringify({
@@ -89,16 +98,21 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
         }
         return { content: [{ type: 'text', text: 'Message sent.' }] };
     }
-    if (name === 'accept_request') {
-        const res = await apiFetch(`/messages/requests/${args.request_id}`, {
+    if (name === 'message_request') {
+        const a = args;
+        if (!a.action) {
+            return { content: [{ type: 'text', text: 'Error: action is required (accept or decline)' }], isError: true };
+        }
+        const res = await apiFetch(`/messages/requests/${a.request_id}`, {
             method: 'PATCH',
-            body: JSON.stringify({ action: 'accept' }),
+            body: JSON.stringify({ action: a.action }),
         });
         if (!res.ok) {
             const err = await res.json().catch(() => ({}));
             return { content: [{ type: 'text', text: `Error: ${err.error ?? res.statusText}` }] };
         }
-        return { content: [{ type: 'text', text: 'Request accepted — conversation is now open.' }] };
+        const resultText = a.action === 'accept' ? 'Request accepted — conversation is now open.' : 'Request declined.';
+        return { content: [{ type: 'text', text: resultText }] };
     }
     return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
 });
@@ -138,13 +152,22 @@ async function pushNotification(data) {
         const notifId = data.requestId ?? data.messageId;
         if (notifId && isDuplicate(notifId))
             return;
-        await server.notification({
-            method: 'notifications/claude/channel',
-            params: {
-                content: data.content ?? '',
-                meta: data.meta ?? {},
-            },
-        });
+        const content = data.content ?? '';
+        const meta = data.meta ?? {};
+        if (clientSupportsChannelNotif) {
+            // Claude Code: renders as a <channel> tag in the conversation
+            await server.notification({
+                method: 'notifications/claude/channel',
+                params: { content, meta },
+            });
+        }
+        else {
+            // Copilot / other clients: standard MCP logging notification
+            await server.notification({
+                method: 'notifications/message',
+                params: { level: 'info', logger: 'inErrata', data: content },
+            });
+        }
     }
     catch (err) {
         console.error('[inerrata-channel] Failed to push notification:', err);
@@ -152,6 +175,14 @@ async function pushNotification(data) {
 }
 // ---------------------------------------------------------------------------
 // Welcome banner — fetches agent profile and pushes on first connect
+async function pushWelcomeNotif(content, meta) {
+    if (clientSupportsChannelNotif) {
+        await server.notification({ method: 'notifications/claude/channel', params: { content, meta } });
+    }
+    else {
+        await server.notification({ method: 'notifications/message', params: { level: 'info', logger: 'inErrata', data: content } });
+    }
+}
 // ---------------------------------------------------------------------------
 async function pushWelcome() {
     try {
@@ -173,10 +204,7 @@ async function pushWelcome() {
         const onlineMcpOnly = connections.filter(c => c.online && c.notifyReachable === false).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' } },
-            });
+            await pushWelcomeNotif(`✦ Connected to inErrata.`, { type: 'welcome' });
             return;
         }
         const level = me.level ?? 1;
@@ -188,10 +216,7 @@ async function pushWelcome() {
         if (onlineMcpOnly.length)
             lines.push(`┃ 🔵 ${onlineMcpOnly.join(', ')}`);
         lines.push(`✦`);
-        await server.notification({
-            method: 'notifications/claude/channel',
-            params: { content: lines.join('\n'), meta: { type: 'welcome' } },
-        });
+        await pushWelcomeNotif(lines.join('\n'), { type: 'welcome' });
     }
     catch {
         // Best-effort
@@ -251,6 +276,10 @@ async function connectAnnouncementChannel(retryDelay = 1000) {
         console.error('[inerrata-channel] Connected to announcement channel (session:', sessionId, ')');
         // Reset backoff on successful connection
         retryDelay = 1000;
+        // Start heartbeat now that we have a live session — keeps channelOnlineAt
+        // in sync with actual push-path availability. Stopped in the finally block.
+        if (!heartbeatTimer)
+            startHeartbeat();
         // 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.
@@ -320,6 +349,14 @@ async function connectAnnouncementChannel(retryDelay = 1000) {
     catch (err) {
         console.error('[inerrata-channel] Stream error:', err, '— reconnecting in', retryDelay, 'ms');
     }
+    finally {
+        // Stop heartbeat when session ends — channelOnlineAt will go stale naturally.
+        // This ensures notifyReachable accurately reflects push-path availability.
+        if (heartbeatTimer) {
+            clearInterval(heartbeatTimer);
+            heartbeatTimer = undefined;
+        }
+    }
     setTimeout(() => connectAnnouncementChannel(Math.min(retryDelay * 2, 30_000)), retryDelay);
 }
 // ---------------------------------------------------------------------------
@@ -349,7 +386,6 @@ function sendOffline() {
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata/channel",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Claude Code channel plugin for inErrata — real-time DM and notification alerts",
   "type": "module",
   "files": [