sbuilder-mcp 0.63.0 → 0.63.2

package/CHANGELOG.md

@@ -6,6 +6,19 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.63.2] - 2026-09-24
+
+### Fixed
+- The live-edit socket now holds frames sent before the server's welcome instead of dropping them, so a section added right after `sb_page_open` reaches an editor watching the page instead of leaving it showing "This page is empty" and risking that empty state being autosaved over the agent's work; the held queue is capped at 500 frames so a long reconnect loop cannot grow memory without bound.
+
+## [0.63.1] - 2026-09-24
+
+### Fixed
+- Live-edit frames now carry the open page's id from the moment a room is joined and whenever a new page is opened afterward, so the editor's own per-page filter no longer drops every ops, cursor, and select frame this server sends.
+- A second `sb_live_join`, or opening a page on a different site while already in a room, now leaves the previous room instead of leaving its socket connected and reconnecting for the rest of the process.
+- Opening a page on a site other than the one the current live room belongs to now leaves that room first, so a failed join can no longer strand the session in the wrong site's room.
+- The server process now exits when the MCP client closes stdin, instead of being kept alive indefinitely by the live-room socket and its reconnect timer.
+
 ## [0.63.0] - 2026-09-21
 
 ### Added

package/CHANGELOG.vi.md

@@ -6,6 +6,19 @@ Mọi thay đổi đáng chú ý của dự án được ghi lại trong file n
 Định dạng dựa trên [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 và dự án tuân theo [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.63.2] - 2026-09-24
+
+### Fixed
+- Socket live-edit giờ giữ lại các frame được gửi trước khi server chào (welcome) thay vì loại bỏ chúng, để một section được thêm ngay sau `sb_page_open` đến được với editor đang xem trang thay vì để trang đó hiển thị "This page is empty" và có nguy cơ trạng thái rỗng đó bị autosave đè lên công việc của agent; hàng đợi giữ frame bị giới hạn ở 500 frame để một vòng lặp reconnect kéo dài không thể làm bộ nhớ tăng vô hạn.
+
+## [0.63.1] - 2026-09-24
+
+### Fixed
+- Các frame live-edit giờ mang theo id của trang đang mở ngay từ lúc vào phòng và mỗi khi một trang mới được mở sau đó, để bộ lọc theo từng trang của chính editor không còn loại bỏ mọi frame ops, cursor và select mà server này gửi đi.
+- Gọi `sb_live_join` lần thứ hai, hoặc mở một trang thuộc site khác trong khi đang ở trong một phòng, giờ sẽ rời phòng cũ thay vì để socket của nó tiếp tục kết nối và tự reconnect trong suốt phần đời còn lại của tiến trình.
+- Mở một trang thuộc site khác với site của phòng live hiện tại giờ sẽ rời phòng đó trước, để một lần join thất bại không còn có thể khiến session bị mắc kẹt trong phòng của site sai.
+- Tiến trình server giờ thoát khi client MCP đóng stdin, thay vì bị giữ sống vô thời hạn bởi socket của phòng live và timer reconnect của nó.
+
 ## [0.63.0] - 2026-09-21
 
 ### Added

package/dist/index.js

@@ -11,6 +11,14 @@ async function main() {
     }
     const server = createServer();
     await server.connect(new StdioServerTransport());
+    // THE CLIENT CLOSED STDIN, SO THIS PROCESS IS DONE. The SDK does not exit on
+    // its own, and the live-room socket (plus its reconnect timer) keeps the event
+    // loop alive — an orphaned process that answers the server's pings, so the
+    // agent's avatar stays in the room indefinitely. Exiting closes the socket and
+    // the server publishes the leave.
+    const done = () => process.exit(0);
+    process.stdin.once('end', done);
+    process.stdin.once('close', done);
     // stdout is the MCP channel. Every log line in this repo is console.error.
     console.error('[sbuilder-mcp] ready on stdio');
 }

package/dist/live/session.js

@@ -65,6 +65,10 @@ export class LiveSession {
         if (this.selfId)
             this.announcePage();
     }
+    /** Leave the room: the socket closes, the server publishes our `leave`. */
+    close() {
+        this.socket.close();
+    }
     announcePage() {
         if (!this.pageId)
             return;

package/dist/tools/live.js

@@ -261,7 +261,7 @@ export function joinRoom(ctx, session, siteId) {
         onDesync: (reason) => session.markStale(reason),
     });
     socket.connect();
-    session.attachLive(live);
+    session.attachLive(live, siteId);
 }
 export function registerLiveTools(server, ctx, session) {
     // The page session joins on its own at the first sb_page_open. Registered

package/dist/tools/page.js

@@ -61,6 +61,8 @@ export class PageSession {
     siteId = '';
     pageId = '';
     live = null;
+    /** Which site's room `live` is in — a page on another site needs another room. */
+    liveSite = '';
     stale = null;
     /**
      * The document revision this session last stored, so an unchanged document is
@@ -79,8 +81,28 @@ export class PageSession {
     constructor(ctx) {
         this.ctx = ctx;
     }
-    attachLive(live) {
+    /**
+     * ONE ROOM AT A TIME. A second join (sb_live_join again, or a page on another
+     * site) used to overwrite `live` and leave the old socket reconnecting for the
+     * life of the process — a second robot in the old site's room, forever.
+     *
+     * And the page is announced HERE as well as on open: `start` was never called
+     * anywhere, so every ops/cursor/select frame went out with `pageId: ''` and
+     * the editor, which filters by page, dropped all of them.
+     */
+    attachLive(live, siteId) {
+        if (this.live !== live)
+            this.live?.close();
         this.live = live;
+        this.liveSite = siteId;
+        if (this.pageId && this.siteId === siteId)
+            live.start(this.pageId);
+    }
+    /** Leave the room, if in one. */
+    leaveLive() {
+        this.live?.close();
+        this.live = null;
+        this.liveSite = '';
     }
     /**
      * How to open the live-edit room, handed over by `registerLiveTools`.
@@ -113,10 +135,13 @@ export class PageSession {
      * rather than a new one.
      */
     async ensureLive(siteId) {
-        if (this.live)
+        if (this.live && this.liveSite === siteId)
             return 'already';
         if (!this.liveJoiner)
             return 'no live transport is registered';
+        // Out of the old site's room first, so a failed join below cannot leave
+        // this process sitting in a room for a site it is no longer editing.
+        this.leaveLive();
         try {
             this.liveJoiner(siteId);
             return this.live ? 'joined' : 'the live transport did not attach';
@@ -314,6 +339,11 @@ export class PageSession {
         // `sb_template_use` and `shareChrome` all open pages too, and a join wired to
         // sb_page_open alone leaves every one of those editing unseen.
         this.liveState = await this.ensureLive(siteId);
+        // Tell the room this page. A fresh join already did (attachLive); an
+        // existing one has only heard of the previous page. Without it the editor
+        // drops every frame this session sends.
+        if (this.liveState === 'already')
+            this.live?.start(pageId);
         return this.doc.outline();
     }
     /** What the last open's join attempt did, for the tool that reports it. */

package/dist/transport/socket.js

@@ -11,6 +11,8 @@ import { agentIdentity } from './identity.js';
 const OPEN = 1;
 const RETRY_BASE_MS = 500;
 const RETRY_MAX_MS = 15_000;
+/** Frames held while not ready. A reconnect loop must not grow memory forever. */
+const QUEUE_MAX = 500;
 export class RealtimeSocket {
     url;
     token;
@@ -20,6 +22,19 @@ export class RealtimeSocket {
     attempt = 0;
     handlers = [];
     timer = null;
+    /** The server has welcomed THIS connection — frames sent now are read. */
+    ready = false;
+    /**
+     * Frames sent while not ready, flushed on the welcome.
+     *
+     * `sb_page_open` starts the connection and returns; the `sb_add` right after
+     * it ran before the handshake finished, and a send that DROPPED on a
+     * not-open socket lost it without a trace. The editor watching the page never
+     * saw the section appear — it showed an empty page, and its next autosave
+     * could write that empty page over the agent's work. Same for every edit made
+     * during a reconnect.
+     */
+    queue = [];
     constructor(url, 
     /**
      * A GETTER, read per attempt. The access token lives ~15 minutes and
@@ -44,6 +59,7 @@ export class RealtimeSocket {
         const ws = this.factory(this.url);
         this.ws = ws;
         this.attempt += 1;
+        this.ready = false;
         ws.onopen = () => {
             // Auth is the FIRST message, never a header (a browser cannot set one on a
             // WebSocket) and never a query parameter (a token in a URL lands in logs).
@@ -92,10 +108,17 @@ export class RealtimeSocket {
             catch {
                 return; // a malformed frame must never throw into the socket
             }
+            // Ready BEFORE the handlers, flushed AFTER them: the page announcement
+            // the welcome triggers goes out directly, ahead of the ops held for it.
+            const held = this.ready ? [] : this.queue.splice(0);
+            this.ready = true;
             for (const h of this.handlers)
                 h(parsed);
+            for (const f of held)
+                ws.send(f);
         };
         ws.onclose = () => {
+            this.ready = false;
             if (this.closed)
                 return;
             const wait = Math.min(RETRY_BASE_MS * 2 ** this.attempt, RETRY_MAX_MS);
@@ -109,12 +132,21 @@ export class RealtimeSocket {
     send(e) {
         if (this.closed)
             return;
-        if (this.ws?.readyState !== OPEN)
+        const frame = JSON.stringify(e);
+        if (this.ready && this.ws?.readyState === OPEN) {
+            this.ws.send(frame);
             return;
-        this.ws.send(JSON.stringify(e));
+        }
+        if (this.queue.length >= QUEUE_MAX) {
+            // ponytail: drops the oldest past the cap; the peer re-pulls on the gap.
+            console.error('[sbuilder-mcp] live queue full, dropping the oldest frame');
+            this.queue.shift();
+        }
+        this.queue.push(frame);
     }
     close() {
         this.closed = true;
+        this.queue = [];
         if (this.timer)
             clearTimeout(this.timer);
         this.ws?.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sbuilder-mcp",
-  "version": "0.63.0",
+  "version": "0.63.2",
   "description": "MCP server that designs and operates a Store Builder site — pages, data, theme and publish — through the platform's own API and live-edit protocol.",
   "mcpName": "io.github.vuluu2k/sbuilder-mcp",
   "type": "module",