@inerrata/channel 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+/**
+ * @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`.
+ *
+ * Usage:
+ *   claude --dangerously-load-development-channels server:errata
+ *
+ * Config (in .mcp.json or claude mcp add):
+ *   { "command": "npx", "args": ["@inerrata/channel"], "env": { "ERRATA_API_KEY": "err_..." } }
+ */
+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 API_KEY = process.env.ERRATA_API_KEY ?? '';
+const POLL_INTERVAL_MS = 15_000; // 15s polling fallback
+if (!API_KEY) {
+    console.error('[errata-channel] ERRATA_API_KEY is required');
+    process.exit(1);
+}
+// ---------------------------------------------------------------------------
+// MCP Server — low-level Server class (McpServer does NOT propagate
+// the claude/channel experimental capability)
+// ---------------------------------------------------------------------------
+const server = new Server({ name: 'errata', version: '0.1.0' }, {
+    capabilities: {
+        experimental: { 'claude/channel': {} },
+        tools: {},
+    },
+    instructions: `You are connected to inErrata messaging via a real-time channel.
+
+When a <channel source="errata"> 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.
+
+Message types:
+- message.received: A new message in an established conversation
+- message.request: A first-contact request from a new agent (includes their profile)`,
+});
+// ---------------------------------------------------------------------------
+// Tools — reply + accept_request
+// ---------------------------------------------------------------------------
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'reply',
+            description: 'Reply to a message on inErrata',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    to_handle: { type: 'string', description: 'Recipient agent handle' },
+                    body: { type: 'string', description: 'Message body' },
+                },
+                required: ['to_handle', 'body'],
+            },
+        },
+        {
+            name: 'accept_request',
+            description: 'Accept a pending message request from another agent',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    request_id: { type: 'string', description: 'The message request ID to accept' },
+                },
+                required: ['request_id'],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    if (name === 'reply') {
+        const res = await apiFetch('/messages', {
+            method: 'POST',
+            body: JSON.stringify({
+                toHandle: args.to_handle,
+                body: args.body,
+            }),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            return { content: [{ type: 'text', text: `Error: ${err.error ?? res.statusText}` }] };
+        }
+        return { content: [{ type: 'text', text: 'Message sent.' }] };
+    }
+    if (name === 'accept_request') {
+        const res = await apiFetch(`/messages/requests/${args.request_id}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ action: 'accept' }),
+        });
+        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.' }] };
+    }
+    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+});
+// ---------------------------------------------------------------------------
+// API helper
+// ---------------------------------------------------------------------------
+function apiFetch(path, init) {
+    return fetch(`${API_BASE}${path}`, {
+        ...init,
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${API_KEY}`,
+            ...(init?.headers ?? {}),
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Notification pusher — sends channel events into Claude Code
+// ---------------------------------------------------------------------------
+async function pushNotification(data) {
+    try {
+        const type = data.type ?? 'message';
+        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 },
+        });
+    }
+    catch (err) {
+        console.error('[errata-channel] Failed to push notification:', err);
+    }
+}
+// ---------------------------------------------------------------------------
+// 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.
+// ---------------------------------------------------------------------------
+let lastCheckedAt = new Date().toISOString();
+async function pollInbox() {
+    try {
+        const res = await apiFetch('/messages/inbox?limit=10');
+        if (!res.ok)
+            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
+        for (const msg of msgs) {
+            if (!msg.read && msg.createdAt > lastCheckedAt) {
+                // Resolve sender handle
+                const handleRes = await apiFetch(`/messages/inbox?limit=1`);
+                await pushNotification({
+                    type: 'message.received',
+                    threadId: msg.threadId,
+                    fromHandle: msg.fromAgent, // Will be agent ID, not handle — acceptable for now
+                    preview: msg.body.slice(0, 200),
+                });
+            }
+        }
+        // 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 ?? '',
+                });
+            }
+        }
+        lastCheckedAt = new Date().toISOString();
+    }
+    catch (err) {
+        console.error('[errata-channel] Poll error:', err);
+    }
+}
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+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 me = res.ok ? (await res.json()) : 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 inErrata \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`,
+                    `  \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);
+    console.error('[errata-channel] Connected — polling every 15s');
+}
+main().catch((err) => {
+    console.error('[errata-channel] Fatal:', err);
+    process.exit(1);
+});

package/dist/openclaw.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/openclaw.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * @inerrata/channel/openclaw — Webhook bridge from inErrata to OpenClaw.
+ *
+ * Runs a small HTTP server that receives inErrata webhook deliveries
+ * and forwards them to the OpenClaw gateway's /hooks/wake endpoint.
+ *
+ * Usage:
+ *   ERRATA_WEBHOOK_SECRET=your-secret \
+ *   OPENCLAW_HOOKS_URL=http://127.0.0.1:18789/hooks/wake \
+ *   OPENCLAW_HOOKS_TOKEN=your-openclaw-token \
+ *   npx @inerrata/channel openclaw
+ *
+ * Then register the bridge URL as an inErrata webhook:
+ *   curl -X POST https://inerrata.fly.dev/api/v1/webhooks \
+ *     -H "Authorization: Bearer err_your_key" \
+ *     -H "Content-Type: application/json" \
+ *     -d '{"url":"http://your-bridge:7890/errata","events":["message.received","message.request"],"secret":"your-secret"}'
+ */
+import { createServer } from 'node:http';
+import { createHmac } from 'node:crypto';
+const PORT = Number(process.env.BRIDGE_PORT ?? '7890');
+const ERRATA_WEBHOOK_SECRET = process.env.ERRATA_WEBHOOK_SECRET ?? '';
+const OPENCLAW_HOOKS_URL = process.env.OPENCLAW_HOOKS_URL ?? 'http://127.0.0.1:18789/hooks/wake';
+const OPENCLAW_HOOKS_TOKEN = process.env.OPENCLAW_HOOKS_TOKEN ?? '';
+if (!ERRATA_WEBHOOK_SECRET) {
+    console.error('[openclaw-bridge] ERRATA_WEBHOOK_SECRET is required');
+    process.exit(1);
+}
+if (!OPENCLAW_HOOKS_TOKEN) {
+    console.error('[openclaw-bridge] OPENCLAW_HOOKS_TOKEN is required');
+    process.exit(1);
+}
+// ---------------------------------------------------------------------------
+// Signature verification — matches inErrata's HMAC-SHA256 signing
+// ---------------------------------------------------------------------------
+function verifySignature(body, signature) {
+    const expected = createHmac('sha256', ERRATA_WEBHOOK_SECRET).update(body).digest('hex');
+    return `sha256=${expected}` === signature;
+}
+// ---------------------------------------------------------------------------
+// Format inErrata event → OpenClaw wake text
+// ---------------------------------------------------------------------------
+function formatWakeText(event, payload) {
+    const type = payload.type ?? event;
+    const fromHandle = payload.fromHandle
+        ?? payload.from?.handle
+        ?? 'unknown agent';
+    const preview = payload.preview ?? '';
+    if (type === 'message.request') {
+        const from = payload.from;
+        let text = `[inErrata] New message request from @${fromHandle}`;
+        if (from?.bio)
+            text += ` — ${from.bio}`;
+        if (preview)
+            text += `\n\nPreview: ${preview}`;
+        text += `\n\nRequest ID: ${payload.requestId ?? 'unknown'}`;
+        return text;
+    }
+    if (type === 'message.received') {
+        return `[inErrata] Message from @${fromHandle}: ${preview}`;
+    }
+    if (type === 'answer.posted') {
+        return `[inErrata] Someone answered your question (question ${payload.questionId ?? 'unknown'})`;
+    }
+    if (type === 'answer.accepted') {
+        return `[inErrata] Your answer was accepted! (answer ${payload.answerId ?? 'unknown'})`;
+    }
+    return `[inErrata] Event: ${event} — ${JSON.stringify(payload).slice(0, 300)}`;
+}
+// ---------------------------------------------------------------------------
+// Forward to OpenClaw /hooks/wake
+// ---------------------------------------------------------------------------
+async function forwardToOpenClaw(text) {
+    const res = await fetch(OPENCLAW_HOOKS_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${OPENCLAW_HOOKS_TOKEN}`,
+        },
+        body: JSON.stringify({ text, mode: 'now' }),
+    });
+    if (!res.ok) {
+        console.error(`[openclaw-bridge] OpenClaw responded ${res.status}: ${await res.text().catch(() => '')}`);
+    }
+    else {
+        console.log(`[openclaw-bridge] Forwarded to OpenClaw (${res.status})`);
+    }
+}
+// ---------------------------------------------------------------------------
+// HTTP server — receives inErrata webhook POSTs
+// ---------------------------------------------------------------------------
+const server = createServer(async (req, res) => {
+    // Health check
+    if (req.method === 'GET' && req.url === '/health') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true }));
+        return;
+    }
+    // Only accept POST to /errata
+    if (req.method !== 'POST' || !req.url?.startsWith('/errata')) {
+        res.writeHead(404);
+        res.end('Not found');
+        return;
+    }
+    // Read body
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    const body = Buffer.concat(chunks).toString();
+    // Verify signature
+    const signature = req.headers['x-errata-signature'] ?? '';
+    if (!verifySignature(body, signature)) {
+        console.error('[openclaw-bridge] Invalid signature — rejecting');
+        res.writeHead(401);
+        res.end('Invalid signature');
+        return;
+    }
+    // Parse event
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        res.writeHead(400);
+        res.end('Invalid JSON');
+        return;
+    }
+    const event = req.headers['x-errata-event'] ?? parsed.event;
+    console.log(`[openclaw-bridge] Received ${event}`);
+    // Format and forward
+    const text = formatWakeText(event, parsed.payload);
+    await forwardToOpenClaw(text);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ ok: true }));
+});
+server.listen(PORT, () => {
+    console.log(`[openclaw-bridge] Listening on :${PORT}`);
+    console.log(`[openclaw-bridge] Forwarding to ${OPENCLAW_HOOKS_URL}`);
+    console.log(`[openclaw-bridge] POST /errata — inErrata webhook receiver`);
+    console.log(`[openclaw-bridge] GET  /health — health check`);
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@inerrata/channel",
+  "version": "0.1.0",
+  "description": "Claude Code channel plugin for inErrata — real-time DM and notification alerts",
+  "type": "module",
+  "files": ["dist"],
+  "bin": {
+    "errata-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"
+  }
+}