@ffschrattenecker/tm1-mcp-server 6.0.0 → 7.0.0

package/dist/tools/analysis/delete-impact.d.ts

@@ -0,0 +1,13 @@
+import type { TM1Client } from "../../tm1-client.js";
+export declare function deleteImpact(tm1Client: TM1Client, kind: "cube" | "dimension", name: string): Promise<{
+    sources: {
+        sourceKind: "process" | "rule";
+        sourceName: string;
+        accessTypes: string[];
+        count: number;
+    }[];
+    truncated?: boolean;
+    referencingSources: number;
+    usedInCubes?: string[];
+}>;
+//# sourceMappingURL=delete-impact.d.ts.map

package/dist/tools/analysis/delete-impact.js

@@ -0,0 +1,30 @@
+import { buildIndexFromTM1 } from "../../lib/callgraph/tm1-adapter.js";
+import { buildCubeOrDimUsages } from "../../lib/callgraph/callGraph.js";
+import { summarizeBySource } from "./analyze-object-usage.js";
+const MAX_SOURCES = 50;
+export async function deleteImpact(tm1Client, kind, name) {
+    const [index, cubes] = await Promise.all([
+        buildIndexFromTM1(tm1Client, { includeControl: false }),
+        kind === "dimension" ? tm1Client.cubes.list() : Promise.resolve([]),
+    ]);
+    const sources = summarizeBySource(buildCubeOrDimUsages(index, kind, name, {
+        includeSystem: false,
+        accessMode: "all",
+    }));
+    const key = name.toLowerCase();
+    const usedInCubes = cubes
+        .filter((c) => (c.dimensions ?? []).some((d) => d.toLowerCase() === key))
+        .map((c) => c.name);
+    return {
+        ...(kind === "dimension" ? { usedInCubes } : {}),
+        referencingSources: sources.length,
+        ...(sources.length > MAX_SOURCES ? { truncated: true } : {}),
+        sources: sources.slice(0, MAX_SOURCES).map((s) => ({
+            sourceKind: s.sourceKind,
+            sourceName: s.sourceName,
+            accessTypes: s.accessTypes,
+            count: s.count,
+        })),
+    };
+}
+//# sourceMappingURL=delete-impact.js.map

package/dist/tools/analysis/invalidate-callgraph-cache.js

@@ -7,8 +7,9 @@ export const registerInvalidateCallgraphCache = defineTool({
     description: "Drop the in-memory ReferenceIndex cache used by tm1_analyze_callgraph / tm1_analyze_object_usage / tm1_analyze_chore_graph. Rarely needed: every successful mutating call through this server already drops it. Use it only after changes made outside this server (Workspace, TI, another client). The next analysis call rebuilds the index (single bulk fetch). Touches no TM1 object, so it is available in readonly mode.",
     annotations: READ_ONLY,
     output: InvalidateCallgraphCacheResultSchema,
-    // Takes no arguments: the cache is process-wide.
+    // Takes no arguments and no connection: the cache is process-wide.
     input: {},
+    connectionless: true,
     handler: () => {
         try {
             const before = getCallgraphCacheStats();

package/dist/tools/analysis/trace-data-flow.js

@@ -13,7 +13,7 @@ const FLOW_MAX_ITEMS = 500;
 export const registerTraceDataFlow = defineTool({
     name: "tm1_trace_data_flow",
     description: [
-        "Trace data flow into and out of a cube in one call, instead of analyze_object_usage + N× get_process_code.",
+        "Trace data flow into and out of a cube in one call, instead of analyze_object_usage + N× get_process.",
         "downstream: processes that READ the cube and which cubes they WRITE to (where the data flows next).",
         "upstream: processes that WRITE the cube and where they SOURCE data (read cubes + datasource).",
         "Combines code-level CellGet/CellPut/DB access with each process's datasource, so view-sourced reads",

package/dist/tools/celldata/write-cells.js

@@ -6,6 +6,12 @@ import { MutationResultSchema } from "../schemas/items.js";
 import { defineTool } from "../define-tool.js";
 import { dimensionCountMismatch } from "../../lib/coordinate-error.js";
 import { resolveCellAddress } from "../../lib/cell-address.js";
+const READ_BACK_LIMIT = 20;
+function sameValue(sent, stored) {
+    if (typeof sent === "number")
+        return Number(stored) === sent;
+    return String(stored ?? "") === sent;
+}
 export const registerWriteCells = defineTool({
     name: "tm1_write_cells",
     description: [
@@ -14,7 +20,8 @@ export const registerWriteCells = defineTool({
         "Writes to consolidated cells are rejected by TM1.",
         "Every cube dimension must be named (any order) — a dimension left out would land on its default member, so the call is refused. Only Sandboxes may be left out: it is bound to Base and echoed as sandboxDefaulted. A named sandbox is addressable only once its IncludeInSandboxDimension is true.",
         "Before: tm1_check_writable_coords to validate that target coordinates are leaf-level and addressable.",
-        "Related: tm1_clear_cube for bulk wipe, tm1_get_cell_value to read back, tm1_execute_process for production data loads.",
+        "The written cells are read back (up to 20; verified.mismatches lists any that differ, e.g. a rule or spread overriding the value), so no separate tm1_get_cell_value is needed.",
+        "Related: tm1_clear_cube for bulk wipe, tm1_execute_process for production data loads.",
     ],
     annotations: DESTRUCTIVE,
     output: MutationResultSchema,
@@ -52,10 +59,38 @@ export const registerWriteCells = defineTool({
         // propagate to the index.ts Proxy unwrapped — wrapping it here would
         // clobber that hint with a generic one.
         const address = resolveCellAddress(cubeName, await tm1Client.cubes.getDimensionNames(cubeName), dimensions);
-        await tm1Client.cells.writeCells(cubeName, address.dimensions, cells.map((c) => ({ ...c, elements: address.toCubeOrder(c.elements) })));
+        const ordered = cells.map((c) => ({
+            ...c,
+            elements: address.toCubeOrder(c.elements),
+        }));
+        await tm1Client.cells.writeCells(cubeName, address.dimensions, ordered);
+        // Read back a bounded sample: each read is its own MDX round trip. The
+        // write has landed by now, so a failed read-back is reported, not thrown.
+        const sample = ordered.slice(0, READ_BACK_LIMIT);
+        let verified;
+        try {
+            const readBack = await Promise.all(sample.map((c) => tm1Client.cells.getValue(cubeName, c.elements)));
+            verified = {
+                checked: sample.length,
+                ...(cells.length > sample.length
+                    ? { unchecked: cells.length - sample.length }
+                    : {}),
+                mismatches: sample
+                    .map((c, i) => ({
+                    elements: c.elements,
+                    sent: c.value,
+                    stored: readBack[i],
+                }))
+                    .filter((m) => !sameValue(m.sent, m.stored)),
+            };
+        }
+        catch (e) {
+            verified = { checked: 0, readBackError: e.message };
+        }
         return actionResponse({
             success: true,
             cellsWritten: cells.length,
+            verified,
             ...(address.sandboxDefaulted
                 ? { sandboxDefaulted: address.sandboxDefaulted }
                 : {}),

package/dist/tools/confirm.d.ts

@@ -2,7 +2,10 @@ import { z } from "zod";
 export declare const CONFIRM_SCHEMA: {
     confirm: z.ZodString;
 };
-export declare function requireConfirm(provided: string, target: string, kind: string): void;
+export declare const DRY_RUN_CONFIRM_SCHEMA: {
+    confirm: z.ZodOptional<z.ZodString>;
+};
+export declare function requireConfirm(provided: string | undefined, target: string, kind: string): void;
 export declare const OVERWRITE_CONFIRM_SCHEMA: {
     confirm: z.ZodOptional<z.ZodString>;
 };

package/dist/tools/confirm.js

@@ -27,13 +27,23 @@ import { TM1Error, TM1ErrorCode } from "../types.js";
 export const CONFIRM_SCHEMA = {
     confirm: z
         .string()
-        .describe("Safety check: repeat the target identifier verbatim (e.g. cube/dimension/process name) to confirm this irreversible action. Mismatched values reject the call."),
+        .describe("Repeat the target name verbatim to confirm this irreversible action; a mismatch rejects the call."),
+};
+// For a destructive tool with a dryRun: a dry run needs no confirm, so the
+// field is optional in the schema and required at runtime on the real call.
+export const DRY_RUN_CONFIRM_SCHEMA = {
+    confirm: z
+        .string()
+        .optional()
+        .describe("Required unless dryRun=true: repeat the target identifier verbatim to confirm this irreversible action. A dry run is not a confirmation."),
 };
 export function requireConfirm(provided, target, kind) {
     if (provided !== target) {
         throw new TM1Error({
             code: TM1ErrorCode.VALIDATION_ERROR,
-            message: `confirm mismatch — expected ${kind} name "${target}", got "${provided}".`,
+            message: provided === undefined
+                ? `This call is irreversible for ${kind} "${target}" and needs confirm="${target}". Nothing was changed.`
+                : `confirm mismatch — expected ${kind} name "${target}", got "${provided}".`,
             hint: `Re-issue the call with confirm="${target}" verbatim. This safety check prevents accidental destructive operations.`,
         });
     }

package/dist/tools/define-tool.d.ts

@@ -1,10 +1,18 @@
 import type { McpServer, ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ZodObject, ZodRawShape, ZodTypeAny } from "zod";
+import { type ZodObject, type ZodRawShape, type ZodTypeAny } from "zod";
 import type { TM1Client } from "../tm1-client.js";
+import { ConnectionRegistry } from "../connections.js";
 import type { Tm1ToolAnnotations } from "./annotations.js";
+/**
+ * Where a tool gets its client from: the multi-connection registry in
+ * production, or one prebuilt client (unit tests, embedders), which is wrapped
+ * as a single-connection registry.
+ */
+export type ClientSource = TM1Client | ConnectionRegistry;
 /** Registrar shape expected by the REGISTRARS array in ./index.ts. */
-export type ToolRegistrar = (server: McpServer, tm1Client: TM1Client) => void;
-export interface ToolSpec<I extends ZodRawShape> {
+export type ToolRegistrar = (server: McpServer, source: ClientSource) => void;
+export declare function asRegistry(source: ClientSource): ConnectionRegistry;
+interface ToolSpecBase<I extends ZodRawShape> {
     /** Wire name, `tm1_*`. */
     name: string;
     /**
@@ -24,19 +32,34 @@ export interface ToolSpec<I extends ZodRawShape> {
     /** MCP behavior hints — one of the presets in ./annotations.js. */
     annotations: Tm1ToolAnnotations;
     /**
-     * Registration gate for tools that exist on one TM1 generation only (v11
-     * threads vs v12 jobs, v11-only save_data). Returning false skips the tool
-     * entirely — it never appears in tools/list. This is deliberately separate
-     * from the `requiresVersion` annotation, which is a client-facing HINT and
-     * is also carried by tools that stay registered on both generations.
+     * Gate for tools that exist on one TM1 generation only (v11 threads vs v12
+     * jobs, v11-only save_data). The tool is registered only when at least one
+     * connection runs that version, and a call against a connection on the other
+     * version is refused. This is deliberately separate from the
+     * `requiresVersion` annotation, which is a client-facing HINT and is also
+     * carried by tools that stay registered on both generations.
      */
-    enabled?: (tm1Client: TM1Client) => boolean;
+    version?: 11 | 12;
+}
+/** A tool that acts on one TM1 connection — every tool but a handful. */
+interface ConnectionToolSpec<I extends ZodRawShape> extends ToolSpecBase<I> {
+    connectionless?: false;
     /**
-     * Handler. Receives the parsed args, the shared TM1 client, and the SDK's
-     * per-call extra (abort signal, request metadata).
+     * Handler. Receives the parsed args, the client of the connection the call
+     * targets, and the SDK's per-call extra (abort signal, request metadata).
      */
     handler: (args: Parameters<ToolCallback<I>>[0], tm1Client: TM1Client, extra: Parameters<ToolCallback<I>>[1]) => ReturnType<ToolCallback<I>>;
 }
+/**
+ * A tool about the connections themselves (tm1_list_connections): it takes no
+ * `connection` argument and gets the registry instead of a client, so calling
+ * it never logs in anywhere.
+ */
+interface ConnectionlessToolSpec<I extends ZodRawShape> extends ToolSpecBase<I> {
+    connectionless: true;
+    handler: (args: Parameters<ToolCallback<I>>[0], registry: ConnectionRegistry, extra: Parameters<ToolCallback<I>>[1]) => ReturnType<ToolCallback<I>>;
+}
+export type ToolSpec<I extends ZodRawShape> = ConnectionToolSpec<I> | ConnectionlessToolSpec<I>;
 /** What ./with-annotations.ts needs at registration time. */
 export interface ResolvedSpec {
     name: string;
@@ -48,4 +71,5 @@ export declare function specFor(name: string): ResolvedSpec | undefined;
 /** Every spec defined so far. Used by the lint gates and by tests. */
 export declare function allSpecs(): ReadonlyMap<string, ResolvedSpec>;
 export declare function defineTool<I extends ZodRawShape>(spec: ToolSpec<I>): ToolRegistrar;
+export {};
 //# sourceMappingURL=define-tool.d.ts.map

package/dist/tools/define-tool.js

@@ -1,5 +1,13 @@
+import { z } from "zod";
+import { ConnectionRegistry } from "../connections.js";
+import { TM1Error, TM1ErrorCode } from "../types.js";
 import { asOutputSchema } from "./schemas/output-schema.js";
 import { markdownCapable } from "./schemas/markdown-capable.js";
+export function asRegistry(source) {
+    return source instanceof ConnectionRegistry
+        ? source
+        : ConnectionRegistry.single(source);
+}
 // Populated at module-load time, when a tool file's top-level defineTool()
 // call runs. That is strictly before registerAllTools() executes, because the
 // import graph resolves first — so the Proxy always finds the spec.
@@ -36,14 +44,53 @@ export function defineTool(spec) {
         // `outputSchema: undefined` for an optional property.
         ...(outputSchema === undefined ? {} : { outputSchema }),
     });
-    return (server, tm1Client) => {
-        if (spec.enabled && !spec.enabled(tm1Client))
+    return (server, source) => {
+        const registry = asRegistry(source);
+        if (spec.connectionless) {
+            const handler = spec.handler;
+            const cb = ((args, extra) => handler(args, registry, extra));
+            server.tool(spec.name, description, spec.input, cb);
+            return;
+        }
+        const handler = spec.handler;
+        if (spec.version !== undefined && !registry.hasVersion(spec.version)) {
             return;
+        }
+        // One connection: the input shape is exactly what the tool declares. More
+        // than one: every tool takes a `connection` naming the target.
+        const input = registry.isSingle
+            ? spec.input
+            : {
+                ...spec.input,
+                connection: z
+                    .enum(registry.usableNames)
+                    .describe("Target TM1 connection."),
+            };
         // ToolCallback<I> is a conditional type over an unresolved generic, so TS
         // cannot check the lambda against it — the cast asserts what the
         // ToolSpec.handler signature already pins down (same args, same return).
-        const cb = ((args, extra) => spec.handler(args, tm1Client, extra));
-        server.tool(spec.name, description, spec.input, cb);
+        const cb = (async (args, extra) => {
+            const { connection, ...rest } = args;
+            const info = registry.resolveInfo(connection);
+            if (!spec.annotations.readOnlyHint && info.mode === "readonly") {
+                throw new TM1Error({
+                    code: TM1ErrorCode.PERMISSION_DENIED,
+                    message: `${spec.name} changes TM1, but connection "${info.name}" is readonly.`,
+                    hint: info.modeReason ??
+                        "Set TM1_MODE=readwrite in that connection's .env to allow writes.",
+                });
+            }
+            if (spec.version !== undefined && info.version !== spec.version) {
+                throw new TM1Error({
+                    code: TM1ErrorCode.UNSUPPORTED_OPERATION,
+                    message: `${spec.name} needs TM1 v${spec.version}; connection "${info.name}" is v${info.version}.`,
+                    hint: `Pick a v${spec.version} connection, or use the v${info.version} equivalent.`,
+                });
+            }
+            const tm1Client = await registry.get(connection);
+            return handler(rest, tm1Client, extra);
+        });
+        server.tool(spec.name, description, input, cb);
     };
 }
 //# sourceMappingURL=define-tool.js.map

package/dist/tools/dimension-management/delete-dimension.js

@@ -1,22 +1,36 @@
 import { z } from "zod";
 import { actionResponse } from "../format.js";
-import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { DRY_RUN_CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
 import { DESTRUCTIVE } from "../annotations.js";
 import { MutationResultSchema } from "../schemas/items.js";
 import { defineTool } from "../define-tool.js";
+import { deleteImpact } from "../analysis/delete-impact.js";
 export const registerDeleteDimension = defineTool({
     name: "tm1_delete_dimension",
     description: [
         "Delete a TM1 dimension and all its hierarchies. Warning: fails if the dimension is used in a cube.",
-        "Before: tm1_find_orphan_dimensions to confirm the dimension is unused, or tm1_analyze_object_usage for a targeted check.",
+        "Before: dryRun=true lists the cubes that contain it and every process or rule that references it, in one call.",
     ],
     annotations: DESTRUCTIVE,
     output: MutationResultSchema,
     input: {
         dimensionName: z.string().describe("Dimension name (case-sensitive)"),
-        ...CONFIRM_SCHEMA,
+        dryRun: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Delete nothing: return what references the dimension (processes and rules, per source) and the cubes it is part of. Needs no confirm and is not one."),
+        ...DRY_RUN_CONFIRM_SCHEMA,
     },
-    handler: async ({ dimensionName, confirm }, tm1Client) => {
+    handler: async ({ dimensionName, dryRun, confirm }, tm1Client) => {
+        if (dryRun) {
+            return actionResponse({
+                success: true,
+                dryRun: true,
+                dimensionName,
+                impact: await deleteImpact(tm1Client, "dimension", dimensionName),
+            });
+        }
         requireConfirm(confirm, dimensionName, "dimension");
         await tm1Client.dimensions.delete(dimensionName);
         return actionResponse({ success: true, dimensionName });

package/dist/tools/index.d.ts

@@ -1,4 +1,4 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { TM1Client } from "../tm1-client.js";
-export declare function registerAllTools(server: McpServer, tm1Client: TM1Client): void;
+import type { ClientSource } from "./define-tool.js";
+export declare function registerAllTools(server: McpServer, source: ClientSource): void;
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -20,11 +20,7 @@ import { registerTraceFeeders } from "./celldata/trace-feeders.js";
 import { registerTraceCellCalculation } from "./celldata/trace-cell-calculation.js";
 // TI development tools (process CRUD, execution, code, params, datasource)
 import { registerExecuteProcess } from "./ti-development/execute-process.js";
-import { registerGetProcessParameters } from "./ti-development/get-process-parameters.js";
-import { registerGetProcessCode } from "./ti-development/get-process-code.js";
 import { registerGetProcess } from "./ti-development/get-process.js";
-import { registerGetProcessDatasource } from "./ti-development/get-process-datasource.js";
-import { registerGetProcessVariables } from "./ti-development/get-process-variables.js";
 import { registerDeleteProcess } from "./ti-development/delete-process.js";
 import { registerCopyProcess } from "./ti-development/copy-process.js";
 import { registerCompileProcess } from "./ti-development/compile-process.js";
@@ -84,6 +80,7 @@ import { registerCreateChore } from "./scheduling/create-chore.js";
 import { registerUpdateChore } from "./scheduling/update-chore.js";
 import { registerDeleteChore } from "./scheduling/delete-chore.js";
 // Operations tools
+import { registerListConnections } from "./operations/list-connections.js";
 import { registerGetMessageLog } from "./operations/get-message-log.js";
 import { registerGetThreads } from "./operations/get-threads.js";
 import { registerGetJobs } from "./operations/get-jobs.js";
@@ -150,14 +147,10 @@ const REGISTRARS = [
     registerTraceFeeders,
     registerTraceCellCalculation,
     registerCheckWritableCoords,
-    // TI development — writes go through registerUpsertProcess (bundled),
-    // reads remain atomic for inspection without pulling full process code.
+    // TI development — writes go through registerUpsertProcess and reads
+    // through registerGetProcess (include-flags pick the parts).
     registerExecuteProcess,
-    registerGetProcessParameters,
-    registerGetProcessCode,
     registerGetProcess,
-    registerGetProcessDatasource,
-    registerGetProcessVariables,
     registerDeleteProcess,
     registerCopyProcess,
     registerCompileProcess,
@@ -216,6 +209,7 @@ const REGISTRARS = [
     registerUpdateChore,
     registerDeleteChore,
     // Operations
+    registerListConnections,
     registerGetMessageLog,
     registerGetThreads,
     registerGetJobs,
@@ -256,8 +250,8 @@ const REGISTRARS = [
     registerAssignClientGroup,
     registerRemoveClientGroup,
 ];
-export function registerAllTools(server, tm1Client) {
+export function registerAllTools(server, source) {
     for (const register of REGISTRARS)
-        register(server, tm1Client);
+        register(server, source);
 }
 //# sourceMappingURL=index.js.map

package/dist/tools/metadata/list-cubes.js

@@ -11,7 +11,7 @@ export const registerListCubes = defineTool({
     name: "tm1_list_cubes",
     description: [
         "List cubes in the TM1 server. Control cubes ('}'-prefixed) excluded unless includeControl=true.",
-        "Combinable name filters (nameExact/nameContains/nameRegex) and projection toggles (includeDimensions, includeRules) trim payload on wide models.",
+        "Returns names; includeDimensions / includeRules add each cube's dimensions[] / hasRules. Combinable name filters: nameExact/nameContains/nameRegex.",
         "Paginated (default 50/page).",
     ],
     annotations: READ_ONLY,
@@ -27,8 +27,8 @@ export const registerListCubes = defineTool({
         includeDimensions: z
             .boolean()
             .optional()
-            .default(true)
-            .describe("Include the dimensions[] array per cube (default: true). Set false for compact output on wide cubes."),
+            .default(false)
+            .describe("Include the dimensions[] array per cube."),
         includeRules: z
             .boolean()
             .optional()

package/dist/tools/metadata/list-processes.js

@@ -10,8 +10,8 @@ import { pageShapeFor } from "../schemas/common.js";
 export const registerListProcesses = defineTool({
     name: "tm1_list_processes",
     description: [
-        "List TurboIntegrator processes (with parameters) in the TM1 server. Control processes ('}'-prefixed) excluded unless includeControl=true.",
-        "Name filters (nameContains/nameRegex/nameNotContains/excludePattern) and fields=['name'] projection trim payload on large models.",
+        "List TurboIntegrator process names in the TM1 server; fields=['name','parameters'] adds each process's parameters. Control processes ('}'-prefixed) excluded unless includeControl=true.",
+        "Name filters: nameContains/nameRegex/nameNotContains/excludePattern.",
         "Paginated (default 50/page).",
     ],
     annotations: READ_ONLY,
@@ -43,14 +43,17 @@ export const registerListProcesses = defineTool({
         fields: z
             .array(z.enum(["name", "parameters"]))
             .optional()
-            .describe("Projection. Default: all fields. Use ['name'] to skip parameters[] and shrink payload ~10x."),
+            .describe("Projection. Default ['name']; include 'parameters' for parameter lists (~10x larger)."),
     },
     handler: async ({ limit, offset, fetchAll, format, includeControl, nameContains, nameRegex, nameNotContains, excludePattern, fields, }, tm1Client) => {
-        const project = (list) => fields && !fields.includes("parameters")
-            ? list.map((p) => ({ name: p.name }))
-            : list;
+        // Names only unless parameters are asked for: listing is how a model
+        // orients, and the parameter blocks are ~10x the bytes of the names.
+        const withParameters = fields?.includes("parameters") ?? false;
+        const project = (list) => withParameters ? list : list.map((p) => ({ name: p.name }));
         const fullScan = async () => {
-            let processes = await tm1Client.processes.list();
+            let processes = await tm1Client.processes.list({
+                namesOnly: !withParameters,
+            });
             if (!includeControl)
                 processes = processes.filter((p) => !p.name.startsWith("}"));
             if (nameContains) {
@@ -79,6 +82,7 @@ export const registerListProcesses = defineTool({
         let page;
         if (canPushDown) {
             const { items, total } = await tm1Client.processes.list({
+                namesOnly: !withParameters,
                 includeControl,
                 ...(nameContains ? { nameContains } : {}),
                 ...(nameNotContains ? { nameNotContains } : {}),

package/dist/tools/model-building/delete-cube.js

@@ -3,22 +3,36 @@ import { defineTool } from "../define-tool.js";
 import { DESTRUCTIVE } from "../annotations.js";
 import { MutationResultSchema } from "../schemas/items.js";
 import { actionResponse } from "../format.js";
-import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { DRY_RUN_CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
 import { withToolHint } from "../error-format.js";
+import { deleteImpact } from "../analysis/delete-impact.js";
 export const registerDeleteCube = defineTool({
     name: "tm1_delete_cube",
     description: [
         "Delete a TM1 cube and all its data. This action is irreversible.",
         "Safety: pass confirm=<cube name verbatim>. Mismatched confirm rejects the call.",
-        "Before: tm1_analyze_object_usage to find rules or processes referencing the cube; tm1_get_cube_stats to size the data loss.",
+        "Before: dryRun=true lists every process or rule that references the cube, in one call; tm1_get_cube_stats sizes the data loss.",
     ],
     annotations: DESTRUCTIVE,
     output: MutationResultSchema,
     input: {
         cubeName: z.string().describe("Cube name (case-sensitive)"),
-        ...CONFIRM_SCHEMA,
+        dryRun: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Delete nothing: return what references the cube (processes and rules, per source). Needs no confirm and is not one."),
+        ...DRY_RUN_CONFIRM_SCHEMA,
     },
-    handler: async ({ cubeName, confirm }, tm1Client) => {
+    handler: async ({ cubeName, dryRun, confirm }, tm1Client) => {
+        if (dryRun) {
+            return actionResponse({
+                success: true,
+                dryRun: true,
+                cubeName,
+                impact: await deleteImpact(tm1Client, "cube", cubeName),
+            });
+        }
         requireConfirm(confirm, cubeName, "cube");
         await withToolHint(tm1Client.cubes.delete(cubeName), "Cube delete failed. Common causes: cube still referenced by TI processes / chores / rules (run tm1_analyze_object_usage to inspect), insufficient permissions, or cube does not exist (tm1_list_cubes to verify name + casing).");
         return actionResponse({ success: true, cubeName });

package/dist/tools/model-building/set-cube-rules.js

@@ -14,7 +14,7 @@ export const registerSetCubeRules = defineTool({
         "Create or replace the rules for a TM1 cube.",
         "SKIPCHECK; belongs at the top and FEEDERS; before all feeder definitions — SKIPCHECK is what makes feeders take effect, so rules with feeders need it.",
         "Pass exactly one source: rules (the full text — replaces everything), edits (find/replace patch against the current text; each find must match exactly once, else nothing is written), or filePath (full text from a host file under TM1_LOCAL_FILE_ROOT).",
-        "The full resulting text is syntax-checked before anything is written (preflight). After: tm1_get_cube_rules to read back; the callgraph cache is dropped automatically.",
+        "The full resulting text is syntax-checked before anything is written (preflight). The stored text is read back after writing (verified.textMatches), so no separate tm1_get_cube_rules is needed; the callgraph cache is dropped automatically.",
     ],
     annotations: IDEMPOTENT_DESTRUCTIVE,
     output: MutationResultSchema,
@@ -65,6 +65,17 @@ export const registerSetCubeRules = defineTool({
             }
         }
         await withToolHint(tm1Client.cubes.updateRules(cubeName, text), `Inspect details for the offending line.`);
+        // Read back what TM1 stored, compared with line endings normalized. The
+        // write has landed by now, so a failed read-back is reported, not thrown.
+        const norm = (x) => x.replace(/\r\n/g, "\n").trimEnd();
+        let verified;
+        try {
+            const stored = (await tm1Client.cubes.getRules(cubeName)).rulesText;
+            verified = { textMatches: norm(stored) === norm(text) };
+        }
+        catch (e) {
+            verified = { readBackError: e.message };
+        }
         const lineCount = text.split("\n").length;
         // Rule changes shift call edges (DB(), feeders) — drop callgraph TTL early.
         const { cleared: callgraphEntriesCleared } = invalidateCallgraphCache();
@@ -75,6 +86,7 @@ export const registerSetCubeRules = defineTool({
             lineCount,
             ...(edits !== undefined ? { editsApplied: edits.length } : {}),
             callgraphEntriesCleared,
+            verified,
         });
     },
 });

package/dist/tools/model-building/unload-cube.js

@@ -10,7 +10,7 @@ export const registerUnloadCube = defineTool({
     // v11 only. v12 answers tm1.Unload with "Demand load, loading and unloading
     // of cubes is no longer supported." — the feature is gone, with no successor
     // endpoint, so the tool is withheld rather than offered and refused.
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: MutationResultSchema,
     input: {
         cubeName: z.string().describe("Name of the cube to unload"),

package/dist/tools/operations/get-audit-log.js

@@ -11,7 +11,7 @@ export const registerGetAuditLog = defineTool({
     annotations: withVersion(READ_ONLY, "v11"),
     // v12 deprecated AuditLogEntry/AuditLogEntries in 12.0.0 and serves an empty
     // collection with no successor endpoint, so the tool can only mislead there.
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: {
         count: z.number().int(),
         entries: z.array(AuditLogEntrySchema),

package/dist/tools/operations/get-jobs.js

@@ -11,7 +11,7 @@ const registerListJobs = defineTool({
     name: "tm1_list_jobs",
     description: "List active jobs (Activity) on a TM1 v12 database — the running tasks that replaced v11 threads. Paginated (default 50/page). (v12 only)",
     annotations: READ_ONLY,
-    enabled: (tm1Client) => tm1Client.version === 12,
+    version: 12,
     output: pageShapeFor(JobSchema),
     input: { ...PAGINATION_SCHEMA, ...FORMAT_SCHEMA },
     handler: async ({ limit, offset, fetchAll, format }, tm1Client) => {
@@ -34,7 +34,7 @@ const registerCancelJob = defineTool({
         "(v12 only)",
     ],
     annotations: DESTRUCTIVE,
-    enabled: (tm1Client) => tm1Client.version === 12,
+    version: 12,
     output: MutationResultSchema,
     input: {
         jobId: z.string().describe("Job ID to cancel"),

package/dist/tools/operations/get-message-log.js

@@ -10,7 +10,7 @@ export const registerGetMessageLog = defineTool({
     // v12 deprecated MessageLogEntry/MessageLogEntries (and the MessageLog /
     // TailMessageLog functions) in 12.0.0; all of them serve empty with no
     // successor endpoint.
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: {
         count: z.number().int(),
         entries: z.array(MessageLogEntrySchema),

package/dist/tools/operations/get-server-info.js

@@ -27,10 +27,19 @@ export const registerGetServerInfo = defineTool({
     handler: async ({ format }, tm1Client) => {
         const info = await tm1Client.server.getInfo();
         const x = info.extra ?? {};
+        const access = tm1Client.access;
         const payload = {
             // The MCP server's own package identity, so a client can gate on it
             // without parsing the initialize handshake.
-            mcpServer: { name: NAME, version: VERSION },
+            // mode/environment let a client read what this connection may do and
+            // where it points, instead of inferring it from which tools are listed.
+            mcpServer: {
+                name: NAME,
+                version: VERSION,
+                mode: access.mode,
+                environment: access.environment ?? "unspecified",
+                ...(access.modeReason ? { modeReason: access.modeReason } : {}),
+            },
             serverName: info.serverName,
             productVersion: info.productVersion,
             productEdition: info.productEdition,