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

package/dist/{chunk-UPWB2QWR.js → chunk-PQWVQMLP.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,6 +9,8 @@ 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";
@@ -15,6 +18,7 @@ import YProvider from "y-partyserver/provider";
 import WebSocket from "ws";
 
 // src/docReaders.ts
+import { markdownFromYFragment } from "@composer-app/shared";
 import * as Y from "yjs";
 function isXmlElement(node) {
   return node instanceof Y.XmlElement;
@@ -104,9 +108,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
@@ -289,6 +291,64 @@ function resolveServerAnchor(doc, spec) {
   };
 }
 
+// src/logger.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var COMPOSER_DIR = process.env.COMPOSER_CONFIG_DIR ?? path.join(os.homedir(), ".composer");
+var LOG_FILE = process.env.COMPOSER_LOG_FILE ?? path.join(COMPOSER_DIR, "mcp.log");
+var ensured = false;
+function ensureDir() {
+  if (ensured) return;
+  try {
+    fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+    ensured = true;
+  } catch {
+  }
+}
+function write(line) {
+  ensureDir();
+  try {
+    fs.appendFileSync(LOG_FILE, line);
+  } catch {
+  }
+  try {
+    process.stderr.write(line);
+  } catch {
+  }
+}
+function log(message, meta) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+  write(`${ts} [composer-mcp] ${message}${metaStr}
+`);
+}
+function logError(message, err) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const detail = err instanceof Error ? `${err.name}: ${err.message}
+${err.stack ?? ""}` : typeof err === "string" ? err : JSON.stringify(err);
+  write(`${ts} [composer-mcp] ERROR ${message}
+${detail}
+`);
+}
+var crashHandlersInstalled = false;
+function installCrashHandlers() {
+  if (crashHandlersInstalled) return;
+  crashHandlersInstalled = true;
+  process.on("uncaughtException", (err) => {
+    logError("uncaughtException", err);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logError("unhandledRejection", reason);
+    process.exit(1);
+  });
+  process.on("exit", (code) => {
+    log("process exit", { code });
+  });
+}
+var LOG_FILE_PATH = LOG_FILE;
+
 // src/roomState.ts
 var RoomState = class {
   doc = new Y3.Doc();
@@ -326,8 +386,74 @@ 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();
+    this.installAwarenessDiagnostics();
+  }
+  /**
+   * 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.
+   *
+   * Calling `setLocalState(getLocalState())` forces an awareness `update`
+   * event, which the provider's handler broadcasts as a normal awareness
+   * frame. 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);
+      }
+    }, 15e3);
+    heartbeat.unref?.();
+  }
+  /**
+   * Diagnostic: prove whether our own awareness state is set locally and
+   * whether the server echoes peer states back to us. Logs four snapshots
+   * over the first 30s of a room's life, then stops. Remove once the
+   * "agent avatar not visible" bug is root-caused.
+   */
+  installAwarenessDiagnostics() {
+    const snapshot = (label) => {
+      const ws = this.provider.ws;
+      const entries = Array.from(this.provider.awareness.getStates().entries());
+      log("awareness-diag", {
+        roomId: this.roomId,
+        label,
+        wsReadyState: ws?.readyState ?? null,
+        synced: this.provider.synced,
+        localClientId: this.doc.clientID,
+        localState: this.provider.awareness.getLocalState(),
+        peerCount: entries.length,
+        peers: entries.map(([clientId, state]) => ({
+          clientId,
+          user: state?.user ?? null
+        }))
+      });
+    };
+    snapshot("t+0 (post-setLocalState)");
+    setTimeout(() => snapshot("t+2s"), 2e3);
+    setTimeout(() => snapshot("t+10s"), 1e4);
+    setTimeout(() => snapshot("t+30s"), 3e4);
+    let tick = 1;
+    const interval = setInterval(() => {
+      snapshot(`t+${tick}min`);
+      tick += 1;
+      if (tick > 10) clearInterval(interval);
+    }, 6e4);
+    interval.unref?.();
   }
   /**
    * Resolves when the provider has completed its first sync handshake.
@@ -482,8 +608,8 @@ function hashState(doc) {
 }
 
 // src/identity.ts
-import * as fs from "fs/promises";
-import * as path from "path";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
 import { nanoid } from "nanoid";
 var PALETTE = [
   "#a855f7",
@@ -510,9 +636,9 @@ function isValidIdentity(value) {
   return typeof v.userId === "string" && typeof v.color === "string";
 }
 async function loadOrCreateIdentity(dir) {
-  const filePath = path.join(dir, FILE_NAME);
+  const filePath = path2.join(dir, FILE_NAME);
   try {
-    const raw = await fs.readFile(filePath, "utf8");
+    const raw = await fs2.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (isValidIdentity(parsed)) {
       return { userId: parsed.userId, color: parsed.color };
@@ -526,118 +652,19 @@ async function loadOrCreateIdentity(dir) {
     userId: nanoid(),
     color: pickColor()
   };
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(filePath, JSON.stringify(identity, null, 2), {
+  await fs2.mkdir(dir, { recursive: true });
+  await fs2.writeFile(filePath, JSON.stringify(identity, null, 2), {
     mode: FILE_MODE
   });
   return identity;
 }
 
 // src/mdToFragment.ts
-import { marked } from "marked";
-import * as Y4 from "yjs";
+import { writeMarkdownToYFragment } from "@composer-app/shared";
 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
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os from "os";
-var COMPOSER_DIR = process.env.COMPOSER_CONFIG_DIR ?? path2.join(os.homedir(), ".composer");
-var LOG_FILE = process.env.COMPOSER_LOG_FILE ?? path2.join(COMPOSER_DIR, "mcp.log");
-var ensured = false;
-function ensureDir() {
-  if (ensured) return;
-  try {
-    fs2.mkdirSync(path2.dirname(LOG_FILE), { recursive: true });
-    ensured = true;
-  } catch {
-  }
-}
-function write(line) {
-  ensureDir();
-  try {
-    fs2.appendFileSync(LOG_FILE, line);
-  } catch {
-  }
-  try {
-    process.stderr.write(line);
-  } catch {
-  }
-}
-function log(message, meta) {
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
-  write(`${ts} [composer-mcp] ${message}${metaStr}
-`);
-}
-function logError(message, err) {
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  const detail = err instanceof Error ? `${err.name}: ${err.message}
-${err.stack ?? ""}` : typeof err === "string" ? err : JSON.stringify(err);
-  write(`${ts} [composer-mcp] ERROR ${message}
-${detail}
-`);
-}
-var crashHandlersInstalled = false;
-function installCrashHandlers() {
-  if (crashHandlersInstalled) return;
-  crashHandlersInstalled = true;
-  process.on("uncaughtException", (err) => {
-    logError("uncaughtException", err);
-    process.exit(1);
-  });
-  process.on("unhandledRejection", (reason) => {
-    logError("unhandledRejection", reason);
-    process.exit(1);
-  });
-  process.on("exit", (code) => {
-    log("process exit", { code });
-  });
-}
-var LOG_FILE_PATH = LOG_FILE;
-
 // src/mcp.ts
 var COMPOSER_DIR2 = process.env.COMPOSER_CONFIG_DIR ?? path3.join(os2.homedir(), ".composer");
 var SERVER_HOST = process.env.COMPOSER_SERVER_HOST ?? "usecomposer.app";
@@ -1124,9 +1151,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 +1185,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
+  loadOrCreateIdentity,
+  startMcpServer,
+  startMcpHttpServer
 };

package/dist/cli.js

@@ -2,8 +2,9 @@
 import {
   loadOrCreateIdentity,
   logError,
+  startMcpHttpServer,
   startMcpServer
-} from "./chunk-UPWB2QWR.js";
+} from "./chunk-PQWVQMLP.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-PQWVQMLP.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.1",
   "description": "Composer MCP",
   "license": "MIT",
   "author": "Josh Philpott",
@@ -29,11 +29,14 @@
   "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",
+    "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": {
+    "@composer-app/shared": "*",
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "marked": "^14.1.0",
     "nanoid": "^5.1.7",
     "partysocket": "^1.1.16",
     "ws": "^8.20.0",
@@ -44,6 +47,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"
   }