@json-to-office/mcp-server 1.8.0 → 1.9.0

package/dist/index.d.ts

@@ -564,6 +564,19 @@ interface RestoredWorkspace extends PersistedMeta {
     head: PersistedDocument;
     pins: PersistedDocument[];
 }
+/**
+ * The durable half of a workspace store.
+ *
+ * Not internally synchronized: `save` and `remove` each read the root, decide
+ * what to prune and then act, so two of them running at once can both decide
+ * there is room, or one can delete a directory the other is half way through
+ * writing. Callers serialize — `createMemoryWorkspaceStore` runs every durable
+ * operation through one queue, which is also where the ordering against a
+ * close is settled. Reads (`list`, `load`) need no such treatment: metadata is
+ * renamed into place after the revision it names, so a concurrent read sees
+ * one committed state or the other, and `load` re-reads before it treats a
+ * missing document as a torn directory.
+ */
 interface WorkspacePersistence {
     /** Absolute path of the root. May not exist on disk until first write. */
     readonly root: string;

package/dist/index.js

@@ -2,7 +2,7 @@
 import { McpServer } from "@modelcontextprotocol/server";
 
 // src/lib/version.ts
-var SERVER_VERSION = true ? "1.8.0" : "dev-mode";
+var SERVER_VERSION = true ? "1.9.0" : "dev-mode";
 var SERVER_NAME = "json-to-office";
 var PACKAGE_NAME = "@json-to-office/mcp-server";
 
@@ -5265,9 +5265,16 @@ function createWorkspacePersistenceAt(root, limits = {}) {
     },
     async load(handle) {
       if (!isPersistableHandle(handle)) return void 0;
-      const meta = await readMeta(handle);
+      let meta = await readMeta(handle);
       if (!meta) return void 0;
-      const head = await readRevision(handle, meta.revision);
+      let head = await readRevision(handle, meta.revision);
+      if (!head) {
+        const second = await readMeta(handle);
+        if (second) {
+          meta = second;
+          head = await readRevision(handle, second.revision);
+        }
+      }
       if (!head) {
         await fs7.rm(dirFor(handle), { recursive: true, force: true }).catch(() => void 0);
         return void 0;
@@ -5434,45 +5441,67 @@ function createMemoryWorkspaceStore(options = {}) {
       if (at - entry.touchedAt > limits.idleTtlMs) evict(entry, "ttl");
     }
   }
+  let durable = Promise.resolve();
+  function queued(work) {
+    const running = durable.then(work);
+    durable = running.catch(() => void 0);
+    return running;
+  }
   async function persist(entry) {
     if (!persistence) return void 0;
     try {
-      await persistence.save({
-        handle: entry.handle,
-        format: entry.format,
-        createdAt: entry.createdAt,
-        updatedAt: entry.updatedAt,
-        ...entry.title !== void 0 && { title: entry.title },
-        head: {
-          revision: entry.revision,
-          text: entry.text,
-          bytes: entry.bytes
-        },
-        pins: [...entry.pins.entries()].map(([revision, pin]) => ({
-          revision,
-          text: pin.text,
-          bytes: pin.bytes
-        }))
+      const written = await queued(async () => {
+        if (entries.get(entry.handle) !== entry) return false;
+        await saveEntry(entry);
+        return true;
       });
+      if (!written) {
+        entry.persisted = false;
+        return void 0;
+      }
       entry.persisted = true;
       return void 0;
     } catch (error) {
       entry.persisted = false;
-      return diagnostic(
-        WORKSPACE_ERROR_CODES.NOT_PERSISTED,
-        `Revision ${entry.revision} of ${entry.handle} is held in memory but was not written to ${persistence.root}: ${error instanceof Error ? error.message : String(error)}`,
-        {
-          severity: "warning",
-          suggestion: "Export the JSON with jto_workspace_snapshot and keep it yourself; this handle will not survive a lost connection.",
-          context: {
-            handle: entry.handle,
-            revision: entry.revision,
-            workspaceRoot: persistence.root
-          }
-        }
-      );
+      return notPersisted(entry, error);
     }
   }
+  async function saveEntry(entry) {
+    if (!persistence) return;
+    await persistence.save({
+      handle: entry.handle,
+      format: entry.format,
+      createdAt: entry.createdAt,
+      updatedAt: entry.updatedAt,
+      ...entry.title !== void 0 && { title: entry.title },
+      head: {
+        revision: entry.revision,
+        text: entry.text,
+        bytes: entry.bytes
+      },
+      pins: [...entry.pins.entries()].map(([revision, pin]) => ({
+        revision,
+        text: pin.text,
+        bytes: pin.bytes
+      }))
+    });
+  }
+  function notPersisted(entry, error) {
+    const root = persistence?.root ?? "";
+    return diagnostic(
+      WORKSPACE_ERROR_CODES.NOT_PERSISTED,
+      `Revision ${entry.revision} of ${entry.handle} is held in memory but was not written to ${root}: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        severity: "warning",
+        suggestion: "Export the JSON with jto_workspace_snapshot and keep it yourself; this handle will not survive a lost connection.",
+        context: {
+          handle: entry.handle,
+          revision: entry.revision,
+          workspaceRoot: root
+        }
+      }
+    );
+  }
   function committed(record, warning) {
     return { ok: true, record, ...warning && { warnings: [warning] } };
   }
@@ -5789,24 +5818,33 @@ function createMemoryWorkspaceStore(options = {}) {
     async close(handle) {
       sweep();
       const entry = entries.get(handle);
-      let durable = false;
-      if (persistence) {
-        try {
-          durable = await persistence.remove(handle);
-        } catch (error) {
-          return failure(
-            WORKSPACE_ERROR_CODES.NOT_CLOSED,
-            `Workspace ${handle} could not be removed from ${persistence.root}: ${error instanceof Error ? error.message : String(error)}. It is still open and still on disk.`,
-            {
-              suggestion: "Check the workspace directory is writable, then close again.",
-              context: { handle, workspaceRoot: persistence.root }
-            }
-          );
-        }
+      if (!persistence) {
+        if (entry) evict(entry, "closed");
+        return { ok: true, handle, closed: entry !== void 0 };
+      }
+      const root = persistence.root;
+      try {
+        return await queued(async () => {
+          const removed = await persistence.remove(handle);
+          const resident = entries.get(handle);
+          if (resident) evict(resident, "closed");
+          else if (removed) tombstone(handle, "closed", 0);
+          return {
+            ok: true,
+            handle,
+            closed: resident !== void 0 || removed
+          };
+        });
+      } catch (error) {
+        return failure(
+          WORKSPACE_ERROR_CODES.NOT_CLOSED,
+          `Workspace ${handle} could not be removed from ${root}: ${error instanceof Error ? error.message : String(error)}. It is still open and still on disk.`,
+          {
+            suggestion: "Check the workspace directory is writable, then close again.",
+            context: { handle, workspaceRoot: root }
+          }
+        );
       }
-      if (entry) evict(entry, "closed");
-      else if (durable) tombstone(handle, "closed", 0);
-      return { ok: true, handle, closed: entry !== void 0 || durable };
     },
     /**
      * Release memory, keep the disk.