@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/model-building/unload-cube.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerUnloadCube = defineTool({
+    name: "tm1_unload_cube",
+    description: "Unload a cube from memory. TM1 discards the in-memory fed-cell index and reloads from disk on next access. Required after feeder corrections, since the fed-cell index is cumulative — changes to existing feeders only take effect after an unload. Safe to call: data is preserved (read from .cub on next access). TM1 v11 only.",
+    annotations: DESTRUCTIVE,
+    // v11 only. v12 answers tm1.Unload with "Demand load, loading and unloading
+    // of cubes is no longer supported." — the feature is gone, with no successor
+    // endpoint, so the tool is withheld rather than offered and refused.
+    enabled: (tm1Client) => tm1Client.version === 11,
+    output: MutationResultSchema,
+    input: {
+        cubeName: z.string().describe("Name of the cube to unload"),
+    },
+    handler: async ({ cubeName }, tm1Client) => {
+        await tm1Client.cubes.unload(cubeName);
+        return actionResponse({ success: true, cubeName });
+    },
+});
+//# sourceMappingURL=unload-cube.js.map

package/dist/tools/operations/diagnose-process-error.d.ts

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

package/dist/tools/operations/diagnose-process-error.js

@@ -0,0 +1,178 @@
+import { z } from "zod";
+import { matchesProcessName, tsFromFilename, truncateTail, tailLines, } from "./error-log-helpers.js";
+import { DiagnoseProcessErrorResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+const DEFAULT_TAIL_LINES = 60;
+const DEFAULT_MAX_LOGS = 3;
+const DEFAULT_RELATED_WINDOW_SEC = 10;
+const DEFAULT_RELATED_MAX_FILES = 5;
+const DEFAULT_RELATED_MAX_BYTES = 16 * 1024;
+export const registerDiagnoseProcessError = defineTool({
+    name: "tm1_diagnose_process_error",
+    description: [
+        "One-call error diagnosis for a failed TI process: lists matching error logs, fetches their content,",
+        "and optionally includes cascade-related sibling logs (same timestamp window) in a single response.",
+        "Replaces the manual sequence tm1_list_error_logs → tm1_get_error_log_content (× N). Returns logs newest-first.",
+    ],
+    annotations: READ_ONLY,
+    output: DiagnoseProcessErrorResultSchema,
+    input: {
+        processName: z
+            .string()
+            .describe("Process name to diagnose. Matches both TM1 filename conventions: modern 'TM1ProcessError_<ts>_<id>_<processName>.log' and legacy '<processName>_<ts>.log'."),
+        since: z
+            .string()
+            .optional()
+            .describe("Only consider logs with LastUpdated >= this ISO timestamp, e.g. '2026-05-04T00:00:00'."),
+        maxLogs: z
+            .number()
+            .int()
+            .min(1)
+            .max(20)
+            .optional()
+            .default(DEFAULT_MAX_LOGS)
+            .describe(`Max number of log files to fetch (newest first, default ${DEFAULT_MAX_LOGS}).`),
+        tail: z
+            .number()
+            .int()
+            .min(1)
+            .max(10000)
+            .optional()
+            .default(DEFAULT_TAIL_LINES)
+            .describe(`Lines to return from the end of each log (default ${DEFAULT_TAIL_LINES}).`),
+        includeRelated: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Also fetch sibling logs within ±relatedWindowSec of each log's timestamp (cascade failure tracing). Default: true."),
+        relatedWindowSec: z
+            .number()
+            .int()
+            .min(1)
+            .max(300)
+            .optional()
+            .default(DEFAULT_RELATED_WINDOW_SEC)
+            .describe(`Time window in seconds for cascade log discovery (default ${DEFAULT_RELATED_WINDOW_SEC}).`),
+        relatedMaxFiles: z
+            .number()
+            .int()
+            .min(1)
+            .max(20)
+            .optional()
+            .default(DEFAULT_RELATED_MAX_FILES)
+            .describe(`Max related logs per primary log (default ${DEFAULT_RELATED_MAX_FILES}).`),
+    },
+    handler: async ({ processName, since, maxLogs, tail, includeRelated, relatedWindowSec, relatedMaxFiles, }, tm1Client) => {
+        const allFiles = await tm1Client.server.listErrorLogFiles({ top: 500 });
+        const matching = allFiles
+            .filter((f) => matchesProcessName(f.filename, processName))
+            .filter((f) => {
+            if (!since)
+                return true;
+            return !f.lastUpdated || f.lastUpdated >= since;
+        })
+            .slice(0, maxLogs);
+        if (matching.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            processName,
+                            since: since ?? null,
+                            logsFound: 0,
+                            logsReturned: 0,
+                            logs: [],
+                        }),
+                    },
+                ],
+            };
+        }
+        const windowMs = relatedWindowSec * 1000;
+        const logs = await Promise.all(matching.map(async (f) => {
+            let content = "";
+            let fetchError;
+            let truncated = false;
+            let totalLines = 0;
+            try {
+                const raw = await tm1Client.server.getErrorLogContent(f.filename);
+                const result = tailLines(raw, tail);
+                content = result.body;
+                truncated = result.truncated;
+                totalLines = result.totalLines;
+            }
+            catch (e) {
+                fetchError = e.message;
+            }
+            const entry = {
+                filename: f.filename,
+                lastUpdated: f.lastUpdated,
+                totalLines,
+                truncated,
+                ...(fetchError ? { fetchError } : { content }),
+            };
+            if (includeRelated) {
+                const sourceTs = tsFromFilename(f.filename);
+                if (sourceTs === null) {
+                    entry.related = {
+                        note: "No embedded timestamp — cascade lookup skipped.",
+                        files: [],
+                    };
+                }
+                else {
+                    const candidates = allFiles
+                        .filter((r) => r.filename !== f.filename)
+                        .map((r) => ({
+                        filename: r.filename,
+                        ts: tsFromFilename(r.filename),
+                    }))
+                        .filter((r) => r.ts !== null)
+                        .filter((r) => Math.abs(r.ts - sourceTs) <= windowMs)
+                        .sort((a, b) => Math.abs(a.ts - sourceTs) - Math.abs(b.ts - sourceTs))
+                        .slice(0, relatedMaxFiles);
+                    const related = await Promise.all(candidates.map(async ({ filename: rf, ts }) => {
+                        try {
+                            const raw = await tm1Client.server.getErrorLogContent(rf);
+                            const { body, truncated: rt } = truncateTail(raw, DEFAULT_RELATED_MAX_BYTES);
+                            return {
+                                filename: rf,
+                                deltaSec: Math.round((ts - sourceTs) / 1000),
+                                truncated: rt,
+                                content: body,
+                            };
+                        }
+                        catch (e) {
+                            return {
+                                filename: rf,
+                                deltaSec: Math.round((ts - sourceTs) / 1000),
+                                fetchError: e.message,
+                            };
+                        }
+                    }));
+                    entry.related = {
+                        windowSec: relatedWindowSec,
+                        found: candidates.length,
+                        files: related,
+                    };
+                }
+            }
+            return entry;
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        processName,
+                        since: since ?? null,
+                        logsFound: matching.length,
+                        logsReturned: logs.length,
+                        logs,
+                    }),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=diagnose-process-error.js.map

package/dist/tools/operations/error-log-helpers.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Match a TI error log filename against a process name.
+ *
+ * Handles TM1 filename conventions:
+ *   - Modern with session hash:  TM1ProcessError_<ts>_<id>_<proc>_<hash>.log  → `_<proc>_` contained
+ *   - Modern without hash:       TM1ProcessError_<ts>_<id>_<proc>.log         → ends with `_<proc>.log`
+ *   - Legacy/manual:             <proc>_<ts>.log                              → starts with `<proc>_`
+ *   - Bare:                      <proc>                                       → exact match
+ *
+ * Substring-based match accepts a theoretical false positive when one process
+ * name is delimited by underscores inside another (e.g. "Import" vs "Re_Import_X").
+ * Acceptable trade for correctness on real-world v11 filenames.
+ */
+export declare function matchesProcessName(filename: string, processName: string): boolean;
+export declare function tsFromFilename(filename: string): number | null;
+export declare function truncateTail(content: string, maxBytes: number): {
+    body: string;
+    truncated: boolean;
+};
+export declare function tailLines(content: string, n: number): {
+    body: string;
+    truncated: boolean;
+    totalLines: number;
+};
+//# sourceMappingURL=error-log-helpers.d.ts.map

package/dist/tools/operations/error-log-helpers.js

@@ -0,0 +1,57 @@
+const TS_RE = /(\d{14})/;
+/**
+ * Match a TI error log filename against a process name.
+ *
+ * Handles TM1 filename conventions:
+ *   - Modern with session hash:  TM1ProcessError_<ts>_<id>_<proc>_<hash>.log  → `_<proc>_` contained
+ *   - Modern without hash:       TM1ProcessError_<ts>_<id>_<proc>.log         → ends with `_<proc>.log`
+ *   - Legacy/manual:             <proc>_<ts>.log                              → starts with `<proc>_`
+ *   - Bare:                      <proc>                                       → exact match
+ *
+ * Substring-based match accepts a theoretical false positive when one process
+ * name is delimited by underscores inside another (e.g. "Import" vs "Re_Import_X").
+ * Acceptable trade for correctness on real-world v11 filenames.
+ */
+export function matchesProcessName(filename, processName) {
+    const f = filename.toLowerCase();
+    const p = processName.toLowerCase();
+    return (f === p ||
+        f.startsWith(`${p}_`) ||
+        f.endsWith(`_${p}.log`) ||
+        f.includes(`_${p}_`));
+}
+export function tsFromFilename(filename) {
+    const m = filename.match(TS_RE);
+    if (!m)
+        return null;
+    const s = m[1];
+    const y = Number(s.slice(0, 4));
+    const mo = Number(s.slice(4, 6)) - 1;
+    const d = Number(s.slice(6, 8));
+    const h = Number(s.slice(8, 10));
+    const mi = Number(s.slice(10, 12));
+    const se = Number(s.slice(12, 14));
+    const ms = Date.UTC(y, mo, d, h, mi, se);
+    return Number.isFinite(ms) ? ms : null;
+}
+export function truncateTail(content, maxBytes) {
+    const totalBytes = Buffer.byteLength(content, "utf8");
+    if (totalBytes <= maxBytes)
+        return { body: content, truncated: false };
+    return {
+        body: Buffer.from(content, "utf8").subarray(-maxBytes).toString("utf8"),
+        truncated: true,
+    };
+}
+export function tailLines(content, n) {
+    const trimmed = content.replace(/[\r\n]+$/, "");
+    const lines = trimmed.split(/\r?\n/);
+    if (lines.length <= n)
+        return { body: trimmed, truncated: false, totalLines: lines.length };
+    return {
+        body: lines.slice(-n).join("\n"),
+        truncated: true,
+        totalLines: lines.length,
+    };
+}
+//# sourceMappingURL=error-log-helpers.js.map

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

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

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

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { FORMAT_SCHEMA, payloadResponse, renderTable, columnsOf, } from "../format.js";
+import { AuditLogEntrySchema } from "../schemas/items.js";
+import { READ_ONLY, withVersion } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerGetAuditLog = defineTool({
+    name: "tm1_get_audit_log",
+    description: "Fetch recent TM1 audit log entries (metadata/security changes: who changed what, when), newest first. " +
+        "Requires AuditLogOn=T in tm1s.cfg — an empty result on an active server usually means auditing is disabled " +
+        "(check auditLogEnabled in tm1_get_server_info). (v11 only)",
+    annotations: withVersion(READ_ONLY, "v11"),
+    // v12 deprecated AuditLogEntry/AuditLogEntries in 12.0.0 and serves an empty
+    // collection with no successor endpoint, so the tool can only mislead there.
+    enabled: (tm1Client) => tm1Client.version === 11,
+    output: {
+        count: z.number().int(),
+        entries: z.array(AuditLogEntrySchema),
+    },
+    input: {
+        top: z
+            .number()
+            .int()
+            .min(1)
+            .max(1000)
+            .optional()
+            .default(100)
+            .describe("Max entries to return (default: 100, max: 1000)"),
+        user: z.string().optional().describe("Filter to one user name"),
+        objectType: z
+            .string()
+            .optional()
+            .describe("Filter to one object type, e.g. 'Cube', 'Dimension', 'Process', 'User', 'Chore', 'Server'"),
+        objectName: z.string().optional().describe("Filter to one object name"),
+        since: z
+            .string()
+            .optional()
+            .describe("Only entries on or after this ISO timestamp, e.g. '2026-06-01T00:00:00Z'"),
+        until: z
+            .string()
+            .optional()
+            .describe("Only entries on or before this ISO timestamp"),
+        includeDetails: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Expand per-entry audit details (nested change records)"),
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ top, user, objectType, objectName, since, until, includeDetails, format }, tm1Client) => {
+        const entries = await tm1Client.server.getAuditLog({
+            top,
+            user,
+            objectType,
+            objectName,
+            since,
+            until,
+            includeDetails,
+        });
+        const payload = { count: entries.length, entries };
+        const columns = columnsOf([
+            "timestamp",
+            "user",
+            "objectType",
+            "objectName",
+            "description",
+        ]);
+        return payloadResponse(payload, format, (p) => `## Audit log\n\n${p.count} entries\n\n${renderTable(p.entries, columns)}`);
+    },
+});
+//# sourceMappingURL=get-audit-log.js.map

package/dist/tools/operations/get-cube-stats.d.ts

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

package/dist/tools/operations/get-cube-stats.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { mapSettledWithConcurrency } from "../../lib/concurrency.js";
+import { FORMAT_SCHEMA, payloadResponse, renderTable, columnsOf, } from "../format.js";
+import { fetchCubeStats, CubeStatsUnavailableError, } from "../../lib/cube-stats/fetcher.js";
+import { CubeStatsResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerGetCubeStats = defineTool({
+    name: "tm1_get_cube_stats",
+    description: [
+        "Read }StatsByCube metrics for one or more cubes (memory, populated cells, fed cells, feeder efficiency).",
+        "Well-known metrics are mapped to typed fields; the full element-name → value map is also returned under `raw` so server-side renames don't break the tool.",
+        "Per-cube errors are reported as items[].error without failing the whole call.",
+        "Servers with no }Stats* control cubes (TM1 v12), or accounts not allowed to read them, return `statsUnavailable` {reason: absent|denied} instead of a raw error.",
+    ],
+    annotations: READ_ONLY,
+    output: CubeStatsResultSchema,
+    input: {
+        cubeName: z
+            .string()
+            .optional()
+            .describe("Single cube name. Mutually exclusive with cubeNames."),
+        cubeNames: z
+            .array(z.string())
+            .min(1)
+            .max(500)
+            .optional()
+            .describe("Batch mode — list of cube names (max 500). Mutually exclusive with cubeName."),
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ cubeName, cubeNames, format }, tm1Client) => {
+        if (cubeName !== undefined && cubeNames !== undefined) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "cubeName and cubeNames are mutually exclusive — pass only one.",
+            });
+        }
+        const targets = cubeNames ?? (cubeName !== undefined ? [cubeName] : []);
+        if (targets.length === 0) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "Specify exactly one of cubeName or cubeNames.",
+            });
+        }
+        // One }StatsByCube MDX per target, capped in flight. Unbounded, a batch
+        // of a few hundred cubes hands TM1's worker pool that many simultaneous
+        // queries — the same reason tm1_audit_feeders caps its runtime pass at
+        // the same width.
+        const settled = await mapSettledWithConcurrency(targets, 10, (name) => fetchCubeStats(tm1Client, name));
+        const items = settled.map((r, i) => {
+            if (r.status === "fulfilled")
+                return r.value;
+            const err = r.reason;
+            // `}StatsByCube` missing or unreadable is a property of the server or
+            // the account, not of this cube — its message is already plain prose.
+            if (err instanceof CubeStatsUnavailableError)
+                return { cubeName: targets[i], raw: {}, error: err.message };
+            const msg = err instanceof TM1Error ? `${err.code}: ${err.message}` : String(err);
+            return { cubeName: targets[i], raw: {}, error: msg };
+        });
+        // Success envelope, not isError: "this server does not keep these
+        // statistics" is an answer, and the tool already reports per-cube
+        // failures inside a successful payload. The top-level annotation is set
+        // only when EVERY target failed for the same server-wide reason, so a
+        // one-off per-cube failure never gets generalised into a claim about
+        // the server.
+        const statsUnavailable = serverWideUnavailability(settled);
+        const payload = {
+            count: items.length,
+            items,
+            ...(statsUnavailable ? { statsUnavailable } : {}),
+        };
+        const columns = columnsOf([
+            { header: "cube", get: (i) => i.cubeName },
+            "memoryTotal",
+            "populatedNumeric",
+            "fedCells",
+            "feederEfficiency",
+            "error",
+        ]);
+        return payloadResponse(payload, format, (p) => `## Cube stats\n\n${p.count} cubes\n\n` +
+            (statsUnavailable ? `> ${statsUnavailable.message}\n\n` : "") +
+            renderTable(p.items, columns));
+    },
+});
+/**
+ * Collapse per-cube failures into one server-wide verdict — but only when
+ * every requested cube failed the same way. A mixed result stays per-cube.
+ */
+function serverWideUnavailability(settled) {
+    if (settled.length === 0)
+        return undefined;
+    let first;
+    for (const r of settled) {
+        if (r.status !== "rejected")
+            return undefined;
+        const err = r.reason;
+        if (!(err instanceof CubeStatsUnavailableError))
+            return undefined;
+        first ??= err;
+        if (err.reason !== first.reason)
+            return undefined;
+    }
+    return first ? { reason: first.reason, message: first.message } : undefined;
+}
+//# sourceMappingURL=get-cube-stats.js.map

package/dist/tools/operations/get-error-log-content.d.ts

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

package/dist/tools/operations/get-error-log-content.js

@@ -0,0 +1,164 @@
+import { z } from "zod";
+import { tsFromFilename, truncateTail } from "./error-log-helpers.js";
+import { ErrorLogContentResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+const DEFAULT_MAX_BYTES = 64 * 1024;
+const HARD_MAX_BYTES = 4 * 1024 * 1024;
+const DEFAULT_RELATED_WINDOW_SEC = 10;
+const HARD_MAX_RELATED_WINDOW_SEC = 300;
+const DEFAULT_RELATED_MAX_FILES = 5;
+const HARD_MAX_RELATED_FILES = 20;
+const DEFAULT_RELATED_MAX_BYTES = 16 * 1024;
+export const registerGetErrorLogContent = defineTool({
+    name: "tm1_get_error_log_content",
+    description: [
+        "Fetch the raw text of one TI error log file produced by a failed process run.",
+        "Use tm1_list_error_logs first to discover available filenames; response is tail/byte-truncated to protect the MCP context.",
+        "includeRelated also pulls sibling logs within a timestamp window — useful for tracing cascade failures in chained TI processes.",
+    ],
+    annotations: READ_ONLY,
+    output: ErrorLogContentResultSchema,
+    input: {
+        filename: z
+            .string()
+            .describe("Exact filename returned by tm1_list_error_logs, e.g. 'MyProc_20260504_123045.log'"),
+        tail: z
+            .number()
+            .int()
+            .positive()
+            .max(10000)
+            .optional()
+            .describe("If set, return only the last N lines (overrides maxBytes byte truncation)."),
+        maxBytes: z
+            .number()
+            .int()
+            .positive()
+            .max(HARD_MAX_BYTES)
+            .optional()
+            .default(DEFAULT_MAX_BYTES)
+            .describe(`Truncate to last N bytes if no tail is given (default ${DEFAULT_MAX_BYTES}, hard max ${HARD_MAX_BYTES}).`),
+        includeRelated: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("If true, also fetch sibling error logs whose embedded YYYYMMDDHHMMSS timestamp is within ±relatedWindowSec of the source log."),
+        relatedWindowSec: z
+            .number()
+            .int()
+            .positive()
+            .max(HARD_MAX_RELATED_WINDOW_SEC)
+            .optional()
+            .default(DEFAULT_RELATED_WINDOW_SEC)
+            .describe(`Time window in seconds for related-log discovery (default ${DEFAULT_RELATED_WINDOW_SEC}, max ${HARD_MAX_RELATED_WINDOW_SEC}).`),
+        relatedMaxFiles: z
+            .number()
+            .int()
+            .positive()
+            .max(HARD_MAX_RELATED_FILES)
+            .optional()
+            .default(DEFAULT_RELATED_MAX_FILES)
+            .describe(`Cap on number of related logs returned (default ${DEFAULT_RELATED_MAX_FILES}, max ${HARD_MAX_RELATED_FILES}).`),
+        relatedMaxBytes: z
+            .number()
+            .int()
+            .positive()
+            .max(HARD_MAX_BYTES)
+            .optional()
+            .default(DEFAULT_RELATED_MAX_BYTES)
+            .describe(`Per-related-log byte cap (tail-truncated, default ${DEFAULT_RELATED_MAX_BYTES}).`),
+    },
+    handler: async ({ filename, tail, maxBytes, includeRelated, relatedWindowSec, relatedMaxFiles, relatedMaxBytes, }, tm1Client) => {
+        const content = await tm1Client.server.getErrorLogContent(filename);
+        const totalBytes = Buffer.byteLength(content, "utf8");
+        let body;
+        let truncated = false;
+        let truncationReason;
+        if (tail !== undefined) {
+            // Strip trailing CR/LF so a file ending in '\n' doesn't yield a phantom empty last line.
+            const trimmed = content.replace(/[\r\n]+$/, "");
+            const allLines = trimmed.split(/\r?\n/);
+            if (allLines.length > tail) {
+                body = allLines.slice(-tail).join("\n");
+                truncated = true;
+                truncationReason = `tail=${tail} (of ${allLines.length} lines)`;
+            }
+            else {
+                body = trimmed;
+            }
+        }
+        else if (totalBytes > maxBytes) {
+            body = Buffer.from(content, "utf8").subarray(-maxBytes).toString("utf8");
+            truncated = true;
+            truncationReason = `maxBytes=${maxBytes} (tail-truncated)`;
+        }
+        else {
+            body = content;
+        }
+        const payload = {
+            filename,
+            totalBytes,
+            returnedBytes: Buffer.byteLength(body, "utf8"),
+            truncated,
+            ...(truncationReason ? { truncationReason } : {}),
+            content: body,
+        };
+        if (includeRelated) {
+            const sourceTs = tsFromFilename(filename);
+            if (sourceTs === null) {
+                payload.related = {
+                    note: "Source filename has no embedded YYYYMMDDHHMMSS timestamp — relation lookup skipped.",
+                    files: [],
+                };
+            }
+            else {
+                const allFiles = await tm1Client.server.listErrorLogFiles({
+                    top: 500,
+                });
+                const windowMs = relatedWindowSec * 1000;
+                const candidates = allFiles
+                    .filter((f) => f.filename !== filename)
+                    .map((f) => ({
+                    filename: f.filename,
+                    ts: tsFromFilename(f.filename),
+                }))
+                    .filter((f) => f.ts !== null)
+                    .filter((f) => Math.abs(f.ts - sourceTs) <= windowMs)
+                    .sort((a, b) => Math.abs(a.ts - sourceTs) - Math.abs(b.ts - sourceTs))
+                    .slice(0, relatedMaxFiles);
+                const fetched = await Promise.all(candidates.map(async ({ filename: rf, ts }) => {
+                    try {
+                        const raw = await tm1Client.server.getErrorLogContent(rf);
+                        const rawBytes = Buffer.byteLength(raw, "utf8");
+                        const { body: rb, truncated: rt } = truncateTail(raw, relatedMaxBytes);
+                        return {
+                            filename: rf,
+                            deltaSec: Math.round((ts - sourceTs) / 1000),
+                            totalBytes: rawBytes,
+                            returnedBytes: Buffer.byteLength(rb, "utf8"),
+                            truncated: rt,
+                            content: rb,
+                        };
+                    }
+                    catch (e) {
+                        return {
+                            filename: rf,
+                            deltaSec: Math.round((ts - sourceTs) / 1000),
+                            error: e.message,
+                        };
+                    }
+                }));
+                payload.related = {
+                    windowSec: relatedWindowSec,
+                    found: candidates.length,
+                    maxFiles: relatedMaxFiles,
+                    files: fetched,
+                };
+            }
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(payload) }],
+        };
+    },
+});
+//# sourceMappingURL=get-error-log-content.js.map

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

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