@databrainhq/mcp-server 0.3.0-rc.1 → 0.3.0-rc.11

package/dist/chunk-RHK62ZJ6.js

@@ -0,0 +1,884 @@
+#!/usr/bin/env node
+import {
+  isId,
+  readTemplateFiles,
+  validateManifest
+} from "./chunk-Q5EYDKSA.js";
+
+// src/utils/errors.ts
+var DatabrainApiError = class extends Error {
+  constructor(status, code, message, details, serverHint, retryable) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.serverHint = serverHint;
+    this.retryable = retryable;
+    this.name = "DatabrainApiError";
+  }
+  toToolResponse() {
+    const parts = [`Error: ${this.message}`];
+    const detailDump = this.formatDetails();
+    if (detailDump) parts.push(detailDump);
+    const hint = this.serverHint ? `Hint: ${this.serverHint}` : this.hint();
+    if (hint) parts.push(hint);
+    return {
+      content: [{ type: "text", text: parts.join("\n\n") }],
+      isError: true
+    };
+  }
+  /**
+   * Surface API-returned details for 4xx errors so the LLM can recover or
+   * report the real reason (validation messages, field names, etc.). Skips
+   * fields already collapsed into `message`/`code`, and skips 5xx where the
+   * payload usually isn't actionable.
+   */
+  formatDetails() {
+    if (this.status < 400 || this.status >= 500) return "";
+    if (!this.details || typeof this.details !== "object") return "";
+    const skipKeys = /* @__PURE__ */ new Set(["message", "detail", "error", "code", "data", "hint", "retryable"]);
+    const extra = {};
+    for (const [k, v] of Object.entries(this.details)) {
+      if (skipKeys.has(k)) continue;
+      if (v === null || v === void 0) continue;
+      extra[k] = v;
+    }
+    if (Object.keys(extra).length === 0) return "";
+    try {
+      return `API details: ${JSON.stringify(extra)}`;
+    } catch {
+      return "";
+    }
+  }
+  hint() {
+    if (this.code === "OAUTH_SIGN_IN_REQUIRED") {
+      return "Hint: Snapshots draw as a signed-in Databrain user. Connect this AI app with a Databrain sign-in (the hosted connector, or /mcp in Claude Code); a service token cannot take them.";
+    }
+    if (this.code === "RENDER_IN_PROGRESS") {
+      return "Hint: Your other snapshot is still rendering. Wait a few seconds, then call the tool again.";
+    }
+    if (this.code === "SNAPSHOT_TIMEOUT" || this.code === "SNAPSHOT_TOO_LARGE") {
+      return "Hint: Ask for one chart with metricId, or a smaller width.";
+    }
+    if (this.code === "UNAUTHORIZED_ORIGIN") {
+      return "Hint: The embed origin is not on the allowed domains list. Add the domain to the allowed domains in the Databrain settings; the token itself is fine.";
+    }
+    if (this.status === 401 || this.status === 403) {
+      if (this.code === "OAUTH_API_ERROR") {
+        return "Hint: Check that the backend accepts the configured OAuth issuer and resource, and that the service principal has permission for this operation. Static fallback applies only to token acquisition failures.";
+      }
+      if (this.code === "INVALID_SERVICE_TOKEN" || this.code === "MISSING_SERVICE_TOKEN" || this.message.toLowerCase().includes("service token")) {
+        return "Hint: The service token (DATABRAIN_SERVICE_TOKEN) is invalid, expired, or missing. It must be set in the MCP server config (not at runtime). Check Settings > Service Tokens in the Databrain UI.";
+      }
+      return "Hint: The per-data-app API token is invalid or expired. Use `create_api_token` to generate a new one. Do not ask the user \u2014 manage tokens via MCP tools.";
+    }
+    if (this.status === 400) {
+      return "Hint: The request was invalid. Check parameter values match expected types and formats. Use the corresponding list tool to verify IDs and names.";
+    }
+    if (this.status === 404) {
+      return "Hint: The requested resource was not found. Verify the ID or name is correct using the corresponding list tool.";
+    }
+    if (this.status === 409) {
+      return "Hint: A resource with this name already exists. Use a different name or list existing resources first.";
+    }
+    if (this.status === 422) {
+      return "Hint: The request parameters are invalid. Check the required fields and their formats.";
+    }
+    if (this.status === 429) {
+      return "Hint: API rate limit reached. Wait a moment and try again.";
+    }
+    if (this.status >= 500) {
+      return "Hint: The Databrain API is experiencing issues. Try again in a few moments.";
+    }
+    return "";
+  }
+};
+function toolError(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function toolSuccess(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+
+// src/utils/logger.ts
+var LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+var currentLevel = process.env.DATABRAIN_LOG_LEVEL || "warn";
+var secrets = /* @__PURE__ */ new Set();
+function registerSecret(value) {
+  if (typeof value === "string" && value.length >= 8) secrets.add(value);
+}
+function redactSecrets(text) {
+  let out = text;
+  for (const secret of secrets) out = out.split(secret).join("[redacted]");
+  return out;
+}
+function log(level, message, data) {
+  if (LOG_LEVELS[level] < LOG_LEVELS[currentLevel]) return;
+  const line = `[databrain-mcp] [${level.toUpperCase()}] ${message}`;
+  const text = data !== void 0 ? `${line} ${JSON.stringify(data)}` : line;
+  process.stderr.write(`${redactSecrets(text)}
+`);
+}
+var logger = {
+  debug: (msg, data) => log("debug", msg, data),
+  info: (msg, data) => log("info", msg, data),
+  warn: (msg, data) => log("warn", msg, data),
+  error: (msg, data) => log("error", msg, data)
+};
+
+// package.json
+var package_default = {
+  name: "@databrainhq/mcp-server",
+  mcpName: "com.usedatabrain/mcp-server",
+  version: "0.3.0-rc.11",
+  description: "MCP server for Databrain embedded analytics - connect databases, create datamarts, configure embeds, and generate frontend code",
+  type: "module",
+  bin: {
+    "mcp-server": "dist/index.js",
+    "databrain-mcp-server": "dist/index.js",
+    "databrain-mcp-chart-apps": "dist/apps/stdio.js",
+    databrain: "dist/cli.js"
+  },
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  files: [
+    "dist",
+    "skills",
+    ".claude-plugin",
+    ".mcp.json"
+  ],
+  scripts: {
+    build: "tsup && node scripts/copy-custom-chart-assets.mjs",
+    dev: "tsx src/index.ts",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:live": "vitest run tests/integration/prompt-flows.test.ts",
+    lint: "tsc --noEmit",
+    prepublishOnly: "npm run build"
+  },
+  keywords: [
+    "mcp",
+    "databrain",
+    "embedded-analytics",
+    "ai",
+    "model-context-protocol"
+  ],
+  license: "MIT",
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@posthog/mcp": "^0.10.7",
+    esbuild: "0.27.3",
+    fflate: "0.8.3",
+    "posthog-node": "^5.21.2",
+    yaml: "^2.9.1",
+    zod: "^3.24.0"
+  },
+  devDependencies: {
+    "@types/node": "^25.3.5",
+    tsup: "^8.4.0",
+    tsx: "^4.19.0",
+    typescript: "^5.7.0",
+    vitest: "^3.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/databrainhq/mcp-server.git"
+  },
+  engines: {
+    node: ">=18.0.0"
+  }
+};
+
+// src/version.ts
+var MCP_SERVER_VERSION = package_default.version;
+
+// src/custom-chart/studio.ts
+import { z } from "zod";
+var studioCell = z.union([z.string().max(4096), z.number().finite(), z.boolean(), z.null()]);
+var studioDraftSchema = z.object({
+  code: z.string().max(64e3),
+  css: z.string().max(32e3),
+  manifest: z.record(z.unknown()),
+  sampleData: z.object({
+    columns: z.array(z.object({
+      id: z.string(),
+      label: z.string(),
+      type: z.enum(["string", "number", "boolean"]),
+      slotId: z.string().optional()
+    }).strict()).max(64),
+    rows: z.array(z.array(studioCell)).max(200)
+  }).strict(),
+  name: z.string().max(256),
+  description: z.string().max(500),
+  iconSvg: z.string().max(16384)
+}).strict();
+function parseStudioStream(text) {
+  if (text.length > 4 * 1024 * 1024) throw new Error("Studio stream too large");
+  let draft;
+  let sessionId;
+  let failure = false;
+  for (const frame of text.split(/\r?\n\r?\n/)) {
+    const line = frame.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart()).join("\n");
+    if (!line || line === "[DONE]") continue;
+    const event = JSON.parse(line);
+    if (event.type === "session" && typeof event.sessionId === "string") sessionId = event.sessionId;
+    if (event.type === "error") failure = true;
+    if (event.type === "tool_execution_end" && event.name === "update_custom_chart" && event.status === "completed" && event.result?.kind === "applied") {
+      draft = studioDraftSchema.parse(event.result.draft);
+    }
+  }
+  if (failure && !draft) throw new Error("Bryn did not complete an edit");
+  return { draft, sessionId, applied: !!draft };
+}
+async function editWithBryn(client, input) {
+  if (!client.isHosted()) return { available: false, draft: input.draft, applied: false };
+  try {
+    const result = await client.request({
+      method: "POST",
+      path: `/api/v2/custom-charts/${encodeURIComponent(input.key)}/bryn/turn`,
+      auth: "service",
+      body: {
+        workspaceId: input.workspaceId,
+        message: input.message,
+        draft: input.draft,
+        sessionId: input.sessionId,
+        mode: "build",
+        viewingOldVersion: false
+      },
+      responseFormat: "studio-sse",
+      timeoutMs: 18e4,
+      noRetryOnTimeout: true
+    });
+    return { available: true, draft: result.draft ?? input.draft, applied: result.applied, sessionId: result.sessionId };
+  } catch (error) {
+    if (error instanceof DatabrainApiError && error.status === 404) {
+      return { available: false, draft: input.draft, applied: false };
+    }
+    throw error;
+  }
+}
+
+// src/utils/cache.ts
+var TtlCache = class {
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(key, value, ttlMs) {
+    this.store.set(key, { value, expiresAt: Date.now() + ttlMs });
+  }
+  invalidateByPrefix(prefix) {
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) {
+        this.store.delete(key);
+      }
+    }
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/client/error-body.ts
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var str = (v) => typeof v === "string" && v.trim() ? v : void 0;
+var fromEnvelope = (v) => {
+  if (!isRecord(v)) return void 0;
+  const out = {
+    code: str(v.code),
+    message: str(v.message) ?? str(v.detail),
+    hint: str(v.hint),
+    retryable: typeof v.retryable === "boolean" ? v.retryable : void 0,
+    details: v.details
+  };
+  return out.code || out.message || out.hint ? out : void 0;
+};
+function parseErrorBody(body) {
+  if (!isRecord(body)) return {};
+  const nested = fromEnvelope(isRecord(body.data) ? body.data.error : void 0) ?? fromEnvelope(body.error) ?? fromEnvelope(body);
+  if (nested) {
+    return { ...nested, message: nested.message ?? str(body.error) };
+  }
+  return { message: str(body.error) };
+}
+
+// src/utils/tool-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var toolContext = new AsyncLocalStorage();
+
+// src/client/oauth-client-credentials.ts
+import { z as z2 } from "zod";
+var oauthHttpsUrl = z2.string().refine((value) => {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password && !url.hash;
+  } catch {
+    return false;
+  }
+}, "OAuth URLs must use HTTPS without userinfo or fragments");
+var oauthConfigSchema = z2.object({
+  issuer: oauthHttpsUrl.refine((value) => {
+    try {
+      return !new URL(value).search;
+    } catch {
+      return false;
+    }
+  }, "OAuth issuer must not contain a query"),
+  clientId: z2.string().min(1),
+  clientSecret: z2.string().min(1),
+  resource: oauthHttpsUrl,
+  scope: z2.string().min(1).optional(),
+  authMethod: z2.enum(["client_secret_basic", "client_secret_post"]).default("client_secret_basic")
+});
+var metadataSchema = z2.object({
+  issuer: z2.string(),
+  token_endpoint: oauthHttpsUrl,
+  token_endpoint_auth_methods_supported: z2.array(z2.string()).optional(),
+  grant_types_supported: z2.array(z2.string()).optional()
+});
+var tokenSchema = z2.object({
+  access_token: z2.string().regex(/^[A-Za-z0-9\-._~+/]+=*$/),
+  token_type: z2.string().refine((value) => value.toLowerCase() === "bearer"),
+  expires_in: z2.number().finite().positive().optional()
+});
+var TOKEN_TIMEOUT_MS = 1e4;
+var FAILURE_COOLDOWN_MS = 3e4;
+var MAX_REFRESH_SKEW_MS = 6e4;
+function authError() {
+  return new Error("OAuth token acquisition failed. Check the configured issuer, client credentials, resource and scopes.");
+}
+var OAuthClientCredentials = class {
+  config;
+  tokenEndpoint;
+  cached;
+  pending;
+  retryAt = 0;
+  constructor(config) {
+    const parsed = oauthConfigSchema.safeParse(config);
+    if (!parsed.success) throw authError();
+    this.config = Object.freeze(parsed.data);
+  }
+  getStatus() {
+    if (this.cached && Date.now() < this.cached.renewAt) return "ready";
+    if (this.retryAt > 0) return "unavailable";
+    return "configured";
+  }
+  async getToken() {
+    if (this.cached && Date.now() < this.cached.renewAt) return this.cached.value;
+    if (this.pending) return this.pending;
+    if (Date.now() < this.retryAt) throw authError();
+    this.cached = void 0;
+    this.pending = this.acquire().catch(() => {
+      this.retryAt = Date.now() + FAILURE_COOLDOWN_MS;
+      throw authError();
+    }).finally(() => {
+      this.pending = void 0;
+    });
+    return this.pending;
+  }
+  async discoverTokenEndpoint(signal) {
+    if (this.tokenEndpoint) return this.tokenEndpoint;
+    const issuer = new URL(this.config.issuer);
+    const path = issuer.pathname.replace(/\/$/, "");
+    const candidates = [.../* @__PURE__ */ new Set([
+      `${issuer.origin}/.well-known/oauth-authorization-server${path}`,
+      `${issuer.origin}/.well-known/openid-configuration${path}`,
+      `${issuer.origin}${path}/.well-known/openid-configuration`
+    ])];
+    for (const url of candidates) {
+      const response = await fetch(url, {
+        headers: { Accept: "application/json" },
+        redirect: "error",
+        signal
+      });
+      if (response.status === 404 || response.status === 405) continue;
+      if (!response.ok) throw authError();
+      const metadata = metadataSchema.parse(await response.json());
+      if (metadata.issuer !== this.config.issuer) throw authError();
+      const methods = metadata.token_endpoint_auth_methods_supported ?? ["client_secret_basic"];
+      if (!methods.includes(this.config.authMethod)) throw authError();
+      if (metadata.grant_types_supported && !metadata.grant_types_supported.includes("client_credentials")) {
+        throw authError();
+      }
+      this.tokenEndpoint = metadata.token_endpoint;
+      return this.tokenEndpoint;
+    }
+    throw authError();
+  }
+  async acquire() {
+    const signal = AbortSignal.timeout(TOKEN_TIMEOUT_MS);
+    const endpoint = await this.discoverTokenEndpoint(signal);
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      resource: this.config.resource
+    });
+    if (this.config.scope) body.set("scope", this.config.scope);
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/x-www-form-urlencoded"
+    };
+    if (this.config.authMethod === "client_secret_post") {
+      body.set("client_id", this.config.clientId);
+      body.set("client_secret", this.config.clientSecret);
+    } else {
+      const encode = (value) => new URLSearchParams({ value }).toString().slice(6);
+      headers.Authorization = `Basic ${Buffer.from(`${encode(this.config.clientId)}:${encode(this.config.clientSecret)}`).toString("base64")}`;
+    }
+    const startedAt = Date.now();
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: body.toString(),
+      redirect: "error",
+      signal
+    });
+    if (!response.ok) throw authError();
+    const token = tokenSchema.parse(await response.json());
+    if (token.expires_in !== void 0) {
+      const lifetimeMs = token.expires_in * 1e3;
+      const expiresAt = startedAt + lifetimeMs;
+      if (!Number.isFinite(expiresAt) || Date.now() >= expiresAt) throw authError();
+      this.cached = {
+        value: token.access_token,
+        renewAt: expiresAt - Math.min(MAX_REFRESH_SKEW_MS, lifetimeMs * 0.1)
+      };
+    }
+    this.retryAt = 0;
+    return token.access_token;
+  }
+};
+
+// src/client/databrain-client.ts
+var MCP_USER_AGENT = `databrain-mcp-server/${MCP_SERVER_VERSION}`;
+var MAX_RETRIES = 3;
+var REQUEST_TIMEOUT_MS = 3e4;
+var NON_TRANSIENT_PATTERNS = [
+  "out of context",
+  "Definition not found",
+  "not a data question",
+  "Query generation failed",
+  "not found",
+  "not authenticated",
+  "Invalid Service Token",
+  "service token"
+];
+var DatabrainClient = class {
+  constructor(config) {
+    this.config = config;
+    registerSecret(config.serviceToken);
+    registerSecret(config.apiToken);
+    if (config.oauth) {
+      if (!oauthHttpsUrl.safeParse(config.apiUrl).success) {
+        throw new Error("OAuth requires an HTTPS Databrain API URL without userinfo or fragments.");
+      }
+      this.oauth = new OAuthClientCredentials(config.oauth);
+      this.config = Object.freeze({ ...config });
+    }
+  }
+  cache = new TtlCache();
+  runtimeApiToken;
+  oauth;
+  oauthFallback = false;
+  hasApiToken() {
+    return !!(this.runtimeApiToken || this.config.apiToken);
+  }
+  /** The hosted composition supplies a signed-in identity, unlike local API credentials. */
+  isHosted() {
+    return false;
+  }
+  setRuntimeApiToken(token) {
+    registerSecret(token);
+    this.runtimeApiToken = token;
+    logger.info("Runtime API token set for this session");
+  }
+  getServiceToken() {
+    return this.config.serviceToken;
+  }
+  getApiUrl() {
+    return this.config.apiUrl;
+  }
+  getDemoDomain() {
+    return this.config.demoDomain;
+  }
+  /**
+   * Describes which credential is currently used as the bearer for outgoing
+   * API calls. Used by `whoami` so the LLM can give the user a truthful answer.
+   */
+  getActiveAuth() {
+    if (this.oauth) {
+      if (this.oauthFallback) return { source: "service-token", oauthFallback: true };
+      return { source: "oauth-client-credentials", status: this.oauth.getStatus() };
+    }
+    if (this.config.serviceToken) return { source: "service-token" };
+    if (this.runtimeApiToken || this.config.apiToken) return { source: "api-token" };
+    return { source: "none" };
+  }
+  async getToken(auth) {
+    if (auth === "none") return void 0;
+    if (auth === "service") {
+      if (this.oauth) {
+        try {
+          const token = await this.oauth.getToken();
+          this.oauthFallback = false;
+          return token;
+        } catch {
+          if (!this.config.serviceToken) {
+            throw new DatabrainApiError(
+              0,
+              "OAUTH_TOKEN_ERROR",
+              "OAuth token acquisition failed. Check the configured issuer, client credentials, resource and scopes."
+            );
+          }
+          if (!this.oauthFallback) logger.warn("OAuth unavailable; using the configured static service token.");
+          this.oauthFallback = true;
+        }
+      }
+      return this.config.serviceToken;
+    }
+    return this.runtimeApiToken || this.config.apiToken;
+  }
+  async request(options) {
+    return this.requestInternal(options);
+  }
+  async requestInternal(options) {
+    const usesOAuth = !!this.oauth && options.auth === "service" && !options.token;
+    const cacheAllowed = !usesOAuth;
+    if (options.invalidateCache) {
+      for (const prefix of options.invalidateCache) {
+        this.cache.invalidateByPrefix(prefix);
+      }
+    }
+    if (cacheAllowed && options.cacheKey && options.cacheTtlMs) {
+      const cached = this.cache.get(options.cacheKey);
+      if (cached !== void 0) {
+        logger.debug(`Cache hit: ${options.cacheKey}`);
+        return cached;
+      }
+    }
+    let token = options.token ?? await this.getToken(options.auth);
+    if (options.auth !== "none" && !options.token && !token) {
+      if (options.auth === "service") {
+        throw new DatabrainApiError(
+          401,
+          "MISSING_SERVICE_TOKEN",
+          "DATABRAIN_SERVICE_TOKEN is required for this operation (org-level token for discovery and data app management). It must be set in the MCP server configuration \u2014 do not ask the user for it at runtime."
+        );
+      }
+      throw new DatabrainApiError(
+        401,
+        "MISSING_API_TOKEN",
+        "A per-data-app API token is required for this embedding operation but none is configured. Call `create_api_token` to generate one, or `set_api_token` if you already have the value. Do not ask the user for this token \u2014 create it via the MCP tools."
+      );
+    }
+    let url = `${this.config.apiUrl}${options.path}`;
+    if (options.query) {
+      const params = new URLSearchParams(options.query);
+      url += `?${params.toString()}`;
+    }
+    let lastError;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        if (usesOAuth && attempt > 1) token = await this.getToken(options.auth);
+        const headers = {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "User-Agent": MCP_USER_AGENT,
+          "X-Databrain-Client": MCP_USER_AGENT,
+          ...options.headers
+        };
+        const ctx = toolContext.getStore();
+        if (ctx) {
+          headers["X-Databrain-MCP-Tool"] = ctx.tool;
+          headers["X-Databrain-MCP-Tool-Category"] = ctx.category;
+          headers["X-Databrain-MCP-Workflow-Intent"] = ctx.workflowIntent;
+          headers["X-Databrain-MCP-Input-Mode"] = ctx.inputMode;
+        }
+        if (token) {
+          if (options.auth === "none") {
+            headers["x-plugin-token"] = token;
+            headers["Origin"] = "https://mcp.usedatabrain.com";
+          } else {
+            headers["Authorization"] = `Bearer ${token}`;
+          }
+        }
+        const response = await fetch(url, {
+          method: options.method,
+          headers,
+          body: options.body ? JSON.stringify(options.body) : void 0,
+          signal: AbortSignal.timeout(options.timeoutMs || REQUEST_TIMEOUT_MS),
+          ...usesOAuth ? { redirect: "error" } : {}
+        });
+        if (!response.ok) {
+          if (usesOAuth) {
+            throw new DatabrainApiError(
+              response.status,
+              "OAUTH_API_ERROR",
+              `Databrain API request failed with status ${response.status} using configured service credentials.`
+            );
+          }
+          const errorBody = await response.text();
+          logger.warn(`[API Error] ${options.method} ${options.path} status=${response.status} body=${errorBody.slice(0, 500)}`);
+          let parsed = {};
+          try {
+            parsed = JSON.parse(errorBody);
+          } catch {
+          }
+          const envelope = parseErrorBody(parsed);
+          const errorMsg = envelope.message || `API request failed with status ${response.status}`;
+          const error = new DatabrainApiError(
+            response.status,
+            envelope.code || `HTTP_${response.status}`,
+            errorMsg,
+            parsed,
+            envelope.hint,
+            envelope.retryable
+          );
+          const isTransient = envelope.retryable !== void 0 ? envelope.retryable && (response.status === 429 || response.status >= 500) : response.status === 429 || response.status >= 500 && !NON_TRANSIENT_PATTERNS.some((p) => errorMsg.includes(p));
+          if (isTransient && attempt < MAX_RETRIES) {
+            const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 8e3);
+            logger.warn(`Retrying in ${delay}ms (attempt ${attempt}/${MAX_RETRIES})`, {
+              status: response.status,
+              path: options.path
+            });
+            await new Promise((r) => setTimeout(r, delay));
+            lastError = error;
+            continue;
+          }
+          throw error;
+        }
+        const text = await response.text();
+        let data = options.responseFormat === "studio-sse" ? parseStudioStream(text) : text ? JSON.parse(text) : {};
+        if (!options.skipDataUnwrap && data && typeof data === "object" && !Array.isArray(data) && "data" in data) {
+          const inner = data.data;
+          if (inner !== null && inner !== void 0) {
+            data = inner;
+          }
+        }
+        if (cacheAllowed && options.cacheKey && options.cacheTtlMs) {
+          this.cache.set(options.cacheKey, data, options.cacheTtlMs);
+        }
+        return data;
+      } catch (err) {
+        if (err instanceof DatabrainApiError) throw err;
+        if (attempt < MAX_RETRIES && err?.name === "TimeoutError" && !options.noRetryOnTimeout) {
+          const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 8e3);
+          logger.warn(`Request timed out, retrying in ${delay}ms`, { path: options.path });
+          await new Promise((r) => setTimeout(r, delay));
+          lastError = err;
+          continue;
+        }
+        throw new DatabrainApiError(
+          0,
+          "NETWORK_ERROR",
+          usesOAuth ? "Failed to connect to Databrain API using configured service credentials." : `Failed to connect to Databrain API: ${err.message}`
+        );
+      }
+    }
+    throw lastError || new DatabrainApiError(0, "UNKNOWN", "Request failed after retries");
+  }
+};
+
+// src/api/custom-charts-api.ts
+var CUSTOM_CHARTS_PATH = "/api/mcp/custom-charts";
+var LIST_CACHE_KEY = "list_custom_charts";
+var encodeKey = (key) => encodeURIComponent(key);
+var CustomChartsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const response = await this.client.request({
+      method: "GET",
+      path: CUSTOM_CHARTS_PATH,
+      auth: "service",
+      cacheKey: LIST_CACHE_KEY,
+      cacheTtlMs: 3e4
+    });
+    if (Array.isArray(response)) return response;
+    return Array.isArray(response?.charts) ? response.charts : [];
+  }
+  async get(key) {
+    const response = await this.client.request({
+      method: "GET",
+      path: `${CUSTOM_CHARTS_PATH}/${encodeKey(key)}`,
+      auth: "service"
+    });
+    const wrapped = response;
+    return wrapped.chart ? wrapped.chart : response;
+  }
+  /** Never persists. The server repeats every client side check. */
+  async validate(body) {
+    const response = await this.client.request({
+      method: "POST",
+      path: `${CUSTOM_CHARTS_PATH}/validate`,
+      auth: "service",
+      body,
+      timeoutMs: 6e4
+    });
+    return {
+      ok: response.ok === true,
+      problems: Array.isArray(response.problems) ? response.problems : [],
+      contentHash: response.contentHash,
+      sizeBytes: response.sizeBytes
+    };
+  }
+  /** Creates the chart (first upload) or a preview version; idempotent on contentHash. */
+  async upload(body) {
+    return this.client.request({
+      method: "POST",
+      path: CUSTOM_CHARTS_PATH,
+      auth: "service",
+      body,
+      timeoutMs: 6e4,
+      invalidateCache: [LIST_CACHE_KEY]
+    });
+  }
+  async bundle(key, versionId) {
+    return this.client.request({
+      method: "GET",
+      path: `${CUSTOM_CHARTS_PATH}/${encodeKey(key)}/versions/${encodeURIComponent(versionId)}/bundle`,
+      auth: "service"
+    });
+  }
+  async publish(key, versionId) {
+    return this.client.request({
+      method: "POST",
+      path: `${CUSTOM_CHARTS_PATH}/${encodeKey(key)}/publish`,
+      auth: "service",
+      body: versionId ? { versionId } : {},
+      invalidateCache: [LIST_CACHE_KEY]
+    });
+  }
+  async discardPreview(key) {
+    return this.client.request({
+      method: "POST",
+      path: `${CUSTOM_CHARTS_PATH}/${encodeKey(key)}/discard-preview`,
+      auth: "service",
+      body: {},
+      invalidateCache: [LIST_CACHE_KEY]
+    });
+  }
+};
+
+// src/custom-chart/api.ts
+function createCustomChartsApi(client) {
+  return new CustomChartsApi(client);
+}
+function apiProblems(err) {
+  if (!(err instanceof DatabrainApiError)) return [];
+  const details = err.details;
+  const list = details?.error?.problems ?? details?.problems;
+  if (!Array.isArray(list)) return [];
+  return list.filter(
+    (item) => !!item && typeof item === "object" && typeof item.code === "string" && typeof item.message === "string"
+  );
+}
+function planUpload(key, existing, versionsKnown) {
+  if (!existing) {
+    return { action: "create chart", key, nextVersionNumber: 1, summary: `will create chart custom:${key} (version 1, status private)` };
+  }
+  const count = typeof versionsKnown === "number" ? versionsKnown : typeof existing.versionsCount === "number" ? existing.versionsCount : void 0;
+  const next = count !== void 0 ? count + 1 : NaN;
+  const label = Number.isFinite(next) ? `version ${next}` : "the next version";
+  return {
+    action: "create version",
+    key,
+    existing,
+    nextVersionNumber: Number.isFinite(next) ? next : 0,
+    summary: `will create ${label} of custom:${key} in preview (status stays ${existing.status}; the published version keeps serving until you publish)`
+  };
+}
+
+// src/custom-chart/scaffold.ts
+var DEFAULT_SLOTS = [
+  { id: "category", label: "Category", role: "dimension", types: ["string"], required: true, description: "One bar per value." },
+  { id: "value", label: "Value", role: "measure", types: ["number"], required: true },
+  { id: "target", label: "Target", role: "measure", types: ["number"], required: false }
+];
+function scaffoldProject(input) {
+  const template = readTemplateFiles();
+  const templateManifest = JSON.parse(template["manifest.json"]);
+  const problems = [];
+  if (!isId(input.key)) {
+    problems.push({
+      code: "manifest.id.invalid",
+      path: "/id",
+      message: "key must match ^[a-z][a-z0-9_-]{0,63}$ (lowercase letters, digits, _ and -)."
+    });
+  }
+  const name = typeof input.name === "string" ? input.name.trim() : "";
+  if (name.length === 0 || name.length > 256) {
+    problems.push({ code: "manifest.name.invalid", path: "/name", message: "name must be 1 to 256 characters." });
+  }
+  const manifest = {
+    schemaVersion: 2,
+    id: input.key,
+    name,
+    version: "1.0.0",
+    ...input.description ? { description: input.description } : {},
+    slots: input.slots && input.slots.length > 0 ? input.slots : templateManifest.slots ?? DEFAULT_SLOTS,
+    options: input.options ?? templateManifest.options
+  };
+  problems.push(...validateManifest(manifest));
+  const packageJson = JSON.parse(template["package.json"]);
+  packageJson.name = input.key;
+  const files = {};
+  for (const [file, content] of Object.entries(template)) {
+    if (file === "manifest.json") files[file] = JSON.stringify(manifest, null, 2) + "\n";
+    else if (file === "package.json") files[file] = JSON.stringify(packageJson, null, 2) + "\n";
+    else files[file] = content;
+  }
+  return {
+    ok: problems.length === 0,
+    problems,
+    files,
+    nextStep: "Write these files into a folder, edit chart.ts, then run `databrain custom-chart validate` and `databrain custom-chart build`. Upload with `databrain custom-chart upload` or the custom_chart_upload tool."
+  };
+}
+
+export {
+  oauthHttpsUrl,
+  oauthConfigSchema,
+  DatabrainApiError,
+  toolError,
+  stringify,
+  toolSuccess,
+  studioDraftSchema,
+  parseStudioStream,
+  editWithBryn,
+  registerSecret,
+  redactSecrets,
+  logger,
+  parseErrorBody,
+  MCP_SERVER_VERSION,
+  toolContext,
+  DatabrainClient,
+  CustomChartsApi,
+  createCustomChartsApi,
+  apiProblems,
+  planUpload,
+  scaffoldProject
+};
+//# sourceMappingURL=chunk-RHK62ZJ6.js.map