@ffschrattenecker/tm1-mcp-server 6.1.1 → 7.0.0

package/CHANGELOG.md

@@ -7,6 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [7.0.0] - 2026-09-27
+
+### Breaking
+
+- **One server for all TM1 connections.** Without `TM1_BASE_URL`, the server discovers every
+  `<name>/.env` under `~/.tm1/mcp-servers` (or `TM1_CONNECTIONS_DIR`) and every tool takes a
+  `connection` argument. Replace the per-instance MCP entries with a single one: the client then
+  carries one tool list instead of one per TM1 instance. Setups with `TM1_BASE_URL` keep working
+  unchanged as a single connection. See docs/CONFIGURATION.md, "Several TM1 connections".
+- **`tm1_get_process_code`, `tm1_get_process_parameters`, `tm1_get_process_variables` and
+  `tm1_get_process_datasource` are removed.** `tm1_get_process` returns every part, each behind
+  an include-flag (`includeCode=false` for parameters/variables/datasource only). The datasource
+  now sits under `dataSource`.
+- **`tm1_list_processes` returns names only by default.** Pass `fields=['name','parameters']`
+  for parameter lists; TM1 is then asked for the parameters too, instead of on every listing.
+- **`tm1_list_cubes` defaults to `includeDimensions=false`.**
+
+### Added
+
+- `tm1_list_connections`: configured connections, their mode, environment, version and session state.
+- `TM1_ENVIRONMENT` / `TM1_ALLOW_PROD_WRITES` are read per connection folder, never inherited from
+  the launching shell. A prod connection forced to readonly says so in `tm1_list_connections` and in
+  the refusal hint of a write tool.
+- Oversized paginated results are cut to the items that fit, with `has_more`/`next_offset`
+  pointing at the rest, instead of failing with `RESPONSE_TOO_LARGE`.
+- Server `instructions` (≤500 characters) tell the model how to pick a connection and keep
+  results small.
+
+### Fixed
+
+- The callgraph cache is keyed per connection, so an index built for one TM1 server is never
+  answered for another.
+
 ## [6.1.1] - 2026-09-26
 
 ### Fixed
@@ -1266,7 +1299,8 @@ Initial public release.
 - Quality gates: strict typecheck, ESLint, `lint:no-flat-api`,
   annotation-coverage, and tool-registration wiring.
 
-[Unreleased]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.1.1...HEAD
+[Unreleased]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v7.0.0...HEAD
+[7.0.0]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.1.1...v7.0.0
 [6.1.1]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.1.0...v6.1.1
 [6.1.0]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.0.1...v6.1.0
 [6.0.1]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.0.0...v6.0.1

package/README.md

@@ -18,7 +18,7 @@ published as `@ffschrattenecker/tm1-mcp-server`. The command is still `tm1-mcp-s
 
 ## Features
 
-115 tools across 12 categories — every one listed in
+112 tools across 12 categories — every one listed in
 [docs/TOOLS.md](docs/TOOLS.md), with working JSON payloads in
 [docs/EXAMPLES.md](docs/EXAMPLES.md). Past plain CRUD over the REST API:
 
@@ -108,6 +108,24 @@ Analytics Engine) connection and its auth modes, host-disk file access.
 > with `TM1_ENVIRONMENT=prod`: it then stays readonly even under
 > `TM1_MODE=readwrite`, unless `TM1_ALLOW_PROD_WRITES=true` is set as well.
 
+### Several TM1 servers — one process
+
+Give each connection its own folder with a `.env` under `~/.tm1/mcp-servers/`
+(or the folder named by `TM1_CONNECTIONS_DIR`) and leave `TM1_BASE_URL` unset:
+
+```text
+~/.tm1/mcp-servers/
+  dev/.env        # TM1_BASE_URL=…  TM1_MODE=readwrite
+  prod/.env       # TM1_BASE_URL=…  (readonly: the default)
+```
+
+One server then serves them all: every tool takes a `connection` argument and
+`tm1_list_connections` shows what is configured. Each folder sets its own
+`TM1_MODE` — a write against a readonly connection is refused per call — and
+no connection logs in before its first use. One entry replaces one MCP server
+per TM1 instance, so the client carries one tool list instead of N.
+[docs/CONFIGURATION.md](docs/CONFIGURATION.md#several-tm1-connections) has the details.
+
 Host-disk file access is default-off in the same spirit: the `.pro` and git
 tools accept inline content, and touch host paths only once
 `TM1_LOCAL_FILE_ROOT` names an allowed directory (paths outside it, and `..`
@@ -200,7 +218,7 @@ security notes and the `autoApprove` allowlist:
 
 <!-- TOOLS-AUTOGEN:START -->
 
-## Tools (115)
+## Tools (112)
 
 Names and one-line descriptions: [docs/TOOLS.md](docs/TOOLS.md).
 
@@ -212,13 +230,13 @@ Names and one-line descriptions: [docs/TOOLS.md](docs/TOOLS.md).
 | fileops | 5 |
 | metadata | 9 |
 | model-building | 9 |
-| operations | 15 |
+| operations | 16 |
 | scheduling | 5 |
 | security | 8 |
 | subsets | 5 |
-| ti-development | 21 |
+| ti-development | 17 |
 | views | 4 |
-| **Total** | **115** |
+| **Total** | **112** |
 
 <!-- TOOLS-AUTOGEN:END -->
 

package/dist/config.d.ts

@@ -33,5 +33,14 @@ export interface TM1Config {
     iamUrl?: string | undefined;
 }
 export declare const DEFAULT_MAX_RESPONSE_CHARS = 80000;
+export type ServerSettings = Pick<TM1Config, "logLevel" | "logFile" | "transport" | "httpHost" | "httpPort" | "httpAllowedOrigins" | "httpToken" | "responseMode" | "maxResponseChars">;
+export declare function loadServerSettings(env?: NodeJS.ProcessEnv): ServerSettings;
 export declare function loadConfig(env?: NodeJS.ProcessEnv): TM1Config;
+/**
+ * Stable label for a connection: host and port, plus the v12
+ * instance/database. Keys per-connection state (process backups, the callgraph
+ * cache, mutation events) — two folders pointing at the same server share it,
+ * which is correct: they see the same objects.
+ */
+export declare function connectionIdOf(config: Pick<TM1Config, "baseUrl" | "instance" | "database">): string;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -23,53 +23,12 @@ function parseIntEnv(name, raw, def) {
     }
     return n;
 }
-// `env` defaults to the process environment. The multi-connection registry
-// passes one record per connection folder instead (see ./connections.ts).
-export function loadConfig(env = process.env) {
-    const baseUrl = env.TM1_BASE_URL;
-    const user = env.TM1_USER;
-    const password = env.TM1_PASSWORD;
-    // CAM auth (mirrors TM1py's RestService._build_authorization_token):
-    //   TM1_CAM_PASSPORT set → "CAMPassport <token>"      (no user/password round-trip)
-    //   TM1_NAMESPACE set     → "CAMNamespace b64(u:p:ns)" (needs user + password + namespace)
-    //   neither               → "Basic b64(u:p)"           (native TM1)
-    // SSO/gateway (Windows SSPI) is intentionally unsupported here: TM1py only does
-    // it via the Windows-only requests_negotiate_sspi package. Supply a passport
-    // obtained out-of-band via TM1_CAM_PASSPORT instead.
-    const namespace = env.TM1_NAMESPACE || undefined;
-    const camPassport = env.TM1_CAM_PASSPORT || undefined;
-    // Required: baseUrl always. user/password only when NOT using a passport — a
-    // passport carries the authenticated identity, so TM1 needs no credentials.
-    // Empty strings are rejected (treated as unset). Password may be empty — some
-    // TM1 setups allow a blank password for the admin account — so we warn but
-    // don't block, letting the real 401 (if any) surface with context.
-    const missing = [];
-    if (!baseUrl)
-        missing.push("TM1_BASE_URL");
-    if (!camPassport) {
-        if (!user)
-            missing.push("TM1_USER");
-        if (password === undefined)
-            missing.push("TM1_PASSWORD");
-    }
-    if (missing.length > 0) {
-        throw new Error(`Missing or empty required environment variables: ${missing.join(", ")}. ` +
-            `Set them in your shell or .env file before starting the server.`);
-    }
-    if (!camPassport && password === "") {
-        process.stderr.write("[tm1-mcp-server] WARNING: TM1_PASSWORD is empty. " +
-            "If TM1 rejects with 401, check whether the account actually allows blank passwords.\n");
-    }
-    const sslRaw = env.TM1_SSL_REJECT_UNAUTHORIZED;
-    const rejectUnauthorized = sslRaw === undefined ? true : sslRaw !== "false";
-    const keepAliveIntervalMs = parseIntEnv("TM1_KEEP_ALIVE_INTERVAL", env.TM1_KEEP_ALIVE_INTERVAL, 60000);
-    const requestTimeoutMs = parseIntEnv("TM1_REQUEST_TIMEOUT", env.TM1_REQUEST_TIMEOUT, 30000);
+export function loadServerSettings(env = process.env) {
     const logLevelRaw = env.TM1_LOG_LEVEL ?? "info";
     const logLevel = VALID_LOG_LEVELS.includes(logLevelRaw)
         ? logLevelRaw
         : "info";
     const logFile = env.TM1_LOG_FILE || undefined;
-    const tm1Version = env.TM1_VERSION || "11.8";
     const transportRaw = env.TM1_MCP_TRANSPORT ?? "stdio";
     const transport = VALID_TRANSPORTS.includes(transportRaw)
         ? transportRaw
@@ -114,6 +73,74 @@ export function loadConfig(env = process.env) {
             `Refusing to expose an unauthenticated /mcp endpoint beyond localhost — set ` +
             `TM1_MCP_HTTP_TOKEN, or bind to 127.0.0.1/localhost.`);
     }
+    // Same parse shape as TM1_MODE: case-insensitive, unknown value throws at
+    // startup rather than silently picking a wire format the operator did not ask
+    // for.
+    const responseModeRaw = (env.TM1_RESPONSE_MODE ?? "legacy")
+        .trim()
+        .toLowerCase();
+    if (!VALID_RESPONSE_MODES.includes(responseModeRaw)) {
+        throw new Error(`Invalid TM1_RESPONSE_MODE: "${env.TM1_RESPONSE_MODE}". Expected "legacy" or "structured".`);
+    }
+    const responseMode = responseModeRaw;
+    // ~80k characters sits under Claude Code's default MCP output cap (25k
+    // tokens) with room for the envelope; 23 recorded results overflowed it.
+    const maxResponseChars = parseIntEnv("TM1_MAX_RESPONSE_CHARS", env.TM1_MAX_RESPONSE_CHARS, DEFAULT_MAX_RESPONSE_CHARS);
+    return {
+        logLevel,
+        logFile,
+        transport,
+        httpHost,
+        httpPort,
+        httpAllowedOrigins,
+        httpToken,
+        responseMode,
+        maxResponseChars,
+    };
+}
+// `env` defaults to the process environment. The multi-connection registry
+// passes one record per connection folder instead (see ./connections.ts).
+export function loadConfig(env = process.env) {
+    const baseUrl = env.TM1_BASE_URL;
+    const user = env.TM1_USER;
+    const password = env.TM1_PASSWORD;
+    // CAM auth (mirrors TM1py's RestService._build_authorization_token):
+    //   TM1_CAM_PASSPORT set → "CAMPassport <token>"      (no user/password round-trip)
+    //   TM1_NAMESPACE set     → "CAMNamespace b64(u:p:ns)" (needs user + password + namespace)
+    //   neither               → "Basic b64(u:p)"           (native TM1)
+    // SSO/gateway (Windows SSPI) is intentionally unsupported here: TM1py only does
+    // it via the Windows-only requests_negotiate_sspi package. Supply a passport
+    // obtained out-of-band via TM1_CAM_PASSPORT instead.
+    const namespace = env.TM1_NAMESPACE || undefined;
+    const camPassport = env.TM1_CAM_PASSPORT || undefined;
+    // Required: baseUrl always. user/password only when NOT using a passport — a
+    // passport carries the authenticated identity, so TM1 needs no credentials.
+    // Empty strings are rejected (treated as unset). Password may be empty — some
+    // TM1 setups allow a blank password for the admin account — so we warn but
+    // don't block, letting the real 401 (if any) surface with context.
+    const missing = [];
+    if (!baseUrl)
+        missing.push("TM1_BASE_URL");
+    if (!camPassport) {
+        if (!user)
+            missing.push("TM1_USER");
+        if (password === undefined)
+            missing.push("TM1_PASSWORD");
+    }
+    if (missing.length > 0) {
+        throw new Error(`Missing or empty required environment variables: ${missing.join(", ")}. ` +
+            `Set them in your shell or .env file before starting the server.`);
+    }
+    if (!camPassport && password === "") {
+        process.stderr.write("[tm1-mcp-server] WARNING: TM1_PASSWORD is empty. " +
+            "If TM1 rejects with 401, check whether the account actually allows blank passwords.\n");
+    }
+    const sslRaw = env.TM1_SSL_REJECT_UNAUTHORIZED;
+    const rejectUnauthorized = sslRaw === undefined ? true : sslRaw !== "false";
+    const keepAliveIntervalMs = parseIntEnv("TM1_KEEP_ALIVE_INTERVAL", env.TM1_KEEP_ALIVE_INTERVAL, 60000);
+    const requestTimeoutMs = parseIntEnv("TM1_REQUEST_TIMEOUT", env.TM1_REQUEST_TIMEOUT, 30000);
+    const server = loadServerSettings(env);
+    const tm1Version = env.TM1_VERSION || "11.8";
     // Case-insensitive so a `TM1_MODE=ReadWrite` typo resolves to readwrite rather
     // than silently falling back to readonly (dropping every write tool without a
     // word). A genuinely-unknown value throws at startup — parity with the numeric
@@ -136,19 +163,6 @@ export function loadConfig(env = process.env) {
         modeReason =
             "TM1_ENVIRONMENT=prod forces readonly; set TM1_ALLOW_PROD_WRITES=true to allow writes.";
     }
-    // Same parse shape as TM1_MODE: case-insensitive, unknown value throws at
-    // startup rather than silently picking a wire format the operator did not ask
-    // for.
-    const responseModeRaw = (env.TM1_RESPONSE_MODE ?? "legacy")
-        .trim()
-        .toLowerCase();
-    if (!VALID_RESPONSE_MODES.includes(responseModeRaw)) {
-        throw new Error(`Invalid TM1_RESPONSE_MODE: "${env.TM1_RESPONSE_MODE}". Expected "legacy" or "structured".`);
-    }
-    const responseMode = responseModeRaw;
-    // ~80k characters sits under Claude Code's default MCP output cap (25k
-    // tokens) with room for the envelope; 23 recorded results overflowed it.
-    const maxResponseChars = parseIntEnv("TM1_MAX_RESPONSE_CHARS", env.TM1_MAX_RESPONSE_CHARS, DEFAULT_MAX_RESPONSE_CHARS);
     // --- v12 (Planning Analytics Engine) connection ---------------------------
     const instance = env.TM1_INSTANCE || undefined;
     const database = env.TM1_DATABASE || undefined;
@@ -217,6 +231,7 @@ export function loadConfig(env = process.env) {
         }
     }
     return {
+        ...server,
         baseUrl: baseUrl,
         // In passport mode user/password are unused; default to "" so the type stays
         // a plain string and the Authorization header is built from the passport.
@@ -227,19 +242,10 @@ export function loadConfig(env = process.env) {
         ssl: { rejectUnauthorized },
         keepAliveIntervalMs,
         requestTimeoutMs,
-        logLevel,
-        logFile,
         tm1Version: effectiveTm1Version,
-        transport,
-        httpHost,
-        httpPort,
-        httpAllowedOrigins,
-        httpToken,
         mode,
         ...(environment !== undefined ? { environment } : {}),
         ...(modeReason !== undefined ? { modeReason } : {}),
-        responseMode,
-        maxResponseChars,
         version,
         instance,
         database,
@@ -251,4 +257,23 @@ export function loadConfig(env = process.env) {
         iamUrl,
     };
 }
+/**
+ * Stable label for a connection: host and port, plus the v12
+ * instance/database. Keys per-connection state (process backups, the callgraph
+ * cache, mutation events) — two folders pointing at the same server share it,
+ * which is correct: they see the same objects.
+ */
+export function connectionIdOf(config) {
+    let host;
+    try {
+        const url = new URL(config.baseUrl);
+        host = url.port ? `${url.hostname}_${url.port}` : url.hostname;
+    }
+    catch {
+        host = config.baseUrl;
+    }
+    return [host, config.instance, config.database]
+        .filter((part) => Boolean(part))
+        .join("_");
+}
 //# sourceMappingURL=config.js.map

package/dist/connections.d.ts

@@ -0,0 +1,69 @@
+import pino from "pino";
+import { type TM1Config } from "./config.js";
+import { TM1Client } from "./tm1-client.js";
+export interface ConnectionInfo {
+    name: string;
+    /** Folder the `.env` came from; undefined for the legacy single connection. */
+    dir?: string | undefined;
+    mode?: TM1Config["mode"] | undefined;
+    environment?: TM1Config["environment"];
+    /** Why mode differs from TM1_MODE (prod forces readonly). */
+    modeReason?: string | undefined;
+    version?: 11 | 12 | undefined;
+    tm1Version?: string | undefined;
+    baseUrl?: string | undefined;
+    /** connectionIdOf() — what mutation events and caches are keyed by. */
+    connectionId?: string | undefined;
+    /** Set when the folder's `.env` could not be turned into a config. */
+    configError?: string | undefined;
+}
+export interface ConnectionStatus extends ConnectionInfo {
+    connected: boolean;
+    lastError?: string | undefined;
+}
+export declare class ConnectionRegistry {
+    private readonly logger;
+    private readonly entries;
+    private constructor();
+    /** Discover connections from the environment (see the header comment). */
+    static fromEnvironment(env: NodeJS.ProcessEnv, logger: pino.Logger): ConnectionRegistry;
+    /** Wrap one prebuilt client (tests, embedders). */
+    static single(client: TM1Client, logger?: pino.Logger): ConnectionRegistry;
+    /**
+     * Prebuilt clients under explicit names. The owner keeps the clients'
+     * lifecycle: disconnectAll() leaves them alone. Mode defaults to readwrite
+     * because the registration-time gate (TM1_MODE via withAnnotations) already
+     * decided what an embedder may call.
+     */
+    static of(clients: ReadonlyArray<{
+        name: string;
+        client: TM1Client;
+        mode?: TM1Config["mode"];
+    }>, logger?: pino.Logger): ConnectionRegistry;
+    private addConfig;
+    private discover;
+    /** Every connection name, including ones whose config failed to load. */
+    get names(): string[];
+    /** Connections that can actually be used. */
+    get usableNames(): string[];
+    /** True when tools should not expose a `connection` argument at all. */
+    get isSingle(): boolean;
+    get anyReadwrite(): boolean;
+    hasVersion(version: 11 | 12): boolean;
+    /** A client exists and is not mid-login. Never triggers a login itself. */
+    isConnected(name: string): boolean;
+    info(name: string): ConnectionInfo | undefined;
+    status(): ConnectionStatus[];
+    /** Resolve a connection name (optional when there is only one). */
+    private entryFor;
+    /**
+     * The client for a connection, built and logged in on first use. A failed
+     * login does not poison the entry: the client's own request path retries
+     * authentication, so the next call gets a fresh attempt.
+     */
+    get(name: string | undefined): Promise<TM1Client>;
+    /** Connection metadata for a resolved call (mode/version gates). */
+    resolveInfo(name: string | undefined): ConnectionInfo;
+    disconnectAll(): Promise<void>;
+}
+//# sourceMappingURL=connections.d.ts.map

package/dist/connections.js

@@ -0,0 +1,262 @@
+// Named TM1 connections served by ONE server process.
+//
+// Before v7 every TM1 connection was its own server: one `.env` per folder
+// under ~/.tm1/mcp-servers/, one process, one full copy of the tool list. With
+// N connections a client carried N × ~113 tool names in context every turn,
+// spawned N processes and held N sessions + keepalives open. The registry keeps
+// the same folders as the source of truth (they are also what the tm1-api
+// skill reads) but serves them all from one tool list: every tool takes a
+// `connection` argument, and each connection's TM1Client is built on first use.
+//
+// Selection:
+//   TM1_CONNECTIONS_DIR set          → discover that folder
+//   TM1_BASE_URL set (and no dir)    → legacy single connection "default"
+//   neither                          → discover ~/.tm1/mcp-servers
+// TM1_CONNECTIONS (comma-separated) narrows discovery to the named folders.
+//
+// Per connection, only the folder's own `.env` decides mode and version. Mode
+// defaults to readonly: a connection-level key (TM1_MODE, TM1_BASE_URL, …) in
+// the server's own environment is NOT inherited, so a TM1_MODE=readwrite in
+// the launching shell cannot silently arm every connection.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parse as parseDotenv } from "dotenv";
+import pino from "pino";
+import { connectionIdOf, loadConfig } from "./config.js";
+import { SessionManager } from "./session-manager.js";
+import { TM1Client } from "./tm1-client.js";
+import { TM1Error, TM1ErrorCode } from "./types.js";
+/** Settings that belong to the server process, not to one TM1 connection. */
+const SERVER_LEVEL_KEYS = new Set([
+    "TM1_LOG_LEVEL",
+    "TM1_LOG_FILE",
+    "TM1_RESPONSE_MODE",
+    "TM1_MAX_RESPONSE_CHARS",
+    "TM1_CONNECTIONS_DIR",
+    "TM1_CONNECTIONS",
+]);
+function isServerLevelKey(key) {
+    return SERVER_LEVEL_KEYS.has(key) || key.startsWith("TM1_MCP_");
+}
+export class ConnectionRegistry {
+    logger;
+    entries = new Map();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /** Discover connections from the environment (see the header comment). */
+    static fromEnvironment(env, logger) {
+        const registry = new ConnectionRegistry(logger);
+        const explicitDir = env.TM1_CONNECTIONS_DIR;
+        if (!explicitDir && env.TM1_BASE_URL) {
+            registry.addConfig("default", loadConfig(env));
+            return registry;
+        }
+        const dir = explicitDir || join(homedir(), ".tm1", "mcp-servers");
+        registry.discover(dir, env);
+        if (registry.entries.size === 0) {
+            throw new Error(`No TM1 connections found. Set TM1_BASE_URL (single connection) or ` +
+                `create <name>/.env folders under ${dir} (or point TM1_CONNECTIONS_DIR at them).`);
+        }
+        // Folders exist but none is usable: fail at startup with every reason,
+        // rather than serve tools whose `connection` enum is empty.
+        if (registry.usableNames.length === 0) {
+            const reasons = registry
+                .status()
+                .map((c) => `  ${c.name}: ${c.configError}`)
+                .join("\n");
+            throw new Error(`No usable TM1 connection under ${dir}:\n${reasons}`);
+        }
+        return registry;
+    }
+    /** Wrap one prebuilt client (tests, embedders). */
+    static single(client, logger = pino({ level: "silent" })) {
+        return ConnectionRegistry.of([{ name: "default", client }], logger);
+    }
+    /**
+     * Prebuilt clients under explicit names. The owner keeps the clients'
+     * lifecycle: disconnectAll() leaves them alone. Mode defaults to readwrite
+     * because the registration-time gate (TM1_MODE via withAnnotations) already
+     * decided what an embedder may call.
+     */
+    static of(clients, logger = pino({ level: "silent" })) {
+        const registry = new ConnectionRegistry(logger);
+        for (const { name, client, mode } of clients) {
+            registry.entries.set(name, {
+                info: {
+                    name,
+                    version: client.version,
+                    mode: mode ?? "readwrite",
+                    connectionId: client.connectionId,
+                },
+                client,
+            });
+        }
+        return registry;
+    }
+    addConfig(name, config, dir) {
+        this.entries.set(name, {
+            info: {
+                name,
+                dir,
+                mode: config.mode,
+                environment: config.environment,
+                modeReason: config.modeReason,
+                version: config.version,
+                tm1Version: config.tm1Version,
+                baseUrl: config.baseUrl,
+                connectionId: connectionIdOf(config),
+            },
+            config,
+        });
+    }
+    discover(dir, env) {
+        if (!existsSync(dir))
+            return;
+        const only = env.TM1_CONNECTIONS
+            ? new Set(env.TM1_CONNECTIONS.split(",")
+                .map((s) => s.trim())
+                .filter(Boolean))
+            : undefined;
+        // Server-level settings and non-TM1 variables (PATH, proxies) carry over;
+        // connection-level TM1_* keys come from the folder only.
+        const base = {};
+        for (const [key, value] of Object.entries(env)) {
+            if (!key.startsWith("TM1_") || isServerLevelKey(key))
+                base[key] = value;
+        }
+        const names = readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && existsSync(join(dir, d.name, ".env")))
+            .map((d) => d.name)
+            .filter((name) => !only || only.has(name))
+            .sort((a, b) => a.localeCompare(b));
+        for (const name of names) {
+            const folder = join(dir, name);
+            try {
+                const fileEnv = parseDotenv(readFileSync(join(folder, ".env")));
+                const connEnv = { ...base };
+                for (const [key, value] of Object.entries(fileEnv)) {
+                    // The folder may not override server-level settings: one folder's
+                    // TM1_MCP_TRANSPORT must not reconfigure the whole process.
+                    if (!isServerLevelKey(key))
+                        connEnv[key] = value;
+                }
+                this.addConfig(name, loadConfig(connEnv), folder);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.logger.warn({ connection: name, err: message }, "skipping connection");
+                this.entries.set(name, {
+                    info: { name, dir: folder, configError: message },
+                });
+            }
+        }
+    }
+    /** Every connection name, including ones whose config failed to load. */
+    get names() {
+        return [...this.entries.keys()];
+    }
+    /** Connections that can actually be used. */
+    get usableNames() {
+        return [...this.entries.values()]
+            .filter((e) => e.config || e.client)
+            .map((e) => e.info.name);
+    }
+    /** True when tools should not expose a `connection` argument at all. */
+    get isSingle() {
+        return this.usableNames.length === 1;
+    }
+    get anyReadwrite() {
+        return [...this.entries.values()].some((e) => e.info.mode === "readwrite");
+    }
+    hasVersion(version) {
+        return [...this.entries.values()].some((e) => e.info.version === version);
+    }
+    /** A client exists and is not mid-login. Never triggers a login itself. */
+    isConnected(name) {
+        const entry = this.entries.get(name);
+        return entry?.client !== undefined && entry.connecting === undefined;
+    }
+    info(name) {
+        return this.entries.get(name)?.info;
+    }
+    status() {
+        return [...this.entries.values()].map((e) => ({
+            ...e.info,
+            connected: e.client !== undefined && e.connecting === undefined && !e.lastError,
+            lastError: e.lastError,
+        }));
+    }
+    /** Resolve a connection name (optional when there is only one). */
+    entryFor(name) {
+        if (name === undefined) {
+            if (this.isSingle)
+                return this.entries.get(this.usableNames[0]);
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `connection is required. One of: ${this.names.join(", ")}.`,
+            });
+        }
+        const entry = this.entries.get(name);
+        if (!entry) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `Unknown connection "${name}". One of: ${this.names.join(", ")}.`,
+            });
+        }
+        if (entry.info.configError) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `Connection "${name}" is misconfigured: ${entry.info.configError}`,
+            });
+        }
+        return entry;
+    }
+    /**
+     * The client for a connection, built and logged in on first use. A failed
+     * login does not poison the entry: the client's own request path retries
+     * authentication, so the next call gets a fresh attempt.
+     */
+    async get(name) {
+        const entry = this.entryFor(name);
+        if (!entry.client) {
+            const config = entry.config;
+            const logger = this.logger.child({ connection: entry.info.name });
+            const sessionManager = new SessionManager(config, logger);
+            entry.client = new TM1Client(config, sessionManager, logger);
+            entry.connecting = entry.client
+                .connect()
+                .then(() => {
+                entry.lastError = undefined;
+            })
+                .catch((err) => {
+                entry.lastError = err instanceof Error ? err.message : String(err);
+                logger.warn({ err }, "initial TM1 connection failed — will retry on request");
+            })
+                .finally(() => {
+                entry.connecting = undefined;
+            });
+        }
+        if (entry.connecting)
+            await entry.connecting;
+        return entry.client;
+    }
+    /** Connection metadata for a resolved call (mode/version gates). */
+    resolveInfo(name) {
+        return this.entryFor(name).info;
+    }
+    async disconnectAll() {
+        await Promise.all([...this.entries.values()].map(async (e) => {
+            if (!e.client || !e.config)
+                return; // prebuilt clients are the owner's
+            try {
+                await e.client.disconnect();
+            }
+            catch (err) {
+                this.logger.error({ err, connection: e.info.name }, "disconnect failed");
+            }
+        }));
+    }
+}
+//# sourceMappingURL=connections.js.map

package/dist/http-transport.d.ts

@@ -1,8 +1,8 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type pino from "pino";
-import type { TM1Config } from "./config.js";
+import type { ServerSettings } from "./config.js";
 export declare function startHttpTransport(buildServer: () => {
     server: McpServer;
     dispose: () => void;
-}, config: TM1Config, logger: pino.Logger): Promise<() => Promise<void>>;
+}, config: ServerSettings, logger: pino.Logger): Promise<() => Promise<void>>;
 //# sourceMappingURL=http-transport.d.ts.map