@composer-app/mcp 0.0.1-beta.0 → 0.0.1-beta.2

package/dist/{chunk-UPWB2QWR.js → chunk-SZ67UYAY.js}

@@ -1,6 +1,7 @@
 // src/mcp.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema
@@ -8,12 +9,119 @@ import {
 import { nanoid as nanoid2 } from "nanoid";
 import path3 from "path";
 import os2 from "os";
+import http from "http";
+import { randomUUID } from "crypto";
 
 // src/roomState.ts
 import * as Y3 from "yjs";
 import YProvider from "y-partyserver/provider";
 import WebSocket from "ws";
 
+// ../shared/src/editor-extensions.ts
+import StarterKit from "@tiptap/starter-kit";
+import { Code } from "@tiptap/extension-code";
+import CodeBlock from "@tiptap/extension-code-block";
+import Image from "@tiptap/extension-image";
+import TaskList from "@tiptap/extension-task-list";
+import TaskItem from "@tiptap/extension-task-item";
+import Highlight from "@tiptap/extension-highlight";
+import Subscript from "@tiptap/extension-subscript";
+import Superscript from "@tiptap/extension-superscript";
+import { Table } from "@tiptap/extension-table";
+import { TableRow } from "@tiptap/extension-table-row";
+import { TableCell } from "@tiptap/extension-table-cell";
+import { TableHeader } from "@tiptap/extension-table-header";
+var CodeWithCombinableMarks = Code.extend({ excludes: "" });
+var FrontmatterSchema = CodeBlock.extend({
+  name: "frontmatter",
+  addInputRules() {
+    return [];
+  },
+  renderMarkdown: (node) => {
+    const text = (node.content ?? []).map((child) => child.text ?? "").join("").trim();
+    if (!text) return "";
+    return `---
+${text}
+---`;
+  }
+});
+function buildEditorExtensions(opts = {}) {
+  const table = opts.table ?? Table;
+  const frontmatter = opts.frontmatter ?? FrontmatterSchema;
+  return [
+    StarterKit.configure({
+      undoRedo: false,
+      code: false,
+      link: {
+        openOnClick: true,
+        HTMLAttributes: { target: "_blank", rel: "noopener noreferrer" },
+        shouldAutoLink: (url) => /^https?:\/\/\S+$/i.test(url)
+      }
+    }),
+    CodeWithCombinableMarks,
+    Image,
+    TaskList,
+    TaskItem.configure({ nested: true }),
+    Highlight,
+    Subscript,
+    Superscript,
+    table.configure({ resizable: false }),
+    TableRow,
+    TableCell,
+    TableHeader,
+    frontmatter
+  ];
+}
+var editorExtensions = buildEditorExtensions();
+
+// ../shared/src/frontmatter.ts
+function extractFrontmatter(text) {
+  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) return null;
+  return { yaml: match[1].trim(), body: match[2] };
+}
+
+// ../shared/src/markdown.ts
+import { getSchema } from "@tiptap/core";
+import { MarkdownManager } from "@tiptap/markdown";
+import {
+  prosemirrorJSONToYXmlFragment,
+  yXmlFragmentToProsemirrorJSON
+} from "@tiptap/y-tiptap";
+function markdownToDocJSON(markdown, extensions = editorExtensions) {
+  const manager = new MarkdownManager({ extensions });
+  const parsed = manager.parse(markdown);
+  if (parsed && parsed.type === "doc") return parsed;
+  return { type: "doc", content: parsed?.content ?? [] };
+}
+function writeMarkdownToYFragment(fragment, markdown, extensions = editorExtensions) {
+  const doc = fragment.doc;
+  if (!doc) throw new Error("fragment must be attached to a Y.Doc");
+  const fm = extractFrontmatter(markdown);
+  const body = fm ? fm.body : markdown;
+  const schema = getSchema(extensions);
+  const bodyDoc = markdownToDocJSON(body, extensions);
+  const children = [];
+  if (fm) {
+    children.push({
+      type: "frontmatter",
+      attrs: { language: "yaml" },
+      content: fm.yaml ? [{ type: "text", text: fm.yaml }] : void 0
+    });
+  }
+  if (bodyDoc.content) children.push(...bodyDoc.content);
+  const fullDoc = { type: "doc", content: children };
+  doc.transact(() => {
+    prosemirrorJSONToYXmlFragment(schema, fullDoc, fragment);
+  });
+}
+function markdownFromYFragment(fragment, extensions = editorExtensions) {
+  const json = yXmlFragmentToProsemirrorJSON(fragment);
+  if (!json || !json.content || json.content.length === 0) return "";
+  const manager = new MarkdownManager({ extensions });
+  return manager.serialize(json);
+}
+
 // src/docReaders.ts
 import * as Y from "yjs";
 function isXmlElement(node) {
@@ -104,9 +212,7 @@ function renderBlockAsMarkdown(block) {
   return text;
 }
 function serializeDocAsMarkdown(doc) {
-  const blocks = topLevelBlocks(doc);
-  if (blocks.length === 0) return "";
-  return blocks.map(renderBlockAsMarkdown).join("\n\n");
+  return markdownFromYFragment(doc.getXmlFragment("default"));
 }
 
 // src/anchors.ts
@@ -326,8 +432,40 @@ var RoomState = class {
     this.provider.awareness.setLocalStateField("user", {
       name: opts.actingAs,
       color: opts.identity.color,
-      userId: opts.identity.userId
+      userId: opts.identity.userId,
+      isAgent: true
     });
+    this.installAwarenessHeartbeat();
+  }
+  /**
+   * Re-broadcast the MCP's awareness every 15s.
+   *
+   * y-partyserver's provider disables the y-protocols awareness
+   * `_checkInterval` (see `clearInterval(awareness._checkInterval)` in
+   * `y-partyserver/dist/provider/index.js`), so the MCP sends its awareness
+   * exactly once — on connect — and never heartbeats after that. Combined
+   * with Cloudflare Durable Object hibernation (which evicts the server's
+   * in-memory `document.awareness` Map on wake), this means a browser that
+   * connects more than ~60s after the MCP sees an empty awareness dump in
+   * `onConnect` and never learns the agent is there. The user's own
+   * awareness flows the other direction fine (they send on connect, server
+   * broadcasts to the MCP), which is why the failure is asymmetric.
+   *
+   * y-partyserver's provider listens to `awareness.on("change", ...)`, and
+   * y-protocols only fires `change` when the new state is deep-unequal to
+   * the previous one. Re-setting an identical state emits `update` but NOT
+   * `change`, so the provider never sends a wire frame. We bump a throwaway
+   * `_hb` field each tick to guarantee deep-inequality, forcing the change
+   * event and a broadcast. 15s is well under any realistic hibernation gap.
+   */
+  installAwarenessHeartbeat() {
+    const heartbeat = setInterval(() => {
+      const local = this.provider.awareness.getLocalState();
+      if (local !== null) {
+        this.provider.awareness.setLocalState({ ...local, _hb: Date.now() });
+      }
+    }, 15e3);
+    heartbeat.unref?.();
   }
   /**
    * Resolves when the provider has completed its first sync handshake.
@@ -486,19 +624,24 @@ import * as fs from "fs/promises";
 import * as path from "path";
 import { nanoid } from "nanoid";
 var PALETTE = [
-  "#a855f7",
-  "#6366f1",
-  "#ef4444",
-  "#14b8a6",
-  "#f59e0b",
-  "#06b6d4",
-  "#ec4899",
-  "#3b82f6",
-  "#22c55e",
-  "#f97316",
-  "#8b5cf6",
-  "#10b981"
+  "#9333ea",
+  // purple-600
+  "#4f46e5",
+  // indigo-600
+  "#dc2626",
+  // red-600
+  "#db2777",
+  // pink-600
+  "#0f766e",
+  // teal-700
+  "#b45309",
+  // amber-700
+  "#0e7490"
+  // cyan-700
 ];
+function isPaletteColor(value) {
+  return PALETTE.includes(value);
+}
 var FILE_NAME = "user.json";
 var FILE_MODE = 384;
 function pickColor() {
@@ -515,7 +658,18 @@ async function loadOrCreateIdentity(dir) {
     const raw = await fs.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (isValidIdentity(parsed)) {
-      return { userId: parsed.userId, color: parsed.color };
+      if (isPaletteColor(parsed.color)) {
+        return { userId: parsed.userId, color: parsed.color };
+      }
+      const migrated = {
+        userId: parsed.userId,
+        color: pickColor()
+      };
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(filePath, JSON.stringify(migrated, null, 2), {
+        mode: FILE_MODE
+      });
+      return migrated;
     }
   } catch (err) {
     const code = err.code;
@@ -534,50 +688,8 @@ async function loadOrCreateIdentity(dir) {
 }
 
 // src/mdToFragment.ts
-import { marked } from "marked";
-import * as Y4 from "yjs";
 function writeMarkdownToFragment(fragment, markdown) {
-  const doc = fragment.doc;
-  if (!doc) throw new Error("fragment must be attached to a Y.Doc");
-  const tokens = marked.lexer(markdown);
-  doc.transact(() => {
-    for (const token of tokens) {
-      const element = buildElementForToken(token);
-      if (element) fragment.push([element]);
-    }
-  });
-}
-function buildElementForToken(token) {
-  if (token.type === "heading") {
-    const heading = token;
-    return makeBlock("heading", heading.text ?? "", {
-      level: String(heading.depth ?? 1)
-    });
-  }
-  if (token.type === "paragraph") {
-    const paragraph = token;
-    return makeBlock("paragraph", paragraph.text ?? "");
-  }
-  if (token.type === "space") {
-    return null;
-  }
-  const raw = token.raw?.trim();
-  if (!raw) return null;
-  return makeBlock("paragraph", raw);
-}
-function makeBlock(nodeName, text, attrs) {
-  const element = new Y4.XmlElement(nodeName);
-  if (attrs) {
-    for (const [key, value] of Object.entries(attrs)) {
-      element.setAttribute(key, value);
-    }
-  }
-  if (text.length > 0) {
-    const xmlText = new Y4.XmlText();
-    xmlText.insert(0, text);
-    element.insert(0, [xmlText]);
-  }
-  return element;
+  writeMarkdownToYFragment(fragment, markdown);
 }
 
 // src/logger.ts
@@ -959,6 +1071,7 @@ ${resolved.currentSectionText}`
     authorName: state.actingAs,
     authorColor: state.identity.color,
     authorUserId: state.identity.userId,
+    authorIsAgent: true,
     text,
     createdAt: Date.now(),
     resolved: false,
@@ -986,6 +1099,7 @@ function handleReplyComment(args) {
     authorName: state.actingAs,
     authorColor: state.identity.color,
     authorUserId: state.identity.userId,
+    authorIsAgent: true,
     text,
     createdAt: Date.now()
   };
@@ -1044,6 +1158,7 @@ ${resolved.currentSectionText}`
     authorName: state.actingAs,
     authorColor: state.identity.color,
     authorUserId: state.identity.userId,
+    authorIsAgent: true,
     createdAt: Date.now(),
     status: "pending",
     anchorFrom,
@@ -1073,6 +1188,7 @@ function handleReplySuggestion(args) {
     authorName: state.actingAs,
     authorColor: state.identity.color,
     authorUserId: state.identity.userId,
+    authorIsAgent: true,
     text,
     createdAt: Date.now()
   };
@@ -1124,9 +1240,7 @@ async function dispatchTool(name, args) {
       return errorResult(`unknown tool: ${name}`);
   }
 }
-async function startMcpServer() {
-  installCrashHandlers();
-  log("mcp server starting", { pid: process.pid, node: process.version });
+function buildServer() {
   const server = new Server(
     { name: "composer-mcp", version: "0.0.1" },
     { capabilities: { tools: {} } }
@@ -1160,18 +1274,90 @@ async function startMcpServer() {
       return errorResult(message);
     }
   });
+  return server;
+}
+async function startMcpServer() {
+  installCrashHandlers();
+  log("mcp server starting", {
+    pid: process.pid,
+    node: process.version,
+    build: "awareness-heartbeat-v1"
+  });
+  const server = buildServer();
   const transport = new StdioServerTransport();
   await server.connect(transport);
   log("mcp server connected", {
+    transport: "stdio",
     serverHost: SERVER_HOST,
     appBase: APP_BASE,
     logFile: LOG_FILE_PATH,
     pid: process.pid
   });
 }
+async function startMcpHttpServer(opts) {
+  installCrashHandlers();
+  log("mcp http server starting", {
+    port: opts.port,
+    pid: process.pid,
+    node: process.version,
+    build: "awareness-heartbeat-v1"
+  });
+  const server = buildServer();
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID()
+  });
+  await server.connect(transport);
+  const httpServer = http.createServer(async (req, res) => {
+    try {
+      const url = req.url ?? "";
+      if (url === "/mcp" || url.startsWith("/mcp?") || url.startsWith("/mcp/")) {
+        await transport.handleRequest(req, res);
+        return;
+      }
+      if (url === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, serverHost: SERVER_HOST }));
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("composer-mcp: POST /mcp");
+    } catch (err) {
+      logError("http handler error", err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end("internal error");
+      } else {
+        res.end();
+      }
+    }
+  });
+  httpServer.listen(opts.port, "127.0.0.1", () => {
+    const url = `http://127.0.0.1:${opts.port}/mcp`;
+    log("mcp http server listening", {
+      url,
+      serverHost: SERVER_HOST,
+      appBase: APP_BASE,
+      logFile: LOG_FILE_PATH,
+      pid: process.pid
+    });
+    console.error(
+      `composer-mcp http listening on ${url}
+  serverHost=${SERVER_HOST}
+  appBase=${APP_BASE}`
+    );
+  });
+  const shutdown = () => {
+    log("mcp http server shutting down");
+    httpServer.close(() => process.exit(0));
+    setTimeout(() => process.exit(0), 500).unref();
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
 
 export {
   loadOrCreateIdentity,
   logError,
-  startMcpServer
+  startMcpServer,
+  startMcpHttpServer
 };

package/dist/cli.js

@@ -2,8 +2,9 @@
 import {
   loadOrCreateIdentity,
   logError,
+  startMcpHttpServer,
   startMcpServer
-} from "./chunk-UPWB2QWR.js";
+} from "./chunk-SZ67UYAY.js";
 
 // src/cli.ts
 import { execFile } from "child_process";
@@ -13,13 +14,36 @@ import path from "path";
 import os from "os";
 import { fileURLToPath } from "url";
 var exec = promisify(execFile);
+var DEFAULT_HTTP_PORT = 3456;
+function resolveHttpPort() {
+  const argv = process.argv.slice(3);
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--port=")) {
+      const n = Number(arg.slice("--port=".length));
+      if (Number.isFinite(n) && n > 0) return n;
+    } else if (arg === "--port" && argv[i + 1]) {
+      const n = Number(argv[i + 1]);
+      if (Number.isFinite(n) && n > 0) return n;
+    }
+  }
+  const envPort = process.env.COMPOSER_MCP_PORT;
+  if (envPort) {
+    const n = Number(envPort);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return DEFAULT_HTTP_PORT;
+}
 async function main() {
   const cmd = process.argv[2];
   if (cmd === "mcp") return startMcpServer();
+  if (cmd === "http") return startMcpHttpServer({ port: resolveHttpPort() });
   if (cmd === "setup") return setup();
   console.log(`composer-mcp
   setup   Register the MCP server with your agent
-  mcp     Run as an MCP server (invoked by the host CLI)`);
+  mcp     Run as an MCP server over stdio (invoked by the host CLI)
+  http    Run as an MCP server over HTTP (for local dev + HMR)
+          flags: --port N  (or COMPOSER_MCP_PORT env; default ${DEFAULT_HTTP_PORT})`);
 }
 async function setup() {
   const dir = path.join(os.homedir(), ".composer-mcp");

package/dist/mcp.js

@@ -1,6 +1,8 @@
 import {
+  startMcpHttpServer,
   startMcpServer
-} from "./chunk-UPWB2QWR.js";
+} from "./chunk-SZ67UYAY.js";
 export {
+  startMcpHttpServer,
   startMcpServer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@composer-app/mcp",
-  "version": "0.0.1-beta.0",
+  "version": "0.0.1-beta.2",
   "description": "Composer MCP",
   "license": "MIT",
   "author": "Josh Philpott",
@@ -27,13 +27,31 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/cli.ts src/mcp.ts --format esm --target node20 --out-dir dist --clean",
-    "dev": "tsup src/cli.ts src/mcp.ts --format esm --target node20 --out-dir dist --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start:local": "tsx --env-file=.env.local src/cli.ts mcp",
+    "start:prod": "tsx --env-file=.env.production src/cli.ts mcp",
+    "typecheck": "tsc --noEmit -p .",
     "test": "vitest run"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "marked": "^14.1.0",
+    "@tiptap/core": "^3.22.0",
+    "@tiptap/extension-code": "^3.22.0",
+    "@tiptap/extension-code-block": "^3.22.0",
+    "@tiptap/extension-highlight": "^3.22.0",
+    "@tiptap/extension-image": "^3.22.0",
+    "@tiptap/extension-subscript": "^3.22.0",
+    "@tiptap/extension-superscript": "^3.22.0",
+    "@tiptap/extension-table": "^3.22.0",
+    "@tiptap/extension-table-cell": "^3.22.0",
+    "@tiptap/extension-table-header": "^3.22.0",
+    "@tiptap/extension-table-row": "^3.22.0",
+    "@tiptap/extension-task-item": "^3.22.0",
+    "@tiptap/extension-task-list": "^3.22.0",
+    "@tiptap/markdown": "^3.22.1",
+    "@tiptap/starter-kit": "^3.22.0",
+    "@tiptap/y-tiptap": "^3.0.2",
     "nanoid": "^5.1.7",
     "partysocket": "^1.1.16",
     "ws": "^8.20.0",
@@ -44,6 +62,7 @@
     "@types/node": "^24.12.0",
     "@types/ws": "^8.18.1",
     "tsup": "^8.3.0",
+    "tsx": "^4.21.0",
     "typescript": "~5.9.3",
     "vitest": "^4.1.3"
   }