7e1e81c1

feat(mcp): emit notifications/claude/channel via direct JSON-RPC

a73x 2026-04-29 05:58

Commit message

feat(mcp): emit notifications/claude/channel via direct JSON-RPC

internal/mcp/mcp.go

@@ @@ -0,0 +1,116 @@ @@
+package mcp
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"os"
+	"sync"
+)
+// ChannelMeta is the meta block of a notifications/claude/channel notification.
+// All fields are strings: Claude Code's schema is Record<string, string> and
+// silently drops non-string values.
+type ChannelMeta struct {
+	Source  string `json:"source"`
+	File    string `json:"file"`
+	Line    string `json:"line"`
+	ReplyTo string `json:"replyTo"`
+}
+type Server struct {
+	in  io.Reader
+	out io.Writer
+	mu  sync.Mutex // serializes writes to out
+}
+func New() *Server {
+	return &Server{in: os.Stdin, out: os.Stdout}
+}
+// NewWithIO is for tests.
+func NewWithIO(in io.Reader, out io.Writer) *Server {
+	return &Server{in: in, out: out}
+}
+func (s *Server) SendChannel(ctx context.Context, meta ChannelMeta, content string) error {
+	frame := map[string]any{
+		"jsonrpc": "2.0",
+		"method":  "notifications/claude/channel",
+		"params": map[string]any{
+			"content": content,
+			"meta": map[string]any{
+				"source":  meta.Source,
+				"file":    meta.File,
+				"line":    meta.Line,
+				"replyTo": meta.ReplyTo,
+			},
+		},
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return json.NewEncoder(s.out).Encode(frame)
+}
+// Run drives the JSON-RPC request loop. Reads requests on s.in; responds to
+// initialize with the required experimental.claude/channel capability; replies
+// with method-not-found for any other request. Notifications (no id) are
+// ignored. Returns nil on EOF or context cancellation.
+func (s *Server) Run(ctx context.Context) error {
+	dec := json.NewDecoder(s.in)
+	for {
+		if ctx.Err() != nil {
+			return nil
+		}
+		var req map[string]any
+		if err := dec.Decode(&req); err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+		method, _ := req["method"].(string)
+		id := req["id"]
+		if id == nil {
+			continue // notification, ignore
+		}
+		switch method {
+		case "initialize":
+			params, _ := req["params"].(map[string]any)
+			protoVer, _ := params["protocolVersion"].(string)
+			if protoVer == "" {
+				protoVer = "2024-11-05"
+			}
+			s.writeResult(id, map[string]any{
+				"protocolVersion": protoVer,
+				"capabilities": map[string]any{
+					"experimental": map[string]any{
+						"claude/channel": map[string]any{},
+					},
+				},
+				"serverInfo": map[string]any{
+					"name":    "filewatch-mcp",
+					"version": "0.1.0",
+				},
+			})
+		default:
+			s.writeError(id, -32601, "method not found")
+		}
+	}
+}
+func (s *Server) writeResult(id, result any) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	_ = json.NewEncoder(s.out).Encode(map[string]any{
+		"jsonrpc": "2.0", "id": id, "result": result,
+	})
+}
+func (s *Server) writeError(id any, code int, msg string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	_ = json.NewEncoder(s.out).Encode(map[string]any{
+		"jsonrpc": "2.0", "id": id, "error": map[string]any{"code": code, "message": msg},
+	})
+}

internal/mcp/mcp_test.go

@@ @@ -0,0 +1,74 @@ @@
+package mcp
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+)
+func TestSendChannelEmitsCorrectFrame(t *testing.T) {
+	var buf bytes.Buffer
+	s := NewWithIO(strings.NewReader(""), &buf)
+	err := s.SendChannel(context.Background(), ChannelMeta{
+		Source:  "filewatch",
+		File:    "src/foo.ts",
+		Line:    "42",
+		ReplyTo: "fw-a1b2c3d4",
+	}, "@claude write a test for foo")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var frame map[string]any
+	if err := json.NewDecoder(&buf).Decode(&frame); err != nil {
+		t.Fatal(err)
+	}
+	if frame["jsonrpc"] != "2.0" {
+		t.Errorf("jsonrpc = %v, want 2.0", frame["jsonrpc"])
+	}
+	if frame["method"] != "notifications/claude/channel" {
+		t.Errorf("method = %v, want notifications/claude/channel", frame["method"])
+	}
+	params := frame["params"].(map[string]any)
+	if params["content"] != "@claude write a test for foo" {
+		t.Errorf("content = %v", params["content"])
+	}
+	meta := params["meta"].(map[string]any)
+	if meta["source"] != "filewatch" || meta["file"] != "src/foo.ts" || meta["replyTo"] != "fw-a1b2c3d4" {
+		t.Errorf("meta wrong: %#v", meta)
+	}
+	// line MUST be a string — Claude Code's schema is Record<string, string> and
+	// silently rejects non-string values.
+	if s, ok := meta["line"].(string); !ok || s != "42" {
+		t.Errorf("line = %v (%T), want \"42\" (string)", meta["line"], meta["line"])
+	}
+}
+func TestInitializeAdvertisesChannelCapability(t *testing.T) {
+	in := strings.NewReader(`{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"test","version":"0"}}}` + "\n")
+	var out bytes.Buffer
+	s := NewWithIO(in, &out)
+	if err := s.Run(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	var resp map[string]any
+	if err := json.NewDecoder(&out).Decode(&resp); err != nil {
+		t.Fatalf("decode: %v\nstdout was: %s", err, out.String())
+	}
+	if resp["id"] != float64(1) {
+		t.Errorf("id = %v", resp["id"])
+	}
+	result, ok := resp["result"].(map[string]any)
+	if !ok {
+		t.Fatalf("no result: %#v", resp)
+	}
+	if result["protocolVersion"] != "2025-11-25" {
+		t.Errorf("protocolVersion echo wrong: %v", result["protocolVersion"])
+	}
+	caps, _ := result["capabilities"].(map[string]any)
+	exp, _ := caps["experimental"].(map[string]any)
+	if _, has := exp["claude/channel"]; !has {
+		t.Errorf("missing experimental.claude/channel capability: %#v", caps)
+	}
+}