@ffschrattenecker/tm1-mcp-server 6.0.0

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

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { maskCode, resolveMaskSecrets } from "../../lib/mask-secrets.js";
+import { commentStats } from "../../lib/strip-comments.js";
+import { ProcessCodeBundleSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+// Default cap for full-code responses. Whole-model code dumps flood the
+// context window; 50 processes is plenty for a first look, and the response
+// reports truncated=true so agents know to raise limit (or pass 0 for all).
+const DEFAULT_LIMIT = 50;
+// Summary mode: drop the four tab bodies, report line metrics instead so
+// analysis agents can survey the process landscape without paying full token
+// cost (mirrors tm1_get_all_cube_rules summary mode).
+function summarize(p) {
+    const prolog = commentStats(p.prolog);
+    const metadata = commentStats(p.metadata);
+    const data = commentStats(p.data);
+    const epilog = commentStats(p.epilog);
+    return {
+        name: p.name,
+        hasSecurityAccess: p.hasSecurityAccess,
+        totalLines: prolog.totalLines +
+            metadata.totalLines +
+            data.totalLines +
+            epilog.totalLines,
+        prologLines: prolog.totalLines,
+        metadataLines: metadata.totalLines,
+        dataLines: data.totalLines,
+        epilogLines: epilog.totalLines,
+        commentLines: prolog.commentLines +
+            metadata.commentLines +
+            data.commentLines +
+            epilog.commentLines,
+    };
+}
+export const registerGetAllProcessesCode = defineTool({
+    name: "tm1_get_all_processes_code",
+    description: "Bulk-load source code (Prolog/Metadata/Data/Epilog) of every TI process in one call, plus each process's HasSecurityAccess elevation flag (hasSecurityAccess) for audit. Control objects (names starting with '}') excluded by default. Credential literals in the code are masked by default (maskSecrets). Full-code responses are capped at 50 processes by default (ordered by name; truncated=true when capped — raise limit or pass limit=0 for all). Set summary=true to drop the tab bodies and get per-process line metrics instead; summary mode surveys ALL processes by default. For keyword surveys prefer tm1_search_code — it avoids dumping every process body into context.",
+    annotations: READ_ONLY,
+    output: {
+        count: z
+            .number()
+            .int()
+            .describe("Total processes matched before limit (lower bound if countIsExact=false)"),
+        countIsExact: z
+            .boolean()
+            .describe("False when count is only a lower bound"),
+        returned: z
+            .number()
+            .int()
+            .describe("Processes in this response after limit"),
+        truncated: z.boolean().describe("True when limit dropped processes"),
+        processes: z
+            .array(ProcessCodeBundleSchema)
+            .describe("Per-process code bundles"),
+    },
+    input: {
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include TM1 control processes whose names start with '}' (default: false)"),
+        limit: z
+            .number()
+            .int()
+            .min(0)
+            .max(500)
+            .optional()
+            .describe("Max processes returned (default 50, max 500, 0 = all). Summary mode defaults to 0 (full survey)."),
+        maskSecrets: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Redact credential literals in every returned tab (ODBCOpen passwords, quoted values assigned to credential-named identifiers, conn-string PWD/UID pairs). " +
+            "Default: true. Set false only when explicitly auditing credentials."),
+        summary: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Drop the four code tabs, return per-process line metrics instead " +
+            "(totalLines, prologLines, metadataLines, dataLines, epilogLines, commentLines) (default: false)"),
+    },
+    handler: async ({ includeControl, limit, maskSecrets, summary }, tm1Client) => {
+        // Full-code mode default-caps at DEFAULT_LIMIT; summary mode defaults to
+        // the whole model (metrics are cheap and a partial survey would be
+        // misleading). Explicit limit wins in both modes; 0 = no cap.
+        const cap = limit ?? (summary ? 0 : DEFAULT_LIMIT);
+        // Server-side cap: $top=cap+1 sentinel detects truncation even if the
+        // server omits @odata.count; $orderby=Name keeps the cut stable.
+        const fetched = cap > 0
+            ? await tm1Client.processes.getAllCode(includeControl, cap + 1)
+            : {
+                items: await tm1Client.processes.getAllCode(includeControl),
+                total: undefined,
+            };
+        const truncated = cap > 0 && fetched.items.length > cap;
+        const kept = truncated ? fetched.items.slice(0, cap) : fetched.items;
+        // An uncapped fetch saw everything and @odata.count is authoritative,
+        // but a truncated capped fetch without @odata.count only proves "more
+        // than cap" — then count is a lower bound, flagged via countIsExact.
+        const countIsExact = !truncated || fetched.total !== undefined;
+        const count = fetched.total ?? fetched.items.length;
+        // summary mode returns no code, so masking is moot — skip the work.
+        const processes = summary
+            ? kept.map(summarize)
+            : resolveMaskSecrets(maskSecrets)
+                ? kept.map((p) => ({
+                    ...p,
+                    prolog: maskCode(p.prolog),
+                    metadata: maskCode(p.metadata),
+                    data: maskCode(p.data),
+                    epilog: maskCode(p.epilog),
+                }))
+                : kept;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        count,
+                        countIsExact,
+                        returned: processes.length,
+                        truncated,
+                        processes,
+                    }),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=get-all-processes-code.js.map

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,38 @@
+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

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

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

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

@@ -0,0 +1,163 @@
+import { z } from "zod";
+import { commentStats, stripCommentBlocks } from "../../lib/strip-comments.js";
+import { maskCode, resolveMaskSecrets, MASK } from "../../lib/mask-secrets.js";
+import { GetProcessResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+const TABS = ["prolog", "metadata", "data", "epilog"];
+const HEAVY_MIN_LINES = 20;
+const HEAVY_RATIO = 0.4;
+export const registerGetProcess = defineTool({
+    name: "tm1_get_process",
+    description: "Native full read of a TI process — the read-twin of tm1_upsert_process. Returns the four code " +
+        "tabs, parameters, variables (plus any datasource columns set to Ignore, which carry no variable) " +
+        "and the HasSecurityAccess elevation flag in one call, " +
+        "using the same field names as upsert_process — the datasource shape is shared, so what this read " +
+        "returns can be fed straight back into upsert_process. Every part is behind an " +
+        "include-flag (all default true); set a flag false to skip that part's REST call. For git " +
+        "persistence use tm1_export_process_to_git instead.",
+    annotations: READ_ONLY,
+    output: GetProcessResultSchema,
+    input: {
+        processName: z.string().describe("Name of the TI process"),
+        includeCode: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include the four code tabs (default true)."),
+        includeParameters: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include parameters (default true)."),
+        includeVariables: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include variables (default true)."),
+        includeDataSource: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include the datasource config (default true)."),
+        includeSecurityAccess: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include the HasSecurityAccess elevation flag (default true)."),
+        maskSecrets: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Redact credential literals in the code tabs (ODBCOpen passwords, credential-named vars) and credential pairs " +
+            "(PWD=, UID=) in the datasource's ODBC connection string. Default true; " +
+            "set false only when explicitly auditing credentials. Note: the datasource password field is always " +
+            "redacted at the service layer, so that field never reveals a real secret either way."),
+        stripComments: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Collapse runs of 4+ comment lines in the code tabs into a marker (dead-code reduction). Default false."),
+    },
+    handler: async ({ processName, includeCode = true, includeParameters = true, includeVariables = true, includeDataSource = true, includeSecurityAccess = true, maskSecrets: maskSecretsRequested = true, stripComments = false, }, tm1Client) => {
+        // A model-supplied `maskSecrets:false` only takes effect when the
+        // operator allowed it via TM1_ALLOW_UNMASKED_SECRETS.
+        const maskSecrets = resolveMaskSecrets(maskSecretsRequested);
+        const payload = { name: processName };
+        let hint;
+        // All enabled fetches run in parallel; disabled flags resolve to
+        // undefined so the destructuring below stays positional.
+        const [code, parameters, varLayout, dataSourceRaw, deployMeta] = await Promise.all([
+            includeCode ? tm1Client.processes.getCode(processName) : undefined,
+            includeParameters
+                ? tm1Client.processes.getParameters(processName)
+                : undefined,
+            includeVariables
+                ? tm1Client.processes.getVariableLayout(processName)
+                : undefined,
+            includeDataSource
+                ? tm1Client.processes.getDataSource(processName)
+                : undefined,
+            includeSecurityAccess
+                ? tm1Client.processes.getDeployMeta(processName)
+                : undefined,
+        ]);
+        if (code !== undefined) {
+            const tabs = {
+                prolog: code.prolog,
+                metadata: code.metadata,
+                data: code.data,
+                epilog: code.epilog,
+            };
+            if (stripComments) {
+                let removedLines = 0;
+                let collapsedBlocks = 0;
+                for (const tab of TABS) {
+                    const r = stripCommentBlocks(tabs[tab]);
+                    tabs[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(tabs[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 (maskSecrets) {
+                for (const tab of TABS)
+                    tabs[tab] = maskCode(tabs[tab]);
+            }
+            Object.assign(payload, tabs);
+        }
+        if (parameters !== undefined)
+            payload.parameters = parameters;
+        if (varLayout !== undefined) {
+            payload.variables = varLayout.variables;
+            // Only reported when there are any: an ignored column is the reason the
+            // remaining positions have gaps, and staying silent invites the reader to
+            // treat the gap as a bug.
+            if (varLayout.ignoredColumns.length > 0)
+                payload.ignoredColumns = varLayout.ignoredColumns;
+        }
+        if (dataSourceRaw !== undefined) {
+            const ds = dataSourceRaw;
+            if (maskSecrets) {
+                if (ds.password !== undefined && ds.password !== "")
+                    ds.password = MASK;
+            }
+            payload.dataSource = ds;
+        }
+        if (deployMeta !== undefined)
+            payload.hasSecurityAccess = deployMeta.hasSecurityAccess;
+        if (hint)
+            payload.hint = hint;
+        return {
+            content: [{ type: "text", text: JSON.stringify(payload) }],
+        };
+    },
+});
+//# sourceMappingURL=get-process.js.map

package/dist/tools/ti-development/import-pro-file.d.ts

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

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

@@ -0,0 +1,153 @@
+import { promises as fs } from "node:fs";
+import { resolveLocalPath } from "../local-file.js";
+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 { ImportProFileResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { OVERWRITE_CONFIRM_SCHEMA, requireOverwriteConfirm, } from "../confirm.js";
+import { preflightResult, runPreflight } from "./preflight.js";
+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"),
+    output: ImportProFileResultSchema,
+    input: {
+        filePath: z
+            .string()
+            .optional()
+            .describe("Absolute path to the .pro file on the MCP server host. Disabled unless TM1_LOCAL_FILE_ROOT is set; the path must resolve within that directory. Otherwise pass 'content' inline."),
+        content: z
+            .string()
+            .optional()
+            .describe("Raw .pro file content as string (alternative to filePath)"),
+        processName: z
+            .string()
+            .optional()
+            .describe("Override process name. Default: name parsed from .pro (602,'Name')."),
+        mode: z
+            .enum(["create", "update", "upsert"])
+            .optional()
+            .default("upsert")
+            .describe("Deployment mode (default: upsert)"),
+        preflight: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Run the syntax check (tm1_check_process_code) AND the reference check (tm1_validate_process_refs) on the exact payload before applying; abort on either. Default true. false skips both."),
+        ...OVERWRITE_CONFIRM_SCHEMA,
+        dataSourcePassword: z
+            .string()
+            .optional()
+            .describe("ODBC password to inject, in clear text; the target server encrypts it. Overrides whatever the file carries. This is the normal way to deploy an ODBC process: a .pro from TM1's own Datadir has its slot 565 ignored (that encoding cannot be replayed over REST), and a v11 export never carries a password. Ignored for non-ODBC datasources."),
+    },
+    handler: async ({ filePath, content, processName: nameOverride, mode, preflight, dataSourcePassword, confirm, }, tm1Client) => {
+        if (!filePath && !content) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "Provide filePath or content",
+            });
+        }
+        let body = content ?? "";
+        if (!body && filePath) {
+            body = await fs.readFile(resolveLocalPath(filePath), "utf8");
+        }
+        const parsed = parseProFile(body);
+        if (parsed.dataSource.type === "ODBC" && dataSourcePassword !== undefined)
+            parsed.dataSource.password = dataSourcePassword;
+        const processName = nameOverride ?? parsed.name;
+        if (!processName) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "Process name not found in .pro (602,'Name') and no name override provided",
+            });
+        }
+        if (preflight) {
+            const failure = await runPreflight(tm1Client, {
+                name: processName,
+                prolog: parsed.prolog,
+                metadata: parsed.metadata,
+                data: parsed.data,
+                epilog: parsed.epilog,
+                parameters: parsed.parameters,
+                variables: parsed.variables,
+                dataSource: parsed.dataSource,
+            });
+            if (failure)
+                return preflightResult(failure);
+        }
+        const allProcs = await tm1Client.processes.list();
+        const exists = allProcs.some((p) => p.name === processName);
+        if (mode === "create" && exists) {
+            throw new TM1Error({
+                code: TM1ErrorCode.CONFLICT,
+                message: `Process '${processName}' already exists; mode=create`,
+            });
+        }
+        if (mode === "update" && !exists) {
+            throw new TM1Error({
+                code: TM1ErrorCode.NOT_FOUND,
+                message: `Process '${processName}' does not exist; mode=update`,
+            });
+        }
+        // Replacing an installed process is not undoable through the API.
+        if (exists)
+            requireOverwriteConfirm(confirm, processName, "process");
+        // Last step before the first write: a failed backup throws, nothing is written.
+        const backup = exists ? await backupProcess(tm1Client, processName) : null;
+        const action = exists ? "updated" : "created";
+        if (!exists) {
+            await withToolHint(tm1Client.processes.create(processName), `Process create failed mid-import. Name '${processName}' may already exist (mode=create would have caught — likely race) or contain invalid characters. tm1_list_processes to verify state before retry.`);
+        }
+        await withToolHint(tm1Client.processes.updateCode(processName, {
+            prolog: parsed.prolog,
+            metadata: parsed.metadata,
+            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.`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        action,
+                        processName,
+                        ...(backup ? { backup } : {}),
+                        parsed: {
+                            prologLines: parsed.prolog.split("\n").length,
+                            metadataLines: parsed.metadata.split("\n").length,
+                            dataLines: parsed.data.split("\n").length,
+                            epilogLines: parsed.epilog.split("\n").length,
+                            parameterCount: parsed.parameters.length,
+                            variableCount: parsed.variables.length,
+                            dataSourceType: parsed.dataSource.type,
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=import-pro-file.js.map

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

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