@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/schemas/metadata.js

@@ -0,0 +1,47 @@
+// Metadata domain: element statistics and per-element attribute values.
+import { z } from "zod";
+import { CellValueSchema, ELEMENT_TYPE } from "./common.js";
+export const CubeSchema = z.object({
+    name: z.string(),
+    dimensions: z.array(z.string()),
+    hasRules: z.boolean().optional(),
+});
+export const ElementStatsSchema = z.object({
+    total: z.number().int(),
+    numeric: z.number().int(),
+    consolidated: z.number().int(),
+    string: z.number().int(),
+    maxLevel: z.number().int(),
+});
+export const ElementAttributeValueSchema = z.object({
+    elementName: z.string(),
+    attributeName: z.string(),
+    value: CellValueSchema,
+});
+export const DimensionSchema = z.object({
+    name: z.string(),
+    hierarchies: z.array(z.string()),
+    // Populated only when getDimensions({includeElementCount: true}) is called.
+    // Map hierarchyName → element total.
+    elementCounts: z.record(z.string(), z.number().int()).optional(),
+    // Populated only when getDimensions({includeElementStats: true}) is called.
+    // Map hierarchyName → Type breakdown (N/C/S) + maxLevel.
+    elementStats: z.record(z.string(), ElementStatsSchema).optional(),
+    // Populated only when includeLastUpdated is asked for. Naive-local ISO
+    // (no Z) decoded from }DimensionProperties.LAST_TIME_UPDATED — a
+    // schema-change stamp. null when the dimension has no stamp.
+    lastUpdated: z.string().nullable().optional(),
+});
+export const HierarchyElementSchema = z.object({
+    name: z.string(),
+    type: ELEMENT_TYPE,
+    level: z.number().int(),
+    parents: z.array(z.string()),
+    children: z.array(z.object({ name: z.string(), weight: z.number() })),
+});
+export const HierarchySchema = z.object({
+    name: z.string(),
+    dimensionName: z.string(),
+    elements: z.array(HierarchyElementSchema),
+});
+//# sourceMappingURL=metadata.js.map

package/dist/schemas/monitoring.d.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+export declare const ThreadSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodString;
+    name: z.ZodString;
+    state: z.ZodString;
+    function: z.ZodString;
+    objectName: z.ZodString;
+    elapsedTime: z.ZodOptional<z.ZodString>;
+    objectType: z.ZodOptional<z.ZodString>;
+    waitTime: z.ZodOptional<z.ZodString>;
+    info: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Thread = z.infer<typeof ThreadSchema>;
+export declare const SessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    user: z.ZodString;
+    active: z.ZodOptional<z.ZodBoolean>;
+    threads: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        type: z.ZodString;
+        name: z.ZodString;
+        state: z.ZodString;
+        function: z.ZodString;
+        objectName: z.ZodString;
+        elapsedTime: z.ZodOptional<z.ZodString>;
+        objectType: z.ZodOptional<z.ZodString>;
+        waitTime: z.ZodOptional<z.ZodString>;
+        info: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Session = z.infer<typeof SessionSchema>;
+export declare const JobSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type JobSession = z.infer<typeof JobSessionSchema>;
+export declare const JobWaitingOnSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    state: z.ZodString;
+}, z.core.$strip>;
+export type JobWaitingOn = z.infer<typeof JobWaitingOnSchema>;
+export declare const JobSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    state: z.ZodString;
+    elapsedTime: z.ZodOptional<z.ZodString>;
+    waitTime: z.ZodOptional<z.ZodString>;
+    session: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        context: z.ZodOptional<z.ZodString>;
+        user: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    waitingOn: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        state: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Job = z.infer<typeof JobSchema>;
+export declare const MessageLogEntrySchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    level: z.ZodString;
+    message: z.ZodString;
+    errorFile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MessageLogEntry = z.infer<typeof MessageLogEntrySchema>;
+export declare const TransactionLogEntrySchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    user: z.ZodString;
+    cubeName: z.ZodString;
+    elements: z.ZodArray<z.ZodString>;
+    oldValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    newValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+}, z.core.$strip>;
+export type TransactionLogEntry = z.infer<typeof TransactionLogEntrySchema>;
+export declare const AuditLogDetailSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    timestamp: z.ZodString;
+    user: z.ZodString;
+    description: z.ZodString;
+    objectType: z.ZodString;
+    objectName: z.ZodString;
+}, z.core.$strip>;
+export type AuditLogDetail = z.infer<typeof AuditLogDetailSchema>;
+export declare const ErrorLogFileSchema: z.ZodObject<{
+    filename: z.ZodString;
+    lastUpdated: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ErrorLogFile = z.infer<typeof ErrorLogFileSchema>;
+//# sourceMappingURL=monitoring.d.ts.map

package/dist/schemas/monitoring.js

@@ -0,0 +1,69 @@
+// Monitoring domain: threads (v11), jobs (v12), sessions and the log entries.
+import { z } from "zod";
+import { CellValueSchema } from "./common.js";
+export const ThreadSchema = z.object({
+    id: z.number(),
+    type: z.string(),
+    name: z.string(),
+    state: z.string(),
+    function: z.string(),
+    objectName: z.string(),
+    elapsedTime: z.string().optional(),
+    objectType: z.string().optional(),
+    waitTime: z.string().optional(),
+    info: z.string().optional(),
+    context: z.string().optional(),
+});
+export const SessionSchema = z.object({
+    id: z.string(),
+    user: z.string(),
+    active: z.boolean().optional(),
+    threads: z.array(ThreadSchema),
+});
+export const JobSessionSchema = z.object({
+    id: z.string(),
+    context: z.string().optional(),
+    user: z.string().optional(),
+});
+export const JobWaitingOnSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    state: z.string(),
+});
+export const JobSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    state: z.string(),
+    elapsedTime: z.string().optional(),
+    waitTime: z.string().optional(),
+    session: JobSessionSchema.optional(),
+    waitingOn: z.array(JobWaitingOnSchema).optional(),
+});
+export const MessageLogEntrySchema = z.object({
+    timestamp: z.string(),
+    level: z.string(),
+    message: z.string(),
+    /** TI error file referenced in `message`, parsed out for direct fetch. */
+    errorFile: z.string().optional(),
+});
+export const TransactionLogEntrySchema = z.object({
+    timestamp: z.string(),
+    user: z.string(),
+    cubeName: z.string(),
+    elements: z.array(z.string()),
+    oldValue: CellValueSchema,
+    newValue: CellValueSchema,
+});
+export const AuditLogDetailSchema = z.object({
+    id: z.number().int(),
+    timestamp: z.string(),
+    user: z.string(),
+    description: z.string(),
+    objectType: z.string(),
+    objectName: z.string(),
+});
+export const ErrorLogFileSchema = z.object({
+    filename: z.string(),
+    lastUpdated: z.string().optional(),
+});
+//# sourceMappingURL=monitoring.js.map

package/dist/schemas/processes.d.ts

@@ -0,0 +1,74 @@
+import { z } from "zod";
+export declare const ProcessParameterSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Numeric: "Numeric";
+        String: "String";
+    }>;
+    defaultValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProcessParameter = z.infer<typeof ProcessParameterSchema>;
+export declare const ProcessVariableSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Numeric: "Numeric";
+        String: "String";
+    }>;
+    position: z.ZodNumber;
+    startByte: z.ZodOptional<z.ZodNumber>;
+    endByte: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ProcessVariable = z.infer<typeof ProcessVariableSchema>;
+export declare const IgnoredColumnSchema: z.ZodObject<{
+    position: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type IgnoredColumn = z.infer<typeof IgnoredColumnSchema>;
+export declare const VariablesUIDataSchema: z.ZodArray<z.ZodString>;
+export declare const ProcessSchema: z.ZodObject<{
+    name: z.ZodString;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            Numeric: "Numeric";
+            String: "String";
+        }>;
+        defaultValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        prompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Process = z.infer<typeof ProcessSchema>;
+export declare const ProcessCodeSchema: z.ZodObject<{
+    prolog: z.ZodString;
+    metadata: z.ZodString;
+    data: z.ZodString;
+    epilog: z.ZodString;
+}, z.core.$strip>;
+export type ProcessCode = z.infer<typeof ProcessCodeSchema>;
+export declare const DataSourceSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        None: "None";
+        TM1CubeView: "TM1CubeView";
+        TM1DimensionSubset: "TM1DimensionSubset";
+        ASCII: "ASCII";
+        ODBC: "ODBC";
+        TM1Process: "TM1Process";
+    }>;
+    dataSourceNameForServer: z.ZodOptional<z.ZodString>;
+    dataSourceNameForClient: z.ZodOptional<z.ZodString>;
+    asciiDelimiterType: z.ZodOptional<z.ZodString>;
+    asciiDelimiterChar: z.ZodOptional<z.ZodString>;
+    asciiQuoteCharacter: z.ZodOptional<z.ZodString>;
+    asciiHeaderRecords: z.ZodOptional<z.ZodNumber>;
+    asciiDecimalSeparator: z.ZodOptional<z.ZodString>;
+    asciiThousandSeparator: z.ZodOptional<z.ZodString>;
+    usesUnicode: z.ZodOptional<z.ZodBoolean>;
+    userName: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    view: z.ZodOptional<z.ZodString>;
+    subset: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DataSource = z.infer<typeof DataSourceSchema>;
+//# sourceMappingURL=processes.d.ts.map

package/dist/schemas/processes.js

@@ -0,0 +1,66 @@
+// TI process domain: parameter and variable declarations.
+import { z } from "zod";
+import { PARAM_TYPE } from "./common.js";
+export const ProcessParameterSchema = z.object({
+    name: z.string(),
+    type: PARAM_TYPE,
+    defaultValue: z.union([z.string(), z.number()]),
+    prompt: z.string().optional(),
+});
+export const ProcessVariableSchema = z.object({
+    name: z.string(),
+    type: PARAM_TYPE,
+    position: z.number().int(),
+    startByte: z.number().int().optional(),
+    endByte: z.number().int().optional(),
+});
+// A datasource column set to "Ignore" carries no variable, so it is absent from
+// `Variables` — it only shows up in `VariablesUIData`. See
+// src/lib/variables-ui-data.ts for the encoding and how it was measured.
+export const IgnoredColumnSchema = z.object({
+    position: z.number().int(),
+    name: z.string().optional(),
+});
+// Raw `Process.VariablesUIData`: one entry per datasource column, ignored ones
+// included. Carried verbatim so nothing measured-but-unmodelled is dropped.
+export const VariablesUIDataSchema = z.array(z.string());
+export const ProcessSchema = z.object({
+    name: z.string(),
+    parameters: z.array(ProcessParameterSchema),
+});
+export const ProcessCodeSchema = z.object({
+    prolog: z.string(),
+    metadata: z.string(),
+    data: z.string(),
+    epilog: z.string(),
+});
+// TI datasource. Field set measured against 11.8.02900.8 (29 real ODBC
+// sources) — `ProcessDataSource` is declared OpenType in $metadata, so the
+// server accepts unknown properties and hands them back only sometimes. Two
+// fields that were never real (`oDBCConnection`, and `lockType` on the thread
+// shape) lived here for months precisely because this shape existed twice.
+export const DataSourceSchema = z.object({
+    type: z.enum([
+        "None",
+        "TM1CubeView",
+        "TM1DimensionSubset",
+        "ASCII",
+        "ODBC",
+        "TM1Process",
+    ]),
+    dataSourceNameForServer: z.string().optional(),
+    dataSourceNameForClient: z.string().optional(),
+    asciiDelimiterType: z.string().optional(),
+    asciiDelimiterChar: z.string().optional(),
+    asciiQuoteCharacter: z.string().optional(),
+    asciiHeaderRecords: z.number().int().optional(),
+    asciiDecimalSeparator: z.string().optional(),
+    asciiThousandSeparator: z.string().optional(),
+    usesUnicode: z.boolean().optional(),
+    userName: z.string().optional(),
+    password: z.string().optional(),
+    query: z.string().optional(),
+    view: z.string().optional(),
+    subset: z.string().optional(),
+});
+//# sourceMappingURL=processes.js.map

package/dist/schemas/scheduling.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const ChoreSchema: z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodBoolean;
+    startTime: z.ZodString;
+    frequency: z.ZodString;
+    processes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Chore = z.infer<typeof ChoreSchema>;
+//# sourceMappingURL=scheduling.d.ts.map

package/dist/schemas/scheduling.js

@@ -0,0 +1,13 @@
+// Chore domain.
+import { z } from "zod";
+export const ChoreSchema = z.object({
+    name: z.string(),
+    active: z.boolean(),
+    startTime: z.string(),
+    frequency: z.string(),
+    processes: z.array(z.object({
+        name: z.string(),
+        parameters: z.record(z.string(), z.union([z.string(), z.number()])),
+    })),
+});
+//# sourceMappingURL=scheduling.js.map

package/dist/schemas/security.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const ClientSchema: z.ZodObject<{
+    Name: z.ZodString;
+    FriendlyName: z.ZodOptional<z.ZodString>;
+    Type: z.ZodOptional<z.ZodString>;
+    Enabled: z.ZodOptional<z.ZodBoolean>;
+    Groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        Name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Client = z.infer<typeof ClientSchema>;
+export declare const GroupSchema: z.ZodObject<{
+    Name: z.ZodString;
+    Clients: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        Name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Group = z.infer<typeof GroupSchema>;
+//# sourceMappingURL=security.d.ts.map

package/dist/schemas/security.js

@@ -0,0 +1,16 @@
+// Security domain. TM1 returns these entities with OData PascalCase keys, and
+// the tool layer passes them through unchanged rather than renaming a shape
+// callers may already match on.
+import { z } from "zod";
+export const ClientSchema = z.object({
+    Name: z.string(),
+    FriendlyName: z.string().optional(),
+    Type: z.string().optional(),
+    Enabled: z.boolean().optional(),
+    Groups: z.array(z.object({ Name: z.string() })).optional(),
+});
+export const GroupSchema = z.object({
+    Name: z.string(),
+    Clients: z.array(z.object({ Name: z.string() })).optional(),
+});
+//# sourceMappingURL=security.js.map

package/dist/schemas/subsets.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const SubsetSchema: z.ZodObject<{
+    name: z.ZodString;
+    dimensionName: z.ZodString;
+    hierarchyName: z.ZodString;
+    private: z.ZodBoolean;
+    expression: z.ZodOptional<z.ZodString>;
+    elements: z.ZodArray<z.ZodString>;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Subset = z.infer<typeof SubsetSchema>;
+//# sourceMappingURL=subsets.d.ts.map

package/dist/schemas/subsets.js

@@ -0,0 +1,12 @@
+// Subset domain.
+import { z } from "zod";
+export const SubsetSchema = z.object({
+    name: z.string(),
+    dimensionName: z.string(),
+    hierarchyName: z.string(),
+    private: z.boolean(),
+    expression: z.string().optional(),
+    elements: z.array(z.string()),
+    alias: z.string().optional(),
+});
+//# sourceMappingURL=subsets.js.map

package/dist/schemas/views.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const ViewAxisSubsetRefSchema: z.ZodObject<{
+    dimensionName: z.ZodOptional<z.ZodString>;
+    hierarchyName: z.ZodOptional<z.ZodString>;
+    subsetName: z.ZodOptional<z.ZodString>;
+    expression: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ViewAxisSubsetRef = z.infer<typeof ViewAxisSubsetRefSchema>;
+//# sourceMappingURL=views.d.ts.map

package/dist/schemas/views.js

@@ -0,0 +1,9 @@
+// View domain: the dimension/subset reference shared by axes and titles.
+import { z } from "zod";
+export const ViewAxisSubsetRefSchema = z.object({
+    dimensionName: z.string().optional(),
+    hierarchyName: z.string().optional(),
+    subsetName: z.string().optional(),
+    expression: z.string().optional(),
+});
+//# sourceMappingURL=views.js.map

package/dist/session-manager.d.ts

@@ -0,0 +1,79 @@
+import type { TM1Config } from "./config.js";
+import type pino from "pino";
+export declare class TimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(label: string, timeoutMs: number);
+}
+export declare class SessionManager {
+    private sessionCookie;
+    private authInFlight;
+    private keepAliveTimer;
+    private readonly config;
+    private readonly logger;
+    private readonly profile;
+    constructor(config: TM1Config, logger?: pino.Logger);
+    /**
+     * Authenticate against TM1. The auth scheme (Basic / CAMNamespace /
+     * CAMPassport for v11, or the configured v12 auth mode) is selected by
+     * config — see ConnectionProfile.buildLoginRequest in
+     * tm1-client/connection/profile.ts.
+     *
+     * Concurrent callers share a single in-flight login. The HTTP transport
+     * re-authenticates directly from its 401 handler (http.ts), so two requests
+     * whose sessions expire at the same time both land here; without this dedup
+     * each opens a fresh TM1 session and the second login's cookie clobbers the
+     * first, leaving the first request retrying with a now-stale cookie (the
+     * "thundering herd on session expiry" race). All re-auth paths — ensureSession,
+     * keepAlive, and the transport 401 retry — funnel through this guard.
+     *
+     * `staleCookie` (optional): the cookie the caller was using when it decided to
+     * re-auth. If another caller has ALREADY rotated the session since then
+     * (current cookie ≠ stale, and non-null), this returns the fresh cookie
+     * without a logout+login. Without this, a delayed 401 carrying an
+     * already-replaced cookie would tear down the healthy session that concurrent
+     * requests are using — the "staggered-401 re-auth churn" cascade.
+     */
+    authenticate(staleCookie?: string): Promise<string>;
+    /**
+     * Perform the actual login round-trip. The request (URL, method, headers,
+     * body) comes from the connection profile — v11 GETs
+     * /api/v1/Configuration/ProductVersion, v12 POSTs /{instance}/auth/v1/session.
+     * Extracts TM1SessionId cookie from the response.
+     */
+    private doAuthenticate;
+    /**
+     * Send a keep-alive request to maintain the active session.
+     * GET /api/v1/ActiveSession with the session cookie.
+     * On 401, triggers re-authentication.
+     */
+    keepAlive(): Promise<void>;
+    /**
+     * Ensure an active session exists. If no session cookie is present,
+     * authenticate first. Returns the session cookie.
+     */
+    ensureSession(): Promise<string>;
+    /**
+     * Start periodic keep-alive requests at the configured interval.
+     */
+    startKeepAlive(): void;
+    /**
+     * Stop the periodic keep-alive timer.
+     */
+    stopKeepAlive(): void;
+    /**
+     * Check whether a session cookie is currently held.
+     */
+    isSessionActive(): boolean;
+    /**
+     * Logout from TM1 by deleting the active session.
+     * DELETE /api/v1/ActiveSession
+     */
+    logout(): Promise<void>;
+    /** Human-readable auth mode for logging (never logs the credential itself). */
+    private authMode;
+    /**
+     * Extract TM1SessionId Set-Cookie response headers.
+     */
+    private extractSessionCookie;
+}
+//# sourceMappingURL=session-manager.d.ts.map