@ffschrattenecker/tm1-mcp-server 6.1.1 → 7.0.1

package/dist/index.js

@@ -2,12 +2,12 @@
 import "./load-env.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { loadConfig } from "./config.js";
+import { loadServerSettings } from "./config.js";
+import { ConnectionRegistry } from "./connections.js";
+import { serverInstructions } from "./server-instructions.js";
 import { createLogger } from "./logger.js";
-import { SessionManager } from "./session-manager.js";
-import { TM1Client } from "./tm1-client.js";
 import { registerAllPrompts } from "./prompts/index.js";
-import { registerAllResources } from "./resources/index.js";
+import { registerAllResources, stateResourceUris } from "./resources/index.js";
 import { SubscriptionRegistry } from "./resources/subscriptions.js";
 import { installPaginatedListHandler } from "./resources/list-handler.js";
 import { registerAllTools } from "./tools/index.js";
@@ -23,7 +23,7 @@ async function startStdioTransport(server, logger) {
         await transport.close();
     };
 }
-function buildMcpServer(tm1Client, config, logger) {
+function buildMcpServer(registry, settings, logger) {
     const server = new McpServer({
         name: NAME,
         version: VERSION,
@@ -34,21 +34,25 @@ function buildMcpServer(tm1Client, config, logger) {
             prompts: { listChanged: true },
             logging: {},
         },
+        instructions: serverInstructions(registry),
     });
     // Register all tools — wrap the server so each registration receives the
     // annotation hint from ANNOTATION_MAP without editing call sites. In readonly
     // mode the proxy silently drops write/destructive tools so they never appear
-    // in the tool listing — no autoApprove lists needed.
-    registerAllTools(withAnnotations(server, logger, config.mode, config.responseMode, config.maxResponseChars), tm1Client);
-    logger.debug(`All MCP tools registered (mode: ${config.mode})`);
+    // in the tool listing — no autoApprove lists needed. With several
+    // connections, write tools are listed when ANY connection is readwrite and
+    // refused per call against a readonly one (see defineTool).
+    const mode = registry.anyReadwrite ? "readwrite" : "readonly";
+    registerAllTools(withAnnotations(server, logger, mode, settings.responseMode, settings.maxResponseChars), registry);
+    logger.debug(`All MCP tools registered (mode: ${mode})`);
     // Register MCP Resources (URI-addressable read-only views over TM1 objects).
-    const resourceCatalog = registerAllResources(server, tm1Client);
+    const resourceCatalog = registerAllResources(server, registry);
     // R2-07: replace the SDK's default ListResourcesRequestSchema handler with a
     // cursor-aware override that paginates the combined static + template list.
     installPaginatedListHandler(server, resourceCatalog, logger);
     // R2-05: install subscribe/unsubscribe handlers and bridge HTTP-layer mutation
     // events to notifications/resources/updated for subscribers of tm1://server/state.
-    const subscriptions = new SubscriptionRegistry(server, logger);
+    const subscriptions = new SubscriptionRegistry(server, logger, stateResourceUris(registry));
     subscriptions.install();
     // Register MCP Prompts (parameterised workflow templates surfaced as slash-commands).
     registerAllPrompts(server);
@@ -61,27 +65,33 @@ function buildMcpServer(tm1Client, config, logger) {
     };
 }
 async function main() {
-    const config = loadConfig();
-    const logger = createLogger(config);
+    const settings = loadServerSettings();
+    const logger = createLogger(settings);
     logger.info("Starting TM1 MCP Server");
-    const sessionManager = new SessionManager(config, logger);
-    const tm1Client = new TM1Client(config, sessionManager, logger);
-    // Try to connect to TM1, but don't block MCP server startup.
-    // request() calls ensureSession() on every tool invocation, so a tool call
-    // will retry auth if the initial connect failed. Keeps Claude able to list
-    // tools and report a meaningful error instead of crashing the whole process.
-    try {
-        await tm1Client.connect();
-        logger.info("TM1 client connected");
-    }
-    catch (err) {
-        logger.warn({ err }, "Initial TM1 connection failed — server will retry on first tool call");
-    }
-    if (config.modeReason) {
-        logger.warn(`${config.modeReason} Write and destructive tools will not be registered.`);
+    // One registry for every configured connection (see ./connections.ts).
+    // Clients are built lazily on first use, so startup costs no TM1 logins.
+    const registry = ConnectionRegistry.fromEnvironment(process.env, logger);
+    for (const c of registry.status()) {
+        if (c.configError) {
+            logger.warn({ connection: c.name, err: c.configError }, "connection unusable");
+        }
+        else {
+            logger.info({
+                connection: c.name,
+                mode: c.mode,
+                environment: c.environment,
+                version: c.tm1Version,
+            }, "connection configured");
+            if (c.modeReason) {
+                logger.warn({ connection: c.name }, `${c.modeReason} Write and destructive tools are refused on this connection.`);
+            }
+        }
     }
-    else if (config.mode === "readonly") {
-        logger.info("TM1_MODE=readonly — write and destructive tools will not be registered");
+    // A single connection keeps the old behavior of logging in at startup, in
+    // the background: request() re-authenticates on every call anyway, so a
+    // failed login here only delays the error to the first tool call.
+    if (registry.isSingle) {
+        void registry.get(undefined);
     }
     // Branch on transport. stdio is the default for local MCP-client setups
     // (Claude Code, Claude Desktop) and gets one long-lived server. http
@@ -92,14 +102,14 @@ async function main() {
     // runs in shutdown(). http builds one per request and disposes each in the
     // transport's own teardown — nothing process-scoped is left for us here.
     let stdioDispose;
-    const httpCloser = config.transport === "http"
-        ? await startHttpTransport(() => buildMcpServer(tm1Client, config, logger), config, logger)
+    const httpCloser = settings.transport === "http"
+        ? await startHttpTransport(() => buildMcpServer(registry, settings, logger), settings, logger)
         : await (async () => {
-            const built = buildMcpServer(tm1Client, config, logger);
+            const built = buildMcpServer(registry, settings, logger);
             stdioDispose = built.dispose;
             return startStdioTransport(built.server, logger);
         })();
-    logger.info(`MCP server configured (mode: ${config.mode}, transport: ${config.transport})`);
+    logger.info(`MCP server configured (connections: ${registry.names.join(", ")}, transport: ${settings.transport})`);
     // Graceful shutdown — ensure TM1 session is always cleaned up.
     let shuttingDown = false;
     const shutdown = async (signal, exitCode = 0) => {
@@ -119,12 +129,7 @@ async function main() {
         catch (err) {
             logger.error({ err }, "Error closing transport");
         }
-        try {
-            await tm1Client.disconnect();
-        }
-        catch (err) {
-            logger.error({ err }, "Error during disconnect");
-        }
+        await registry.disconnectAll();
         process.exit(exitCode);
     };
     process.on("SIGINT", () => {
@@ -139,7 +144,7 @@ async function main() {
     // Parent process death — only meaningful on stdio (Claude spawns us as a
     // child). For http we ignore stdin events since the process lifecycle is
     // independent.
-    if (config.transport === "stdio") {
+    if (settings.transport === "stdio") {
         process.stdin.on("end", () => {
             logger.info("stdin ended (parent process gone), shutting down");
             void shutdown("stdin-end");

package/dist/lib/callgraph/tm1-adapter.d.ts

@@ -26,7 +26,10 @@ export declare function getCallgraphCacheStats(): Array<{
 }>;
 /**
  * Build a full ReferenceIndex from a connected TM1 server.
- * TTL-cached (60 s) per `includeControl` flag. Concurrent calls share one inflight promise.
+ * TTL-cached (60 s) per connection and `includeControl` flag — one server
+ * process serves several TM1 connections, so the key must name the connection
+ * or one server's index would be answered for another. Concurrent calls share
+ * one inflight promise.
  */
 export declare function buildIndexFromTM1(tm1Client: TM1Client, opts?: BuildIndexOpts): Promise<ReferenceIndex>;
 //# sourceMappingURL=tm1-adapter.d.ts.map

package/dist/lib/callgraph/tm1-adapter.js

@@ -71,11 +71,14 @@ export function getCallgraphCacheStats() {
 }
 /**
  * Build a full ReferenceIndex from a connected TM1 server.
- * TTL-cached (60 s) per `includeControl` flag. Concurrent calls share one inflight promise.
+ * TTL-cached (60 s) per connection and `includeControl` flag — one server
+ * process serves several TM1 connections, so the key must name the connection
+ * or one server's index would be answered for another. Concurrent calls share
+ * one inflight promise.
  */
 export async function buildIndexFromTM1(tm1Client, opts = {}) {
     const includeControl = opts.includeControl ?? false;
-    const key = `inc=${includeControl}`;
+    const key = `${tm1Client.connectionId}|inc=${includeControl}`;
     if (!opts.bypassCache) {
         const hit = cache.get(key);
         if (hit && Date.now() - hit.ts < CACHE_TTL_MS)

package/dist/lib/slim-json-schema.d.ts

@@ -14,7 +14,15 @@
  * (`properties` & friends), where the keys are user-chosen field names — a tool
  * with a field literally called `$schema` keeps its subschema.
  *
+ * Descriptions that restate the node's own `default` ("(default: false)",
+ * "Default: 50.") lose that phrase: the `default` keyword right next to it
+ * already says so. Only a phrase whose value equals the emitted default is
+ * removed, so a description documenting a default the schema does not carry
+ * (an optional field resolved in the handler) keeps it.
+ *
  * Pure: the input is never mutated, the result is a fresh deep clone.
  */
+/** Remove "(default: X)" / "Default: X." where X is the emitted default. */
+export declare function stripDefaultPhrase(description: string, defaultValue: unknown): string;
 export declare function slimJsonSchema(schema: unknown): unknown;
 //# sourceMappingURL=slim-json-schema.d.ts.map

package/dist/lib/slim-json-schema.js

@@ -14,6 +14,12 @@
  * (`properties` & friends), where the keys are user-chosen field names — a tool
  * with a field literally called `$schema` keeps its subschema.
  *
+ * Descriptions that restate the node's own `default` ("(default: false)",
+ * "Default: 50.") lose that phrase: the `default` keyword right next to it
+ * already says so. Only a phrase whose value equals the emitted default is
+ * removed, so a description documenting a default the schema does not carry
+ * (an optional field resolved in the handler) keeps it.
+ *
  * Pure: the input is never mutated, the result is a fresh deep clone.
  */
 // Zod serializes `.int()` to the JS safe-integer range; these two exact values
@@ -29,6 +35,25 @@ const NAME_KEYED_CONTAINERS = new Set([
     "$defs",
     "dependentSchemas",
 ]);
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Remove "(default: X)" / "Default: X." where X is the emitted default. */
+export function stripDefaultPhrase(description, defaultValue) {
+    if (typeof defaultValue !== "boolean" &&
+        typeof defaultValue !== "number" &&
+        typeof defaultValue !== "string") {
+        return description;
+    }
+    const value = escapeRegExp(String(defaultValue));
+    return (description
+        .replace(new RegExp(String.raw `\s*\(default:?\s*${value}\)`, "gi"), "")
+        .replace(new RegExp(String.raw `\s*\bDefault:?\s*${value}(?:[.;]|(?=\s)|$)`, "gi"), "")
+        .replace(/\s+([.,;])/g, "$1")
+        .trim()
+        // A phrase that opened the sentence leaves its trailing dash behind.
+        .replace(/^[—–-]\s*/, ""));
+}
 export function slimJsonSchema(schema) {
     return slimNode(schema, false);
 }
@@ -40,10 +65,19 @@ function slimNode(node, nameKeyed) {
     if (node === null || typeof node !== "object")
         return node;
     const out = {};
+    const defaultValue = nameKeyed
+        ? undefined
+        : node.default;
     for (const [key, value] of Object.entries(node)) {
         if (!nameKeyed) {
             if (key === "$schema")
                 continue;
+            if (key === "description" && typeof value === "string") {
+                const text = stripDefaultPhrase(value, defaultValue);
+                if (text)
+                    out[key] = text;
+                continue;
+            }
             if (key === "minimum" && value === SAFE_INT_MIN)
                 continue;
             if (key === "maximum" && value === SAFE_INT_MAX)

package/dist/lib/strip-comments.js

@@ -1,4 +1,4 @@
-// Pure helpers for tm1_get_process_code's stripComments mode. No I/O.
+// Pure helpers for tm1_get_process's stripComments mode. No I/O.
 //
 // TM1 TI code uses only `#` line comments (no block comments); `#` starts a
 // comment that runs to end of line. Grown models accumulate large blocks of

package/dist/lib/tm1-events.d.ts

@@ -2,6 +2,8 @@ import { EventEmitter } from "node:events";
 export interface Tm1MutationEvent {
     method: string;
     path: string;
+    /** connectionIdOf() of the connection that mutated; see config.ts. */
+    connectionId?: string;
 }
 interface Tm1Events {
     mutation: (e: Tm1MutationEvent) => void;

package/dist/prompts/index.js

@@ -72,8 +72,8 @@ export function registerAllPrompts(server) {
         `Diagnose why TI process **${processName}** failed. Follow this sequence:`,
         "",
         `1. **Error logs**: call \`tm1_diagnose_process_error(processName="${processName}", includeRelated=true, tail=80)\` — pulls newest logs + cascade siblings (sub-processes failing seconds apart).`,
-        `2. **Parameters**: call \`tm1_get_process_parameters(processName="${processName}")\` — verify the call site passed the right shape.`,
-        `3. **Source code**: call \`tm1_get_process_code(processName="${processName}")\` to inspect Prolog/Metadata/Data/Epilog.`,
+        `2. **Parameters**: call \`tm1_get_process(processName="${processName}", includeCode=false)\` — verify the call site passed the right shape.`,
+        `3. **Source code**: call \`tm1_get_process(processName="${processName}")\` to inspect Prolog/Metadata/Data/Epilog.`,
         `4. **Static refs**: call \`tm1_validate_process_refs(processName="${processName}")\` — surfaces unresolved cube/dimension references.`,
         `5. **Callgraph**: call \`tm1_analyze_callgraph(processName="${processName}", summary=true)\` — what does this process call, what calls it.`,
         `6. **Server log** (v11 only): \`tm1_get_message_log(filter="${processName}", top=50)\` for server-side correlation. Skip on v12 — the message log endpoint is deprecated there and the tool is not registered.`,

package/dist/resources/index.d.ts

@@ -1,5 +1,7 @@
 import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { TM1Client } from "../tm1-client.js";
+import { type ClientSource } from "../tools/define-tool.js";
 import type { ResourceCatalog } from "./list-handler.js";
-export declare function registerAllResources(server: McpServer, tm1: TM1Client): ResourceCatalog;
+export declare function registerAllResources(server: McpServer, source: ClientSource): ResourceCatalog;
+/** URIs of every connection's server-state resource, keyed by connectionId. */
+export declare function stateResourceUris(source: ClientSource): Map<string, string>;
 //# sourceMappingURL=index.d.ts.map

package/dist/resources/index.js

@@ -7,6 +7,7 @@
 // Each resource maps to an existing TM1 service call — same backend logic
 // as the get_* tools, different MCP entry point.
 import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { asRegistry } from "../tools/define-tool.js";
 import { maskCode } from "../lib/mask-secrets.js";
 function asJsonContent(uri, payload) {
     return {
@@ -19,15 +20,41 @@ function asJsonContent(uri, payload) {
         ],
     };
 }
-export function registerAllResources(server, tm1) {
+export function registerAllResources(server, source) {
     // Build a parallel catalog as we go so installPaginatedListHandler can
     // override SDK's default ListResourcesRequestSchema with cursor support.
     // registerResource still wires the read callbacks; we just keep our own
     // listing source of truth.
     const entries = [];
+    const registry = asRegistry(source);
+    for (const name of registry.usableNames) {
+        const single = registry.isSingle;
+        registerConnectionResources(server, entries, {
+            base: single ? "tm1://" : `tm1://${name}/`,
+            key: single ? "" : `${name}:`,
+            titlePrefix: single ? "" : `${name}: `,
+            client: () => registry.get(name),
+            enumerate: () => single || registry.isConnected(name),
+        });
+    }
+    return { entries };
+}
+/** URIs of every connection's server-state resource, keyed by connectionId. */
+export function stateResourceUris(source) {
+    const registry = asRegistry(source);
+    const uris = new Map();
+    for (const name of registry.usableNames) {
+        const uri = registry.isSingle
+            ? "tm1://server/state"
+            : `tm1://${name}/server/state`;
+        uris.set(uri, registry.info(name)?.connectionId ?? "");
+    }
+    return uris;
+}
+function registerConnectionResources(server, entries, ctx) {
     // ── Static endpoints ────────────────────────────────────────────────
-    server.registerResource("server-info", "tm1://server/info", {
-        title: "TM1 Server Info",
+    server.registerResource(`${ctx.key}server-info`, `${ctx.base}server/info`, {
+        title: `${ctx.titlePrefix}TM1 Server Info`,
         description: "TM1 server configuration snapshot: name, version, data directory, timezone, integrated security mode.",
         mimeType: "application/json",
     }, async (uri) => {
@@ -35,7 +62,7 @@ export function registerAllResources(server, tm1) {
         // carries the full merged /Configuration body, which can include
         // sensitive settings — resources have no params, so unlike the
         // curated tm1_get_server_info tool there is no place to opt in.
-        const info = await tm1.server.getInfo();
+        const info = await (await ctx.client()).server.getInfo();
         return asJsonContent(uri, {
             serverName: info.serverName,
             productVersion: info.productVersion,
@@ -49,28 +76,28 @@ export function registerAllResources(server, tm1) {
     entries.push({
         kind: "static",
         resource: {
-            uri: "tm1://server/info",
-            name: "server-info",
-            title: "TM1 Server Info",
+            uri: `${ctx.base}server/info`,
+            name: `${ctx.key}server-info`,
+            title: `${ctx.titlePrefix}TM1 Server Info`,
             description: "TM1 server configuration snapshot: name, version, data directory, timezone, integrated security mode.",
             mimeType: "application/json",
         },
     });
-    server.registerResource("server-state", "tm1://server/state", {
-        title: "TM1 Server State",
+    server.registerResource(`${ctx.key}server-state`, `${ctx.base}server/state`, {
+        title: `${ctx.titlePrefix}TM1 Server State`,
         description: "Health-check snapshot: connection state, version, capability flags, object counts (cubes/dimensions/processes/chores/clients).",
         mimeType: "application/json",
     }, async (uri) => {
         const [info, cubes, dims, procs, chores, clients] = await Promise.all([
-            tm1.server.getInfo(),
-            tm1.cubes.list(),
-            tm1.dimensions.list(),
-            tm1.processes.list(),
-            tm1.chores.list(),
-            tm1.security.listClients(),
+            (await ctx.client()).server.getInfo(),
+            (await ctx.client()).cubes.list(),
+            (await ctx.client()).dimensions.list(),
+            (await ctx.client()).processes.list({ namesOnly: true }),
+            (await ctx.client()).chores.list(),
+            (await ctx.client()).security.listClients(),
         ]);
         return asJsonContent(uri, {
-            connected: tm1.isConnected(),
+            connected: (await ctx.client()).isConnected(),
             server: {
                 name: info.serverName,
                 productVersion: info.productVersion,
@@ -89,25 +116,29 @@ export function registerAllResources(server, tm1) {
     entries.push({
         kind: "static",
         resource: {
-            uri: "tm1://server/state",
-            name: "server-state",
-            title: "TM1 Server State",
+            uri: `${ctx.base}server/state`,
+            name: `${ctx.key}server-state`,
+            title: `${ctx.titlePrefix}TM1 Server State`,
             description: "Health-check snapshot: connection state, version, capability flags, object counts (cubes/dimensions/processes/chores/clients).",
             mimeType: "application/json",
         },
     });
     // ── Resource templates ──────────────────────────────────────────────
-    // Process source code — `tm1://process/{name}/code`
-    server.registerResource("process-code", new ResourceTemplate("tm1://process/{name}/code", {
+    // Process source code — `tm1://[<connection>/]process/{name}/code`
+    server.registerResource(`${ctx.key}process-code`, new ResourceTemplate(`${ctx.base}process/{name}/code`, {
         list: async () => {
-            const procs = await tm1.processes.list();
+            if (!ctx.enumerate())
+                return { resources: [] };
+            const procs = await (await ctx.client()).processes.list({
+                namesOnly: true,
+            });
             return {
                 resources: procs
                     .filter((p) => !p.name.startsWith("}"))
                     .map((p) => ({
-                    name: `process-code-${p.name}`,
-                    uri: `tm1://process/${encodeURIComponent(p.name)}/code`,
-                    title: `TI: ${p.name}`,
+                    name: `${ctx.key}process-code-${p.name}`,
+                    uri: `${ctx.base}process/${encodeURIComponent(p.name)}/code`,
+                    title: `${ctx.titlePrefix}TI: ${p.name}`,
                     description: `Source code (Prolog/Metadata/Data/Epilog) of TI process '${p.name}'.`,
                     mimeType: "application/json",
                 })),
@@ -115,7 +146,9 @@ export function registerAllResources(server, tm1) {
         },
         complete: {
             name: async (value) => {
-                const procs = await tm1.processes.list();
+                const procs = await (await ctx.client()).processes.list({
+                    namesOnly: true,
+                });
                 const lower = value.toLowerCase();
                 return procs
                     .filter((p) => !p.name.startsWith("}") && p.name.toLowerCase().includes(lower))
@@ -124,15 +157,15 @@ export function registerAllResources(server, tm1) {
             },
         },
     }), {
-        title: "TI Process Source Code",
-        description: "Source code of any TurboIntegrator process by name. URI: tm1://process/{name}/code.",
+        title: `${ctx.titlePrefix}TI Process Source Code`,
+        description: `Source code of any TurboIntegrator process by name. URI: ${ctx.base}process/{name}/code.`,
         mimeType: "application/json",
     }, async (uri, vars) => {
         const raw = vars.name;
         const name = decodeURIComponent(Array.isArray(raw) ? raw[0] : (raw ?? ""));
-        const code = await tm1.processes.getCode(name);
+        const code = await (await ctx.client()).processes.getCode(name);
         // Hard-mask credential literals unconditionally: resources take no
-        // parameters, so unlike tm1_get_process_code there is no maskSecrets
+        // parameters, so unlike tm1_get_process there is no maskSecrets
         // opt-out — returning the code verbatim would bypass the tool-path
         // redaction (ODBCOpen passwords, credential assignments).
         return asJsonContent(uri, {
@@ -145,38 +178,44 @@ export function registerAllResources(server, tm1) {
     entries.push({
         kind: "template",
         templateMetadata: {
-            title: "TI Process Source Code",
-            description: "Source code of any TurboIntegrator process by name. URI: tm1://process/{name}/code.",
+            title: `${ctx.titlePrefix}TI Process Source Code`,
+            description: `Source code of any TurboIntegrator process by name. URI: ${ctx.base}process/{name}/code.`,
             mimeType: "application/json",
         },
         list: async () => {
-            const procs = await tm1.processes.list();
+            if (!ctx.enumerate())
+                return { resources: [] };
+            const procs = await (await ctx.client()).processes.list({
+                namesOnly: true,
+            });
             return {
                 resources: procs
                     .filter((p) => !p.name.startsWith("}"))
                     .map((p) => ({
-                    name: `process-code-${p.name}`,
-                    uri: `tm1://process/${encodeURIComponent(p.name)}/code`,
-                    title: `TI: ${p.name}`,
+                    name: `${ctx.key}process-code-${p.name}`,
+                    uri: `${ctx.base}process/${encodeURIComponent(p.name)}/code`,
+                    title: `${ctx.titlePrefix}TI: ${p.name}`,
                     description: `Source code (Prolog/Metadata/Data/Epilog) of TI process '${p.name}'.`,
                     mimeType: "application/json",
                 })),
             };
         },
     });
-    // Cube rules — `tm1://cube/{name}/rules`
-    server.registerResource("cube-rules", new ResourceTemplate("tm1://cube/{name}/rules", {
+    // Cube rules — `tm1://[<connection>/]cube/{name}/rules`
+    server.registerResource(`${ctx.key}cube-rules`, new ResourceTemplate(`${ctx.base}cube/{name}/rules`, {
         list: async () => {
+            if (!ctx.enumerate())
+                return { resources: [] };
             // Filter to cubes that actually carry rules — avoids cluttering
             // the resource tree with rule-less cubes whose body is "".
-            const cubes = await tm1.cubes.list({ includeRules: true });
+            const cubes = await (await ctx.client()).cubes.list({ includeRules: true });
             return {
                 resources: cubes
                     .filter((c) => !c.name.startsWith("}") && c.hasRules)
                     .map((c) => ({
-                    name: `cube-rules-${c.name}`,
-                    uri: `tm1://cube/${encodeURIComponent(c.name)}/rules`,
-                    title: `Rules: ${c.name}`,
+                    name: `${ctx.key}cube-rules-${c.name}`,
+                    uri: `${ctx.base}cube/${encodeURIComponent(c.name)}/rules`,
+                    title: `${ctx.titlePrefix}Rules: ${c.name}`,
                     description: `Rules text of cube '${c.name}' (SKIPCHECK + FEEDERS sections).`,
                     mimeType: "text/plain",
                 })),
@@ -184,7 +223,7 @@ export function registerAllResources(server, tm1) {
         },
         complete: {
             name: async (value) => {
-                const cubes = await tm1.cubes.list();
+                const cubes = await (await ctx.client()).cubes.list();
                 const lower = value.toLowerCase();
                 return cubes
                     .filter((c) => !c.name.startsWith("}") && c.name.toLowerCase().includes(lower))
@@ -193,13 +232,13 @@ export function registerAllResources(server, tm1) {
             },
         },
     }), {
-        title: "Cube Rules Text",
-        description: "Rules text of any TM1 cube by name. URI: tm1://cube/{name}/rules. Returns plain text.",
+        title: `${ctx.titlePrefix}Cube Rules Text`,
+        description: `Rules text of any TM1 cube by name. URI: ${ctx.base}cube/{name}/rules. Returns plain text.`,
         mimeType: "text/plain",
     }, async (uri, vars) => {
         const raw = vars.name;
         const name = decodeURIComponent(Array.isArray(raw) ? raw[0] : (raw ?? ""));
-        const rules = await tm1.cubes.getRules(name);
+        const rules = await (await ctx.client()).cubes.getRules(name);
         return {
             contents: [
                 {
@@ -213,25 +252,26 @@ export function registerAllResources(server, tm1) {
     entries.push({
         kind: "template",
         templateMetadata: {
-            title: "Cube Rules Text",
-            description: "Rules text of any TM1 cube by name. URI: tm1://cube/{name}/rules. Returns plain text.",
+            title: `${ctx.titlePrefix}Cube Rules Text`,
+            description: `Rules text of any TM1 cube by name. URI: ${ctx.base}cube/{name}/rules. Returns plain text.`,
             mimeType: "text/plain",
         },
         list: async () => {
-            const cubes = await tm1.cubes.list({ includeRules: true });
+            if (!ctx.enumerate())
+                return { resources: [] };
+            const cubes = await (await ctx.client()).cubes.list({ includeRules: true });
             return {
                 resources: cubes
                     .filter((c) => !c.name.startsWith("}") && c.hasRules)
                     .map((c) => ({
-                    name: `cube-rules-${c.name}`,
-                    uri: `tm1://cube/${encodeURIComponent(c.name)}/rules`,
-                    title: `Rules: ${c.name}`,
+                    name: `${ctx.key}cube-rules-${c.name}`,
+                    uri: `${ctx.base}cube/${encodeURIComponent(c.name)}/rules`,
+                    title: `${ctx.titlePrefix}Rules: ${c.name}`,
                     description: `Rules text of cube '${c.name}' (SKIPCHECK + FEEDERS sections).`,
                     mimeType: "text/plain",
                 })),
             };
         },
     });
-    return { entries };
 }
 //# sourceMappingURL=index.js.map

package/dist/resources/subscriptions.d.ts

@@ -3,9 +3,10 @@ import type pino from "pino";
 export declare class SubscriptionRegistry {
     private readonly server;
     private readonly logger;
+    private readonly stateUris;
     private readonly subscribed;
     private mutationListener?;
-    constructor(server: McpServer, logger: pino.Logger);
+    constructor(server: McpServer, logger: pino.Logger, stateUris?: ReadonlyMap<string, string>);
     /** Install subscribe/unsubscribe request handlers + mutation listener. */
     install(): void;
     /** Detach listener — used for shutdown / tests. */