@composer-app/mcp 0.0.1-beta.7 → 0.0.3

package/dist/{chunk-EJUJPBX2.js → chunk-GPFWLOYB.js}

@@ -4534,6 +4534,24 @@ function resolveServerAnchor(doc, spec) {
 }
 
 // src/roomState.ts
+var HAD_UPGRADE_403 = /* @__PURE__ */ Symbol("composer.upgrade403");
+var TerminalDetectingWS = class extends WebSocket {
+  constructor(...args) {
+    super(...args);
+    this.on("unexpected-response", (_req, res) => {
+      if (res.statusCode === 403) {
+        this[HAD_UPGRADE_403] = true;
+      }
+    });
+  }
+};
+var TERMINAL_CLOSE_CODES = /* @__PURE__ */ new Set([4403, 4410]);
+var MAX_CONSECUTIVE_FAILURES = 15;
+function reconnectDelayMs(failuresSoFar) {
+  if (failuresSoFar <= 5) return 1e4;
+  if (failuresSoFar <= 10) return 3e4;
+  return 6e4;
+}
 var RoomState = class _RoomState {
   doc;
   actingAs;
@@ -4569,10 +4587,37 @@ var RoomState = class _RoomState {
   /**
    * Set true when `composer_next_event`'s goodbye branch has fired. Tells
    * `handleNextEvent` to refuse subsequent calls until the user explicitly
-   * re-engages (which happens via `composer_create_room` / `composer_join_room`,
-   * both of which build a fresh `RoomState` so this flag resets naturally).
+   * re-engages via `composer_create_room` / `composer_join_room` — both of
+   * which clear the latch (create builds a fresh RoomState; rejoin reuses
+   * the cached one and calls `clearGoodbye()`).
    */
   goodbyeIssued = false;
+  /**
+   * Set when the connection enters a terminal state — either the server
+   * explicitly rejected (HTTP 403 / close code 4403 / 4410) or the client
+   * circuit breaker tripped after too many consecutive failures. Once set,
+   * `ensureConnected` / `waitForInitialSync` reject immediately and tool
+   * calls surface a clear error rather than the host silently hanging.
+   */
+  terminalReject = null;
+  /**
+   * Listeners that fire when terminal state is signalled. Used to unblock
+   * pending `waitForInitialSync` promises so the host doesn't hang for the
+   * full 15s timeout after a kick.
+   */
+  terminalRejectListeners = /* @__PURE__ */ new Set();
+  /**
+   * Counter for consecutive failed reconnects. Reset to 0 on a successful
+   * `connected` status event. Per the design, does NOT reset on idle
+   * disconnects — only on a real successful open.
+   */
+  consecutiveFailures = 0;
+  /**
+   * Pending manually-scheduled reconnect timer (we replace y-partyserver's
+   * default exponential backoff with the tiered schedule from the design).
+   * Cleared on destroy and on each new close event.
+   */
+  scheduledReconnect = null;
   constructor(opts) {
     this.roomId = opts.roomId;
     this.actingAs = opts.actingAs;
@@ -4590,7 +4635,56 @@ var RoomState = class _RoomState {
       this.provider = new YProvider(opts.serverHost, opts.roomId, this.doc, {
         party: "composer-room",
         connect: false,
-        WebSocketPolyfill: WebSocket
+        WebSocketPolyfill: TerminalDetectingWS
+      });
+    }
+    if (!opts._providerForTest) {
+      this.provider.on(
+        "connection-close",
+        (...args) => {
+          const event = args[0];
+          if (this.terminalReject) return;
+          if (!this.provider.shouldConnect) {
+            return;
+          }
+          const ws = this.provider.ws;
+          const had403 = ws ? !!ws[HAD_UPGRADE_403] : false;
+          if (had403 || TERMINAL_CLOSE_CODES.has(event.code)) {
+            this.signalTerminalReject({
+              kind: "rejected",
+              code: had403 ? 403 : event.code,
+              reason: had403 ? "server refused upgrade (HTTP 403). composer-mcp may be out of date or this client is blocked. Update composer-mcp or contact the room owner." : event.code === 4410 ? `server has killed this client version. ${event.reason || "Please update composer-mcp."}` : `server kicked this client (close code ${event.code}). ${event.reason || "Please update composer-mcp."}`
+            });
+            return;
+          }
+          this.consecutiveFailures++;
+          if (this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+            this.signalTerminalReject({
+              kind: "aborted",
+              failures: this.consecutiveFailures
+            });
+            return;
+          }
+          this.provider.shouldConnect = false;
+          if (this.scheduledReconnect) clearTimeout(this.scheduledReconnect);
+          const delay = reconnectDelayMs(this.consecutiveFailures);
+          this.scheduledReconnect = setTimeout(() => {
+            this.scheduledReconnect = null;
+            if (this.terminalReject) return;
+            this.provider.connect?.()?.catch?.((err) => {
+              console.error(
+                `[composer-mcp] reconnect attempt ${this.consecutiveFailures} failed: ${err}`
+              );
+            });
+          }, delay);
+          this.scheduledReconnect.unref?.();
+        }
+      );
+      this.provider.on("status", (...args) => {
+        const status = args[0];
+        if (status.status === "connected") {
+          this.consecutiveFailures = 0;
+        }
       });
     }
   }
@@ -4618,6 +4712,51 @@ var RoomState = class _RoomState {
       _docForTest: doc
     });
   }
+  signalTerminalReject(rej) {
+    if (this.terminalReject) return;
+    this.terminalReject = rej;
+    if (this.scheduledReconnect) {
+      clearTimeout(this.scheduledReconnect);
+      this.scheduledReconnect = null;
+    }
+    const listeners = [...this.terminalRejectListeners];
+    this.terminalRejectListeners.clear();
+    for (const fn of listeners) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+    this.provider.destroy();
+  }
+  terminalRejectError() {
+    const rej = this.terminalReject;
+    if (!rej) {
+      return new Error(
+        `[composer-mcp] room "${this.roomId}" entered terminal state (unknown).`
+      );
+    }
+    if (rej.kind === "aborted") {
+      return new Error(
+        `[composer-mcp] connection to room "${this.roomId}" aborted after ${rej.failures} failed reconnect attempts. Run composer_join_room to retry.`
+      );
+    }
+    return new Error(
+      `[composer-mcp] room "${this.roomId}" rejected by server: ${rej.reason}`
+    );
+  }
+  /** Test/diagnostic accessor — not part of the stable surface. */
+  get isTerminallyRejected() {
+    return this.terminalReject !== null;
+  }
+  /** Test/diagnostic accessor — not part of the stable surface. */
+  get terminalRejectKind() {
+    return this.terminalReject?.kind ?? null;
+  }
+  /** Test/diagnostic accessor — not part of the stable surface. */
+  get failureCount() {
+    return this.consecutiveFailures;
+  }
   /** Test-only accessor for the underlying awareness instance. */
   get awarenessForTest() {
     return this.provider.awareness;
@@ -4629,6 +4768,7 @@ var RoomState = class _RoomState {
    * of hanging the MCP tool call indefinitely.
    */
   async waitForInitialSync(timeoutMs = 15e3) {
+    if (this.terminalReject) throw this.terminalRejectError();
     if (this.provider.synced) return;
     if (!this.provider.on || !this.provider.off) return;
     const provider = this.provider;
@@ -4638,12 +4778,20 @@ var RoomState = class _RoomState {
       const onSync = (...args) => {
         const synced = args[0];
         if (!synced) return;
+        cleanup();
+        resolve();
+      };
+      const onTerminal = () => {
+        cleanup();
+        reject(this.terminalRejectError());
+      };
+      const cleanup = () => {
         clearTimeout(timer);
         offSub("sync", onSync);
-        resolve();
+        this.terminalRejectListeners.delete(onTerminal);
       };
       const timer = setTimeout(() => {
-        offSub("sync", onSync);
+        cleanup();
         reject(
           new Error(
             `timed out after ${timeoutMs}ms waiting for sync handshake on room "${this.roomId}"`
@@ -4651,6 +4799,7 @@ var RoomState = class _RoomState {
         );
       }, timeoutMs);
       onSub("sync", onSync);
+      this.terminalRejectListeners.add(onTerminal);
     });
   }
   idleDisconnectTimer = null;
@@ -4661,6 +4810,7 @@ var RoomState = class _RoomState {
    * disconnect because we're back in active use.
    */
   async ensureConnected(timeoutMs = 15e3) {
+    if (this.terminalReject) throw this.terminalRejectError();
     if (this.idleDisconnectTimer) {
       clearTimeout(this.idleDisconnectTimer);
       this.idleDisconnectTimer = null;
@@ -4694,7 +4844,7 @@ var RoomState = class _RoomState {
     this.idleDisconnectTimer = setTimeout(() => {
       this.idleDisconnectTimer = null;
       this.setMonitoring(false);
-      this.provider.disconnect?.();
+      this.disconnect();
     }, ms);
     this.idleDisconnectTimer.unref?.();
   }
@@ -4702,13 +4852,18 @@ var RoomState = class _RoomState {
    * Close the socket immediately. Available for explicit teardown
    * (e.g., destroy()). Does not touch monitoring state — the socket close
    * causes y-partyserver to broadcast the awareness removal, which is the
-   * visual signal peers care about.
+   * visual signal peers care about. Clears any pending circuit-breaker
+   * reconnect so the user's intent to disconnect isn't silently undone.
    */
   disconnect() {
     if (this.idleDisconnectTimer) {
       clearTimeout(this.idleDisconnectTimer);
       this.idleDisconnectTimer = null;
     }
+    if (this.scheduledReconnect) {
+      clearTimeout(this.scheduledReconnect);
+      this.scheduledReconnect = null;
+    }
     this.provider.disconnect?.();
   }
   /**
@@ -4717,9 +4872,9 @@ var RoomState = class _RoomState {
    * socket must already be open (caller should have ensured this).
    *
    *   setMonitoring(true)  — called once on first composer_next_event entry.
-   *   setMonitoring(false) — called on the goodbye branch; clears awareness
-   *                          immediately so the avatar disappears as the
-   *                          farewell lands.
+   *   setMonitoring(false) — called on the silent-exit branch; clears
+   *                          awareness immediately so the avatar disappears
+   *                          as the agent leaves.
    *
    * Subsequent calls with the same value are no-ops.
    */
@@ -4754,6 +4909,15 @@ var RoomState = class _RoomState {
   markGoodbyeIssued() {
     this.goodbyeIssued = true;
   }
+  /**
+   * Reset the goodbye latch on rejoin. `composer_join_room` reuses the
+   * cached RoomState when one is still in the rooms map, so without this
+   * the latch would remain set and the next `composer_next_event` would
+   * be refused — even though the user explicitly asked to re-engage.
+   */
+  clearGoodbye() {
+    this.goodbyeIssued = false;
+  }
   get hasIssuedGoodbye() {
     return this.goodbyeIssued;
   }
@@ -4822,6 +4986,11 @@ var RoomState = class _RoomState {
       clearTimeout(this.idleDisconnectTimer);
       this.idleDisconnectTimer = null;
     }
+    if (this.scheduledReconnect) {
+      clearTimeout(this.scheduledReconnect);
+      this.scheduledReconnect = null;
+    }
+    this.terminalRejectListeners.clear();
     this.provider.destroy();
     this.doc.destroy();
   }
@@ -5269,15 +5438,18 @@ async function resolveActingAs(actingAsArg) {
   if (!actingAsArg) {
     throw new Error(
       [
-        "First Composer room on this machine \u2014 you need a persistent name before proceeding. STOP and ask the user what to call you.",
+        "First Composer room on this machine \u2014 orient the user, then ask what to call you. STOP and output ONE short message before retrying.",
         "",
-        "Offer ONE suggested default they can accept with a tap:",
-        `  - If you know the user's first name from conversation context, suggest "<FirstName>'s Agent" (e.g. "Josh's Agent").`,
-        "  - Otherwise pick something playful from outside the model-family space (e.g. Monty, Gerty, Rosie, Otto, Pip). Do NOT suggest Claude / Gemini / GPT / Sonnet / Opus / Haiku / other model names.",
+        "The message should cover four things, in order:",
+        '  1. GREET \u2014 open with "Welcome to Composer!"',
+        '  2. WHAT COMPOSER IS \u2014 "Composer is a real-time markdown editor for humans and agents."',
+        '  3. WHAT YOU CAN DO IN IT \u2014 "I can join your docs with you, respond to comments, and post inline suggestions."',
+        "  4. ASK FOR A NAME \u2014 suggest ONE default they can accept in a single word.",
+        `     - If you know the user's first name from conversation context, suggest "<FirstName>'s Agent" (e.g. "Josh's Agent").`,
+        "     - Otherwise pick something playful from outside the model-family space (e.g. Monty, Gerty, Rosie, Otto, Pip). Do NOT suggest Claude / Gemini / GPT / Sonnet / Opus / Haiku / other model names.",
+        `     - Phrase it as a check, e.g. "I'll go by <suggested name> in the doc if that's okay with you?"`,
         "",
-        `Phrase it like: "I'll go by <suggested name> in Composer docs \u2014 sound good, or pick your own?"`,
-        "",
-        "Retry with their answer as `actingAs`. It persists to ~/.composer/user.json and is reused for every future room on this machine, so only ask once."
+        "Retry the call with their answer as `actingAs`. The name persists to ~/.composer/user.json and is reused for every future room on this machine, so this orientation only happens once per machine."
       ].join("\n")
     );
   }
@@ -5351,7 +5523,7 @@ var TOOL_DEFS = [
   },
   {
     name: "composer_next_event",
-    description: "Block for up to `timeoutSec` (default 30s) waiting for a remote event. Returns `{ kind: 'mention' | 'timeout', ... }`. **The monitor loop is always-on** \u2014 every return carries a directive you must follow without waiting for user input. On `mention`, the `reason` is one of: `direct_mention` (sidecar or text named you \u2014 always reply), `active_thread` (plain reply on a thread you're already in \u2014 reply if the content invites one), or `solo_room` (you're alone with one human who didn't explicitly tag anyone \u2014 default to a helpful reply, but skip if the text reads like a note-to-self, acknowledgement, or aside). Handle the event, then execute the return's `requiredNextToolCall`. On `timeout`, `recentActivity` tells you whether to keep monitoring or exit with the goodbye line from `userMessage`.",
+    description: "Block for up to `timeoutSec` (default 30s) waiting for a remote event. Returns `{ kind: 'mention' | 'timeout', ... }`. **The monitor loop is always-on** \u2014 every return carries a directive you must follow without waiting for user input. On `mention`, the `reason` is one of: `direct_mention` (sidecar or text named you \u2014 always reply), `active_thread` (plain reply on a thread you're already in \u2014 reply if the content invites one), or `solo_room` (you're alone with one human who didn't explicitly tag anyone \u2014 default to a helpful reply, but skip if the text reads like a note-to-self, acknowledgement, or aside). Handle the event, then execute the return's `requiredNextToolCall`. On a final `timeout` (no `requiredNextToolCall`), the return carries `userMessage` \u2014 the agent's goodbye line in its own voice. Print `userMessage` verbatim as your final output before exiting; do NOT post anything in the doc.",
     inputSchema: {
       type: "object",
       properties: {
@@ -5518,6 +5690,21 @@ var TOOL_DEFS = [
       required: ["roomId", "threadId"]
     }
   },
+  {
+    name: "composer_export_to_file",
+    description: "Dump the current Composer doc to a local markdown file. ONE-WAY ONLY: Composer is the source of truth, the file is OVERWRITTEN on every call. The path must be absolute. Use when the user asks to 'save this to a file', 'export to disk', or runs /composer:export. Returns { roomId, path, bytesWritten }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        roomId: { type: "string" },
+        path: {
+          type: "string",
+          description: "Absolute filesystem path to write to. Existing files are overwritten. Parent directory must already exist."
+        }
+      },
+      required: ["roomId", "path"]
+    }
+  },
   {
     name: "composer_agent_status",
     description: 'Drive the live state indicator on an in-flight agent-authored record (a reply, or the thread-head Comment / Suggestion). Use AFTER posting an ack with `state: "thinking"` via the reply/add tools \u2014 this tool advances state mid-work without creating a new reply, and optionally rewrites text in place at completion. Transitions: thinking \u2192 working (tool use started) \u2192 replying (assembling final answer, optional) \u2192 ready (terminal; text now holds the final content OR a thin pointer to a standalone artifact). When `replyId` is set, updates that reply inside `threadId`; when absent, updates the thread-head record (use `kind` to disambiguate). Returns { replyId } for reply updates or { id } for thread-head updates.',
@@ -5644,11 +5831,12 @@ function asAnchor(value) {
 }
 function buildMonitorHandoff(roomId, browserUrl, actingAs, opts) {
   const mention = `@${actingAs}`;
-  const step1_sayToUser = opts.isFirstRun ? `${browserUrl}
+  const opener = opts.mode === "create" ? "I've created a new doc for you" : "I've joined the doc";
+  const step1_sayToUser = opts.isFirstRun ? `${opener} and am launching another agent to watch for comments. Tag me (${mention}) in any Composer comment to bring me in \u2014 and share the link to invite other people (or their agents) to collaborate with us.
 
-First time using Composer? Here's how it works: I'm monitoring this doc right here in your terminal. Reach me anytime by tagging ${mention} in any comment or reply \u2014 I'll answer right in the thread, and I can also post suggestions you accept or reject inline.` : `${browserUrl}
+${browserUrl}` : `${opener} and am launching another agent to watch for comments. Tag me (${mention}) in any Composer comment to bring me in.
 
-I'm monitoring this doc from the terminal \u2014 tag me with ${mention} in any comment and I'll reply right there.`;
+${browserUrl}`;
   return {
     step1_sayToUser,
     step2_callTool: {
@@ -5697,6 +5885,7 @@ async function handleCreateRoom(args) {
     identity
   });
   await state.ensureConnected();
+  state.setMonitoring(true);
   if (seedMarkdown) {
     writeMarkdownToFragment(state.doc.getXmlFragment("default"), seedMarkdown);
   }
@@ -5708,7 +5897,10 @@ async function handleCreateRoom(args) {
     browserUrl,
     actingAs,
     snapshot: state.snapshot(),
-    ...buildMonitorHandoff(roomId, browserUrl, actingAs, { isFirstRun })
+    ...buildMonitorHandoff(roomId, browserUrl, actingAs, {
+      isFirstRun,
+      mode: "create"
+    })
   });
 }
 async function handleJoinRoom(args) {
@@ -5723,6 +5915,9 @@ async function handleJoinRoom(args) {
       roomId,
       actingAs: existing.actingAs
     });
+    existing.clearGoodbye();
+    await existing.ensureConnected();
+    existing.setMonitoring(true);
     existing.scheduleIdleDisconnect(3e4);
     return okResult({
       roomId,
@@ -5733,7 +5928,8 @@ async function handleJoinRoom(args) {
       // first-run situation — we already wrote a name to disk at least
       // once in this process lifetime to have created `existing`.
       ...buildMonitorHandoff(roomId, browserUrl, existing.actingAs, {
-        isFirstRun: false
+        isFirstRun: false,
+        mode: "join"
       })
     });
   }
@@ -5746,6 +5942,7 @@ async function handleJoinRoom(args) {
     identity
   });
   await state.ensureConnected();
+  state.setMonitoring(true);
   rooms.set(roomId, state);
   log(`composer room joined \u2192 ${browserUrl}`, { roomId, actingAs });
   state.scheduleIdleDisconnect(3e4);
@@ -5754,7 +5951,10 @@ async function handleJoinRoom(args) {
     browserUrl,
     actingAs,
     snapshot: state.snapshot(),
-    ...buildMonitorHandoff(roomId, browserUrl, actingAs, { isFirstRun })
+    ...buildMonitorHandoff(roomId, browserUrl, actingAs, {
+      isFirstRun,
+      mode: "join"
+    })
   });
 }
 function handleAttachRoom(args) {
@@ -5769,7 +5969,14 @@ var ACTIVITY_WINDOW_MS = (() => {
   const n = Number(raw);
   return Number.isFinite(n) && n > 0 ? n : 15 * 60 * 1e3;
 })();
-var LEAVE_MESSAGE = "I've left the document. You can ask me to rejoin anytime and I'll continue replying.";
+var goodbyeIdleTimeout = (roomId) => `Run \`/composer:join\` when you want me back \u2014 or open the doc again at ${browserUrlFor(roomId)}.`;
+var GOODBYE_SERVER_KICKED = `I'm having trouble reaching the Composer doc. Try restarting your Claude session, or try again in a bit.`;
+var GOODBYE_RECONNECT_ABORTED = `I'm having trouble reaching the Composer doc. Make sure you're connected to the internet or try running \`/composer:join\` in a bit to have me join again.`;
+function terminalRejectGoodbye(state) {
+  if (state.terminalRejectKind === "rejected") return GOODBYE_SERVER_KICKED;
+  if (state.terminalRejectKind === "aborted") return GOODBYE_RECONNECT_ABORTED;
+  return null;
+}
 async function handleNextEvent(args, signal) {
   const a = asObject(args);
   const roomId = asString(a.roomId, "roomId");
@@ -5780,6 +5987,16 @@ async function handleNextEvent(args, signal) {
       "Already said goodbye for this room. The user must explicitly ask you to rejoin (which will trigger a fresh `composer_join_room`). Do not call `composer_next_event` again on this roomId."
     );
   }
+  const earlyGoodbye = terminalRejectGoodbye(state);
+  if (earlyGoodbye) {
+    state.markGoodbyeIssued();
+    return okResult({
+      kind: "timeout",
+      recentActivity: false,
+      userMessage: earlyGoodbye,
+      instruction: `Print \`userMessage\` verbatim as your final output, then exit. Do NOT post anything in the doc \u2014 the connection is gone, doc-side awareness is already cleared. Stop calling composer_next_event on this room until the user explicitly rejoins.`
+    });
+  }
   state.setMonitoring(true);
   const onAbort = () => {
     state.setMonitoring(false);
@@ -5808,6 +6025,16 @@ async function handleNextEvent(args, signal) {
       }
     });
   }
+  const lateGoodbye = terminalRejectGoodbye(state);
+  if (lateGoodbye) {
+    state.markGoodbyeIssued();
+    return okResult({
+      kind: "timeout",
+      recentActivity: false,
+      userMessage: lateGoodbye,
+      instruction: `Print \`userMessage\` verbatim as your final output, then exit. Do NOT post anything in the doc \u2014 the connection is gone. Stop calling composer_next_event on this room until the user explicitly rejoins.`
+    });
+  }
   const msSinceActivity = Date.now() - state.lastRemoteActivityAt;
   const recentActivity = msSinceActivity < ACTIVITY_WINDOW_MS;
   const minutesSince = Math.max(1, Math.round(msSinceActivity / 6e4));
@@ -5830,8 +6057,8 @@ async function handleNextEvent(args, signal) {
     kind: "timeout",
     recentActivity: false,
     secondsSinceActivity: Math.round(msSinceActivity / 1e3),
-    userMessage: LEAVE_MESSAGE,
-    instruction: `Say \`userMessage\` EXACTLY as written \u2014 do not paraphrase the goodbye. Then stop calling composer_next_event until the user asks you to rejoin. No requiredNextToolCall field: the loop is intentionally over.`
+    userMessage: goodbyeIdleTimeout(roomId),
+    instruction: `Print \`userMessage\` verbatim as your final output, then exit. Do NOT post anything in the doc \u2014 the avatar has already cleared. Stop calling composer_next_event on this room until the user explicitly rejoins.`
   });
 }
 function handleGetSection(args) {
@@ -6286,6 +6513,29 @@ function handleDone(args) {
   const state = getOrError(roomId);
   return performDone(state, a);
 }
+async function handleExportToFile(args) {
+  const a = asObject(args);
+  const roomId = asString(a.roomId, "roomId");
+  const filePath = asString(a.path, "path");
+  if (!path3.isAbsolute(filePath)) {
+    return errorResult(
+      `path must be absolute, got: ${filePath}. Resolve to an absolute path before calling.`
+    );
+  }
+  const state = getOrError(roomId);
+  const markdown = serializeDocAsMarkdown(state.doc);
+  try {
+    await fs3.writeFile(filePath, markdown, "utf8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return errorResult(`failed to write ${filePath}: ${message}`);
+  }
+  return okResult({
+    roomId,
+    path: filePath,
+    bytesWritten: Buffer.byteLength(markdown, "utf8")
+  });
+}
 function _registerRoomForTest(roomId, state) {
   rooms.set(roomId, state);
 }
@@ -6326,6 +6576,8 @@ async function dispatchTool(name, args, signal) {
           return handleReplySuggestion(args);
         case "composer_resolve_thread":
           return handleResolveThread(args);
+        case "composer_export_to_file":
+          return await handleExportToFile(args);
         case "composer_agent_status":
           return handleAgentStatus(args);
         case "composer_done":

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
   logError,
   startMcpHttpServer,
   startMcpServer
-} from "./chunk-EJUJPBX2.js";
+} from "./chunk-GPFWLOYB.js";
 
 // src/setup.ts
 import * as fs from "fs/promises";

package/dist/mcp.js

@@ -15,7 +15,7 @@ import {
   startMcpHttpServer,
   startMcpServer,
   teardownAllRooms
-} from "./chunk-EJUJPBX2.js";
+} from "./chunk-GPFWLOYB.js";
 export {
   __test_clearRooms,
   __test_dispatch,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@composer-app/mcp",
-  "version": "0.0.1-beta.7",
+  "version": "0.0.3",
   "description": "Composer MCP",
   "license": "MIT",
   "author": "Josh Philpott",