@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/operations/list-error-logs.js

@@ -0,0 +1,157 @@
+import { z } from "zod";
+import { FORMAT_SCHEMA, pageResponse, wrappedPageResponse, columnsOf, } from "../format.js";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { ErrorLogFileSchema, ErrorLogGroupSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { pageShapeFor } from "../schemas/common.js";
+// Best-effort extraction of {process, ts} from an error-log filename.
+// Two known patterns (see server-service.listErrorLogFiles):
+//   modern v11: TM1ProcessError_<ts>_<id>_<proc>(_<hash>)?.log
+//   legacy:     <proc>_<ts>.log
+// Process names may contain underscores, so the modern parse greedily captures
+// the tail and strips a trailing session-hash token (_<hex6+>). This is a
+// heuristic — good enough for audit triage, not a guaranteed exact split.
+export function parseLogName(filename) {
+    const modern = filename.match(/^TM1ProcessError_(\d{14})_\d+_(.+)\.log$/i);
+    if (modern) {
+        // Strip the trailing TM1 session-hash token. Real-world v11 hashes are
+        // lowercase base36 (e.g. "_mp2su7f4sybb"), not just hex, so match any
+        // lowercase-alphanumeric token of length >= 8 that contains at least one
+        // digit (the digit requirement avoids stripping real word suffixes like
+        // "_export"). Collapses TIRecord_<proc>_<hash> variants onto one process.
+        const proc = modern[2].replace(/_(?=[a-z0-9]*\d)[a-z0-9]{8,}$/, "");
+        return { ts: modern[1], process: proc };
+    }
+    const legacy = filename.match(/^(.+)_(\d{8,14})\.log$/i);
+    if (legacy) {
+        return { ts: legacy[2], process: legacy[1] };
+    }
+    return { process: null, ts: null };
+}
+// "20260615123045" → "2026-06-15T12:30:45" (best-effort; shorter ts left as-is).
+export function formatTs(ts) {
+    if (!ts || ts.length < 8)
+        return null;
+    const y = ts.slice(0, 4);
+    const mo = ts.slice(4, 6);
+    const d = ts.slice(6, 8);
+    const h = ts.slice(8, 10) || "00";
+    const mi = ts.slice(10, 12) || "00";
+    const s = ts.slice(12, 14) || "00";
+    return `${y}-${mo}-${d}T${h}:${mi}:${s}`;
+}
+// Whole-day count between two 14-digit timestamps, inclusive (min 1).
+export function spanDays(firstTs, lastTs) {
+    const toDate = (ts) => {
+        const iso = formatTs(ts);
+        return iso ? new Date(iso) : null;
+    };
+    const a = toDate(firstTs);
+    const b = toDate(lastTs);
+    if (!a || !b || Number.isNaN(a.getTime()) || Number.isNaN(b.getTime()))
+        return 1;
+    const diffDays = Math.floor((b.getTime() - a.getTime()) / 86_400_000);
+    return Math.max(1, diffDays + 1);
+}
+export const registerListErrorLogs = defineTool({
+    name: "tm1_list_error_logs",
+    description: [
+        "List TI process error log files on the TM1 server, newest first. Paginated (default 50/page).",
+        "For one-call diagnosis of a failed process prefer tm1_diagnose_process_error (list + fetch combined); use this to browse the catalogue, then tm1_get_error_log_content for raw text.",
+        "groupBy='process' returns a per-process audit summary instead of individual files.",
+    ],
+    annotations: READ_ONLY,
+    output: pageShapeFor(z.union([ErrorLogFileSchema, ErrorLogGroupSchema])),
+    input: {
+        processName: z
+            .string()
+            .optional()
+            .describe("Optional process-name filter — matches both modern v11 'TM1ProcessError_<ts>_<id>_<processName>_<hash>.log' and legacy '<processName>_<ts>.log' filename patterns."),
+        since: z
+            .string()
+            .optional()
+            .describe("Only logs with LastUpdated >= this ISO timestamp, e.g. '2026-05-01T00:00:00'"),
+        groupBy: z
+            .literal("process")
+            .optional()
+            .describe("Set to 'process' for an aggregated audit summary instead of individual files: " +
+            "per process {count, firstSeen, lastSeen, spanDays, perDay}, sorted by count desc. " +
+            "Answers 'which processes fail regularly' in one call. Process name is extracted from the " +
+            "filename heuristically; unparseable names bucket under '(unparsed)'."),
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ processName, since, groupBy, limit, offset, fetchAll, format }, tm1Client) => {
+        // Pull a generous slice from the server (top=500); pagination is applied client-side
+        // so callers always see total + has_more even if they limit to a small page.
+        const files = await tm1Client.server.listErrorLogFiles({
+            processName,
+            since,
+            top: 500,
+        });
+        if (groupBy === "process") {
+            const acc = new Map();
+            for (const f of files) {
+                const { process, ts } = parseLogName(f.filename);
+                const key = process ?? "(unparsed)";
+                let g = acc.get(key);
+                if (!g) {
+                    g = { count: 0, first: null, last: null };
+                    acc.set(key, g);
+                }
+                g.count++;
+                if (ts) {
+                    if (g.first === null || ts < g.first)
+                        g.first = ts;
+                    if (g.last === null || ts > g.last)
+                        g.last = ts;
+                }
+            }
+            const allGroups = [...acc.entries()]
+                .map(([process, g]) => {
+                const span = g.first && g.last ? spanDays(g.first, g.last) : 1;
+                return {
+                    process,
+                    count: g.count,
+                    firstSeen: formatTs(g.first),
+                    lastSeen: formatTs(g.last),
+                    spanDays: span,
+                    perDay: Math.round((g.count / span) * 100) / 100,
+                };
+            })
+                .sort((a, b) => b.count - a.count || a.process.localeCompare(b.process));
+            const groupPage = paginate(allGroups, limit, offset, fetchAll);
+            const wrapper = {
+                groupBy: "process",
+                processName,
+                since,
+                totalFiles: files.length,
+                groupCount: allGroups.length,
+                ...groupPage,
+            };
+            const groupColumns = columnsOf([
+                "process",
+                "count",
+                "firstSeen",
+                "lastSeen",
+                "spanDays",
+                "perDay",
+            ]);
+            return wrappedPageResponse(wrapper, groupPage, format, {
+                title: "Error log summary (by process)",
+                columns: groupColumns,
+            });
+        }
+        const page = paginate(files, limit, offset, fetchAll);
+        const columns = columnsOf([
+            "filename",
+            {
+                header: "lastUpdated",
+                get: (f) => f.lastUpdated ?? formatTs(parseLogName(f.filename).ts) ?? "",
+            },
+        ]);
+        return pageResponse(page, format, { title: "Error logs", columns });
+    },
+});
+//# sourceMappingURL=list-error-logs.js.map

package/dist/tools/operations/save-data.d.ts

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

package/dist/tools/operations/save-data.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { withToolHint } from "../error-format.js";
+import { IDEMPOTENT_WRITE, withVersion } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerSaveData = defineTool({
+    name: "tm1_save_data",
+    description: [
+        "Persist in-memory cube data to disk: SaveDataAll (all cubes) or CubeSaveData when `cube` is given.",
+        "Run after write sessions (tm1_write_cells, TI loads) — unsaved changes are lost on server crash.",
+        "Persists in-memory data to disk only; it does not clear or truncate the transaction log.",
+        "v11 only — v12 removed SaveDataAll/CubeSaveData (cloud engine persists automatically).",
+        "Executes as an unbound TI process via ExecuteProcessWithReturn; no process object is created on the server.",
+    ],
+    annotations: withVersion(IDEMPOTENT_WRITE, "v11"),
+    enabled: (tm1Client) => tm1Client.version === 11,
+    output: MutationResultSchema,
+    input: {
+        cube: z
+            .string()
+            .optional()
+            .describe("Save only this cube (CubeSaveData). Omit to save all cubes (SaveDataAll)."),
+        timeoutMs: z
+            .number()
+            .int()
+            .min(1000)
+            .max(3600000)
+            .optional()
+            .describe("Override the default request timeout (ms, 1000–3600000). SaveDataAll on large models can take minutes."),
+    },
+    handler: async ({ cube, timeoutMs }, tm1Client, extra) => {
+        const result = await withToolHint(tm1Client.processes.saveData(cube, {
+            signal: extra?.signal,
+            ...(timeoutMs ? { timeoutMs } : {}),
+        }), "SaveData failed. On v12 this tool is unsupported (SaveDataAll removed). Check tm1_get_server_info for productVersion; for a single cube verify the name via tm1_list_cubes.");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ ...result, scope: cube ?? "all" }),
+                },
+            ],
+            // A failed SaveData is a data-persistence failure (in-memory data not
+            // written to disk) — surface it as an MCP error, not a success payload
+            // carrying success:false, so the caller can't silently miss data loss.
+            ...(result.success === false ? { isError: true } : {}),
+        };
+    },
+});
+//# sourceMappingURL=save-data.js.map

package/dist/tools/pagination.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const UNBOUNDED_MAX_ITEMS = 5000;
+export declare const PAGINATION_SCHEMA: {
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    fetchAll: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+};
+export interface Page<T> {
+    total: number;
+    count: number;
+    offset: number;
+    has_more: boolean;
+    next_offset: number | null;
+    items: T[];
+}
+export declare function paginate<T>(items: readonly T[], limit: number, offset: number, fetchAll?: boolean): Page<T>;
+/**
+ * Wrap an already-server-sliced page (`$top`/`$skip`) in the same `Page<T>`
+ * envelope `paginate()` produces, using the server's `@odata.count` as `total`.
+ *
+ * `has_more` is derived from `offset + count < total`, never from
+ * `count === limit` — the latter is off by one whenever the last page happens
+ * to be exactly `limit` long.
+ *
+ * Only call this when every active filter was expressed in `$filter`.
+ * `@odata.count` counts post-filter rows; if a filter ran client-side, `total`
+ * would exceed what the caller can actually reach and `has_more` would promise
+ * pages that come back empty. Fall back to `paginate()` over a full fetch in
+ * that case.
+ */
+export declare function pageFromServer<T>(items: readonly T[], total: number, offset: number): Page<T>;
+//# sourceMappingURL=pagination.d.ts.map

package/dist/tools/pagination.js

@@ -0,0 +1,116 @@
+// Pagination helpers for list_* MCP tools. Two shapes of one envelope:
+//
+//   paginate()       — slices an in-memory array. Used when the handler had to
+//                      fetch the whole collection anyway (a filter TM1 cannot
+//                      express, fetchAll, limit=0).
+//   pageFromServer() — wraps a page TM1 already sliced via $top/$skip, with
+//                      `total` taken from `@odata.count`.
+//
+// Both produce a byte-identical `Page<T>`, so the push-down decision is
+// invisible to callers and needs no output-schema change. Which one a handler
+// may use is a correctness question, not a performance one: `@odata.count` is
+// computed after `$filter`, so it equals the true total only when *every*
+// active filter was pushed down. Any filter that stays client-side must force
+// the paginate() path.
+import { z } from "zod";
+// Hard ceiling for the unbounded modes (`fetchAll`, `limit=0`). Not a page
+// size — a backstop. 5000 rows of a typical list item already run into six
+// figures of characters; past that the response stops being usable by the
+// agent that asked for it, and the honest answer is "here is the first slab,
+// keep paging" rather than a response nobody can read.
+export const UNBOUNDED_MAX_ITEMS = 5000;
+// Descriptions are deliberately terse: this block is inlined into 19 tool input
+// schemas, so every byte is paid 19x in every `tools/list` payload. Anything
+// JSON Schema already emits structurally (`default`, `minimum`, `maximum`) is
+// NOT repeated in prose — only semantics the schema cannot express (0 = all,
+// fetchAll's payload cost and its cap) stay in the text.
+export const PAGINATION_SCHEMA = {
+    limit: z
+        .number()
+        .int()
+        .min(0)
+        .max(500)
+        .optional()
+        .default(50)
+        .describe("Page size; 0 = all."),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .default(0)
+        .describe("Items to skip."),
+    fetchAll: z
+        .boolean()
+        .optional()
+        .default(false)
+        // Terse on purpose: this string ships 19x in every tools/list (see the
+        // note above and the 60-char gate in tests/unit/pagination.test.ts). The
+        // cap is not expressible in JSON Schema — it only applies on this branch —
+        // so it has to be prose, but short prose.
+        .describe(`All items, ignoring limit/offset. Capped ${UNBOUNDED_MAX_ITEMS}.`),
+};
+export function paginate(items, limit, offset, fetchAll = false) {
+    if (fetchAll || limit === 0) {
+        // Bounded even here. `fetchAll` / `limit=0` are escape hatches from the
+        // page SIZE, not from every limit: a dimension with 200k elements would
+        // otherwise serialize 200k rows into one response and exhaust the caller's
+        // context long before TM1 breaks a sweat.
+        //
+        // The cap reuses the normal envelope instead of inventing a new signal —
+        // has_more/next_offset already mean "more rows exist, resume here", so a
+        // capped fetchAll is simply a first page the caller can walk on from.
+        // Nothing disappears silently.
+        const slice = items.slice(0, UNBOUNDED_MAX_ITEMS);
+        const has_more = slice.length < items.length;
+        return {
+            total: items.length,
+            count: slice.length,
+            offset: 0,
+            has_more,
+            next_offset: has_more ? slice.length : null,
+            items: slice,
+        };
+    }
+    const safeOffset = Math.max(0, Math.min(offset, items.length));
+    const slice = items.slice(safeOffset, safeOffset + limit);
+    const has_more = safeOffset + slice.length < items.length;
+    return {
+        total: items.length,
+        count: slice.length,
+        offset: safeOffset,
+        has_more,
+        next_offset: has_more ? safeOffset + slice.length : null,
+        items: slice,
+    };
+}
+/**
+ * Wrap an already-server-sliced page (`$top`/`$skip`) in the same `Page<T>`
+ * envelope `paginate()` produces, using the server's `@odata.count` as `total`.
+ *
+ * `has_more` is derived from `offset + count < total`, never from
+ * `count === limit` — the latter is off by one whenever the last page happens
+ * to be exactly `limit` long.
+ *
+ * Only call this when every active filter was expressed in `$filter`.
+ * `@odata.count` counts post-filter rows; if a filter ran client-side, `total`
+ * would exceed what the caller can actually reach and `has_more` would promise
+ * pages that come back empty. Fall back to `paginate()` over a full fetch in
+ * that case.
+ */
+export function pageFromServer(items, total, offset) {
+    const safeOffset = Math.max(0, offset);
+    // A server total below what we already hold means the collection shrank
+    // between the count and the slice; trust the rows we actually have.
+    const safeTotal = Math.max(total, safeOffset + items.length);
+    const has_more = safeOffset + items.length < safeTotal;
+    return {
+        total: safeTotal,
+        count: items.length,
+        offset: safeOffset,
+        has_more,
+        next_offset: has_more ? safeOffset + items.length : null,
+        items: [...items],
+    };
+}
+//# sourceMappingURL=pagination.js.map

package/dist/tools/scheduling/create-chore.d.ts

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

package/dist/tools/scheduling/create-chore.js

@@ -0,0 +1,93 @@
+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";
+// TM1's chore endpoint rejects DateTimeOffset strings without a UTC marker. If the caller
+// omits the offset we append 'Z' and report it back so they can fix the input upstream.
+function coerceUtc(iso) {
+    const hasOffset = /(?:Z|[+-]\d{2}:?\d{2})$/.test(iso);
+    return hasOffset
+        ? { value: iso, coerced: false }
+        : { value: `${iso}Z`, coerced: true };
+}
+const ChoreStepSchema = z.object({
+    process: z.string().describe("TI process name"),
+    parameters: z
+        .array(z.object({
+        name: z.string(),
+        value: z.union([z.string(), z.number()]),
+    }))
+        .optional()
+        .default([]),
+});
+export const registerCreateChore = defineTool({
+    name: "tm1_create_chore",
+    description: [
+        "Create a new TM1 chore with a schedule and list of TI processes to run.",
+        "Fails if a chore with the same name already exists; use tm1_update_chore for idempotent edits.",
+        "After: tm1_toggle_chore to activate scheduling, tm1_execute_chore to run immediately.",
+    ],
+    annotations: WRITE,
+    output: MutationResultSchema,
+    input: {
+        choreName: z.string().describe("Chore name"),
+        startTime: z
+            .string()
+            .describe("Start time in ISO 8601 format with timezone (Z or ±HH:MM). If no offset is given, UTC ('Z') is auto-appended. Example: '2025-01-01T06:00:00Z'."),
+        active: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Whether to activate the chore immediately (default: false)"),
+        dstSensitive: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Whether the schedule adjusts for daylight saving time (default: true)"),
+        executionMode: z
+            .enum(["SingleCommit", "MultipleCommit"])
+            .optional()
+            .default("MultipleCommit")
+            .describe("SingleCommit: the chore commits once at the end. MultipleCommit: each step commits independently. " +
+            "Measured (12.5.9): the mode changes only how far a ProcessRollback reaches — under SingleCommit it discards everything the chore wrote up to that point, under MultipleCommit only the rolling-back step. " +
+            "Under NEITHER mode does a failing step stop the chore: later steps still run and still commit."),
+        frequency: z
+            .object({
+            days: z.number().int().min(0).default(1),
+            hours: z.number().int().min(0).max(23).default(0),
+            minutes: z.number().int().min(0).max(59).default(0),
+            seconds: z.number().int().min(0).max(59).default(0),
+        })
+            .describe("How often the chore runs"),
+        steps: z
+            .array(ChoreStepSchema)
+            .min(1)
+            .describe("Ordered list of TI processes to execute"),
+    },
+    handler: async ({ choreName, startTime, active, dstSensitive, executionMode, frequency, steps, }, tm1Client) => {
+        const { value: normalizedStartTime, coerced } = coerceUtc(startTime);
+        await tm1Client.chores.create({
+            name: choreName,
+            startTime: normalizedStartTime,
+            active,
+            dstSensitive,
+            executionMode,
+            frequency,
+            steps,
+        });
+        return actionResponse({
+            success: true,
+            name: choreName,
+            stepCount: steps.length,
+            active,
+            startTime: normalizedStartTime,
+            ...(coerced
+                ? {
+                    warning: `startTime had no timezone offset; auto-appended 'Z' → '${normalizedStartTime}'. Pass an explicit offset to silence this.`,
+                }
+                : {}),
+        });
+    },
+});
+//# sourceMappingURL=create-chore.js.map

package/dist/tools/scheduling/delete-chore.d.ts

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

package/dist/tools/scheduling/delete-chore.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { actionResponse } from "../format.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerDeleteChore = defineTool({
+    name: "tm1_delete_chore",
+    description: "Delete a TM1 chore permanently. Irreversible — pass confirm=<chore name verbatim>.",
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        choreName: z.string().describe("Chore name (case-sensitive)"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ choreName, confirm }, tm1Client) => {
+        requireConfirm(confirm, choreName, "chore");
+        await tm1Client.chores.delete(choreName);
+        return actionResponse({ success: true, choreName });
+    },
+});
+//# sourceMappingURL=delete-chore.js.map

package/dist/tools/scheduling/execute-chore.d.ts

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

package/dist/tools/scheduling/execute-chore.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { ChoreResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerExecuteChore = defineTool({
+    name: "tm1_execute_chore",
+    description: [
+        "Execute a TM1 chore immediately, bypassing its schedule. Runs synchronously — the call returns when the chore is done, so raise timeoutMs for long chains.",
+        "Non-idempotent: runs every chained process. Before: tm1_analyze_chore_graph to preview the call chain.",
+        "Chores do NOT stop at a failing step (measured): later steps still run and still commit. Read `outcome`, not `success` alone — `completed_with_errors` means a step failed AND the chore's writes were committed, so re-running duplicates them. A step that aborts commits inside a chore, unlike the same process run on its own.",
+        "`rolled_back` (ChoreExecuteStatusCode ProcessRollbackCalled) discards the whole chore so far under ExecutionMode SingleCommit, only the rolling-back step under MultipleCommit.",
+        "`statusUnavailable: true` means the server cannot report chore status (v11, and v12 before 12.5.0): the chore ran, the outcome is unknown.",
+        "On failure: tm1_diagnose_process_error for the failing step.",
+    ],
+    annotations: DESTRUCTIVE,
+    output: ChoreResultSchema,
+    input: {
+        choreName: z.string().describe("Chore name (case-sensitive)"),
+        timeoutMs: z
+            .number()
+            .int()
+            .min(1000)
+            .max(3600000)
+            .optional()
+            .describe("Override the default 30s request timeout for this call (ms, 1000–3600000). Use for chores running long TI chains."),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ choreName, timeoutMs, confirm }, tm1Client, extra) => {
+        // Runs every chained process; undoing the call does not undo the writes.
+        // Guards against accidental invocation — not a security control.
+        requireConfirm(confirm, choreName, "chore");
+        const result = await tm1Client.chores.execute(choreName, {
+            signal: extra?.signal,
+            ...(timeoutMs ? { timeoutMs } : {}),
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            // Same rule as tm1_execute_process: a chore that ran and reported failure
+            // is a tool failure, not a successful call carrying success:false.
+            //
+            // `statusUnavailable` is the exception and must NOT flag. It also has
+            // success:false, but it means "this build cannot report chore status" —
+            // on v11 that is EVERY chore run. Flagging it would turn a known API
+            // limitation into an error on every single call.
+            ...(result.success === false && result.statusUnavailable !== true
+                ? { isError: true }
+                : {}),
+        };
+    },
+});
+//# sourceMappingURL=execute-chore.js.map

package/dist/tools/scheduling/toggle-chore.d.ts

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

package/dist/tools/scheduling/toggle-chore.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { IDEMPOTENT_WRITE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerToggleChore = defineTool({
+    name: "tm1_toggle_chore",
+    description: "Activate or deactivate a TM1 chore (enable/disable its schedule).",
+    annotations: IDEMPOTENT_WRITE,
+    output: MutationResultSchema,
+    input: {
+        choreName: z.string().describe("Chore name (case-sensitive)"),
+        active: z
+            .boolean()
+            .describe("true to activate scheduling, false to deactivate"),
+    },
+    handler: async ({ choreName, active }, tm1Client) => {
+        await tm1Client.chores.toggleActive(choreName, active);
+        return actionResponse({ success: true, choreName, active });
+    },
+});
+//# sourceMappingURL=toggle-chore.js.map

package/dist/tools/scheduling/update-chore.d.ts

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

package/dist/tools/scheduling/update-chore.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { IDEMPOTENT_WRITE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerUpdateChore = defineTool({
+    name: "tm1_update_chore",
+    description: "Update an existing TM1 chore. Only the provided fields are changed.",
+    annotations: IDEMPOTENT_WRITE,
+    output: MutationResultSchema,
+    input: {
+        choreName: z.string().describe("Chore name (case-sensitive)"),
+        startTime: z
+            .string()
+            .optional()
+            .describe("New start time in ISO 8601 format"),
+        active: z
+            .boolean()
+            .optional()
+            .describe("Enable or disable the chore schedule"),
+        dstSensitive: z
+            .boolean()
+            .optional()
+            .describe("Adjust for daylight saving time"),
+        executionMode: z.enum(["SingleCommit", "MultipleCommit"]).optional(),
+        frequency: z
+            .object({
+            days: z.number().int().min(0),
+            hours: z.number().int().min(0).max(23),
+            minutes: z.number().int().min(0).max(59),
+            seconds: z.number().int().min(0).max(59),
+        })
+            .optional(),
+        steps: z
+            .array(z.object({
+            process: z.string(),
+            parameters: z
+                .array(z.object({
+                name: z.string(),
+                value: z.union([z.string(), z.number()]),
+            }))
+                .optional()
+                .default([]),
+        }))
+            .optional()
+            .describe("Replace all steps (full replacement, not partial)"),
+    },
+    handler: async ({ choreName, ...updates }, tm1Client) => {
+        let coerced = false;
+        if (updates.startTime !== undefined &&
+            !/(?:Z|[+-]\d{2}:?\d{2})$/.test(updates.startTime)) {
+            updates.startTime = `${updates.startTime}Z`;
+            coerced = true;
+        }
+        await tm1Client.chores.update(choreName, updates);
+        const payload = {
+            success: true,
+            choreName,
+            ...(updates.startTime !== undefined
+                ? { startTime: updates.startTime }
+                : {}),
+            ...(coerced
+                ? {
+                    warning: `startTime had no timezone offset; auto-appended 'Z' → '${updates.startTime}'. Pass an explicit offset to silence this.`,
+                }
+                : {}),
+        };
+        return actionResponse(payload);
+    },
+});
+//# sourceMappingURL=update-chore.js.map

package/dist/tools/schemas/common.d.ts

@@ -0,0 +1,10 @@
+import { z, type ZodTypeAny } from "zod";
+export declare function pageShapeFor<T extends ZodTypeAny>(itemSchema: T): {
+    total: z.ZodNumber;
+    count: z.ZodNumber;
+    offset: z.ZodNumber;
+    has_more: z.ZodBoolean;
+    next_offset: z.ZodNullable<z.ZodNumber>;
+    items: z.ZodArray<T>;
+};
+//# sourceMappingURL=common.d.ts.map