@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/ti-development/diff-processes.js

@@ -0,0 +1,312 @@
+import { z } from "zod";
+import { maskCode, resolveMaskSecrets } from "../../lib/mask-secrets.js";
+import { DiffProcessesResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+function computeEditScript(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const w = n + 1;
+    const dp = new Uint32Array((m + 1) * w);
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            if (a[i] === b[j]) {
+                dp[i * w + j] = 1 + (dp[(i + 1) * w + (j + 1)] ?? 0);
+            }
+            else {
+                const skipA = dp[(i + 1) * w + j] ?? 0;
+                const skipB = dp[i * w + (j + 1)] ?? 0;
+                dp[i * w + j] = skipA >= skipB ? skipA : skipB;
+            }
+        }
+    }
+    const ops = [];
+    let i = 0, j = 0;
+    while (i < m || j < n) {
+        const ai = a[i], bj = b[j];
+        if (i < m && j < n && ai === bj) {
+            ops.push({ op: "eq", line: ai });
+            i++;
+            j++;
+        }
+        else if (i < m &&
+            (j >= n || (dp[(i + 1) * w + j] ?? 0) >= (dp[i * w + (j + 1)] ?? 0))) {
+            ops.push({ op: "del", line: ai });
+            i++;
+        }
+        else {
+            ops.push({ op: "add", line: bj });
+            j++;
+        }
+    }
+    return ops;
+}
+function buildHunks(ops, contextLines) {
+    const pos = [];
+    let lA = 1, lB = 1;
+    for (const op of ops) {
+        pos.push({ ...op, lineA: lA, lineB: lB });
+        if (op.op === "eq") {
+            lA++;
+            lB++;
+        }
+        else if (op.op === "del") {
+            lA++;
+        }
+        else {
+            lB++;
+        }
+    }
+    const inHunk = new Set();
+    for (let i = 0; i < pos.length; i++) {
+        if (pos[i].op !== "eq") {
+            for (let k = Math.max(0, i - contextLines); k <= Math.min(pos.length - 1, i + contextLines); k++) {
+                inHunk.add(k);
+            }
+        }
+    }
+    if (inHunk.size === 0)
+        return [];
+    const indices = [...inHunk].sort((a, b) => a - b);
+    const ranges = [];
+    let s = indices[0], p = indices[0];
+    for (let i = 1; i < indices.length; i++) {
+        if (indices[i] > p + 1) {
+            ranges.push([s, p]);
+            s = indices[i];
+        }
+        p = indices[i];
+    }
+    ranges.push([s, p]);
+    return ranges.map(([from, to]) => {
+        const lines = [];
+        let startA = -1, startB = -1, countA = 0, countB = 0;
+        for (let i = from; i <= to; i++) {
+            const px = pos[i];
+            if (startA === -1) {
+                startA = px.lineA;
+                startB = px.lineB;
+            }
+            if (px.op === "eq") {
+                lines.push({ type: " ", text: px.line });
+                countA++;
+                countB++;
+            }
+            else if (px.op === "del") {
+                lines.push({ type: "-", text: px.line });
+                countA++;
+            }
+            else {
+                lines.push({ type: "+", text: px.line });
+                countB++;
+            }
+        }
+        return { startA, countA, startB, countB, lines };
+    });
+}
+const NORM = (s) => s.replace(/\r\n/g, "\n").trimEnd();
+function tabCodeDiff(codeA, codeB, contextLines) {
+    const na = NORM(codeA);
+    const nb = NORM(codeB);
+    if (na === nb) {
+        const lc = na ? na.split("\n").length : 0;
+        return { identical: true, linesA: lc, linesB: lc, hunks: [] };
+    }
+    const a = na ? na.split("\n") : [];
+    const b = nb ? nb.split("\n") : [];
+    const ops = computeEditScript(a, b);
+    const hunks = buildHunks(ops, contextLines);
+    return { identical: false, linesA: a.length, linesB: b.length, hunks };
+}
+// ── param / var / datasource diff ────────────────────────────────────────────
+function diffParams(a, b) {
+    const ma = new Map(a.map((p) => [p.name, p]));
+    const mb = new Map(b.map((p) => [p.name, p]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [name, pb] of mb) {
+        const pa = ma.get(name);
+        if (!pa) {
+            added.push(name);
+            continue;
+        }
+        if (pa.type !== pb.type ||
+            String(pa.defaultValue ?? "") !== String(pb.defaultValue ?? "") ||
+            (pa.prompt ?? "") !== (pb.prompt ?? "")) {
+            changed.push({ name, a: pa, b: pb });
+        }
+    }
+    for (const name of ma.keys())
+        if (!mb.has(name))
+            removed.push(name);
+    return {
+        identical: added.length === 0 && removed.length === 0 && changed.length === 0,
+        added,
+        removed,
+        changed,
+    };
+}
+function diffVars(a, b) {
+    const ma = new Map(a.map((v) => [v.name, v]));
+    const mb = new Map(b.map((v) => [v.name, v]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [name, vb] of mb) {
+        const va = ma.get(name);
+        if (!va) {
+            added.push(name);
+            continue;
+        }
+        if (va.type !== vb.type || va.position !== vb.position)
+            changed.push({ name, a: va, b: vb });
+    }
+    for (const name of ma.keys())
+        if (!mb.has(name))
+            removed.push(name);
+    return {
+        identical: added.length === 0 && removed.length === 0 && changed.length === 0,
+        added,
+        removed,
+        changed,
+    };
+}
+// Columns set to "Ignore" carry no variable, so diffVars above cannot see
+// them: two processes differing only in which columns they skip would otherwise
+// come back identical.
+function diffIgnoredColumns(a, b) {
+    const ma = new Map(a.map((c) => [c.position, c]));
+    const mb = new Map(b.map((c) => [c.position, c]));
+    const added = [];
+    const removed = [];
+    const renamed = [];
+    for (const [position, cb] of mb) {
+        const ca = ma.get(position);
+        if (!ca) {
+            added.push(position);
+            continue;
+        }
+        if (ca.name !== cb.name)
+            renamed.push({
+                position,
+                ...(ca.name !== undefined ? { a: ca.name } : {}),
+                ...(cb.name !== undefined ? { b: cb.name } : {}),
+            });
+    }
+    for (const position of ma.keys())
+        if (!mb.has(position))
+            removed.push(position);
+    return {
+        identical: added.length === 0 && removed.length === 0 && renamed.length === 0,
+        added,
+        removed,
+        renamed,
+    };
+}
+function diffDs(a, b) {
+    const diffs = [];
+    const fields = [
+        "type",
+        "dataSourceNameForServer",
+        "dataSourceNameForClient",
+        "asciiDelimiterChar",
+        "asciiQuoteCharacter",
+        "asciiDecimalSeparator",
+        "asciiThousandSeparator",
+        "asciiHeaderRecords",
+        "view",
+        "subset",
+        "userName",
+        // The SQL is the substance of an ODBC source: two processes that differ
+        // only in their query are not the same process. `password` stays out —
+        // both sides read back redacted, so it can only produce noise.
+        "query",
+    ];
+    for (const f of fields) {
+        if ((a[f] ?? "") !== (b[f] ?? ""))
+            diffs.push(`${String(f)}: ${JSON.stringify(a[f])} → ${JSON.stringify(b[f])}`);
+    }
+    return { identical: diffs.length === 0, differences: diffs };
+}
+// ── tool ──────────────────────────────────────────────────────────────────────
+const ALL_TABS = ["prolog", "metadata", "data", "epilog"];
+export const registerDiffProcesses = defineTool({
+    name: "tm1_diff_processes",
+    description: [
+        "Compare two installed TI processes tab-by-tab (Prolog/Metadata/Data/Epilog).",
+        "Returns per-tab identical flag, line counts, and unified diff hunks for changed tabs.",
+        "Also diffs parameters, variables, and datasource.",
+        "Analogue of tm1_diff_process_with_file but server-side — no .pro file needed.",
+    ],
+    annotations: READ_ONLY,
+    output: DiffProcessesResultSchema,
+    input: {
+        processA: z.string().describe("First process name (case-sensitive)"),
+        processB: z.string().describe("Second process name (case-sensitive)"),
+        tabs: z
+            .array(z.enum(["prolog", "metadata", "data", "epilog"]))
+            .optional()
+            .describe("Tabs to diff (default: all four)"),
+        contextLines: z
+            .number()
+            .int()
+            .min(0)
+            .max(10)
+            .optional()
+            .default(3)
+            .describe("Lines of context around each changed hunk (default 3, max 10)"),
+        maskSecrets: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Redact credential literals on BOTH sides before diffing (so a cred present on only one side can't leak via the diff). " +
+            "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."),
+    },
+    handler: async ({ processA, processB, tabs, contextLines, maskSecrets }, tm1Client) => {
+        const diffTabs = tabs && tabs.length > 0 ? tabs : ALL_TABS;
+        const mask = resolveMaskSecrets(maskSecrets) ? maskCode : (s) => s;
+        const [codeA, codeB, paramsA, paramsB, varsA, varsB, dsA, dsB] = await Promise.all([
+            tm1Client.processes.getCode(processA),
+            tm1Client.processes.getCode(processB),
+            tm1Client.processes.getParameters(processA),
+            tm1Client.processes.getParameters(processB),
+            tm1Client.processes.getVariableLayout(processA),
+            tm1Client.processes.getVariableLayout(processB),
+            tm1Client.processes.getDataSource(processA),
+            tm1Client.processes.getDataSource(processB),
+        ]);
+        const tabResults = {};
+        for (const tab of diffTabs) {
+            tabResults[tab] = tabCodeDiff(mask(codeA[tab] ?? ""), mask(codeB[tab] ?? ""), contextLines);
+        }
+        const parameters = diffParams(paramsA, paramsB);
+        const variables = diffVars(varsA.variables, varsB.variables);
+        const ignoredColumns = diffIgnoredColumns(varsA.ignoredColumns, varsB.ignoredColumns);
+        const dataSource = diffDs(dsA, dsB);
+        const identical = Object.values(tabResults).every((t) => t.identical) &&
+            parameters.identical &&
+            variables.identical &&
+            ignoredColumns.identical &&
+            dataSource.identical;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        processA,
+                        processB,
+                        identical,
+                        tabs: tabResults,
+                        parameters,
+                        variables,
+                        ignoredColumns,
+                        dataSource,
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=diff-processes.js.map

package/dist/tools/ti-development/execute-process.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Client-abort recovery hint, branched by TM1 major version: v11 exposes
+ * server threads (tm1_list_threads / tm1_cancel_thread), v12 exposes jobs
+ * (tm1_list_jobs / tm1_cancel_job) instead.
+ */
+export declare function abortHint(version: 11 | 12): string;
+export declare const registerExecuteProcess: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=execute-process.d.ts.map

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

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { withToolHint } from "../error-format.js";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { ProcessResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+/**
+ * Client-abort recovery hint, branched by TM1 major version: v11 exposes
+ * server threads (tm1_list_threads / tm1_cancel_thread), v12 exposes jobs
+ * (tm1_list_jobs / tm1_cancel_job) instead.
+ */
+export function abortHint(version) {
+    const monitor = version === 12 ? "tm1_list_jobs" : "tm1_list_threads";
+    const cancel = version === 12 ? "tm1_cancel_job" : "tm1_cancel_thread";
+    return `Request aborted by the client — the process was NOT confirmed failed and may still be executing. Use ${monitor} to check for it and ${cancel} to stop it. Do NOT blindly re-run: that risks a duplicate execution.`;
+}
+export const registerExecuteProcess = defineTool({
+    name: "tm1_execute_process",
+    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.",
+        "On failure: use tm1_diagnose_process_error for combined log + cascade fetch.",
+    ],
+    annotations: DESTRUCTIVE,
+    output: ProcessResultSchema,
+    input: {
+        processName: z.string().describe("Name of the TI process to execute"),
+        parameters: z
+            .record(z.string(), z.union([z.string(), z.number()]))
+            .optional()
+            .describe("Optional key-value map of process parameters"),
+        timeoutMs: z
+            .number()
+            .int()
+            .min(1000)
+            .max(3600000)
+            .optional()
+            .describe("Override the default 30s request timeout for this call (ms, 1000–3600000). Use for long-running TI runs."),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ processName, parameters, timeoutMs, confirm }, tm1Client, extra) => {
+        // A TI run writes through to cubes, and undoing the call does not undo
+        // its effects. Guards against an auto-approve client firing it
+        // speculatively — NOT a security control: whatever can call the tool can
+        // also supply `confirm`.
+        requireConfirm(confirm, processName, "process");
+        // R2-02: TM1 REST exposes no mid-run progress for tm1.Execute, so we
+        // emit periodic heartbeat notifications (every 5s) instead. Keeps
+        // client UI alive during long TI runs and lets users distinguish
+        // "still working" from "hung". Heartbeat-only; total stays undefined
+        // since TI duration is unknown ahead of time.
+        const progressToken = extra?._meta?.progressToken;
+        const start = Date.now();
+        let heartbeatTimer;
+        if (progressToken !== undefined) {
+            const tick = () => {
+                const elapsedSec = Math.round((Date.now() - start) / 1000);
+                void extra
+                    .sendNotification({
+                    method: "notifications/progress",
+                    params: {
+                        progressToken,
+                        progress: elapsedSec,
+                        message: `${processName} still running (${elapsedSec}s elapsed)`,
+                    },
+                })
+                    .catch(() => undefined);
+            };
+            heartbeatTimer = setInterval(tick, 5000);
+        }
+        try {
+            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.`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+                // A TI process that ran but reported failure is a tool failure, not a
+                // successful call carrying success:false. Flag isError so agents that
+                // branch on the MCP error signal don't silently treat it as success;
+                // the full payload (processErrorStatus, errorLogFile) is preserved by
+                // normalizeErrorResult for diagnosis.
+                ...(result.success === false ? { isError: true } : {}),
+            };
+        }
+        catch (err) {
+            // Client-side cancellation (notifications/cancelled) aborts the fetch,
+            // but the TI process keeps running server-side — TM1 REST has no
+            // mid-run abort. withToolHint's runtime-failure hint ("diagnose then
+            // re-run") is actively wrong here: it invites a duplicate execution.
+            // Detect the abort via the MCP signal and point at the live thread.
+            if (extra?.signal?.aborted) {
+                throw new TM1Error({
+                    code: TM1ErrorCode.TM1_ERROR,
+                    message: `Execution of '${processName}' was cancelled client-side before it returned; the TI process may still be running on the TM1 server.`,
+                    hint: abortHint(tm1Client.version),
+                });
+            }
+            throw err;
+        }
+        finally {
+            if (heartbeatTimer !== undefined)
+                clearInterval(heartbeatTimer);
+        }
+    },
+});
+//# sourceMappingURL=execute-process.js.map

package/dist/tools/ti-development/export-process-to-git.d.ts

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

package/dist/tools/ti-development/export-process-to-git.js

@@ -0,0 +1,113 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { supportsCredentialExport } from "../../lib/credential-format.js";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { resolveLocalPath } from "../local-file.js";
+import { maskCode, resolveMaskSecrets } from "../../lib/mask-secrets.js";
+import { ExportProcessToGitResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { readProcessAsGit } from "./process-backup.js";
+export const registerExportProcessToGit = defineTool({
+    name: "tm1_export_process_to_git",
+    description: [
+        "Serialize a TM1 process to the tm1-git two-file layout: a '{name}.json' (parameters, variables, ignored datasource columns, datasource) plus a '{name}.ti' (Prolog/Metadata/Data/Epilog as plain code).",
+        "The .ti holds the code in TM1's native `Code` representation (#region <Tab> / #endregion, CRLF, empty tabs omitted); the .json holds the structure. Code lives outside the JSON so Git diffs stay readable.",
+        "Returns both file bodies (json + ti) inline by default. Pass writeToDir to persist them to disk instead: the code is then written to files and omitted from the response to avoid duplicating it into the context window; only metadata (filenames, counts, writtenTo paths) comes back. Round-trip safe with tm1_import_process_from_git.",
+        "Security: the ODBC datasource password is stripped unless includeDataSourcePassword is set (which also requires writeToDir); credential literals in the TI code are masked when maskSecrets is on; credentialsOmitted=true flags when a password was stripped.",
+        "includeDataSourcePassword is v12-only: what v11 hands out expires with the server run, so exporting it would produce a file that looks complete and fails later.",
+    ],
+    annotations: READ_ONLY,
+    output: ExportProcessToGitResultSchema,
+    input: {
+        processName: z.string().describe("Name of the TI process to export"),
+        writeToDir: z
+            .string()
+            .optional()
+            .describe("Optional absolute host directory to write '{name}.json' and '{name}.ti' into. Disabled unless TM1_LOCAL_FILE_ROOT is set; the path must resolve within that directory. If omitted, content is only returned inline."),
+        maskSecrets: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Redact credential literals in the exported .ti code (inline and written file) and credential pairs (PWD=, UID=) in the datasource's ODBC connection string in the .json. " +
+            "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."),
+        includeDataSourcePassword: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Write the ODBC datasource password into the .json. Off by default, and v12 ONLY — on v11 it is refused, because the credential v11 hands out expires with the server run and would leave a .json that looks complete and fails at connect time; clone with tm1_copy_process instead, or deploy with tm1_import_process_from_git's dataSourcePassword. On v12 the value written is the PLAIN password, in a layout meant for version control — requires writeToDir, and do not commit the result."),
+    },
+    handler: async ({ processName, writeToDir, maskSecrets, includeDataSourcePassword }, tm1Client) => {
+        if (includeDataSourcePassword && !writeToDir) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "includeDataSourcePassword requires writeToDir — the credential must go to a file, not into the inline response.",
+            });
+        }
+        // See src/lib/credential-format.ts: a v11 credential is scoped to one
+        // server run, so an exported one rots without any visible sign.
+        if (includeDataSourcePassword &&
+            !supportsCredentialExport(tm1Client.version)) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "includeDataSourcePassword is v12-only. On v11 the exported credential stops working when the TM1 service restarts, and the .json gives no sign of it. To clone a process with its password inside this instance use tm1_copy_process; to deploy elsewhere or later, export without the password and pass dataSourcePassword to tm1_import_process_from_git.",
+            });
+        }
+        const pair = await readProcessAsGit(tm1Client, processName, {
+            includePassword: includeDataSourcePassword === true,
+        });
+        const mask = resolveMaskSecrets(maskSecrets) ? maskCode : (s) => s;
+        const ti = mask(pair.ti);
+        const { json, credentialsOmitted } = pair;
+        const jsonFileName = `${processName}.json`;
+        const tiFileName = `${processName}.ti`;
+        const writtenTo = {
+            json: null,
+            ti: null,
+        };
+        if (writeToDir) {
+            // Reject path separators in the process name so the join below cannot
+            // climb out of the target directory (resolveLocalPath also confines it).
+            if (/[\\/]|\.\./.test(processName)) {
+                throw new TM1Error({
+                    code: TM1ErrorCode.VALIDATION_ERROR,
+                    message: `Process name '${processName}' contains path separators; cannot derive safe file names`,
+                });
+            }
+            const dir = resolveLocalPath(writeToDir, "writeToDir");
+            const jsonPath = resolveLocalPath(path.join(dir, jsonFileName), "writeToDir");
+            const tiPath = resolveLocalPath(path.join(dir, tiFileName), "writeToDir");
+            // Create the target directory only AFTER confinement above, so the
+            // symlink-aware realpath check ran against the pre-existing tree.
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(jsonPath, json, "utf8");
+            await fs.writeFile(tiPath, ti, "utf8");
+            writtenTo.json = jsonPath;
+            writtenTo.ti = tiPath;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        processName,
+                        jsonFileName,
+                        tiFileName,
+                        parameterCount: pair.parameterCount,
+                        variableCount: pair.variableCount,
+                        dataSourceType: pair.dataSourceType,
+                        credentialsOmitted,
+                        hasSecurityAccess: pair.hasSecurityAccess,
+                        writtenTo,
+                        // Echo the file bodies inline only when NOT persisting to disk. With
+                        // writeToDir the caller already has the files, so returning the code
+                        // would just duplicate thousands of tokens into the context window.
+                        ...(writeToDir ? {} : { json, ti }),
+                    }),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=export-process-to-git.js.map

package/dist/tools/ti-development/export-process-to-pro.d.ts

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

package/dist/tools/ti-development/export-process-to-pro.js

@@ -0,0 +1,117 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { resolveLocalPath } from "../local-file.js";
+import { serializeToPro } from "../../lib/pro-serializer.js";
+import { maskCode, resolveMaskSecrets } from "../../lib/mask-secrets.js";
+import { supportsCredentialExport } from "../../lib/credential-format.js";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { ExportProcessToProResultSchema } from "../schemas/items.js";
+import { READ_ONLY, withVersion } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerExportProcessToPro = defineTool({
+    name: "tm1_export_process_to_pro",
+    description: [
+        "Reverse of tm1_import_pro_file: serialize a TM1 process back to a .pro file body.",
+        "Fetches code (Prolog/Metadata/Data/Epilog), parameters, variables (including the columns set to Ignore), and datasource in parallel.",
+        "Returns the .pro content inline by default; pass writeToFile to also persist to an absolute path on the MCP host.",
+        "Round-trip safe with tm1_import_pro_file — useful for syncing live server state into a Git repo.",
+        "NOT a drop-in replacement for the .pro file in TM1's Datadir: the output omits TM1's BOM, its '601' version header and CRLF line endings. Measured on 11.8: TM1 does load such a file at startup and rewrites it in its own dialect, but it decodes slot 565 with its own scheme — a password written here becomes garbage that TM1 then persists, so the process looks configured and fails at runtime. Deploy via tm1_import_pro_file, not by copying into the Datadir.",
+    ],
+    annotations: withVersion(READ_ONLY, "v11"),
+    output: ExportProcessToProResultSchema,
+    input: {
+        processName: z.string().describe("Name of the TI process to export"),
+        writeToFile: z
+            .string()
+            .optional()
+            .describe("Optional absolute host path to write the .pro file to. Disabled unless TM1_LOCAL_FILE_ROOT is set; the path must resolve within that directory. If omitted, content is only returned inline."),
+        maskSecrets: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Redact credential literals in the exported code (inline and written file). 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."),
+        includeDataSourcePassword: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Write the ODBC datasource password into the file (slot 565). Off by default, and v12 ONLY — on v11 it is refused, because the " +
+            "credential v11 hands out expires with the server run and would leave a file that looks complete and fails at connect time; clone " +
+            "with tm1_copy_process instead, or deploy with tm1_import_pro_file's dataSourcePassword. On v12 the value written is the PLAIN " +
+            "password. Requires writeToFile, so it never enters the inline response. Do not commit such a file."),
+    },
+    handler: async ({ processName, writeToFile, maskSecrets, includeDataSourcePassword }, tm1Client) => {
+        if (includeDataSourcePassword && !writeToFile) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "includeDataSourcePassword requires writeToFile — the credential must go to a file, not into the inline response.",
+            });
+        }
+        // See src/lib/credential-format.ts: a v11 credential is scoped to one
+        // server run, so an exported one rots without any visible sign.
+        if (includeDataSourcePassword &&
+            !supportsCredentialExport(tm1Client.version)) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "includeDataSourcePassword is v12-only. On v11 the exported credential stops working when the TM1 service restarts, and the file gives no sign of it. To clone a process with its password inside this instance use tm1_copy_process; to deploy elsewhere or later, export without the password and pass dataSourcePassword to tm1_import_pro_file.",
+            });
+        }
+        const [code, parameters, layout, dataSource] = await Promise.all([
+            tm1Client.processes.getCode(processName),
+            tm1Client.processes.getParameters(processName),
+            tm1Client.processes.getVariableLayout(processName),
+            tm1Client.processes.getDataSource(processName, {
+                includeSecrets: includeDataSourcePassword === true,
+            }),
+        ]);
+        // Without the opt-in the service hands back a "[redacted]" marker, which
+        // must not be written into the file as if it were the credential.
+        if (!includeDataSourcePassword)
+            delete dataSource.password;
+        const credentialsIncluded = Boolean(includeDataSourcePassword && dataSource.password);
+        const mask = resolveMaskSecrets(maskSecrets) ? maskCode : (s) => s;
+        const proContent = serializeToPro({
+            name: processName,
+            prolog: mask(code.prolog),
+            metadata: mask(code.metadata),
+            data: mask(code.data),
+            epilog: mask(code.epilog),
+            parameters,
+            variables: layout.variables,
+            ...(layout.variablesUIData !== undefined
+                ? { variablesUIData: layout.variablesUIData }
+                : {}),
+            dataSource,
+        });
+        let writtenTo = null;
+        if (writeToFile) {
+            const target = resolveLocalPath(writeToFile, "writeToFile");
+            // Create the parent directory only AFTER confinement above, so the
+            // symlink-aware realpath check ran against the pre-existing tree.
+            await fs.mkdir(path.dirname(target), { recursive: true });
+            await fs.writeFile(target, proContent, "utf8");
+            writtenTo = target;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        processName,
+                        byteLength: Buffer.byteLength(proContent, "utf8"),
+                        writtenTo,
+                        parameterCount: parameters.length,
+                        variableCount: layout.variables.length,
+                        dataSourceType: dataSource.type,
+                        credentialsIncluded,
+                        // Written to disk only when credentials are in play — otherwise
+                        // the caller already has the body and it stays out of the context.
+                        ...(includeDataSourcePassword ? {} : { content: proContent }),
+                    }),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=export-process-to-pro.js.map

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

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