@ffschrattenecker/tm1-mcp-server 6.0.0

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

@@ -0,0 +1,198 @@
+import { promises as fs } from "node:fs";
+import { z } from "zod";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { resolveLocalPath } from "../local-file.js";
+import { parseProcessFromGit, unplacedBlobContent, } from "../../lib/git-process.js";
+import { withToolHint } from "../error-format.js";
+import { IDEMPOTENT_DESTRUCTIVE } from "../annotations.js";
+import { ImportProcessFromGitResultSchema } 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 registerImportProcessFromGit = defineTool({
+    name: "tm1_import_process_from_git",
+    description: [
+        "Deploy a TM1 process from the tm1-git two-file layout ('{name}.json' + '{name}.ti'). Provide the pair inline (jsonContent + tiContent) or as host paths (jsonPath + tiPath).",
+        "Reverse of tm1_export_process_to_git. Modes: 'create' (fail if exists), 'update' (fail if missing), 'upsert' (default).",
+        "If the source datasource is ODBC, pass dataSourcePassword to re-inject the credential that export strips.",
+    ],
+    annotations: IDEMPOTENT_DESTRUCTIVE,
+    output: ImportProcessFromGitResultSchema,
+    input: {
+        jsonContent: z
+            .string()
+            .optional()
+            .describe("Raw '{name}.json' body as string (structure)."),
+        tiContent: z
+            .string()
+            .optional()
+            .describe("Raw '{name}.ti' body as string (procedure tabs)."),
+        jsonPath: z
+            .string()
+            .optional()
+            .describe("Absolute host path to the .json file. Disabled unless TM1_LOCAL_FILE_ROOT is set; must resolve within that directory."),
+        tiPath: z
+            .string()
+            .optional()
+            .describe("Absolute host path to the .ti file. Disabled unless TM1_LOCAL_FILE_ROOT is set; must resolve within that directory."),
+        processName: z
+            .string()
+            .optional()
+            .describe("Override process name. Default: name from the JSON."),
+        mode: z
+            .enum(["create", "update", "upsert"])
+            .optional()
+            .default("upsert")
+            .describe("Deployment mode (default: upsert)"),
+        dataSourcePassword: z
+            .string()
+            .optional()
+            .describe("ODBC password to re-inject, in clear text; the target server encrypts it. Overrides whatever the .json carries. Export omits the password unless includeDataSourcePassword was set, which is possible on v12 only — so on v11 this is the only way to deploy a working ODBC process. Ignored for non-ODBC datasources."),
+        ...OVERWRITE_CONFIRM_SCHEMA,
+        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."),
+    },
+    handler: async ({ jsonContent, tiContent, jsonPath, tiPath, processName: nameOverride, mode, dataSourcePassword, preflight, confirm, }, tm1Client) => {
+        let json = jsonContent ?? "";
+        let ti = tiContent ?? "";
+        if (!json && jsonPath)
+            json = await fs.readFile(resolveLocalPath(jsonPath, "jsonPath"), "utf8");
+        if (!ti && tiPath)
+            ti = await fs.readFile(resolveLocalPath(tiPath, "tiPath"), "utf8");
+        if (!json || !ti) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "Provide both the JSON and TI parts (jsonContent+tiContent or jsonPath+tiPath)",
+            });
+        }
+        let parsed;
+        try {
+            parsed = parseProcessFromGit(json, ti);
+        }
+        catch (err) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: err.message,
+            });
+        }
+        const processName = nameOverride ?? parsed.name;
+        if (!processName) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "Process name not found in JSON ('name') and no name override provided",
+            });
+        }
+        const dataSource = { ...parsed.dataSource };
+        if (dataSource.type === "ODBC" && dataSourcePassword !== undefined) {
+            dataSource.password = dataSourcePassword;
+        }
+        if (preflight) {
+            // The raw .ti blob is what deploys (TM1 splits it into tabs), so the
+            // parsed tabs are only an exact stand-in for it when every byte of the
+            // blob sits inside exactly one tab region. Anything else would be
+            // installed without having been checked.
+            const unplaced = unplacedBlobContent(ti);
+            if (unplaced.length > 0) {
+                return preflightResult({
+                    stage: "preflight",
+                    check: "syntax",
+                    processName,
+                    code: TM1ErrorCode.VALIDATION_ERROR,
+                    message: `The .ti blob carries content the preflight cannot place in a tab: ${unplaced.join("; ")}.`,
+                    hint: "Nothing was installed. Keep all code inside one #region Prolog/Metadata/Data/Epilog … #endregion block per tab — re-export with tm1_export_process_to_git if unsure.",
+                });
+            }
+            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,
+            });
+            if (failure)
+                return preflightResult(failure);
+        }
+        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");
+        // 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 (race) or contain invalid characters. tm1_list_processes to verify state before retry.`);
+        }
+        // Write code via TM1's native Code property: send the raw #region blob
+        // (normalized to CRLF, as TM1 emits/expects) and let the server split it
+        // into the four tabs. This is a full replace — tabs whose region is
+        // absent are cleared, matching the exported .ti exactly.
+        // The parsed tabs were preflighted above; unplacedBlobContent() made
+        // sure they cover this blob exactly, so what was checked is what deploys.
+        await withToolHint(tm1Client.processes.updateCodeBlob(processName, ti.replace(/\r?\n/g, "\r\n")), `Code update failed after process '${processName}' was ${exists ? "located" : "created"}. PARTIAL APPLY: shell exists but tabs are stale/empty. Re-run with mode=update once root cause fixed, or tm1_delete_process to roll back.`);
+        // On an update the file replaces the whole definition, as the code tabs
+        // already do: an empty parameter list, variable layout or a None
+        // datasource is applied, not skipped. Skipping left the newer values in
+        // place, so importing an older version (a backup) did not restore it.
+        if (exists || parsed.parameters.length > 0) {
+            await withToolHint(tm1Client.processes.updateParameters(processName, parsed.parameters), `Parameter update failed for '${processName}'. Code applied but parameters missing. tm1_upsert_process with mode=update + parameters=[...] to recover.`);
+        }
+        // Ignored columns live only in the UI data, so a .json can carry column
+        // layout with an empty variable list — patch on either.
+        if (exists ||
+            parsed.variables.length > 0 ||
+            (parsed.variablesUIData?.length ?? 0) > 0) {
+            await withToolHint(tm1Client.processes.updateVariables(processName, parsed.variables, parsed.variablesUIData ??
+                (parsed.variables.length === 0 ? [] : undefined)), `Variable update failed for '${processName}'. Code+parameters applied but variables missing. tm1_upsert_process with mode=update + variables=[...] to recover.`);
+        }
+        if (exists || dataSource.type !== "None") {
+            await withToolHint(tm1Client.processes.updateDataSource(processName, dataSource), `Datasource update failed for '${processName}' (type=${dataSource.type}). Code+params+vars applied. For ODBC verify dataSourcePassword/DSN and re-run with mode=update.`);
+        }
+        if (parsed.hasSecurityAccess !== undefined) {
+            await withToolHint(tm1Client.processes.updateSecurityAccess(processName, parsed.hasSecurityAccess), `HasSecurityAccess update failed for '${processName}'. Code+params+vars+datasource applied. Re-run with mode=update once root cause fixed.`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        action,
+                        processName,
+                        ...(backup ? { backup } : {}),
+                        ...(parsed.hasSecurityAccess !== undefined
+                            ? { hasSecurityAccess: parsed.hasSecurityAccess }
+                            : {}),
+                        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: dataSource.type,
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=import-process-from-git.js.map

package/dist/tools/ti-development/install-pro-bundle.d.ts

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

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

@@ -0,0 +1,288 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { compileUserRegex } from "../../lib/safe-regex.js";
+import { parseProFile } from "../../lib/pro-parser.js";
+import { resolveLocalPath } from "../local-file.js";
+import { IDEMPOTENT_DESTRUCTIVE, withVersion } from "../annotations.js";
+import { InstallProBundleResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { runPreflight } from "./preflight.js";
+import { backupProcess } from "./process-backup.js";
+export const registerInstallProBundle = defineTool({
+    name: "tm1_install_pro_bundle",
+    description: "Install all .pro files from a directory in one call. Iterates the directory (non-recursive by default), applies tm1_import_pro_file logic per file, and reports per-file outcome. Stops on first failure unless continueOnError=true. Useful for Bedrock or library deployments.",
+    annotations: withVersion(IDEMPOTENT_DESTRUCTIVE, "v11"),
+    output: InstallProBundleResultSchema,
+    input: {
+        directory: z
+            .string()
+            .describe("Absolute host path to directory containing .pro files. Disabled unless TM1_LOCAL_FILE_ROOT is set; the directory must resolve within that root."),
+        recursive: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Recurse into subdirectories (default false)"),
+        pattern: z
+            .string()
+            .optional()
+            .describe("Regex (JS) on filename. Default: matches *.pro (case-insensitive)."),
+        mode: z
+            .enum(["create", "update", "upsert"])
+            .optional()
+            .default("upsert")
+            .describe("Per-file deployment mode (default upsert)"),
+        preflight: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Per file: the syntax check AND the reference check on the exact payload; a failure marks the file preflight_failed. Default true. false skips both."),
+        continueOnError: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Continue installing remaining files after a failure. Default false (stop on first error)."),
+        confirm: z
+            .string()
+            .optional()
+            .describe("Required when any file would overwrite an installed process: the directory's last path segment, verbatim. dryRun lists the overwrites without needing it. Each replaced process is saved first; its result entry names the backup .json/.ti pair."),
+        dryRun: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Parse + preflight only — no create/update calls. Default false."),
+    },
+    handler: async ({ directory, recursive, pattern, mode, preflight, continueOnError, dryRun, confirm, }, tm1Client, extra) => {
+        // R2-02: emit MCP progress notifications per-file so clients can show
+        // a moving progress bar during multi-file deploys. Only fires when the
+        // client opted in by passing _meta.progressToken in the tool call;
+        // sendNotification is fire-and-forget so a non-progress-aware client
+        // can't break the install loop.
+        const progressToken = extra?._meta?.progressToken;
+        const sendProgress = (progress, total, message) => {
+            if (progressToken === undefined)
+                return;
+            void extra
+                .sendNotification({
+                method: "notifications/progress",
+                params: { progressToken, progress, total, message },
+            })
+                .catch(() => undefined);
+        };
+        const safeDir = resolveLocalPath(directory, "directory");
+        const filenameRe = pattern
+            ? compileUserRegex(pattern, undefined, "pattern")
+            : /\.pro$/i;
+        async function collect(dir) {
+            const out = [];
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const e of entries) {
+                const full = path.join(dir, e.name);
+                if (e.isDirectory()) {
+                    if (recursive)
+                        out.push(...(await collect(full)));
+                }
+                else if (e.isFile() && filenameRe.test(e.name)) {
+                    out.push(full);
+                }
+            }
+            return out;
+        }
+        const files = (await collect(safeDir)).sort();
+        if (files.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ directory, filesFound: 0, results: [] }),
+                    },
+                ],
+            };
+        }
+        const installed = await tm1Client.processes.list();
+        const installedNames = new Set(installed.map((p) => p.name));
+        // Which files would replace an installed process. Worked out before the
+        // first write so a missing confirm stops the bundle with nothing
+        // installed, and a dryRun can show the list to the user.
+        const overwrites = [];
+        if (mode !== "create") {
+            for (const file of files) {
+                try {
+                    const name = parseProFile(await fs.readFile(file, "utf8")).name;
+                    if (name && installedNames.has(name))
+                        overwrites.push(name);
+                }
+                catch {
+                    /* unreadable or unparseable — reported per file below */
+                }
+            }
+        }
+        const bundle = path.basename(safeDir);
+        if (!dryRun && overwrites.length > 0 && confirm !== bundle) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `${overwrites.length} file(s) would overwrite installed processes (${overwrites.slice(0, 20).join(", ")}${overwrites.length > 20 ? ", …" : ""}). Nothing was installed.`,
+                hint: `Show the user the overwrite list (dryRun=true returns it), then re-issue with confirm="${bundle}". mode="create" installs only processes that do not exist yet.`,
+                details: JSON.stringify({ overwrites }),
+            });
+        }
+        const results = [];
+        let stopped = false;
+        sendProgress(0, files.length, `starting install of ${files.length} files`);
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            sendProgress(i, files.length, `processing ${path.basename(file)}`);
+            if (stopped) {
+                results.push({
+                    file,
+                    processName: null,
+                    status: "skipped",
+                    error: "stopped after earlier failure",
+                });
+                continue;
+            }
+            try {
+                const body = await fs.readFile(file, "utf8");
+                const parsed = parseProFile(body);
+                const processName = parsed.name;
+                if (!processName) {
+                    results.push({
+                        file,
+                        processName: null,
+                        status: "error",
+                        error: "Process name not found in .pro",
+                    });
+                    if (!continueOnError)
+                        stopped = true;
+                    continue;
+                }
+                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) {
+                        results.push({
+                            file,
+                            processName,
+                            status: "preflight_failed",
+                            error: failure.message,
+                            ...(failure.errors ? { preflightErrors: failure.errors } : {}),
+                            ...(failure.issues ? { preflightIssues: failure.issues } : {}),
+                        });
+                        if (!continueOnError)
+                            stopped = true;
+                        continue;
+                    }
+                }
+                const exists = installedNames.has(processName);
+                if (mode === "create" && exists) {
+                    results.push({
+                        file,
+                        processName,
+                        status: "error",
+                        error: `Already exists; mode=create`,
+                    });
+                    if (!continueOnError)
+                        stopped = true;
+                    continue;
+                }
+                if (mode === "update" && !exists) {
+                    results.push({
+                        file,
+                        processName,
+                        status: "error",
+                        error: `Does not exist; mode=update`,
+                    });
+                    if (!continueOnError)
+                        stopped = true;
+                    continue;
+                }
+                if (dryRun) {
+                    results.push({
+                        file,
+                        processName,
+                        status: exists ? "updated" : "created",
+                    });
+                    continue;
+                }
+                // A failed backup throws into the catch below: this file is not
+                // installed, and without continueOnError the run stops.
+                const backup = exists
+                    ? await backupProcess(tm1Client, processName)
+                    : null;
+                if (!exists)
+                    await tm1Client.processes.create(processName);
+                await tm1Client.processes.updateCode(processName, {
+                    prolog: parsed.prolog,
+                    metadata: parsed.metadata,
+                    data: parsed.data,
+                    epilog: parsed.epilog,
+                });
+                // On an update the file replaces the whole definition (see
+                // import-pro-file.ts): empty lists and a None datasource are applied.
+                if (exists || parsed.parameters.length > 0) {
+                    await tm1Client.processes.updateParameters(processName, parsed.parameters);
+                }
+                if (exists ||
+                    parsed.variables.length > 0 ||
+                    parsed.variablesUIData.length > 0) {
+                    await tm1Client.processes.updateVariables(processName, parsed.variables, parsed.variablesUIData.length > 0 || parsed.variables.length === 0
+                        ? parsed.variablesUIData
+                        : undefined);
+                }
+                if (exists || parsed.dataSource.type !== "None") {
+                    await tm1Client.processes.updateDataSource(processName, parsed.dataSource);
+                }
+                installedNames.add(processName);
+                results.push({
+                    file,
+                    processName,
+                    status: exists ? "updated" : "created",
+                    ...(backup ? { backup } : {}),
+                });
+            }
+            catch (err) {
+                const msg = err instanceof TM1Error
+                    ? `${err.code}: ${err.message}`
+                    : (err.message ?? String(err));
+                results.push({
+                    file,
+                    processName: null,
+                    status: "error",
+                    error: msg,
+                });
+                if (!continueOnError)
+                    stopped = true;
+            }
+        }
+        sendProgress(files.length, files.length, "install complete");
+        const summary = {
+            directory,
+            filesFound: files.length,
+            dryRun,
+            mode,
+            overwrites,
+            counts: {
+                created: results.filter((r) => r.status === "created").length,
+                updated: results.filter((r) => r.status === "updated").length,
+                preflight_failed: results.filter((r) => r.status === "preflight_failed")
+                    .length,
+                error: results.filter((r) => r.status === "error").length,
+                skipped: results.filter((r) => r.status === "skipped").length,
+            },
+            results,
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(summary) }],
+        };
+    },
+});
+//# sourceMappingURL=install-pro-bundle.js.map

package/dist/tools/ti-development/preflight.d.ts

@@ -0,0 +1,39 @@
+import type { TM1Client } from "../../tm1-client.js";
+import type { DataSource, ProcessParameter, ProcessVariable } from "../../types.js";
+import { TM1ErrorCode } from "../../types.js";
+import { type RefIssue } from "../../lib/process-refs.js";
+export interface PreflightPayload {
+    name: string;
+    prolog: string;
+    metadata: string;
+    data: string;
+    epilog: string;
+    parameters?: ProcessParameter[];
+    variables?: ProcessVariable[];
+    dataSource?: DataSource;
+}
+export interface PreflightFailure {
+    stage: "preflight";
+    check: "syntax" | "references";
+    processName: string;
+    code: typeof TM1ErrorCode.VALIDATION_ERROR;
+    message: string;
+    hint: string;
+    errors?: Array<{
+        procedure?: string | undefined;
+        lineNumber?: number | undefined;
+        message: string;
+    }>;
+    issues?: RefIssue[];
+}
+/** Undefined when the payload passes both checks. */
+export declare function runPreflight(tm1Client: TM1Client, p: PreflightPayload): Promise<PreflightFailure | undefined>;
+/** The isError tool result for a failed preflight. */
+export declare function preflightResult(failure: PreflightFailure): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: true;
+};
+//# sourceMappingURL=preflight.d.ts.map

package/dist/tools/ti-development/preflight.js

@@ -0,0 +1,56 @@
+import { TM1ErrorCode } from "../../types.js";
+import { checkProcessRefs } from "../../lib/process-refs.js";
+const SKIP_NOTE = "Nothing was installed. preflight:false skips BOTH the syntax and the reference check — use it only for a name the code creates at runtime in a way the check cannot see.";
+/** Undefined when the payload passes both checks. */
+export async function runPreflight(tm1Client, p) {
+    const check = await tm1Client.processes.check({
+        name: p.name,
+        prolog: p.prolog,
+        metadata: p.metadata,
+        data: p.data,
+        epilog: p.epilog,
+        ...(p.parameters !== undefined ? { parameters: p.parameters } : {}),
+        ...(p.variables !== undefined ? { variables: p.variables } : {}),
+        ...(p.dataSource !== undefined ? { dataSource: p.dataSource } : {}),
+    });
+    if (!check.success) {
+        return {
+            stage: "preflight",
+            check: "syntax",
+            processName: p.name,
+            code: TM1ErrorCode.VALIDATION_ERROR,
+            message: `Preflight syntax check failed: ${check.errors.length} error(s).`,
+            hint: `Fix the lines in errors[] (procedure + lineNumber). ${SKIP_NOTE}`,
+            errors: check.errors,
+        };
+    }
+    const refs = await checkProcessRefs(tm1Client, p);
+    if (refs.unresolved > 0) {
+        const names = [
+            ...new Set(refs.issues.map((i) => i.kind === "element"
+                ? `element '${i.name}' in dimension '${i.dimension}'`
+                : `${i.kind} '${i.name}'`)),
+        ];
+        return {
+            stage: "preflight",
+            check: "references",
+            processName: p.name,
+            code: TM1ErrorCode.VALIDATION_ERROR,
+            message: `Preflight reference check failed: ${names.join(", ")} not found on the server.`,
+            // Deliberately not "correct the name": a near match (SalesPlan for
+            // 'Sales Plan') is a different object, and swapping it in unasked is
+            // the silent substitution this check exists to stop.
+            hint: `Report each unresolved name to the user before changing anything — a similarly named object is a different object, not a fix. Create the object first if the code needs it. ${SKIP_NOTE}`,
+            issues: refs.issues,
+        };
+    }
+    return undefined;
+}
+/** The isError tool result for a failed preflight. */
+export function preflightResult(failure) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(failure) }],
+        isError: true,
+    };
+}
+//# sourceMappingURL=preflight.js.map

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

@@ -0,0 +1,29 @@
+import type { TM1Client } from "../../tm1-client.js";
+export interface ProcessBackup {
+    json: string;
+    ti: string;
+}
+export interface GitPair {
+    json: string;
+    ti: string;
+    credentialsOmitted: boolean;
+    parameterCount: number;
+    variableCount: number;
+    dataSourceType: string;
+    hasSecurityAccess: boolean;
+}
+/** Read an installed process as the tm1-git pair. Code is returned as stored. */
+export declare function readProcessAsGit(tm1Client: TM1Client, processName: string, opts?: {
+    includePassword?: boolean;
+}): Promise<GitPair>;
+/** The backup root, or null when backups are switched off. */
+export declare function backupRoot(): string | null;
+export declare function safeFileName(name: string): string;
+/**
+ * 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 declare function backupProcess(tm1Client: TM1Client, processName: string, now?: Date): Promise<ProcessBackup | null>;
+//# sourceMappingURL=process-backup.d.ts.map