@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/operations/get-jobs.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { actionResponse, FORMAT_SCHEMA, pageResponse, columnsOf, } from "../format.js";
+import { DESTRUCTIVE, READ_ONLY } from "../annotations.js";
+import { JobSchema, MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { pageShapeFor } from "../schemas/common.js";
+// v12-only: Jobs replace v11 Threads as the "what is running" surface. On a v11
+// connection these tools are not registered (thread tools are instead).
+const registerListJobs = defineTool({
+    name: "tm1_list_jobs",
+    description: "List active jobs (Activity) on a TM1 v12 database — the running tasks that replaced v11 threads. Paginated (default 50/page). (v12 only)",
+    annotations: READ_ONLY,
+    enabled: (tm1Client) => tm1Client.version === 12,
+    output: pageShapeFor(JobSchema),
+    input: { ...PAGINATION_SCHEMA, ...FORMAT_SCHEMA },
+    handler: async ({ limit, offset, fetchAll, format }, tm1Client) => {
+        const jobs = await tm1Client.monitoring.getJobs();
+        const page = paginate(jobs, limit, offset, fetchAll);
+        const columns = columnsOf([
+            "id",
+            "description",
+            "state",
+            "elapsedTime",
+        ]);
+        return pageResponse(page, format, { title: "Jobs", columns });
+    },
+});
+const registerCancelJob = defineTool({
+    name: "tm1_cancel_job",
+    description: [
+        "Cancel a running TM1 v12 job by its ID. Use tm1_list_jobs to find the ID.",
+        "Non-idempotent: cancelling a finished job errors. Before: tm1_list_jobs to confirm the job is still running.",
+        "(v12 only)",
+    ],
+    annotations: DESTRUCTIVE,
+    enabled: (tm1Client) => tm1Client.version === 12,
+    output: MutationResultSchema,
+    input: {
+        jobId: z.string().describe("Job ID to cancel"),
+    },
+    handler: async ({ jobId }, tm1Client) => {
+        await tm1Client.monitoring.cancelJob(jobId);
+        return actionResponse({ success: true, jobId });
+    },
+});
+export const registerGetJobs = (server, tm1Client) => {
+    registerListJobs(server, tm1Client);
+    registerCancelJob(server, tm1Client);
+};
+//# sourceMappingURL=get-jobs.js.map

package/dist/tools/operations/get-message-log.d.ts

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

package/dist/tools/operations/get-message-log.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { FORMAT_SCHEMA, payloadResponse, renderTable, columnsOf, } from "../format.js";
+import { MessageLogEntrySchema } from "../schemas/items.js";
+import { READ_ONLY, withVersion } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerGetMessageLog = defineTool({
+    name: "tm1_get_message_log",
+    description: "Fetch recent TM1 server message log entries, newest first. Useful for debugging TI process errors. The `filter`/`level`/`since` filters are applied SERVER-SIDE, so a matching entry is found even when it is older than the newest `top` rows (no false 'no error found'). When an entry references a TI error file, the parsed filename is surfaced as `errorFile` — pass it straight to tm1_get_error_log_content to read the failure detail. (v11 only)",
+    annotations: withVersion(READ_ONLY, "v11"),
+    // v12 deprecated MessageLogEntry/MessageLogEntries (and the MessageLog /
+    // TailMessageLog functions) in 12.0.0; all of them serve empty with no
+    // successor endpoint.
+    enabled: (tm1Client) => tm1Client.version === 11,
+    output: {
+        count: z.number().int(),
+        entries: z.array(MessageLogEntrySchema),
+    },
+    input: {
+        top: z
+            .number()
+            .int()
+            .min(1)
+            .max(500)
+            .optional()
+            .default(100)
+            .describe("Number of entries to fetch (default: 100, max: 500). Applied AFTER the filters, so a filter still finds older matches beyond the newest 500 rows."),
+        filter: z
+            .string()
+            .optional()
+            .describe("Optional text filter — only entries whose message contains this string are returned (case-insensitive). Pushed to the server, so matches older than `top` are found."),
+        level: z
+            .string()
+            .optional()
+            .describe("Optional exact level filter, e.g. 'ERROR', 'WARN', 'INFO'."),
+        since: z
+            .string()
+            .optional()
+            .describe("Only entries on or after this timestamp (UTC). Date '2026-06-01' or datetime '2026-06-01T00:00:00' (a 'Z' is added if missing)."),
+        until: z
+            .string()
+            .optional()
+            .describe("Only entries on or before this timestamp (UTC). Same format as since."),
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ top, filter, level, since, until, format }, tm1Client) => {
+        const filtered = await tm1Client.server.getMessageLog({
+            top,
+            filter,
+            level,
+            since,
+            until,
+        });
+        const payload = { count: filtered.length, entries: filtered };
+        const columns = columnsOf([
+            "timestamp",
+            "level",
+            "message",
+            "errorFile",
+        ]);
+        return payloadResponse(payload, format, (p) => `## Message log\n\n${p.count} entries\n\n${renderTable(p.entries, columns)}`);
+    },
+});
+//# sourceMappingURL=get-message-log.js.map

package/dist/tools/operations/get-server-info.d.ts

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

package/dist/tools/operations/get-server-info.js

@@ -0,0 +1,180 @@
+import { FORMAT_SCHEMA, payloadResponse, renderKV } from "../format.js";
+import { maskSecretsDeep } from "../../lib/mask-secrets.js";
+import { READ_ONLY } from "../annotations.js";
+import { ServerInfoSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { NAME, VERSION } from "../../version.js";
+// Pull a nested key path from the raw merged configuration. Returns undefined if any
+// segment is missing — TM1 versions vary in which sections they expose.
+function pick(extra, path) {
+    let node = extra;
+    for (const seg of path) {
+        if (node === null || node === undefined || typeof node !== "object")
+            return undefined;
+        node = node[seg];
+    }
+    return node;
+}
+export const registerGetServerInfo = defineTool({
+    name: "tm1_get_server_info",
+    description: [
+        "Return TM1 server identity + curated configuration (TI, Rules, MTQ, JobQueuing, Memory, Logging, HTTP, Security) from /Configuration + /ActiveConfiguration.",
+        "Use this instead of probing TI hacks (e.g. HierarchyCreate/Destroy) to detect feature support. Raw merged configuration is preserved under `_raw`.",
+    ],
+    annotations: READ_ONLY,
+    output: ServerInfoSchema,
+    input: { ...FORMAT_SCHEMA },
+    handler: async ({ format }, tm1Client) => {
+        const info = await tm1Client.server.getInfo();
+        const x = info.extra ?? {};
+        const payload = {
+            // The MCP server's own package identity, so a client can gate on it
+            // without parsing the initialize handshake.
+            mcpServer: { name: NAME, version: VERSION },
+            serverName: info.serverName,
+            productVersion: info.productVersion,
+            productEdition: info.productEdition,
+            adminHost: info.adminHost,
+            dataDirectory: info.dataDirectory,
+            timeZoneId: info.timeZoneId,
+            integratedSecurityMode: info.integratedSecurityMode,
+            modelling: {
+                enableNewHierarchyCreation: pick(x, [
+                    "Modelling",
+                    "EnableNewHierarchyCreation",
+                ]),
+                mdxSelectCalculatedMemberInputs: pick(x, [
+                    "Modelling",
+                    "MDXSelectCalculatedMemberInputs",
+                ]),
+                defaultMeasuresDimension: pick(x, [
+                    "Modelling",
+                    "DefaultMeasuresDimension",
+                ]),
+                userDefinedCalculations: pick(x, [
+                    "Modelling",
+                    "UserDefinedCalculations",
+                ]),
+            },
+            ti: {
+                maximumTILockObjects: pick(x, [
+                    "Modelling",
+                    "TI",
+                    "MaximumTILockObjects",
+                ]),
+                enableTIDebugging: pick(x, ["Modelling", "TI", "EnableTIDebugging"]),
+                useExcelSerialDate: pick(x, ["Modelling", "TI", "UseExcelSerialDate"]),
+            },
+            rules: {
+                allowSeparateNandCRules: pick(x, [
+                    "Modelling",
+                    "Rules",
+                    "AllowSeparateNandCRules",
+                ]),
+                automaticallyAddCubeDependencies: pick(x, [
+                    "Modelling",
+                    "Rules",
+                    "AutomaticallyAddCubeDependencies",
+                ]),
+                rulesOverwriteCellsOnLoad: pick(x, [
+                    "Modelling",
+                    "Rules",
+                    "RulesOverwriteCellsOnLoad",
+                ]),
+                forceReevaluationOfFeeders: pick(x, [
+                    "Modelling",
+                    "Rules",
+                    "ForceReevaluationOfFeedersForFedCellsOnDataChange",
+                ]),
+            },
+            mtq: {
+                useAllThreads: pick(x, ["Performance", "MTQ", "UseAllThreads"]),
+                numberOfThreadsToUse: pick(x, [
+                    "Performance",
+                    "MTQ",
+                    "NumberOfThreadsToUse",
+                ]),
+                singleCellConsolidation: pick(x, [
+                    "Performance",
+                    "MTQ",
+                    "SingleCellConsolidation",
+                ]),
+                mtqQuery: pick(x, ["Performance", "MTQ", "MTQQuery"]),
+                mtFeeders: pick(x, ["Performance", "MTQ", "MTFeeders"]),
+                mtFeedersAtStartup: pick(x, [
+                    "Performance",
+                    "MTQ",
+                    "MTFeedersAtStartup",
+                ]),
+            },
+            jobQueuing: {
+                enabled: pick(x, ["Performance", "JobQueuing", "Enable"]),
+                threadPoolSize: pick(x, [
+                    "Performance",
+                    "JobQueuing",
+                    "ThreadPoolSize",
+                ]),
+                maxWaitTime: pick(x, ["Performance", "JobQueuing", "MaxWaitTime"]),
+            },
+            memory: {
+                maximumViewSizeMB: pick(x, [
+                    "Performance",
+                    "Memory",
+                    "MaximumViewSizeMB",
+                ]),
+                maximumUserSandboxSizeMB: pick(x, [
+                    "Performance",
+                    "Memory",
+                    "MaximumUserSandboxSizeMB",
+                ]),
+                disableSandboxing: pick(x, ["Administration", "DisableSandboxing"]) ??
+                    pick(x, ["DisableSandboxing"]),
+            },
+            logging: {
+                loggingDirectory: pick(x, [
+                    "Administration",
+                    "DebugLog",
+                    "LoggingDirectory",
+                ]),
+                auditLogEnabled: pick(x, ["Administration", "AuditLog", "Enable"]),
+                auditLogMaxKB: pick(x, [
+                    "Administration",
+                    "AuditLog",
+                    "MaxFileSizeKilobytes",
+                ]),
+                performanceMonitorOn: pick(x, [
+                    "Administration",
+                    "PerformanceMonitorOn",
+                ]),
+            },
+            http: {
+                port: pick(x, ["Access", "HTTP", "Port"]),
+                sessionTimeout: pick(x, ["Access", "HTTP", "SessionTimeout"]),
+                requestEntityMaxKB: pick(x, [
+                    "Access",
+                    "HTTP",
+                    "RequestEntityMaxSizeInKB",
+                ]),
+            },
+            security: {
+                sslEnabled: pick(x, ["Access", "SSL", "Enable"]),
+                securityPackageName: pick(x, [
+                    "Access",
+                    "Authentication",
+                    "SecurityPackageName",
+                ]),
+                integratedSecurityMode: pick(x, [
+                    "Access",
+                    "Authentication",
+                    "IntegratedSecurityMode",
+                ]),
+                ldapEnabled: pick(x, ["Access", "LDAP", "Enable"]),
+            },
+            // Mask credential-named values (e.g. Access.LDAP.Password) before the
+            // full raw config leaves the server — always on, no opt-out.
+            _raw: maskSecretsDeep(x),
+        };
+        return payloadResponse(payload, format, (p) => renderKV(p, "Server info"));
+    },
+});
+//# sourceMappingURL=get-server-info.js.map

package/dist/tools/operations/get-server-state.d.ts

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

package/dist/tools/operations/get-server-state.js

@@ -0,0 +1,129 @@
+import { FORMAT_SCHEMA, payloadResponse, renderKV } from "../format.js";
+import { READ_ONLY } from "../annotations.js";
+import { ServerStateResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+// Pull a nested key path from the raw merged configuration.
+function pick(extra, path) {
+    let node = extra;
+    for (const seg of path) {
+        if (node === null || node === undefined || typeof node !== "object")
+            return undefined;
+        node = node[seg];
+    }
+    return node;
+}
+/** A rejection reason is `any`; take its message only when there really is one. */
+function reasonText(reason) {
+    if (reason instanceof Error)
+        return reason.message;
+    if (typeof reason === "object" && reason !== null) {
+        const message = reason.message;
+        if (typeof message === "string")
+            return message;
+    }
+    return String(reason);
+}
+function settleCount(res) {
+    if (res.status === "fulfilled")
+        return { count: res.value.length };
+    return {
+        count: null,
+        error: res.reason?.message ?? String(res.reason),
+    };
+}
+export const registerGetServerState = defineTool({
+    name: "tm1_get_server_state",
+    description: [
+        "Health-check style snapshot of the TM1 server in one call.",
+        "Returns: connection state, version, key capability flags (MTQ, JobQueuing, EnableNewHierarchyCreation),",
+        "and object counts for cubes, dimensions, processes, chores, and clients.",
+        "All fetches run in parallel; per-bucket failures are reported as count: null with an error message instead of failing the whole call.",
+    ],
+    annotations: READ_ONLY,
+    output: ServerStateResultSchema,
+    input: { ...FORMAT_SCHEMA },
+    handler: async ({ format }, tm1Client) => {
+        const [infoRes, cubesRes, dimsRes, procsRes, choresRes, clientsRes] = await Promise.allSettled([
+            tm1Client.server.getInfo(),
+            tm1Client.cubes.list(),
+            tm1Client.dimensions.list(),
+            tm1Client.processes.list(),
+            tm1Client.chores.list(),
+            tm1Client.security.listClients(),
+        ]);
+        const info = infoRes.status === "fulfilled" ? infoRes.value : null;
+        const x = info?.extra ?? {};
+        const counts = {
+            cubes: settleCount(cubesRes),
+            dimensions: settleCount(dimsRes),
+            processes: settleCount(procsRes),
+            chores: settleCount(choresRes),
+            clients: settleCount(clientsRes),
+        };
+        // OData silently returns empty arrays for objects the user cannot read.
+        // Detect implausible count combinations that signal security filtering.
+        const securityWarnings = [];
+        const dimCount = counts.dimensions.count;
+        if (dimCount !== null && dimCount > 0) {
+            if (counts.cubes.count === 0) {
+                securityWarnings.push(`0 cubes visible despite ${dimCount} dimensions — TM1 security is likely filtering cubes (user lacks READ rights). ` +
+                    `Use tm1_list_cubes(includeControl: true) to verify, or check group membership with tm1_list_groups.`);
+            }
+            if (counts.processes.count === 0) {
+                securityWarnings.push(`0 processes visible despite ${dimCount} dimensions — TM1 security may be filtering processes.`);
+            }
+        }
+        if (counts.clients.count === null && counts.clients.error) {
+            securityWarnings.push(`Client list failed (${counts.clients.error}) — likely a non-admin session; some object counts may be filtered.`);
+        }
+        const state = {
+            connected: tm1Client.isConnected(),
+            server: info
+                ? {
+                    name: info.serverName,
+                    productVersion: info.productVersion,
+                    dataDirectory: info.dataDirectory,
+                    timeZoneId: info.timeZoneId,
+                }
+                : {
+                    error: reasonText(infoRes.reason),
+                },
+            capabilities: info
+                ? {
+                    enableNewHierarchyCreation: pick(x, [
+                        "Modelling",
+                        "EnableNewHierarchyCreation",
+                    ]),
+                    allowSeparateNandCRules: pick(x, [
+                        "Modelling",
+                        "Rules",
+                        "AllowSeparateNandCRules",
+                    ]),
+                    mtqUseAllThreads: pick(x, ["Performance", "MTQ", "UseAllThreads"]),
+                    mtqNumberOfThreads: pick(x, [
+                        "Performance",
+                        "MTQ",
+                        "NumberOfThreadsToUse",
+                    ]),
+                    jobQueuingEnabled: pick(x, ["Performance", "JobQueuing", "Enable"]),
+                    jobQueuingThreadPoolSize: pick(x, [
+                        "Performance",
+                        "JobQueuing",
+                        "ThreadPoolSize",
+                    ]),
+                    disableSandboxing: pick(x, ["Administration", "DisableSandboxing"]) ??
+                        pick(x, ["DisableSandboxing"]),
+                    loggingDirectory: pick(x, [
+                        "Administration",
+                        "DebugLog",
+                        "LoggingDirectory",
+                    ]),
+                }
+                : null,
+            counts,
+            ...(securityWarnings.length > 0 && { securityWarnings }),
+        };
+        return payloadResponse(state, format, (s) => renderKV(s, "Server state"));
+    },
+});
+//# sourceMappingURL=get-server-state.js.map

package/dist/tools/operations/get-sessions.d.ts

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

package/dist/tools/operations/get-sessions.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { FORMAT_SCHEMA, pageResponse, payloadResponse, columnsOf, } from "../format.js";
+import { READ_ONLY } from "../annotations.js";
+import { SessionSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { pageShapeFor } from "../schemas/common.js";
+export const registerGetSessions = defineTool({
+    name: "tm1_list_sessions",
+    description: [
+        "List active sessions on the TM1 server with their associated user and threads.",
+        "Pair monitoring tools — tm1_list_threads/tm1_cancel_thread on v11, tm1_list_jobs/tm1_cancel_job on v12 — to see who is connected and what they are running.",
+        "Paginated (default 50/page).",
+    ],
+    annotations: READ_ONLY,
+    output: {
+        ...pageShapeFor(SessionSchema),
+        summary: z
+            .object({
+            namedUsers: z.number().int(),
+            anonymousCount: z.number().int(),
+        })
+            .optional()
+            .describe("Present only when compact=true: aggregate headcount, items[] is empty in that mode"),
+    },
+    input: {
+        activeOnly: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("If true, return only sessions flagged Active by the server (default: false — return all)"),
+        withThreads: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include thread details per session (default: true)"),
+        compact: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Return summary only: { total, namedUsers, anonymousCount }. Skips pagination and per-session detail. Useful for a quick headcount without flooding context."),
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ activeOnly, withThreads, compact, limit, offset, fetchAll, format }, tm1Client) => {
+        const sessions = await tm1Client.monitoring.getSessions();
+        const filtered = activeOnly
+            ? sessions.filter((s) => s.active !== false)
+            : sessions;
+        if (compact) {
+            const namedUsers = filtered.filter((s) => s.user && s.user.trim() !== "").length;
+            const summary = {
+                total: filtered.length,
+                count: 0,
+                offset: 0,
+                has_more: false,
+                next_offset: null,
+                items: [],
+                summary: { namedUsers, anonymousCount: filtered.length - namedUsers },
+            };
+            return payloadResponse(summary, format, (p) => `## Sessions (compact)\n\n${p.total} total · ${p.summary.namedUsers} named users · ${p.summary.anonymousCount} anonymous`);
+        }
+        const projected = withThreads
+            ? filtered
+            : filtered.map((s) => ({ ...s, threads: [] }));
+        const page = paginate(projected, limit, offset, fetchAll);
+        const columns = columnsOf([
+            "id",
+            "user",
+            "active",
+            { header: "threads", get: (s) => s.threads?.length ?? 0 },
+        ]);
+        return pageResponse(page, format, { title: "Sessions", columns });
+    },
+});
+//# sourceMappingURL=get-sessions.js.map

package/dist/tools/operations/get-threads.d.ts

@@ -0,0 +1,3 @@
+import { type ToolRegistrar } from "../define-tool.js";
+export declare const registerGetThreads: ToolRegistrar;
+//# sourceMappingURL=get-threads.d.ts.map

package/dist/tools/operations/get-threads.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { actionResponse, FORMAT_SCHEMA, pageResponse, columnsOf, } from "../format.js";
+import { DESTRUCTIVE, READ_ONLY } from "../annotations.js";
+import { MutationResultSchema, ThreadSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { pageShapeFor } from "../schemas/common.js";
+const registerListThreads = defineTool({
+    name: "tm1_list_threads",
+    description: "List active threads on the TM1 server (running processes, chores, MDX queries, etc.). Paginated (default 50/page). (v11 only)",
+    annotations: READ_ONLY,
+    enabled: (tm1Client) => tm1Client.version === 11,
+    output: pageShapeFor(ThreadSchema),
+    input: { ...PAGINATION_SCHEMA, ...FORMAT_SCHEMA },
+    handler: async ({ limit, offset, fetchAll, format }, tm1Client) => {
+        const threads = await tm1Client.monitoring.getThreads();
+        const page = paginate(threads, limit, offset, fetchAll);
+        const columns = columnsOf([
+            "id",
+            "name",
+            "state",
+            "function",
+            "objectName",
+        ]);
+        return pageResponse(page, format, { title: "Threads", columns });
+    },
+});
+const registerCancelThread = defineTool({
+    name: "tm1_cancel_thread",
+    description: [
+        "Cancel a running TM1 server thread by its ID. Use tm1_list_threads to find the ID.",
+        "Non-idempotent: cancelling a finished thread errors. Before: tm1_list_threads to confirm the thread is still running.",
+        "(v11 only)",
+    ],
+    annotations: DESTRUCTIVE,
+    enabled: (tm1Client) => tm1Client.version === 11,
+    output: MutationResultSchema,
+    input: {
+        id: z.number().int().describe("Thread ID to cancel"),
+    },
+    handler: async ({ id }, tm1Client) => {
+        await tm1Client.monitoring.cancelThread(id);
+        return actionResponse({ success: true, threadId: id });
+    },
+});
+export const registerGetThreads = (server, tm1Client) => {
+    registerListThreads(server, tm1Client);
+    registerCancelThread(server, tm1Client);
+};
+//# sourceMappingURL=get-threads.js.map

package/dist/tools/operations/get-transaction-log.d.ts

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

package/dist/tools/operations/get-transaction-log.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { FORMAT_SCHEMA, payloadResponse, renderTable, columnsOf, } from "../format.js";
+import { READ_ONLY, withVersion } from "../annotations.js";
+import { TransactionLogEntrySchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerGetTransactionLog = defineTool({
+    name: "tm1_get_transaction_log",
+    description: "Fetch recent TM1 transaction log entries (cell writes), newest first. Optional filters: cube, user, and a since/until time range. NOTE: the endpoint scans the log server-side and a full scan can take minutes-to-hours. A cheap preflight probe fails fast on unreachable/no-rights; without `since` the server walks expanding time windows backward (10min→1y) and stops once `top` rows are found, so it never triggers a full scan. Pass since/until (from-to) to bound it explicitly. (v11 only)",
+    annotations: withVersion(READ_ONLY, "v11"),
+    // v12 deprecated TransactionLogEntry/TransactionLogEntries (and the
+    // TransactionLog / TailTransactionLog functions) in 12.0.0; all of them serve
+    // empty with no successor endpoint.
+    enabled: (tm1Client) => tm1Client.version === 11,
+    output: {
+        count: z.number().int(),
+        coverage: z
+            .enum(["complete", "partial"])
+            .describe("partial=hit top, more may exist earlier"),
+        scannedFrom: z.string().describe("earliest timestamp scanned"),
+        entries: z.array(TransactionLogEntrySchema),
+    },
+    input: {
+        top: z
+            .number()
+            .int()
+            .min(1)
+            .max(1000)
+            .optional()
+            .default(100)
+            .describe("Max entries to return (default: 100, max: 1000)"),
+        cubeName: z.string().optional().describe("Filter to one cube"),
+        user: z.string().optional().describe("Filter to one user"),
+        since: z
+            .string()
+            .optional()
+            .describe("Lower bound — only entries on or after this timestamp (UTC). Date '2026-04-17' or datetime '2026-04-17T00:00:00' (a 'Z' is added if missing). When omitted, expanding backward windows are used instead of a full scan."),
+        until: z
+            .string()
+            .optional()
+            .describe("Upper bound — only entries on or before this timestamp (UTC). Same format as since. Combine with since for an explicit from-to range; with neither, the window anchor is now."),
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ top, cubeName, user, since, until, format }, tm1Client) => {
+        const { entries, coverage, scannedFrom } = await tm1Client.server.getTransactionLog({
+            top,
+            cubeName,
+            user,
+            since,
+            until,
+        });
+        const payload = { count: entries.length, coverage, scannedFrom, entries };
+        const columns = columnsOf([
+            "timestamp",
+            "user",
+            { header: "cube", get: (e) => e.cubeName },
+            "elements",
+            { header: "old", get: (e) => e.oldValue },
+            { header: "new", get: (e) => e.newValue },
+        ]);
+        return payloadResponse(payload, format, (p) => `## Transaction log\n\n${p.count} entries (coverage: ${p.coverage}, scanned back to ${p.scannedFrom})\n\n${renderTable(p.entries, columns)}`);
+    },
+});
+//# sourceMappingURL=get-transaction-log.js.map

package/dist/tools/operations/list-error-logs.d.ts

@@ -0,0 +1,8 @@
+export declare function parseLogName(filename: string): {
+    process: string | null;
+    ts: string | null;
+};
+export declare function formatTs(ts: string | null): string | null;
+export declare function spanDays(firstTs: string, lastTs: string): number;
+export declare const registerListErrorLogs: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=list-error-logs.d.ts.map