@ffschrattenecker/tm1-mcp-server 7.0.1 → 8.0.0

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

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { TM1Error, TM1ErrorCode } from "../../types.js";
 import { parseProFile } from "../../lib/pro-parser.js";
 import { withToolHint } from "../error-format.js";
-import { IDEMPOTENT_DESTRUCTIVE, withVersion } from "../annotations.js";
+import { IDEMPOTENT_DESTRUCTIVE } from "../annotations.js";
 import { ImportProFileResultSchema } from "../schemas/items.js";
 import { defineTool } from "../define-tool.js";
 import { OVERWRITE_CONFIRM_SCHEMA, requireOverwriteConfirm, } from "../confirm.js";
@@ -13,7 +13,7 @@ import { backupProcess } from "./process-backup.js";
 export const registerImportProFile = defineTool({
     name: "tm1_import_pro_file",
     description: "Parse a TM1 .pro file (Tabs / Parameters / Variables / DataSource) and deploy the process in one call. Provide either filePath (absolute path on the MCP host) or content (the .pro file body as string). Modes: 'create' (fail if exists), 'update' (fail if missing), 'upsert' (default — create or update). A .pro carries an ODBC password only when it came from tm1_export_process_to_pro against a v12 database, which writes it in clear; TM1's own Datadir .pro encodes slot 565 in a form that cannot be replayed over REST, and v11 exports never contain a password at all. Pass dataSourcePassword in every other case.",
-    annotations: withVersion(IDEMPOTENT_DESTRUCTIVE, "v11"),
+    annotations: IDEMPOTENT_DESTRUCTIVE,
     output: ImportProFileResultSchema,
     input: {
         filePath: z
@@ -108,25 +108,14 @@ export const registerImportProFile = defineTool({
             data: parsed.data,
             epilog: parsed.epilog,
         }), `Code update failed after process '${processName}' was ${exists ? "located" : "created"}. PARTIAL APPLY: the process shell exists but tabs are stale/empty. Re-run tm1_import_pro_file with mode=update once root cause fixed, or tm1_delete_process to roll back.`);
-        // On an update the file replaces the whole definition, as the code tabs
-        // already do: an empty parameter list, variable layout or a None
-        // datasource is applied, not skipped. Skipping left the newer values in
-        // place, so importing an older version (a backup) did not restore it.
-        if (exists || parsed.parameters.length > 0) {
-            await withToolHint(tm1Client.processes.updateParameters(processName, parsed.parameters), `Parameter update failed for '${processName}'. Code applied but parameters missing. Inspect parsed parameters and re-run tm1_upsert_process with mode=update + parameters=[...] to recover.`);
-        }
-        // Ignored columns live only in the UI data, so a file can carry column
-        // layout with an empty variable list — patch on either.
-        if (exists ||
-            parsed.variables.length > 0 ||
-            parsed.variablesUIData.length > 0) {
-            await withToolHint(tm1Client.processes.updateVariables(processName, parsed.variables, parsed.variablesUIData.length > 0 || parsed.variables.length === 0
-                ? parsed.variablesUIData
-                : undefined), `Variable update failed for '${processName}'. Code+parameters applied but variables missing. tm1_upsert_process with mode=update + variables=[...] to recover.`);
-        }
-        if (exists || parsed.dataSource.type !== "None") {
-            await withToolHint(tm1Client.processes.updateDataSource(processName, parsed.dataSource), `Datasource update failed for '${processName}' (type=${parsed.dataSource.type}). Code+params+vars applied. Verify datasource credentials/path (ASCII file existence, ODBC DSN, view name) and re-run tm1_upsert_process with mode=update + dataSource={...} to recover.`);
-        }
+        // The file is the whole truth: an empty list or a None source is sent as
+        // well, because TM1 applies both (measured on 11.8 and 12.5) and skipping
+        // them left the removed parameters, variables and source on the server.
+        await withToolHint(tm1Client.processes.updateParameters(processName, parsed.parameters), `Parameter update failed for '${processName}'. Code applied but parameters missing. Inspect parsed parameters and re-run tm1_upsert_process with mode=update + parameters=[...] to recover.`);
+        // A file without a column-layout block leaves the server's layout as it
+        // is; one that carries it replaces it.
+        await withToolHint(tm1Client.processes.updateVariables(processName, parsed.variables, parsed.variablesUIData.length > 0 ? parsed.variablesUIData : undefined), `Variable update failed for '${processName}'. Code+parameters applied but variables missing. tm1_upsert_process with mode=update + variables=[...] to recover.`);
+        await withToolHint(tm1Client.processes.updateDataSource(processName, parsed.dataSource), `Datasource update failed for '${processName}' (type=${parsed.dataSource.type}). Code+params+vars applied. Verify datasource credentials/path (ASCII file existence, ODBC DSN, view name) and re-run tm1_upsert_process with mode=update + dataSource={...} to recover.`);
         return {
             content: [
                 {

package/dist/tools/ti-development/import-process-from-git.js

@@ -148,24 +148,14 @@ export const registerImportProcessFromGit = defineTool({
         // The parsed tabs were preflighted above; unplacedBlobContent() made
         // sure they cover this blob exactly, so what was checked is what deploys.
         await withToolHint(tm1Client.processes.updateCodeBlob(processName, ti.replace(/\r?\n/g, "\r\n")), `Code update failed after process '${processName}' was ${exists ? "located" : "created"}. PARTIAL APPLY: shell exists but tabs are stale/empty. Re-run with mode=update once root cause fixed, or tm1_delete_process to roll back.`);
-        // On an update the file replaces the whole definition, as the code tabs
-        // already do: an empty parameter list, variable layout or a None
-        // datasource is applied, not skipped. Skipping left the newer values in
-        // place, so importing an older version (a backup) did not restore it.
-        if (exists || parsed.parameters.length > 0) {
-            await withToolHint(tm1Client.processes.updateParameters(processName, parsed.parameters), `Parameter update failed for '${processName}'. Code applied but parameters missing. tm1_upsert_process with mode=update + parameters=[...] to recover.`);
-        }
-        // Ignored columns live only in the UI data, so a .json can carry column
-        // layout with an empty variable list — patch on either.
-        if (exists ||
-            parsed.variables.length > 0 ||
-            (parsed.variablesUIData?.length ?? 0) > 0) {
-            await withToolHint(tm1Client.processes.updateVariables(processName, parsed.variables, parsed.variablesUIData ??
-                (parsed.variables.length === 0 ? [] : undefined)), `Variable update failed for '${processName}'. Code+parameters applied but variables missing. tm1_upsert_process with mode=update + variables=[...] to recover.`);
-        }
-        if (exists || dataSource.type !== "None") {
-            await withToolHint(tm1Client.processes.updateDataSource(processName, dataSource), `Datasource update failed for '${processName}' (type=${dataSource.type}). Code+params+vars applied. For ODBC verify dataSourcePassword/DSN and re-run with mode=update.`);
-        }
+        // The file is the whole truth: an empty list or a None source is sent as
+        // well, because TM1 applies both (measured on 11.8 and 12.5) and skipping
+        // them left the removed parameters, variables and source on the server.
+        await withToolHint(tm1Client.processes.updateParameters(processName, parsed.parameters), `Parameter update failed for '${processName}'. Code applied but parameters missing. tm1_upsert_process with mode=update + parameters=[...] to recover.`);
+        // An export without variablesUIData (older format) leaves the server's
+        // column layout as it is; one that carries it replaces it.
+        await withToolHint(tm1Client.processes.updateVariables(processName, parsed.variables, parsed.variablesUIData), `Variable update failed for '${processName}'. Code+parameters applied but variables missing. tm1_upsert_process with mode=update + variables=[...] to recover.`);
+        await withToolHint(tm1Client.processes.updateDataSource(processName, dataSource), `Datasource update failed for '${processName}' (type=${dataSource.type}). Code+params+vars applied. For ODBC verify dataSourcePassword/DSN and re-run with mode=update.`);
         if (parsed.hasSecurityAccess !== undefined) {
             await withToolHint(tm1Client.processes.updateSecurityAccess(processName, parsed.hasSecurityAccess), `HasSecurityAccess update failed for '${processName}'. Code+params+vars+datasource applied. Re-run with mode=update once root cause fixed.`);
         }

package/dist/tools/ti-development/install-pro-bundle.js

@@ -5,7 +5,7 @@ import { TM1Error, TM1ErrorCode } from "../../types.js";
 import { compileUserRegex } from "../../lib/safe-regex.js";
 import { parseProFile } from "../../lib/pro-parser.js";
 import { resolveLocalPath } from "../local-file.js";
-import { IDEMPOTENT_DESTRUCTIVE, withVersion } from "../annotations.js";
+import { IDEMPOTENT_DESTRUCTIVE } from "../annotations.js";
 import { InstallProBundleResultSchema } from "../schemas/items.js";
 import { defineTool } from "../define-tool.js";
 import { runPreflight } from "./preflight.js";
@@ -13,7 +13,7 @@ import { backupProcess } from "./process-backup.js";
 export const registerInstallProBundle = defineTool({
     name: "tm1_install_pro_bundle",
     description: "Install all .pro files from a directory in one call. Iterates the directory (non-recursive by default), applies tm1_import_pro_file logic per file, and reports per-file outcome. Stops on first failure unless continueOnError=true. Useful for Bedrock or library deployments.",
-    annotations: withVersion(IDEMPOTENT_DESTRUCTIVE, "v11"),
+    annotations: IDEMPOTENT_DESTRUCTIVE,
     output: InstallProBundleResultSchema,
     input: {
         directory: z

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

@@ -42,7 +42,14 @@ export const registerUpsertProcess = defineTool({
         data: z.string().optional(),
         epilog: z.string().optional(),
         parameters: z.array(parameterSchema).optional(),
-        variables: z.array(variableSchema).optional(),
+        variables: z
+            .array(variableSchema)
+            .optional()
+            .describe("Replaces the complete variable list; [] removes every variable."),
+        variablesUIData: z
+            .array(z.string())
+            .optional()
+            .describe("Raw per-column layout (VariablesUIData), one entry per source column including ignored ones, sent verbatim. Take it from tm1_get_process_variables or an export; do not construct entries. Omitted: the server keeps its current layout."),
         dataSource: dataSourceSchema.optional(),
         hasSecurityAccess: z
             .boolean()
@@ -66,7 +73,7 @@ export const registerUpsertProcess = defineTool({
             .default(false)
             .describe("Write nothing. Run the syntax AND reference check on the process as it would be after this call (both reported, neither stops the other) and diff it against the installed version (credentials masked). Needs no confirm and is not one: the real call still needs it. Replaces a separate check_process_code + validate_process_refs + diff before the risk assessment."),
     },
-    handler: async ({ processName, prolog, metadata, data, epilog, parameters, variables, dataSource, hasSecurityAccess, mode, preflight, autoCompile, dryRun, confirm, }, tm1Client) => {
+    handler: async ({ processName, prolog, metadata, data, epilog, parameters, variables, variablesUIData, dataSource, hasSecurityAccess, mode, preflight, autoCompile, dryRun, confirm, }, tm1Client) => {
         const trail = [];
         const exists = await tm1Client.processes.exists(processName);
         if (mode === "create" && exists) {
@@ -199,8 +206,21 @@ export const registerUpsertProcess = defineTool({
             await tm1Client.processes.updateParameters(processName, parameters);
             trail.push("updateProcessParameters");
         }
-        if (variables !== undefined && variables.length > 0) {
-            await tm1Client.processes.updateVariables(processName, variables);
+        let warning;
+        if (variables !== undefined || variablesUIData !== undefined) {
+            // A Variables PATCH alone leaves the server's VariablesUIData in place
+            // (measured on 11.8 and 12.5). When the new variable count no longer
+            // matches the kept layout's non-ignored columns, the ignore markers
+            // point at the wrong columns — say so rather than guess a layout.
+            if (exists && variables !== undefined && variablesUIData === undefined) {
+                const layout = await tm1Client.processes.getVariableLayout(processName);
+                const kept = layout.variablesUIData?.length ?? 0;
+                const used = kept - layout.ignoredColumns.length;
+                if (kept > 0 && used !== variables.length) {
+                    warning = `VariablesUIData left as on the server: it describes ${used} used and ${layout.ignoredColumns.length} ignored column(s), but ${variables.length} variable(s) were written. Pass variablesUIData to replace the column layout.`;
+                }
+            }
+            await tm1Client.processes.updateVariables(processName, variables, variablesUIData);
             trail.push("updateProcessVariables");
         }
         if (dataSource !== undefined) {
@@ -213,7 +233,7 @@ export const registerUpsertProcess = defineTool({
         }
         // Process body/parameters/datasource may have changed call sites — drop the
         // 60s callgraph TTL so the next analysis sees fresh references instead of stale graph.
-        const { cleared: callgraphEntriesCleared } = invalidateCallgraphCache();
+        const { cleared: callgraphEntriesCleared } = invalidateCallgraphCache(tm1Client.connectionId);
         // 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 turn.
         const sent = { prolog, metadata, data, epilog };
@@ -247,6 +267,7 @@ export const registerUpsertProcess = defineTool({
                         ...(backup ? { backup } : {}),
                         ...(verified !== undefined ? { verified } : {}),
                         ...(compile !== undefined ? { compile } : {}),
+                        ...(warning !== undefined ? { warning } : {}),
                     }, null, 2),
                 },
             ],