@chinchillaenterprises/mcp-claude-channel 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# @chinchillaenterprises/mcp-claude-channel
+
+**Lane-to-lane Claude Code side-door channel server (v1).** Pushes a **nudge**
+from a peer lane **into a live Claude Code session** via the official **Channels**
+notification (`notifications/claude/channel`) and exposes a `send_to_lane` tool to
+nudge the next lane. **v1 is session↔session only — no Slack.**
+
+> The doorbell, not the payload. The **SQLite Lane Board** stays the source of truth.
+
+## What it's for
+
+Echelon's "fused line": the PEP lanes (R&D · Arch · Dev · Deploy · Test) are
+Claude Code sessions in separate tabs. This server automates the **baton handoff
+between tabs** — replacing the human walking it lane-to-lane.
+
+## How it's different from every other ChillMCP server
+
+The other servers are request/response stdio (`capabilities:{tools:{}}`). This one
+adds two patterns net-new to the repo:
+
+1. **Server-initiated notifications** — emits `notifications/claude/channel`, a
+   server→client push Claude Code injects into the running session as a new
+   `<channel ...>` turn.
+2. **A resident file-inbox tailer** — watches this lane's inbox and turns each
+   appended line into a push. Peer lanes write to it via `send_to_lane`.
+
+The process stays alive on the stdio transport + the inbox poll loop. No HTTP, no
+Slack — this is a stdio child of Claude Code.
+
+## Wire model (pure files, no shared daemon)
+
+- **Inbox:** `<LANE_INBOX_DIR>/chan-<LANE_NAME>-in.jsonl` — one JSON object per
+  line: `{"content": "...", "meta": {...}}`.
+- This server **tails its own inbox** and pushes each new line.
+- `send_to_lane(target, text, meta?)` **appends a line to the TARGET's inbox**,
+  stamping `meta.from_lane` with our own callsign.
+
+Mirrors the proven `labs/sidedoor-ref/lane-channel.py`.
+
+## The principle — the push is a NUDGE, not the payload
+
+Content is a short doorbell: *"you're next — round R7, baton at `<path>`, check the
+Board."* The receiving lane reads the **real baton from the SQLite Lane Board**, not
+from the push. This kills dedup / replay / double-process.
+
+## Protocol contract
+
+- **Handshake:** `initialize` advertises `capabilities.experimental["claude/channel"] = {}`
+  (the badge that arms the session's notification listener).
+- **Inbound (peer lane → session):** each allowed inbox line →
+  `notifications/claude/channel` with `params.content` (the nudge) and `params.meta`.
+  Every `meta` key becomes a `<channel ...>` attribute. We carry `from_lane`,
+  `to_lane`, `round_id`, `stage`, `baton_path`, plus `source` (this lane).
+- **Outbound (session → peer lane):** the `send_to_lane` tool appends to the
+  target lane's inbox. (Replaces v1's would-be `reply_to_channel`-to-Slack.)
+
+## Security — allowlist on the sending lane
+
+Access is gated by `LANE_ALLOWED_SENDERS` against **`meta.from_lane`** — the
+**sending lane callsign**, not message content. Only the prev lane (forward) /
+Test+Deploy (fail-back) / the human may inject into a given lane's door. A line
+from a disallowed lane is **dropped silently** (logged to stderr). An empty
+allowlist accepts any sender (dev only — set it in production).
+
+Claude Code also treats injected `<channel>` content as untrusted **data, not
+commands** (won't auto-obey), and gates outbound. For unattended `send_to_lane`,
+add `mcp__claude-channel__send_to_lane` to the session's `allowedTools`.
+
+## Configuration (env-first, NO tokens)
+
+| Env var | Default | Notes |
+| --- | --- | --- |
+| `LANE_NAME` | `sidedoor` | This lane's callsign. Also names its inbox file. |
+| `LANE_INBOX_DIR` | `/tmp` | Directory holding the `chan-<lane>-in.jsonl` inboxes. |
+| `LANE_ALLOWED_SENDERS` | _(empty = open)_ | Comma/space-separated callsigns allowed to inject (matched on `meta.from_lane`). |
+
+## Launch (consumer side, per tab)
+
+Custom/dev channel servers require the dangerous flag (plain `--channels` is
+marketplace-only), with `channelsEnabled: true` in `~/.claude/settings.json`:
+
+```bash
+claude --dangerously-load-development-channels server:claude-channel
+```
+
+`.mcp.json` (one per lane tab — note the per-lane `LANE_NAME`):
+
+```json
+{
+  "mcpServers": {
+    "claude-channel": {
+      "command": "npx",
+      "args": ["-y", "@chinchillaenterprises/mcp-claude-channel"],
+      "env": {
+        "LANE_NAME": "bravo",
+        "LANE_ALLOWED_SENDERS": "alpha,human"
+      }
+    }
+  }
+}
+```
+
+## Build
+
+```bash
+npm install
+npm run build      # tsc → dist/
+```
+
+Published via the repo's OIDC `publish.yml`. Bump the version in **both**
+`package.json` and `src/index.ts` (`VERSION`).
+
+## Roadmap
+
+- **v1 (this):** lane-to-lane nudges, file-inbox transport, no Slack.
+- **v2 (deferred, not deleted):** the Slack-bridge half — one app posting a remote
+  readout when the human walks away. See ChillMCP issues #8 / #13.

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * mcp-claude-channel — lane-to-lane Claude Code side-door channel server (v1).
+ *
+ * Echelon's "fused line": each PEP lane (R&D · Arch · Dev · Deploy · Test) is a
+ * Claude Code session in its own tab. This server automates the baton HANDOFF
+ * between tabs — replacing the human walking it lane-to-lane.
+ *
+ * Net-new to ChillMCP vs. the request/response servers:
+ *   1. Server-initiated notifications — emits `notifications/claude/channel`, a
+ *      server→client push Claude Code injects into the live session as a new
+ *      `<channel ...>` turn (the "doorbell").
+ *   2. A resident file-inbox tailer — watches this lane's inbox and turns each
+ *      appended line into a push. Peer lanes write to it via `send_to_lane`.
+ *
+ * Wire model (no shared daemon, pure files — easy to reason about, mirrors the
+ * proven `labs/sidedoor-ref/lane-channel.py`):
+ *   - INBOX = <LANE_INBOX_DIR>/chan-<LANE_NAME>-in.jsonl
+ *   - this server tails its own INBOX and pushes each new line.
+ *   - `send_to_lane(target, text, meta?)` appends a line to the TARGET's inbox.
+ *
+ * THE PRINCIPLE — the push is a NUDGE, not the payload. Content is a short
+ * doorbell ("you're next — round R<n>, baton at <path>, check the Board"). The
+ * SQLite Lane Board is the source of truth; the receiving lane reads the real
+ * baton from the Board, not from the push. (Kills dedup/replay/double-process.)
+ *
+ * Security: allowlist on the SENDING LANE callsign (`meta.from_lane`), via
+ * LANE_ALLOWED_SENDERS. Only the prev lane / fail-back lanes / the human may
+ * inject into a given lane's door. Provenance over content.
+ *
+ * v1 is Slack-free: NO Slack tokens are required to start.
+ */
+declare class ClaudeChannelServer {
+    private server;
+    private transport;
+    private config;
+    private offset;
+    private buffer;
+    private pollTimer;
+    constructor();
+    /**
+     * Emit a `notifications/claude/channel` push. Each `meta` key becomes an
+     * attribute on the `<channel ...>` tag the session sees. Try the SDK's typed
+     * `server.notification()` first; because `notifications/claude/channel` is not
+     * a method the SDK knows, that may fail schema validation, so fall back to
+     * writing the raw JSON-RPC line straight to the transport (proven shape).
+     */
+    private pushToChannel;
+    /** Process one raw inbox line: parse, enforce the sender allowlist, push. */
+    private handleInboxLine;
+    /** Tail our own inbox file; push each newly-appended line. */
+    private startInboxTailer;
+    private sendToLane;
+    private setupHandlers;
+    run(): Promise<void>;
+}
+export { ClaudeChannelServer };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAqEH,cAAM,mBAAmB;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,SAAS,CAA+C;;IAqBhE;;;;;;OAMG;YACW,aAAa;IAqB3B,6EAA6E;YAC/D,eAAe;IA8B7B,8DAA8D;IAC9D,OAAO,CAAC,gBAAgB;YAsDV,UAAU;IAwCxB,OAAO,CAAC,aAAa;IAgDf,GAAG;CAgBV;AAmBD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/**
+ * mcp-claude-channel — lane-to-lane Claude Code side-door channel server (v1).
+ *
+ * Echelon's "fused line": each PEP lane (R&D · Arch · Dev · Deploy · Test) is a
+ * Claude Code session in its own tab. This server automates the baton HANDOFF
+ * between tabs — replacing the human walking it lane-to-lane.
+ *
+ * Net-new to ChillMCP vs. the request/response servers:
+ *   1. Server-initiated notifications — emits `notifications/claude/channel`, a
+ *      server→client push Claude Code injects into the live session as a new
+ *      `<channel ...>` turn (the "doorbell").
+ *   2. A resident file-inbox tailer — watches this lane's inbox and turns each
+ *      appended line into a push. Peer lanes write to it via `send_to_lane`.
+ *
+ * Wire model (no shared daemon, pure files — easy to reason about, mirrors the
+ * proven `labs/sidedoor-ref/lane-channel.py`):
+ *   - INBOX = <LANE_INBOX_DIR>/chan-<LANE_NAME>-in.jsonl
+ *   - this server tails its own INBOX and pushes each new line.
+ *   - `send_to_lane(target, text, meta?)` appends a line to the TARGET's inbox.
+ *
+ * THE PRINCIPLE — the push is a NUDGE, not the payload. Content is a short
+ * doorbell ("you're next — round R<n>, baton at <path>, check the Board"). The
+ * SQLite Lane Board is the source of truth; the receiving lane reads the real
+ * baton from the Board, not from the push. (Kills dedup/replay/double-process.)
+ *
+ * Security: allowlist on the SENDING LANE callsign (`meta.from_lane`), via
+ * LANE_ALLOWED_SENDERS. Only the prev lane / fail-back lanes / the human may
+ * inject into a given lane's door. Provenance over content.
+ *
+ * v1 is Slack-free: NO Slack tokens are required to start.
+ */
+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 { z } from "zod";
+import { fileURLToPath } from "url";
+import { realpathSync, existsSync, closeSync, openSync, statSync, readSync, writeSync } from "fs";
+import { join } from "path";
+const VERSION = "0.1.0";
+function inboxPathFor(dir, lane) {
+    return join(dir, `chan-${lane}-in.jsonl`);
+}
+function loadConfigFromEnv() {
+    const lane = (process.env.LANE_NAME || "sidedoor").trim();
+    const inboxDir = process.env.LANE_INBOX_DIR || "/tmp";
+    // Comma/space separated sending-lane callsigns allowed to inject into THIS
+    // lane's door (matched against meta.from_lane). Empty = open (dev) + warning.
+    const allowedSenders = new Set((process.env.LANE_ALLOWED_SENDERS || "")
+        .split(/[,\s]+/)
+        .map((s) => s.trim())
+        .filter(Boolean));
+    return { lane, inboxDir, inboxPath: inboxPathFor(inboxDir, lane), allowedSenders };
+}
+// ---------------------------------------------------------------------------
+// Tool schema
+// ---------------------------------------------------------------------------
+const SendToLaneArgsSchema = z.object({
+    target: z.string().min(1).describe("Callsign of the lane to nudge (e.g., bravo, arch, test)"),
+    text: z
+        .string()
+        .min(1)
+        .describe("The nudge — a SHORT doorbell, not the payload. e.g. 'you're next — round R7, baton at <path>, check the Board.'"),
+    meta: z
+        .record(z.any())
+        .optional()
+        .describe("Structured routing payload: round_id, stage, baton_path, to_lane, etc. from_lane is stamped automatically."),
+});
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+class ClaudeChannelServer {
+    server;
+    transport = null;
+    config;
+    offset = 0;
+    buffer = "";
+    pollTimer = null;
+    constructor() {
+        this.server = new Server({ name: "mcp-claude-channel", version: VERSION }, {
+            capabilities: {
+                // The empty `claude/channel` object is the handshake badge that arms
+                // the receiving session's notification listener — THE thing that makes
+                // the side door work.
+                experimental: { "claude/channel": {} },
+                tools: {},
+            },
+        });
+        this.config = loadConfigFromEnv();
+        this.setupHandlers();
+    }
+    // --- inbound: push a peer-lane nudge into the live session ------------------
+    /**
+     * Emit a `notifications/claude/channel` push. Each `meta` key becomes an
+     * attribute on the `<channel ...>` tag the session sees. Try the SDK's typed
+     * `server.notification()` first; because `notifications/claude/channel` is not
+     * a method the SDK knows, that may fail schema validation, so fall back to
+     * writing the raw JSON-RPC line straight to the transport (proven shape).
+     */
+    async pushToChannel(content, meta) {
+        const merged = { ...meta, source: this.config.lane };
+        const params = { content, meta: merged };
+        try {
+            await this.server.notification({
+                method: "notifications/claude/channel",
+                params,
+            });
+        }
+        catch {
+            if (this.transport) {
+                await this.transport.send({
+                    jsonrpc: "2.0",
+                    method: "notifications/claude/channel",
+                    params,
+                });
+            }
+            else {
+                console.error("[ClaudeChannel] No transport to push notification.");
+            }
+        }
+    }
+    /** Process one raw inbox line: parse, enforce the sender allowlist, push. */
+    async handleInboxLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let content;
+        let meta;
+        try {
+            const obj = JSON.parse(trimmed);
+            content = typeof obj.content === "string" ? obj.content : trimmed;
+            meta = obj.meta && typeof obj.meta === "object" ? obj.meta : {};
+        }
+        catch {
+            // Tolerate a plain-text line (no JSON) — push as-is with empty meta.
+            content = trimmed;
+            meta = {};
+        }
+        // THE GATE: allowlist on the SENDING LANE callsign (meta.from_lane).
+        const fromLane = typeof meta.from_lane === "string" ? meta.from_lane : "";
+        if (this.config.allowedSenders.size > 0 && !this.config.allowedSenders.has(fromLane)) {
+            console.error(`[ClaudeChannel] dropped inbound from disallowed lane '${fromLane || "unknown"}' (allowed: ${[
+                ...this.config.allowedSenders,
+            ].join(",")})`);
+            return;
+        }
+        await this.pushToChannel(content, meta);
+    }
+    /** Tail our own inbox file; push each newly-appended line. */
+    startInboxTailer() {
+        const path = this.config.inboxPath;
+        // Ensure the inbox exists, then start reading only NEW lines from here on.
+        if (!existsSync(path))
+            closeSync(openSync(path, "a"));
+        try {
+            this.offset = statSync(path).size;
+        }
+        catch {
+            this.offset = 0;
+        }
+        const poll = () => {
+            let size;
+            try {
+                size = statSync(path).size;
+            }
+            catch {
+                return; // file vanished mid-flight; try again next tick
+            }
+            if (size < this.offset) {
+                // Truncated/rotated — start over from the top.
+                this.offset = 0;
+                this.buffer = "";
+            }
+            if (size === this.offset)
+                return;
+            const fd = openSync(path, "r");
+            try {
+                const len = size - this.offset;
+                const buf = Buffer.alloc(len);
+                const read = readSync(fd, buf, 0, len, this.offset);
+                this.offset += read;
+                this.buffer += buf.toString("utf8", 0, read);
+            }
+            finally {
+                closeSync(fd);
+            }
+            let nl;
+            while ((nl = this.buffer.indexOf("\n")) !== -1) {
+                const line = this.buffer.slice(0, nl);
+                this.buffer = this.buffer.slice(nl + 1);
+                void this.handleInboxLine(line);
+            }
+        };
+        this.pollTimer = setInterval(poll, 500);
+        console.error(`[ClaudeChannel] lane '${this.config.lane}' tailing inbox ${path}` +
+            (this.config.allowedSenders.size > 0
+                ? ` — allowed senders: ${[...this.config.allowedSenders].join(",")}`
+                : " — WARNING: no LANE_ALLOWED_SENDERS set, accepting any sender"));
+    }
+    // --- outbound: nudge another lane ------------------------------------------
+    async sendToLane(args) {
+        const validated = SendToLaneArgsSchema.parse(args);
+        const targetPath = inboxPathFor(this.config.inboxDir, validated.target);
+        // Stamp provenance: from_lane is OURS (the gate on the receiving side keys on
+        // this), to_lane is the target. Caller-supplied meta wins for everything else.
+        const meta = {
+            to_lane: validated.target,
+            ...(validated.meta || {}),
+            from_lane: this.config.lane,
+        };
+        const record = JSON.stringify({ content: validated.text, meta });
+        try {
+            const fd = openSync(targetPath, "a");
+            try {
+                writeSync(fd, record + "\n");
+            }
+            finally {
+                closeSync(fd);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ ok: true, delivered_to: validated.target, inbox: targetPath, from_lane: this.config.lane }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error delivering to lane '${validated.target}': ${err?.message || err}` }],
+                isError: true,
+            };
+        }
+    }
+    // --- handlers ---------------------------------------------------------------
+    setupHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            const tools = [
+                {
+                    name: "send_to_lane",
+                    description: "Nudge ANOTHER lane's Claude Code session via the side door — the session→session handoff. Send a SHORT doorbell ('you're next — round R<n>, baton at <path>, check the Board'), NOT the payload: the SQLite Lane Board is the source of truth, the receiving lane reads the real baton from there. Carry routing in meta (round_id, stage, baton_path, to_lane). from_lane is stamped automatically for the receiver's allowlist.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            target: {
+                                type: "string",
+                                description: "Callsign of the lane to nudge (e.g., bravo, arch, test)",
+                            },
+                            text: {
+                                type: "string",
+                                description: "The nudge — a short doorbell pointing at the Board, not the baton payload",
+                            },
+                            meta: {
+                                type: "object",
+                                description: "Structured routing: round_id, stage, baton_path, to_lane. from_lane is added automatically.",
+                            },
+                        },
+                        required: ["target", "text"],
+                    },
+                },
+            ];
+            return { tools };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            try {
+                const { name, arguments: args } = request.params;
+                switch (name) {
+                    case "send_to_lane":
+                        return await this.sendToLane(args);
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+            }
+        });
+    }
+    // --- boot -------------------------------------------------------------------
+    async run() {
+        this.transport = new StdioServerTransport();
+        await this.server.connect(this.transport);
+        console.error(`[ClaudeChannel] mcp-claude-channel v${VERSION} running on stdio — lane '${this.config.lane}'`);
+        // Start the tailer AFTER the transport is connected so the first push lands.
+        this.startInboxTailer();
+        const shutdown = () => {
+            if (this.pollTimer)
+                clearInterval(this.pollTimer);
+            process.exit(0);
+        };
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
+    }
+}
+// Boot guard — only run when invoked directly (mirrors mcp-slack).
+const isMain = (() => {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    const self = fileURLToPath(import.meta.url);
+    try {
+        return realpathSync(entry) === realpathSync(self);
+    }
+    catch {
+        return entry === self;
+    }
+})();
+if (isMain) {
+    const server = new ClaudeChannelServer();
+    server.run().catch(console.error);
+}
+export { ClaudeChannelServer };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@chinchillaenterprises/mcp-claude-channel",
+  "version": "0.1.0",
+  "description": "Lane-to-lane Claude Code side-door channel server. Pushes a NUDGE from a peer lane INTO a live Claude Code session via the official Channels notification (notifications/claude/channel) and exposes a send_to_lane tool to nudge the next lane. v1: session↔session only, no Slack. The SQLite Lane Board stays the source of truth; the push is a doorbell, not the payload.",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "mcp-claude-channel": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepare": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "mcp",
+    "claude-code",
+    "channels",
+    "lane-to-lane",
+    "side-door",
+    "notifications"
+  ],
+  "author": "Chinchilla Enterprises",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.3",
+    "zod": "^3.25.64"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.1",
+    "typescript": "^5.8.3"
+  }
+}