@ffschrattenecker/tm1-mcp-server 6.0.0

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

@@ -0,0 +1,118 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { serializeProcessToGit } from "../../lib/git-process.js";
+// Automatic backup of an installed process before a tool overwrites it.
+//
+// Replacing a process is not undoable through the REST API, and until this
+// existed the rollback copy depended on the caller remembering to export
+// first. The backup is the tm1-git pair tm1_export_process_to_git produces,
+// so tm1_import_process_from_git is the restore path.
+//
+// The directory is chosen by the server, never by the caller, so it is not
+// confined to TM1_LOCAL_FILE_ROOT and is on by default:
+//   TM1_PROCESS_BACKUP_DIR unset → ~/.tm1-mcp-server/backups
+//   TM1_PROCESS_BACKUP_DIR=off   → no backup
+// Under it: <connection>/<process>/<timestamp>.json + .ti.
+//
+// The code is written UNMASKED. A masked backup restores a process that
+// carries placeholder literals, looks deployed, and fails at runtime. The ODBC
+// datasource password is never written (serializeProcessToGit strips it).
+const DIR_ENV = "TM1_PROCESS_BACKUP_DIR";
+/** Read an installed process as the tm1-git pair. Code is returned as stored. */
+export async function readProcessAsGit(tm1Client, processName, opts) {
+    const includePassword = opts?.includePassword === true;
+    const [ti, parameters, layout, dataSource, deployMeta] = await Promise.all([
+        tm1Client.processes.getCodeBlob(processName),
+        tm1Client.processes.getParameters(processName),
+        tm1Client.processes.getVariableLayout(processName),
+        tm1Client.processes.getDataSource(processName, {
+            includeSecrets: includePassword,
+        }),
+        tm1Client.processes.getDeployMeta(processName),
+    ]);
+    const { json, credentialsOmitted } = serializeProcessToGit({
+        name: processName,
+        parameters,
+        variables: layout.variables,
+        ...(layout.variablesUIData !== undefined
+            ? { variablesUIData: layout.variablesUIData }
+            : {}),
+        dataSource,
+        hasSecurityAccess: deployMeta.hasSecurityAccess,
+    }, { includePassword });
+    return {
+        json,
+        ti,
+        credentialsOmitted,
+        parameterCount: parameters.length,
+        variableCount: layout.variables.length,
+        dataSourceType: dataSource.type,
+        hasSecurityAccess: deployMeta.hasSecurityAccess,
+    };
+}
+/** The backup root, or null when backups are switched off. */
+export function backupRoot() {
+    const raw = process.env[DIR_ENV]?.trim();
+    if (raw?.toLowerCase() === "off")
+        return null;
+    return raw
+        ? path.resolve(raw)
+        : path.join(os.homedir(), ".tm1-mcp-server", "backups");
+}
+// Windows rejects < > : " / \ | ? * and control characters, and trailing dots
+// or spaces. The real name is inside the .json, so the mapping need not be
+// reversible.
+export function safeFileName(name) {
+    const cleaned = name
+        // eslint-disable-next-line no-control-regex
+        .replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_")
+        .replace(/[. ]+$/, "_");
+    return cleaned === "" || cleaned === "." || cleaned === ".." ? "_" : cleaned;
+}
+function timestamp(now) {
+    // 2026-09-25T14:03:07.123Z → 20260925T140307123Z
+    return now.toISOString().replace(/[-:.]/g, "");
+}
+/**
+ * Write the installed state of `processName` to the backup directory and
+ * return the two paths, or null when backups are off. Throws a TM1Error when
+ * the backup cannot be written: callers run this before their first write, so
+ * a failed backup means nothing is overwritten.
+ */
+export async function backupProcess(tm1Client, processName, now = new Date()) {
+    const root = backupRoot();
+    if (root === null)
+        return null;
+    try {
+        const pair = await readProcessAsGit(tm1Client, processName);
+        const dir = path.join(root, safeFileName(tm1Client.connectionId), safeFileName(processName));
+        await fs.mkdir(dir, { recursive: true });
+        const base = path.join(dir, timestamp(now));
+        const backup = { json: `${base}.json`, ti: `${base}.ti` };
+        // wx: never replace an earlier backup, even on a same-millisecond retry.
+        await fs.writeFile(backup.json, pair.json, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        await fs.writeFile(backup.ti, pair.ti, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        return backup;
+    }
+    catch (err) {
+        const reason = err instanceof TM1Error
+            ? `${err.code}: ${err.message}`
+            : err.message;
+        throw new TM1Error({
+            code: err instanceof TM1Error ? err.code : TM1ErrorCode.VALIDATION_ERROR,
+            message: `Backup of process '${processName}' failed before overwriting it: ${reason}. Nothing was written.`,
+            hint: `Fix the cause (${DIR_ENV} must name a writable directory), or set ${DIR_ENV}=off to overwrite without a backup.`,
+        });
+    }
+}
+//# sourceMappingURL=process-backup.js.map

package/dist/tools/ti-development/search-code.d.ts

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

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

@@ -0,0 +1,208 @@
+import { z } from "zod";
+import { compileUserRegex } from "../../lib/safe-regex.js";
+import { maskCodeLine, resolveMaskSecrets } from "../../lib/mask-secrets.js";
+import { FORMAT_SCHEMA, wrappedPageResponse, columnsOf } from "../format.js";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { READ_ONLY } from "../annotations.js";
+import { SearchCodeResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+const ALL_TABS = ["prolog", "metadata", "data", "epilog"];
+const COMMENT_RE = /^\s*(?:#|\/\/)/;
+export const registerSearchCode = defineTool({
+    name: "tm1_search_code",
+    description: [
+        "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.",
+        "Set groupBy='process' (or 'tab') for a sorted count aggregation instead of individual match lines.",
+    ],
+    annotations: READ_ONLY,
+    output: SearchCodeResultSchema,
+    input: {
+        pattern: z
+            .string()
+            .min(1)
+            .max(2000)
+            .describe("Regex pattern (JavaScript flavor). Anchors and groups supported."),
+        tabs: z
+            .array(z.enum(["prolog", "metadata", "data", "epilog"]))
+            .optional()
+            .describe("Tabs to search (default: all four)"),
+        caseSensitive: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Case-sensitive match (default false)"),
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include TM1 control processes ('}'-prefixed). Default false."),
+        maxMatchesPerProcess: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .default(20)
+            .describe("Cap matches per process to avoid runaway output (default 20)"),
+        maxTotalMatches: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .default(500)
+            .describe("Hard cap on total matches across all processes (default 500)"),
+        maskSecrets: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Redact credential literals in match text. 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."),
+        excludeCommented: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Skip lines beginning with '#' or '//' (TI comment markers). Default: false."),
+        deduplicateByLine: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Collapse matches with identical (tab, line-text) across processes into one result. " +
+            "The first-seen process is kept; others go into alsoFoundIn[]. " +
+            "Drastically reduces output on servers with many process variants. Default: false."),
+        groupBy: z
+            .enum(["process", "tab"])
+            .optional()
+            .describe("Aggregate mode. Instead of individual match lines, return counts grouped by process or tab, " +
+            "sorted by matchCount desc. Answers 'which process has the most X calls' in a tiny payload " +
+            "instead of dumping every matching line. Counts are complete: maxMatchesPerProcess/maxTotalMatches " +
+            "and maskSecrets do not apply in this mode."),
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ pattern, tabs, caseSensitive, includeControl, maxMatchesPerProcess, maxTotalMatches, maskSecrets, excludeCommented, deduplicateByLine, groupBy, limit, offset, fetchAll, format, }, tm1Client) => {
+        const flags = caseSensitive ? "g" : "gi";
+        const regex = compileUserRegex(pattern, flags);
+        const searchTabs = tabs && tabs.length > 0 ? tabs : ALL_TABS;
+        const all = await tm1Client.processes.getAllCode(includeControl);
+        if (groupBy) {
+            // Aggregate mode: count every matching line, grouped by process or tab.
+            // No per-process / total caps here so the counts are complete — the
+            // payload is bounded by the number of groups, not the match count.
+            const counts = new Map();
+            let totalMatches = 0;
+            for (const proc of all) {
+                for (const tab of searchTabs) {
+                    const code = proc[tab] ?? "";
+                    if (!code)
+                        continue;
+                    const lines = code.split(/\r?\n/);
+                    for (let i = 0; i < lines.length; i++) {
+                        regex.lastIndex = 0;
+                        const raw = lines[i];
+                        if (excludeCommented && COMMENT_RE.test(raw))
+                            continue;
+                        if (regex.test(raw)) {
+                            const key = groupBy === "process" ? proc.name : tab;
+                            counts.set(key, (counts.get(key) ?? 0) + 1);
+                            totalMatches++;
+                        }
+                    }
+                }
+            }
+            const groups = [...counts.entries()]
+                .map(([key, matchCount]) => ({ [groupBy]: key, matchCount }))
+                .sort((a, b) => b.matchCount - a.matchCount);
+            const groupPage = paginate(groups, limit, offset, fetchAll);
+            const groupWrapper = {
+                pattern,
+                caseSensitive,
+                tabsSearched: searchTabs,
+                processesScanned: all.length,
+                groupBy,
+                groupCount: groups.length,
+                matchCount: totalMatches,
+                ...groupPage,
+            };
+            const groupColumns = columnsOf([
+                { header: groupBy, get: (g) => g[groupBy] },
+                "matchCount",
+            ]);
+            return wrappedPageResponse(groupWrapper, groupPage, format, {
+                title: `Search: ${pattern} (grouped by ${groupBy})`,
+                columns: groupColumns,
+            });
+        }
+        const matches = [];
+        let truncated = false;
+        outer: for (const proc of all) {
+            let perProcess = 0;
+            for (const tab of searchTabs) {
+                const code = proc[tab] ?? "";
+                if (!code)
+                    continue;
+                const lines = code.split(/\r?\n/);
+                for (let i = 0; i < lines.length; i++) {
+                    regex.lastIndex = 0;
+                    const raw = lines[i];
+                    if (excludeCommented && COMMENT_RE.test(raw))
+                        continue;
+                    if (regex.test(raw)) {
+                        const text = (resolveMaskSecrets(maskSecrets) ? maskCodeLine(raw) : raw)
+                            .trim()
+                            .slice(0, 240);
+                        matches.push({ process: proc.name, tab, line: i + 1, text });
+                        perProcess++;
+                        if (matches.length >= maxTotalMatches) {
+                            truncated = true;
+                            break outer;
+                        }
+                        if (perProcess >= maxMatchesPerProcess)
+                            break;
+                    }
+                }
+                if (perProcess >= maxMatchesPerProcess)
+                    break;
+            }
+        }
+        let deduplicated = false;
+        let rawMatchCount;
+        if (deduplicateByLine && matches.length > 0) {
+            rawMatchCount = matches.length;
+            const seen = new Map();
+            for (const m of matches) {
+                const key = `${m.tab}\x00${m.text}`;
+                const existing = seen.get(key);
+                if (existing) {
+                    (existing.alsoFoundIn ??= []).push(m.process);
+                }
+                else {
+                    seen.set(key, { ...m });
+                }
+            }
+            matches.length = 0;
+            for (const m of seen.values())
+                matches.push(m);
+            deduplicated = true;
+        }
+        const page = paginate(matches, limit, offset, fetchAll);
+        const wrapper = {
+            pattern,
+            caseSensitive,
+            tabsSearched: searchTabs,
+            processesScanned: all.length,
+            matchCount: matches.length,
+            ...(deduplicated && { rawMatchCount, deduplicated }),
+            truncated,
+            maskSecrets,
+            excludeCommented,
+            ...page,
+        };
+        const columns = columnsOf(["process", "tab", "line", "text"]);
+        return wrappedPageResponse(wrapper, page, format, {
+            title: `Search: ${pattern}`,
+            columns,
+        });
+    },
+});
+//# sourceMappingURL=search-code.js.map

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

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

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

@@ -0,0 +1,167 @@
+import { z } from "zod";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { invalidateCallgraphCache } from "../../lib/callgraph/tm1-adapter.js";
+import { dataSourceSchema as sharedDataSourceSchema } from "../../lib/process-parts-schema.js";
+import { IDEMPOTENT_DESTRUCTIVE } from "../annotations.js";
+import { UpsertProcessResultSchema } 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";
+// 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.
+// Strict, so a misspelled field is rejected instead of silently dropped.
+const dataSourceSchema = sharedDataSourceSchema.strict();
+const parameterSchema = z.object({
+    name: z.string(),
+    type: z.enum(["String", "Numeric"]),
+    defaultValue: z.union([z.string(), z.number()]),
+    prompt: z.string().optional(),
+});
+const variableSchema = z.object({
+    name: z.string(),
+    type: z.enum(["String", "Numeric"]),
+    position: z.number().int().positive(),
+    startByte: z.number().int().optional(),
+    endByte: z.number().int().optional(),
+});
+export const registerUpsertProcess = defineTool({
+    name: "tm1_upsert_process",
+    description: "Atomic-style create-or-update for a TI process. Bundles createProcess (if missing) + updateProcessCode + updateProcessParameters + updateProcessVariables + updateProcessDataSource into a single MCP call. NOTE: TM1 itself does not support a real transaction — on partial failure, the steps that already succeeded are not rolled back. The tool reports which step failed.",
+    annotations: IDEMPOTENT_DESTRUCTIVE,
+    output: UpsertProcessResultSchema,
+    input: {
+        processName: z.string(),
+        prolog: z.string().optional(),
+        metadata: z.string().optional(),
+        data: z.string().optional(),
+        epilog: z.string().optional(),
+        parameters: z.array(parameterSchema).optional(),
+        variables: z.array(variableSchema).optional(),
+        dataSource: dataSourceSchema.optional(),
+        hasSecurityAccess: z
+            .boolean()
+            .optional()
+            .describe("When set, applies the process's HasSecurityAccess flag via a dedicated PATCH after the other steps."),
+        mode: z.enum(["create", "update", "upsert"]).optional().default("upsert"),
+        ...OVERWRITE_CONFIRM_SCHEMA,
+        preflight: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Before writing, run the syntax check AND the reference check on the process as it will be after this call (omitted tabs, parameters and variables keep their installed values). Abort on either. Default true. false skips both."),
+        autoCompile: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("After deploy, run tm1.Compile and include the result in the response (compile: {ok, errorCount, errors}). Off by default — compile holds a brief lock on the process and serializes badly under bulk-deploy."),
+    },
+    handler: async ({ processName, prolog, metadata, data, epilog, parameters, variables, dataSource, hasSecurityAccess, mode, preflight, autoCompile, confirm, }, tm1Client) => {
+        const trail = [];
+        const exists = await tm1Client.processes.exists(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");
+        if (preflight) {
+            // Check the process as it will stand after this call, not the fields
+            // the caller happened to send: an omitted tab keeps its installed code.
+            const current = exists
+                ? await tm1Client.processes.getCode(processName)
+                : { prolog: "", metadata: "", data: "", epilog: "" };
+            const failure = await runPreflight(tm1Client, {
+                name: processName,
+                prolog: prolog ?? current.prolog,
+                metadata: metadata ?? current.metadata,
+                data: data ?? current.data,
+                epilog: epilog ?? current.epilog,
+                parameters: parameters ??
+                    (exists ? await tm1Client.processes.getParameters(processName) : []),
+                variables: variables !== undefined && variables.length > 0
+                    ? variables
+                    : exists
+                        ? await tm1Client.processes.getVariables(processName)
+                        : [],
+                ...(dataSource !== undefined ? { dataSource } : {}),
+            });
+            if (failure)
+                return preflightResult(failure);
+        }
+        // Last step before the first write: a failed backup throws, nothing is written.
+        const backup = exists ? await backupProcess(tm1Client, processName) : null;
+        if (!exists) {
+            await tm1Client.processes.create(processName);
+            trail.push("createProcess");
+        }
+        if (prolog !== undefined ||
+            metadata !== undefined ||
+            data !== undefined ||
+            epilog !== undefined) {
+            await tm1Client.processes.updateCode(processName, {
+                ...(prolog !== undefined ? { prolog } : {}),
+                ...(metadata !== undefined ? { metadata } : {}),
+                ...(data !== undefined ? { data } : {}),
+                ...(epilog !== undefined ? { epilog } : {}),
+            });
+            trail.push("updateProcessCode");
+        }
+        if (parameters !== undefined) {
+            await tm1Client.processes.updateParameters(processName, parameters);
+            trail.push("updateProcessParameters");
+        }
+        if (variables !== undefined && variables.length > 0) {
+            await tm1Client.processes.updateVariables(processName, variables);
+            trail.push("updateProcessVariables");
+        }
+        if (dataSource !== undefined) {
+            await tm1Client.processes.updateDataSource(processName, dataSource);
+            trail.push("updateProcessDataSource");
+        }
+        if (hasSecurityAccess !== undefined) {
+            await tm1Client.processes.updateSecurityAccess(processName, hasSecurityAccess);
+            trail.push("updateSecurityAccess");
+        }
+        // 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();
+        let compile;
+        if (autoCompile) {
+            const result = await tm1Client.processes.compile(processName);
+            compile = {
+                ok: result.success,
+                errorCount: result.errors.length,
+                errors: result.errors,
+            };
+            trail.push("compileProcess");
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        processName,
+                        action: exists ? "updated" : "created",
+                        appliedSteps: trail,
+                        callgraphEntriesCleared,
+                        ...(backup ? { backup } : {}),
+                        ...(compile !== undefined ? { compile } : {}),
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=upsert-process.js.map

package/dist/tools/ti-development/validate-process-refs.d.ts

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

package/dist/tools/ti-development/validate-process-refs.js

@@ -0,0 +1,73 @@
+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 { checkProcessRefs } from "../../lib/process-refs.js";
+import { READ_ONLY } from "../annotations.js";
+import { ValidateProcessRefsResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerValidateProcessRefs = defineTool({
+    name: "tm1_validate_process_refs",
+    description: [
+        "Scan a TI process (live, by name, or from .pro) for cube/dimension references in well-known TI functions (CellGetN/S, CellPutN/S, ViewCreate, DimensionElementInsertDirect, AttrPutS, etc.) and verify each name resolves on the server. TM1 lets syntactically valid code reference non-existent objects — this catches the gap between compile and runtime.",
+        "Element literals in cell functions (CellGetN/S, CellPutN/S, CellIncrementN, …) are looked up in the dimension at their position, with TM1's own resolution (case/space-insensitive, aliases, 'Hierarchy:Element'); a missing one is an issue of kind 'element'. TI does not abort on a missing element — the write is just skipped — so this is the only place it shows before a run. Elements passed as variables are not checked.",
+        "Existence probes (DimensionExists, CubeExists, DimIx, …) and names the code itself creates (CubeCreate/DimensionCreate/DimensionElementInsert…) are not flagged.",
+        "partial=true means some names are passed as parameters or computed values and could not be checked (see unresolvableArgs). The install tools run this same check in their preflight.",
+    ],
+    annotations: READ_ONLY,
+    output: ValidateProcessRefsResultSchema,
+    input: {
+        processName: z
+            .string()
+            .optional()
+            .describe("Validate an installed process by name"),
+        filePath: z
+            .string()
+            .optional()
+            .describe("Validate a .pro file (absolute host path). Disabled unless TM1_LOCAL_FILE_ROOT is set; the path must resolve within that directory. Otherwise pass 'content' inline."),
+        content: z.string().optional().describe("Validate raw .pro content"),
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include control objects ('}'-prefixed) as valid targets. Default true."),
+    },
+    handler: async ({ processName, filePath, content, includeControl }, tm1Client) => {
+        if (!processName && !filePath && !content) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "Provide processName, filePath, or content",
+            });
+        }
+        let code;
+        let resolvedName = processName ?? "";
+        if (processName) {
+            code = await tm1Client.processes.getCode(processName);
+        }
+        else {
+            let body = content ?? "";
+            if (!body && filePath) {
+                body = await fs.readFile(resolveLocalPath(filePath), "utf8");
+            }
+            const parsed = parseProFile(body);
+            code = {
+                prolog: parsed.prolog,
+                metadata: parsed.metadata,
+                data: parsed.data,
+                epilog: parsed.epilog,
+            };
+            resolvedName = parsed.name ?? "(from-file)";
+        }
+        const report = await checkProcessRefs(tm1Client, code, { includeControl });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ processName: resolvedName, ...report }, null, 2),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=validate-process-refs.js.map

package/dist/tools/views/create-mdx-view.d.ts

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

package/dist/tools/views/create-mdx-view.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { WRITE } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerCreateMdxView = defineTool({
+    name: "tm1_create_mdx_view",
+    description: "Create a public MDX-based view on a cube. The view persists server-side and can be used as a TI process datasource (TM1CubeView) or executed via tm1_get_view.",
+    annotations: WRITE,
+    output: MutationResultSchema,
+    input: {
+        cubeName: z.string().describe("Cube the view belongs to"),
+        viewName: z.string().describe("New view name"),
+        mdx: z.string().describe("MDX SELECT query defining the view"),
+    },
+    handler: async ({ cubeName, viewName, mdx }, tm1Client) => {
+        await tm1Client.views.createMdx(cubeName, viewName, mdx);
+        return actionResponse({ success: true, cubeName, viewName });
+    },
+});
+//# sourceMappingURL=create-mdx-view.js.map

package/dist/tools/views/create-native-view.d.ts

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