@ffschrattenecker/tm1-mcp-server 6.1.1 → 7.0.1

package/dist/tools/operations/list-connections.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { READ_ONLY } from "../annotations.js";
+const ConnectionSchema = z.object({
+    name: z.string(),
+    mode: z.enum(["readwrite", "readonly"]).optional(),
+    environment: z.enum(["dev", "test", "prod"]).optional(),
+    modeReason: z.string().optional(),
+    tm1Version: z.string().optional(),
+    connected: z.boolean(),
+    error: z.string().optional(),
+});
+export const registerListConnections = defineTool({
+    name: "tm1_list_connections",
+    description: "List the TM1 connections this server can reach: name (the `connection` argument of every other tool), readonly/readwrite mode, TM1_ENVIRONMENT label (and why mode was forced), TM1 version, and whether a session is open. Makes no TM1 call.",
+    annotations: READ_ONLY,
+    output: z.object({ connections: z.array(ConnectionSchema) }),
+    input: {},
+    connectionless: true,
+    handler: (_args, registry) => {
+        const connections = registry.status().map((c) => ({
+            name: c.name,
+            ...(c.mode && { mode: c.mode }),
+            ...(c.environment && { environment: c.environment }),
+            ...(c.modeReason && { modeReason: c.modeReason }),
+            ...(c.tm1Version && { tm1Version: c.tm1Version }),
+            connected: c.connected,
+            ...((c.configError ?? c.lastError) && {
+                error: c.configError ?? c.lastError,
+            }),
+        }));
+        return {
+            content: [
+                { type: "text", text: JSON.stringify({ connections }) },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=list-connections.js.map

package/dist/tools/operations/save-data.js

@@ -13,7 +13,7 @@ export const registerSaveData = defineTool({
         "Executes as an unbound TI process via ExecuteProcessWithReturn; no process object is created on the server.",
     ],
     annotations: withVersion(IDEMPOTENT_WRITE, "v11"),
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: MutationResultSchema,
     input: {
         cube: z

package/dist/tools/ti-development/execute-process.js

@@ -32,7 +32,7 @@ export const registerExecuteProcess = defineTool({
     description: [
         "Execute a TurboIntegrator process on the TM1 server with optional parameters.",
         "Non-idempotent: each call re-runs the process — do not retry blindly on transport errors without checking server state.",
-        "Before: tm1_check_process_code (syntax) and/or tm1_compile_process (full compile). Discover required params with tm1_get_process_parameters.",
+        "Before: tm1_check_process_code (syntax) and/or tm1_compile_process (full compile). Discover required params with tm1_get_process.",
         "When TM1 wrote an error log for the run (failure or minor errors), its last 40 lines come back as errorLog. For cascade siblings and older logs use tm1_diagnose_process_error.",
     ],
     annotations: DESTRUCTIVE,
@@ -86,7 +86,7 @@ export const registerExecuteProcess = defineTool({
             const result = await withToolHint(tm1Client.processes.execute(processName, parameters, {
                 signal: extra?.signal,
                 ...(timeoutMs ? { timeoutMs } : {}),
-            }), `Process '${processName}' failed at runtime. Inspect cascade with tm1_diagnose_process_error(processName='${processName}', includeRelated=true). Verify parameter shape via tm1_get_process_parameters; check syntax with tm1_compile_process before re-running.`);
+            }), `Process '${processName}' failed at runtime. Inspect cascade with tm1_diagnose_process_error(processName='${processName}', includeRelated=true). Verify parameter shape via tm1_get_process; check syntax with tm1_compile_process before re-running.`);
             // TM1 names the run's own error log when it wrote one (minor errors
             // included). Attach its tail so judging the run takes no extra call.
             const errorLog = result.errorLogFile

package/dist/tools/ti-development/import-pro-file.js

@@ -79,7 +79,7 @@ export const registerImportProFile = defineTool({
             if (failure)
                 return preflightResult(failure);
         }
-        const allProcs = await tm1Client.processes.list();
+        const allProcs = await tm1Client.processes.list({ namesOnly: true });
         const exists = allProcs.some((p) => p.name === processName);
         if (mode === "create" && exists) {
             throw new TM1Error({

package/dist/tools/ti-development/search-code.js

@@ -14,7 +14,7 @@ export const registerSearchCode = defineTool({
         "Regex search across all TI process code (Prolog/Metadata/Data/Epilog).",
         "Returns matches paginated (default 50/page) with process name, tab, line number, and trimmed line text.",
         "Wrapper over tm1_get_all_processes_code that avoids dumping ~MB of code through the channel.",
-        "Use tm1_get_process_code on a hit to inspect the surrounding context.",
+        "Use tm1_get_process on a hit to inspect the surrounding context.",
         "Set groupBy='process' (or 'tab') for a sorted count aggregation instead of individual match lines.",
     ],
     annotations: READ_ONLY,

package/dist/tools/ti-development/upsert-process.js

@@ -13,7 +13,7 @@ import { backupProcess } from "./process-backup.js";
 // The same data source shape the git round-trip and check_process_code use.
 // This tool used to carry its own copy, which had drifted: it was missing
 // `query`, so an ODBC source could be created here but its SQL could not —
-// while tm1_get_process_datasource reads it back.
+// while tm1_get_process reads it back.
 // Strict, so a misspelled field is rejected instead of silently dropped.
 const dataSourceSchema = sharedDataSourceSchema.strict();
 const parameterSchema = z.object({
@@ -215,7 +215,7 @@ export const registerUpsertProcess = defineTool({
         // 60s callgraph TTL so the next analysis sees fresh references instead of stale graph.
         const { cleared: callgraphEntriesCleared } = invalidateCallgraphCache();
         // Read the code back: TM1 stores what REST sent, so a mismatch means the
-        // write did not land as sent. Saves the caller a get_process_code turn.
+        // write did not land as sent. Saves the caller a get_process turn.
         const sent = { prolog, metadata, data, epilog };
         const sentTabs = TABS.filter((t) => sent[t] !== undefined);
         let verified;

package/dist/tools/with-annotations.d.ts

@@ -1,6 +1,16 @@
 import type pino from "pino";
 import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type McpToolResult } from "./error-format.js";
 export declare function deriveTitle(toolName: string): string;
+/**
+ * Cut an oversized page down to the longest prefix of its items that fits,
+ * turning it into an ordinary shorter page: count, has_more and next_offset
+ * are rewritten so the caller walks on from exactly where it stopped. The
+ * result is still valid JSON of the declared shape — unlike a text cut — and
+ * the call is not wasted. Returns undefined when not even one item fits (or
+ * the payload is not a page), leaving the caller to report the overflow.
+ */
+export declare function trimPageToFit(result: McpToolResult, maxChars: number): McpToolResult | undefined;
 export declare function narrowingHint(inputKeys: ReadonlySet<string>): string;
 export declare function withAnnotations(server: McpServer, logger: pino.Logger, mode: "readwrite" | "readonly", responseMode?: "legacy" | "structured", maxResponseChars?: number): McpServer;
 //# sourceMappingURL=with-annotations.d.ts.map

package/dist/tools/with-annotations.js

@@ -14,7 +14,7 @@ const TITLE_CASING = {
     v11: "v11",
 };
 // Derive a human-readable title from a snake_case tool name:
-// "tm1_get_process_code" → "Get Process Code". Single point of derivation —
+// "tm1_get_process" → "Get Process". Single point of derivation —
 // no per-tool overrides in ANNOTATION_MAP.
 export function deriveTitle(toolName) {
     return toolName
@@ -49,6 +49,55 @@ function responseChars(result) {
         return text;
     return JSON.stringify(result.structuredContent).length;
 }
+function isPagePayload(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    return (Array.isArray(v.items) &&
+        typeof v.offset === "number" &&
+        typeof v.total === "number");
+}
+/**
+ * Cut an oversized page down to the longest prefix of its items that fits,
+ * turning it into an ordinary shorter page: count, has_more and next_offset
+ * are rewritten so the caller walks on from exactly where it stopped. The
+ * result is still valid JSON of the declared shape — unlike a text cut — and
+ * the call is not wasted. Returns undefined when not even one item fits (or
+ * the payload is not a page), leaving the caller to report the overflow.
+ */
+export function trimPageToFit(result, maxChars) {
+    const page = result.structuredContent;
+    if (!isPagePayload(page))
+        return undefined;
+    const withText = (result.content ?? []).some((c) => c.type === "text");
+    const build = (n) => {
+        const trimmed = {
+            ...page,
+            count: n,
+            has_more: true, // n < items.length: at least one item was dropped
+            next_offset: page.offset + n,
+            items: page.items.slice(0, n),
+        };
+        return {
+            ...result,
+            content: withText
+                ? [{ type: "text", text: JSON.stringify(trimmed) }]
+                : [],
+            structuredContent: trimmed,
+        };
+    };
+    // Largest n in [1, items.length) whose serialization fits.
+    let lo = 0;
+    let hi = page.items.length - 1;
+    while (lo < hi) {
+        const mid = Math.ceil((lo + hi) / 2);
+        if (responseChars(build(mid)) <= maxChars)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return lo > 0 ? build(lo) : undefined;
+}
 // How to narrow a call, derived from the tool's own input keys so a new tool
 // gets a correct hint without a per-tool table to keep in step.
 export function narrowingHint(inputKeys) {
@@ -199,12 +248,18 @@ responseMode = "legacy", maxResponseChars = DEFAULT_MAX_RESPONSE_CHARS) {
         }
     };
     const SLOW_TOOL_MS = 5000;
-    // Replace an oversized success with an error that says how to narrow the
-    // call. Never truncate: a cut JSON payload is worse than none.
+    // An oversized page is cut to the items that fit (see trimPageToFit).
+    // Anything else becomes an error that says how to narrow the call — never a
+    // truncated text: a cut JSON payload is worse than none.
     const guardSize = (toolName, result, hint) => {
         const size = responseChars(result);
         if (size <= maxResponseChars)
             return result;
+        const trimmed = trimPageToFit(result, maxResponseChars);
+        if (trimmed) {
+            logger.info({ tool: toolName, size, maxResponseChars }, "page trimmed to fit the response limit");
+            return trimmed;
+        }
         logger.warn({ tool: toolName, size, maxResponseChars }, "response too large");
         return formatTm1ErrorResult(new TM1Error({
             code: TM1ErrorCode.RESPONSE_TOO_LARGE,

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ffschrattenecker/tm1-mcp-server",
-  "version": "6.1.1",
+  "version": "7.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ffschrattenecker/tm1-mcp-server",
-      "version": "6.1.1",
+      "version": "7.0.1",
       "license": "MIT",
       "dependencies": {
         "@modelcontextprotocol/sdk": "1.30.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ffschrattenecker/tm1-mcp-server",
-  "version": "6.1.1",
+  "version": "7.0.1",
   "description": "MCP server for IBM Planning Analytics / TM1 — full model lifecycle via REST API",
   "repository": {
     "type": "git",
@@ -60,11 +60,12 @@
     "lint:mutation-envelope": "node scripts/check-mutation-envelope.mjs",
     "lint:format": "prettier --check .",
     "format": "prettier --write .",
-    "verify": "npm run typecheck && npm run typecheck:tests && npm run lint:no-flat-api && npm run lint:output-schema-budget && npm run lint:tool-registration && npm run lint:input-naming && npm run lint:mutation-envelope && npm run lint:format && npm run lint:eslint && npm run coverage:check",
+    "verify": "npm run typecheck && npm run typecheck:tests && npm run lint:no-flat-api && npm run lint:output-schema-budget && npm run lint:tool-surface-budget && npm run lint:tool-registration && npm run lint:input-naming && npm run lint:mutation-envelope && npm run lint:format && npm run lint:eslint && npm run coverage:check",
     "tools:list": "node scripts/gen-tool-list.mjs",
     "tools:update-readme": "node scripts/gen-tool-list.mjs --write-readme",
     "lint:eslint": "eslint .",
-    "measure:tools": "node scripts/measure-tool-surface.mjs"
+    "measure:tools": "node scripts/measure-tool-surface.mjs",
+    "lint:tool-surface-budget": "node scripts/measure-tool-surface.mjs --top 0 --budget 133000"
   },
   "keywords": [
     "mcp",

package/dist/tools/ti-development/get-process-code.d.ts

@@ -1,2 +0,0 @@
-export declare const registerGetProcessCode: import("../define-tool.js").ToolRegistrar;
-//# sourceMappingURL=get-process-code.d.ts.map

package/dist/tools/ti-development/get-process-code.js

@@ -1,100 +0,0 @@
-import { z } from "zod";
-import { commentStats, stripCommentBlocks } from "../../lib/strip-comments.js";
-import { maskCode, resolveMaskSecrets } from "../../lib/mask-secrets.js";
-import { ProcessCodeSchema } from "../schemas/items.js";
-import { READ_ONLY } from "../annotations.js";
-import { defineTool } from "../define-tool.js";
-// A tab counts as comment-heavy (worth flagging for stripComments) only when it
-// is both long enough to matter and mostly comments.
-const HEAVY_MIN_LINES = 20;
-const HEAVY_RATIO = 0.4;
-const TABS = ["prolog", "metadata", "data", "epilog"];
-export const registerGetProcessCode = defineTool({
-    name: "tm1_get_process_code",
-    description: "Get the source code of all four tabs (Prolog, Metadata, Data, Epilog) of a TI process. " +
-        "Grown TM1 models often carry large blocks of commented-out dead code; set stripComments=true " +
-        "to collapse runs of 4+ comment lines into a `# [... N lines ...]` marker and save context.",
-    annotations: READ_ONLY,
-    output: ProcessCodeSchema,
-    input: {
-        processName: z.string().describe("Name of the TI process"),
-        stripComments: z
-            .boolean()
-            .optional()
-            .default(false)
-            .describe("If true, collapse blocks of 4+ consecutive comment lines into a single marker (dead-code reduction). " +
-            "Inline and short comments are kept. Default false (full verbatim source)."),
-        maskSecrets: z
-            .boolean()
-            .optional()
-            .default(true)
-            .describe("Redact credential literals in the returned code. Masks the password arg of ODBCOpen() and quoted values " +
-            "assigned to credential-named identifiers (pPwd, sToken, …). Default: true. Set false only when explicitly auditing credentials."),
-        includeSecurityAccess: z
-            .boolean()
-            .optional()
-            .default(false)
-            .describe("Also fetch process's HasSecurityAccess elevation flag (one extra GET). " +
-            "Default false — pure code reads stay single request."),
-    },
-    handler: async ({ processName, stripComments, maskSecrets, includeSecurityAccess }, tm1Client) => {
-        const code = await tm1Client.processes.getCode(processName);
-        let hint;
-        if (stripComments) {
-            let removedLines = 0;
-            let collapsedBlocks = 0;
-            for (const tab of TABS) {
-                const r = stripCommentBlocks(code[tab]);
-                code[tab] = r.code;
-                removedLines += r.removedLines;
-                collapsedBlocks += r.collapsedBlocks;
-            }
-            if (collapsedBlocks > 0) {
-                hint =
-                    `stripComments collapsed ${collapsedBlocks} comment block(s) (${removedLines} lines) into markers. ` +
-                        `Re-run without stripComments for the full source.`;
-            }
-        }
-        else {
-            let worst;
-            for (const tab of TABS) {
-                const s = commentStats(code[tab]);
-                if (s.totalLines < HEAVY_MIN_LINES)
-                    continue;
-                const ratio = s.commentLines / s.totalLines;
-                if (ratio >= HEAVY_RATIO && (!worst || ratio > worst.ratio)) {
-                    worst = {
-                        tab,
-                        total: s.totalLines,
-                        comment: s.commentLines,
-                        ratio,
-                    };
-                }
-            }
-            if (worst) {
-                const pct = Math.round(worst.ratio * 100);
-                hint =
-                    `${worst.tab} tab is ${pct}% comments (${worst.comment}/${worst.total} lines). ` +
-                        `Set stripComments=true to collapse dead-code blocks and save context.`;
-            }
-        }
-        if (resolveMaskSecrets(maskSecrets)) {
-            for (const tab of TABS)
-                code[tab] = maskCode(code[tab]);
-        }
-        let hasSecurityAccess;
-        if (includeSecurityAccess) {
-            hasSecurityAccess = (await tm1Client.processes.getDeployMeta(processName))
-                .hasSecurityAccess;
-        }
-        const payload = {
-            ...code,
-            ...(hasSecurityAccess !== undefined ? { hasSecurityAccess } : {}),
-            ...(hint ? { hint } : {}),
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(payload) }],
-        };
-    },
-});
-//# sourceMappingURL=get-process-code.js.map

package/dist/tools/ti-development/get-process-datasource.d.ts

@@ -1,2 +0,0 @@
-export declare const registerGetProcessDatasource: import("../define-tool.js").ToolRegistrar;
-//# sourceMappingURL=get-process-datasource.d.ts.map

package/dist/tools/ti-development/get-process-datasource.js

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import { FORMAT_SCHEMA, payloadResponse, renderKV } from "../format.js";
-import { DataSourceSchema } from "../schemas/items.js";
-import { READ_ONLY } from "../annotations.js";
-import { defineTool } from "../define-tool.js";
-export const registerGetProcessDatasource = defineTool({
-    name: "tm1_get_process_datasource",
-    description: "Get the data source configuration of a TurboIntegrator process. The password field is always redacted.",
-    annotations: READ_ONLY,
-    output: DataSourceSchema,
-    input: {
-        processName: z.string().describe("Name of the TI process"),
-        ...FORMAT_SCHEMA,
-    },
-    handler: async ({ processName, format }, tm1Client) => {
-        const ds = await tm1Client.processes.getDataSource(processName);
-        return payloadResponse(ds, format, (d) => renderKV(d, `Datasource of ${processName}`));
-    },
-});
-//# sourceMappingURL=get-process-datasource.js.map

package/dist/tools/ti-development/get-process-parameters.d.ts

@@ -1,2 +0,0 @@
-export declare const registerGetProcessParameters: import("../define-tool.js").ToolRegistrar;
-//# sourceMappingURL=get-process-parameters.d.ts.map

package/dist/tools/ti-development/get-process-parameters.js

@@ -1,25 +0,0 @@
-import { z } from "zod";
-import { FORMAT_SCHEMA, payloadResponse, renderTable, columnsOf, } from "../format.js";
-import { ProcessParameterSchema } from "../schemas/items.js";
-import { READ_ONLY } from "../annotations.js";
-import { defineTool } from "../define-tool.js";
-export const registerGetProcessParameters = defineTool({
-    name: "tm1_get_process_parameters",
-    description: "Get the parameters of a TurboIntegrator process including names, types and defaults",
-    annotations: READ_ONLY,
-    output: {
-        processName: z.string(),
-        parameters: z.array(ProcessParameterSchema),
-    },
-    input: {
-        processName: z.string().describe("Name of the TI process"),
-        ...FORMAT_SCHEMA,
-    },
-    handler: async ({ processName, format }, tm1Client) => {
-        const params = await tm1Client.processes.getParameters(processName);
-        const payload = { processName, parameters: params };
-        const columns = columnsOf(["name", "type", "defaultValue", "prompt"]);
-        return payloadResponse(payload, format, (p) => `## Parameters of ${p.processName}\n\n${renderTable(p.parameters, columns)}`);
-    },
-});
-//# sourceMappingURL=get-process-parameters.js.map

package/dist/tools/ti-development/get-process-variables.d.ts

@@ -1,2 +0,0 @@
-export declare const registerGetProcessVariables: import("../define-tool.js").ToolRegistrar;
-//# sourceMappingURL=get-process-variables.d.ts.map

package/dist/tools/ti-development/get-process-variables.js

@@ -1,38 +0,0 @@
-import { z } from "zod";
-import { FORMAT_SCHEMA, payloadResponse, renderTable, columnsOf, } from "../format.js";
-import { IgnoredColumnSchema, ProcessVariableSchema, } from "../schemas/items.js";
-import { READ_ONLY } from "../annotations.js";
-import { defineTool } from "../define-tool.js";
-export const registerGetProcessVariables = defineTool({
-    name: "tm1_get_process_variables",
-    description: "Get the variables (column-name mapping for ASCII/ODBC sources) of a TurboIntegrator process. " +
-        "Columns set to 'Ignore' carry no variable and are reported separately in ignoredColumns — " +
-        "they are the reason variable positions can have gaps.",
-    annotations: READ_ONLY,
-    output: {
-        processName: z.string(),
-        variables: z.array(ProcessVariableSchema),
-        ignoredColumns: z.array(IgnoredColumnSchema),
-    },
-    input: {
-        processName: z.string().describe("Name of the TI process"),
-        ...FORMAT_SCHEMA,
-    },
-    handler: async ({ processName, format }, tm1Client) => {
-        const { variables, ignoredColumns } = await tm1Client.processes.getVariableLayout(processName);
-        const payload = { processName, variables, ignoredColumns };
-        const columns = columnsOf([
-            "name",
-            "type",
-            "position",
-            "startByte",
-            "endByte",
-        ]);
-        const ignoredCols = columnsOf(["position", "name"]);
-        return payloadResponse(payload, format, (p) => `## Variables of ${p.processName}\n\n${renderTable(p.variables, columns)}` +
-            (p.ignoredColumns.length > 0
-                ? `\n\n### Ignored columns\n\n${renderTable(p.ignoredColumns, ignoredCols)}`
-                : ""));
-    },
-});
-//# sourceMappingURL=get-process-variables.js.map