@apicircle/mcp-server 1.0.7 → 1.0.8

package/dist/index.d.cts

@@ -173,16 +173,29 @@ declare class FileBackedWorkspaceProvider implements WorkspaceProvider {
 
 declare class MultiWorkspaceProvider implements Workspaces {
     private readonly registryRoot;
-    private active;
+    /** Last-known active workspace id. Refreshed every time the lazy
+     *  provider resolves; reflects what the most recent operation saw on
+     *  disk, not a stale boot-time snapshot. */
     private activeWorkspaceId;
+    /** The lazy provider tool handlers consume as `ctx.workspace`. Holds a
+     *  reference back to this instance so each call updates
+     *  `activeWorkspaceId` for `activeId()` callers + diagnostic logs. */
+    private readonly lazyProvider;
     constructor(registryRoot: string);
     /**
-     * Hydrate the active provider from disk. Must be called once before the
-     * MCP host boots so `ctx.workspace.read()` doesn't race the first
-     * registry-load. Returns the registry the boot can log.
+     * Read the registry from disk so the host can log a boot banner. Does
+     * NOT cache a per-id provider — each `activeProvider()` call re-reads
+     * the registry, so a workspace switch in the desktop is picked up by
+     * the next tool call without restarting the MCP server.
      */
     init(): Promise<WorkspaceRegistry>;
-    /** The provider tool handlers see as `ctx.workspace`. */
+    /**
+     * The provider tool handlers see as `ctx.workspace`. Returns a lazy
+     * provider whose `read` / `apply` / `write` calls re-read
+     * `registry.json` so the right active workspace is always targeted
+     * even if the desktop switched workspaces since this MCP process
+     * started.
+     */
     activeProvider(): WorkspaceProvider;
     list(): Promise<WorkspaceSummary[]>;
     for(workspaceId: string): WorkspaceProvider;
@@ -190,7 +203,8 @@ declare class MultiWorkspaceProvider implements Workspaces {
     setActive(workspaceId: string): Promise<void>;
     /**
      * Idempotent registry write — used by tests / tools that need to
-     * persist registry updates that didn't go through `setActive`.
+     * persist registry updates that didn't go through `setActive`. The
+     * lazy active provider picks the new id up on its next operation.
      */
     writeRegistry(registry: WorkspaceRegistry): Promise<void>;
 }

package/dist/index.d.ts

@@ -173,16 +173,29 @@ declare class FileBackedWorkspaceProvider implements WorkspaceProvider {
 
 declare class MultiWorkspaceProvider implements Workspaces {
     private readonly registryRoot;
-    private active;
+    /** Last-known active workspace id. Refreshed every time the lazy
+     *  provider resolves; reflects what the most recent operation saw on
+     *  disk, not a stale boot-time snapshot. */
     private activeWorkspaceId;
+    /** The lazy provider tool handlers consume as `ctx.workspace`. Holds a
+     *  reference back to this instance so each call updates
+     *  `activeWorkspaceId` for `activeId()` callers + diagnostic logs. */
+    private readonly lazyProvider;
     constructor(registryRoot: string);
     /**
-     * Hydrate the active provider from disk. Must be called once before the
-     * MCP host boots so `ctx.workspace.read()` doesn't race the first
-     * registry-load. Returns the registry the boot can log.
+     * Read the registry from disk so the host can log a boot banner. Does
+     * NOT cache a per-id provider — each `activeProvider()` call re-reads
+     * the registry, so a workspace switch in the desktop is picked up by
+     * the next tool call without restarting the MCP server.
      */
     init(): Promise<WorkspaceRegistry>;
-    /** The provider tool handlers see as `ctx.workspace`. */
+    /**
+     * The provider tool handlers see as `ctx.workspace`. Returns a lazy
+     * provider whose `read` / `apply` / `write` calls re-read
+     * `registry.json` so the right active workspace is always targeted
+     * even if the desktop switched workspaces since this MCP process
+     * started.
+     */
     activeProvider(): WorkspaceProvider;
     list(): Promise<WorkspaceSummary[]>;
     for(workspaceId: string): WorkspaceProvider;
@@ -190,7 +203,8 @@ declare class MultiWorkspaceProvider implements Workspaces {
     setActive(workspaceId: string): Promise<void>;
     /**
      * Idempotent registry write — used by tests / tools that need to
-     * persist registry updates that didn't go through `setActive`.
+     * persist registry updates that didn't go through `setActive`. The
+     * lazy active provider picks the new id up on its next operation.
      */
     writeRegistry(registry: WorkspaceRegistry): Promise<void>;
 }

package/dist/index.js

@@ -6,7 +6,7 @@ import { z } from "zod";
 // package.json
 var package_default = {
   name: "@apicircle/mcp-server",
-  version: "1.0.7",
+  version: "1.0.8",
   private: false,
   type: "module",
   description: "Model Context Protocol server exposing API Circle Studio's workspace as a tool catalog. Used by Claude Desktop, ChatGPT, Cursor, GitHub Copilot, and any other MCP-compatible AI client.",
@@ -2832,17 +2832,58 @@ import {
   setActiveWorkspace as setActiveWorkspaceOnDisk,
   workspaceDirFor
 } from "@apicircle/core/workspace/registry";
+var LazyActiveWorkspaceProvider = class {
+  constructor(registryRoot, onActiveResolved) {
+    this.registryRoot = registryRoot;
+    this.onActiveResolved = onActiveResolved;
+  }
+  registryRoot;
+  onActiveResolved;
+  async resolveActive() {
+    const registry = await loadRegistry(this.registryRoot);
+    const activeId = registry?.activeWorkspaceId ?? null;
+    if (!activeId) {
+      throw new Error(
+        "No active workspace. Open the desktop app at least once, or run `apicircle workspaces create <name>`."
+      );
+    }
+    this.onActiveResolved(activeId);
+    return new FileBackedWorkspaceProvider(workspaceDirFor(this.registryRoot, activeId));
+  }
+  async read() {
+    const provider = await this.resolveActive();
+    return provider.read();
+  }
+  async apply(patch) {
+    const provider = await this.resolveActive();
+    return provider.apply(patch);
+  }
+  async write(next) {
+    const provider = await this.resolveActive();
+    return provider.write(next);
+  }
+};
 var MultiWorkspaceProvider = class {
   constructor(registryRoot) {
     this.registryRoot = registryRoot;
+    this.lazyProvider = new LazyActiveWorkspaceProvider(this.registryRoot, (id) => {
+      this.activeWorkspaceId = id;
+    });
   }
   registryRoot;
-  active = null;
+  /** Last-known active workspace id. Refreshed every time the lazy
+   *  provider resolves; reflects what the most recent operation saw on
+   *  disk, not a stale boot-time snapshot. */
   activeWorkspaceId = null;
+  /** The lazy provider tool handlers consume as `ctx.workspace`. Holds a
+   *  reference back to this instance so each call updates
+   *  `activeWorkspaceId` for `activeId()` callers + diagnostic logs. */
+  lazyProvider;
   /**
-   * Hydrate the active provider from disk. Must be called once before the
-   * MCP host boots so `ctx.workspace.read()` doesn't race the first
-   * registry-load. Returns the registry the boot can log.
+   * Read the registry from disk so the host can log a boot banner. Does
+   * NOT cache a per-id provider — each `activeProvider()` call re-reads
+   * the registry, so a workspace switch in the desktop is picked up by
+   * the next tool call without restarting the MCP server.
    */
   async init() {
     const registry = await loadRegistry(this.registryRoot) ?? {
@@ -2850,22 +2891,18 @@ var MultiWorkspaceProvider = class {
       activeWorkspaceId: null,
       workspaces: []
     };
-    if (registry.activeWorkspaceId) {
-      this.activeWorkspaceId = registry.activeWorkspaceId;
-      this.active = new FileBackedWorkspaceProvider(
-        workspaceDirFor(this.registryRoot, registry.activeWorkspaceId)
-      );
-    }
+    this.activeWorkspaceId = registry.activeWorkspaceId;
     return registry;
   }
-  /** The provider tool handlers see as `ctx.workspace`. */
+  /**
+   * The provider tool handlers see as `ctx.workspace`. Returns a lazy
+   * provider whose `read` / `apply` / `write` calls re-read
+   * `registry.json` so the right active workspace is always targeted
+   * even if the desktop switched workspaces since this MCP process
+   * started.
+   */
   activeProvider() {
-    if (!this.active) {
-      throw new Error(
-        "No active workspace. Open the desktop app at least once, or run `apicircle workspaces create <name>`."
-      );
-    }
-    return this.active;
+    return this.lazyProvider;
   }
   // ─── Workspaces interface ──────────────────────────────────────────────────
   async list() {
@@ -2913,23 +2950,17 @@ var MultiWorkspaceProvider = class {
     if (!registry || !registry.workspaces.some((w) => w.id === workspaceId)) {
       throw new WorkspaceNotFoundError(workspaceId);
     }
-    const next = await setActiveWorkspaceOnDisk(this.registryRoot, workspaceId);
-    void next;
+    await setActiveWorkspaceOnDisk(this.registryRoot, workspaceId);
     this.activeWorkspaceId = workspaceId;
-    this.active = new FileBackedWorkspaceProvider(workspaceDirFor(this.registryRoot, workspaceId));
   }
   /**
    * Idempotent registry write — used by tests / tools that need to
-   * persist registry updates that didn't go through `setActive`.
+   * persist registry updates that didn't go through `setActive`. The
+   * lazy active provider picks the new id up on its next operation.
    */
   async writeRegistry(registry) {
     await saveRegistry(this.registryRoot, registry);
     this.activeWorkspaceId = registry.activeWorkspaceId;
-    if (registry.activeWorkspaceId) {
-      this.active = new FileBackedWorkspaceProvider(
-        workspaceDirFor(this.registryRoot, registry.activeWorkspaceId)
-      );
-    }
   }
 };