@nuvlore/extension-bds 0.1.1

package/tools/bds_chef_client_log_read.mjs

@@ -0,0 +1,23 @@
+export const description = "Read Chef client logs from a private-cloud host through the approved Boundary sudo read tool.";
+
+import { createPrivateCloudLogReadTool, fixedPrivateLogSpec } from "../src/bds-atomic-log-tools.mjs";
+
+const spec = fixedPrivateLogSpec({
+  toolName: "bds_chef_client_log_read",
+  description: "Read Chef client logs from a private-cloud host through the approved Boundary sudo read tool.",
+  path: "/var/log/chef/client.log"
+});
+
+export const __test = spec;
+
+const sharedTool = createPrivateCloudLogReadTool(spec);
+
+export default {
+  name: sharedTool.name,
+  description,
+  inputSchema: sharedTool.inputSchema,
+  meta: sharedTool.meta,
+  annotations: sharedTool.annotations,
+  invoke: sharedTool.invoke,
+  handler: sharedTool.handler
+};

package/tools/bds_dashboard_links.mjs

@@ -0,0 +1,178 @@
+export const description = "Build BDS Grafana, Pharos alerting, silence, and Solas links from alert labels such as alertname, source, and bds_cluster.";
+
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+
+const dashboards = {
+  cluster: { uid: "iQhYywmVz", slug: "bds-clusters", title: "BDS Clusters" },
+  datanode: { uid: "Bp5q5ixVz", slug: "bds-datanode", title: "BDS Datanode" },
+  hdfs: { uid: "ysSId274z", slug: "bds-hdfs", title: "BDS HDFS" },
+  yarn: { uid: "HnpfOgV4z", slug: "bds-yarn", title: "BDS YARN" },
+  namenode: { uid: "XPkK8QmVa", slug: "bds-namenode", title: "BDS Namenode" },
+  resourcemanager: { uid: "1U97nRG4z", slug: "bds-resourcemanager", title: "BDS Resourcemanager" },
+  nodemanager: { uid: "lD9rPZ-Vz", slug: "bds-nodemanager", title: "BDS Nodemanager" },
+  k8s: { uid: "AvFKfSfVk", slug: "bds-k8-dc", title: "BDS K8 DC" },
+  kms: { uid: "9kz5yk74z", slug: "bds-kms", title: "BDS KMS" },
+  zk: { uid: "TjGI3_a4k", slug: "bds-zookeeper", title: "BDS ZooKeeper" },
+  airflow: { uid: "lYJhbDY4z", slug: "bds-airflow", title: "BDS Airflow" },
+  spark: { uid: "-TvJPdnGz2", slug: "bds-spark-applications", title: "BDS Spark Applications" },
+  single_server: { uid: "u6xjOTK4k", slug: "inf-bds-single-server-dashboard", title: "INF BDS Single Server Dashboard" }
+};
+
+export class DashboardRecommendationRule {
+  constructor({ id, dashboards: recommended }) {
+    this.id = id;
+    this.dashboards = recommended;
+  }
+}
+
+export class DashboardRecommendationPolicy {
+  constructor(rules = [
+    new DashboardRecommendationRule({ id: "disk", dashboards: ["single_server", "datanode", "hdfs", "cluster"] }),
+    new DashboardRecommendationRule({ id: "yarn", dashboards: ["yarn", "resourcemanager", "nodemanager", "cluster"] }),
+    new DashboardRecommendationRule({ id: "kubernetes", dashboards: ["k8s", "cluster"] }),
+    new DashboardRecommendationRule({ id: "airflow", dashboards: ["airflow", "cluster"] }),
+    new DashboardRecommendationRule({ id: "spark", dashboards: ["spark", "yarn", "cluster"] }),
+  ], fallback = ["cluster", "single_server", "yarn", "hdfs", "k8s"]) {
+    this.rulesById = new Map(rules.map((rule) => [rule.id, rule]));
+    this.fallback = fallback;
+  }
+
+  recommend(domain = "") {
+    const rule = this.rulesById.get(domain);
+    return rule?.dashboards ?? this.fallback;
+  }
+}
+
+const dashboardRecommendationPolicy = new DashboardRecommendationPolicy();
+
+function grafanaHost(environment) {
+  if (environment === "dev") return "grafana.dev.wdpharos.io";
+  if (environment === "il4") return "grafana.pharos-metrics.workdaygovcloud.com";
+  return "grafana.produs.us.wdpharos.io";
+}
+
+function addCommonParams(url, input) {
+  url.searchParams.set("orgId", "1");
+  url.searchParams.set("from", input.from ?? "now-6h");
+  url.searchParams.set("to", input.to ?? "now");
+  if (input.refresh) url.searchParams.set("refresh", input.refresh);
+  if (input.cluster) url.searchParams.set("var-bds_cluster", input.cluster);
+  if (input.namespace) url.searchParams.set("var-namespace", input.namespace);
+  if (input.source) url.searchParams.set("var-source", input.source);
+  return url;
+}
+
+function dashboardUrl(environment, dashboard, input) {
+  const def = dashboards[dashboard];
+  const url = new URL(`https://${grafanaHost(environment)}/d/${def.uid}/${def.slug}`);
+  return addCommonParams(url, input).toString();
+}
+
+function alertRuleUrl(environment, alertName) {
+  const search = alertName
+    ? `datasource:Cortex label:pharos_namespace=bds ${alertName}`
+    : "datasource:Cortex label:pharos_namespace=bds";
+  const url = new URL(`https://${grafanaHost(environment)}/alerting/list`);
+  url.searchParams.set("search", search);
+  return url.toString();
+}
+
+function silenceUrl(environment, filters = []) {
+  const url = new URL(`https://${grafanaHost(environment)}/alerting/silences`);
+  if (filters.length) {
+    url.searchParams.set("queryString", filters.map((filter) => `${filter.key}=${filter.value}`).join(","));
+  }
+  return url.toString();
+}
+
+function solasUrl(input) {
+  const query = [
+    "server_type:bds",
+    input.cluster ? `server_role:${input.cluster}` : "",
+    input.source ? `hostname:${input.source}` : ""
+  ].filter(Boolean).join(" AND ");
+  const url = new URL("https://solas.workday.com/s/readonly/app/discover");
+  url.searchParams.set("query", query);
+  url.searchParams.set("from", input.from ?? "now-6h");
+  url.searchParams.set("to", input.to ?? "now");
+  return url.toString();
+}
+
+function recommendedDashboards(domain = "") {
+  return dashboardRecommendationPolicy.recommend(domain);
+}
+
+function bdsDashboardLinks(input) {
+  const filters = [
+    input.alertName ? { key: "alertname", value: input.alertName } : null,
+    input.source ? { key: "source", value: input.source } : null,
+    input.cluster ? { key: "bds_cluster", value: input.cluster } : null
+  ].filter(Boolean);
+  const selected = input.dashboards?.length ? input.dashboards : recommendedDashboards(input.domain);
+  const result = {
+    mode: "link-pack",
+    provider: "bds-observability",
+    environment: input.environment,
+    domain: input.domain ?? "",
+    alertName: input.alertName ?? "",
+    source: input.source ?? "",
+    cluster: input.cluster ?? "",
+    timeRange: { from: input.from ?? "now-6h", to: input.to ?? "now" },
+    dashboards: selected.map((dashboard) => ({
+      key: dashboard,
+      title: dashboards[dashboard].title,
+      url: dashboardUrl(input.environment, dashboard, input)
+    })),
+    pharos: {
+      alertRule: alertRuleUrl(input.environment, input.alertName ?? ""),
+      silences: silenceUrl(input.environment, filters)
+    },
+    solas: solasUrl(input),
+    filters
+  };
+  return JSON.stringify(result, null, 2);
+}
+
+export class BdsDashboardLinksService {
+  invoke(input) {
+    return bdsDashboardLinks(input);
+  }
+}
+
+const defaultService = new BdsDashboardLinksService();
+
+export default defineReadOnlyTool({
+  name: "bds_dashboard_links",
+  description: "Build BDS Grafana, Pharos alerting, silence, and Solas links from alert labels such as alertname, source, and bds_cluster.",
+  inputSchema: {
+    environment: z.enum(["dev", "prod", "il4"]).default("prod"),
+    alertName: z.string().trim().min(1).max(200).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    source: z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9_.:@/-]+$/).optional(),
+    cluster: z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    namespace: z.string().trim().min(1).max(80).regex(/^[A-Za-z0-9_.:-]+$/).default("bds"),
+    domain: z.enum(["disk", "yarn", "kubernetes", "airflow", "spark"]).optional(),
+    from: z.string().trim().min(1).max(80).default("now-6h"),
+    to: z.string().trim().min(1).max(80).default("now"),
+    refresh: z.string().trim().min(1).max(40).optional(),
+    dashboards: z.array(z.enum(Object.keys(dashboards))).max(12).optional()
+  },
+  async handler(input) {
+    try {
+      return ok(defaultService.invoke(input));
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export const __test = {
+  BdsDashboardLinksService,
+  DashboardRecommendationPolicy,
+  DashboardRecommendationRule,
+  alertRuleUrl,
+  bdsDashboardLinks,
+  dashboardUrl,
+  recommendedDashboards,
+  silenceUrl
+};

package/tools/bds_dashboard_query_knowledge.mjs

@@ -0,0 +1,258 @@
+export const description = "Scan BDS Grafana dashboard JSON files and summarize learned PromQL patterns: metrics, labels, functions, variables, domains, and representative panel queries.";
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+import { dashboardCatalog, extractPanelQueries, extractVariables } from "./bds_dashboard_query_read.mjs";
+
+const DEFAULT_DASHBOARD_DIR = "/Users/boqiang.liang/500-work/bds-terraform/alert-manager/dashboards";
+
+const PROMQL_FUNCTIONS = new Set([
+  "abs", "avg", "avg_over_time", "ceil", "changes", "clamp", "count", "count_over_time",
+  "delta", "deriv", "floor", "histogram_quantile", "increase", "irate", "label_replace",
+  "last_over_time", "max", "max_over_time", "min", "min_over_time", "predict_linear",
+  "quantile", "rate", "round", "sort", "sort_desc", "sum", "time", "topk"
+]);
+
+function increment(map, key, amount = 1) {
+  if (!key) return;
+  map.set(key, (map.get(key) ?? 0) + amount);
+}
+
+function topEntries(map, limit) {
+  return [...map.entries()]
+    .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+    .slice(0, limit)
+    .map(([name, count]) => ({ name, count }));
+}
+
+function metricNames(expr) {
+  const names = new Set();
+  const regex = /\b([a-zA-Z_:][a-zA-Z0-9_:]*)\s*(?=\{|\[|$)/g;
+  for (const match of expr.matchAll(regex)) {
+    const name = match[1];
+    if (!PROMQL_FUNCTIONS.has(name) && !["by", "without", "bool", "offset"].includes(name)) {
+      names.add(name);
+    }
+  }
+  return [...names];
+}
+
+function labelNames(expr) {
+  const names = new Set();
+  const regex = /\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:=~|!~|=|!=)/g;
+  for (const match of expr.matchAll(regex)) names.add(match[1]);
+  return [...names];
+}
+
+function functionNames(expr) {
+  const names = new Set();
+  const regex = /\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g;
+  for (const match of expr.matchAll(regex)) {
+    if (PROMQL_FUNCTIONS.has(match[1])) names.add(match[1]);
+  }
+  return [...names];
+}
+
+function variableNames(expr) {
+  const names = new Set();
+  const regex = /\$([a-zA-Z_][a-zA-Z0-9_]*)|\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}|\[\[([a-zA-Z_][a-zA-Z0-9_]*)\]\]/g;
+  for (const match of expr.matchAll(regex)) names.add(match[1] ?? match[2] ?? match[3]);
+  return [...names];
+}
+
+export const BDS_DASHBOARD_DOMAIN_RULES = [
+  { domain: "airflow", dashboards: ["airflow"] },
+  { domain: "hdfs-control-plane", dashboards: ["journalnode", "namenode", "zookeeper"] },
+  { domain: "hdfs", dashboards: ["datanode", "hdfs"] },
+  { domain: "yarn", dashboards: ["nodemanager", "resource_manager", "resourcemanager", "rm", "yarn"] },
+  { domain: "kubernetes", dashboards: ["k8s"] },
+  { domain: "kms", dashboards: ["kms"] },
+  { domain: "scylla", dashboards: ["migration_service", "scylla_bdm", "service_proxy"] },
+  { domain: "spark", dashboards: ["spark"] }
+];
+
+export class BdsDashboardDomainClassifier {
+  constructor({ rules = BDS_DASHBOARD_DOMAIN_RULES, fallback = "general" } = {}) {
+    this.domainByDashboard = new Map();
+    for (const rule of rules) {
+      for (const dashboard of rule.dashboards ?? []) {
+        this.domainByDashboard.set(dashboard, rule.domain);
+      }
+    }
+    this.fallback = fallback;
+  }
+
+  classify({ key = "" } = {}) {
+    return this.domainByDashboard.get(key) || this.fallback;
+  }
+}
+
+const defaultDomainClassifier = new BdsDashboardDomainClassifier();
+
+async function loadDashboard(fileName, dashboardDir) {
+  const dashboardPath = join(dashboardDir, fileName);
+  return {
+    dashboardPath,
+    dashboard: JSON.parse(await readFile(dashboardPath, "utf8"))
+  };
+}
+
+async function scanDashboard(key, fileName, input, domainClassifier = defaultDomainClassifier) {
+  const { dashboardPath, dashboard } = await loadDashboard(fileName, input.dashboardDir ?? DEFAULT_DASHBOARD_DIR);
+  const panels = extractPanelQueries(dashboard, {
+    cluster: input.cluster,
+    namespace: input.namespace,
+    source: input.source,
+    scyllaCluster: input.scyllaCluster,
+    limit: 1_000
+  });
+  const metrics = new Map();
+  const labels = new Map();
+  const functions = new Map();
+  const variables = new Map();
+  const panelExamples = [];
+  let queryCount = 0;
+
+  for (const panel of panels) {
+    for (const target of panel.targets) {
+      queryCount += 1;
+      for (const metric of metricNames(target.expr)) increment(metrics, metric);
+      for (const label of labelNames(target.expr)) increment(labels, label);
+      for (const fn of functionNames(target.expr)) increment(functions, fn);
+      for (const variable of variableNames(target.expr)) increment(variables, variable);
+      if (panelExamples.length < input.examplesPerDashboard) {
+        panelExamples.push({
+          panel: panel.title,
+          refId: target.refId,
+          expr: target.expr,
+          renderedExpr: target.renderedExpr
+        });
+      }
+    }
+  }
+
+  return {
+    key,
+    fileName,
+    dashboardPath,
+    uid: dashboard.uid ?? "",
+    title: dashboard.title ?? "",
+    domain: domainClassifier.classify({ key }),
+    variablesDefined: extractVariables(dashboard).map((variable) => ({
+      name: variable.name,
+      definition: variable.definition
+    })),
+    panelCount: panels.length,
+    queryCount,
+    topMetrics: topEntries(metrics, input.topLimit),
+    topLabels: topEntries(labels, input.topLimit),
+    promqlFunctions: topEntries(functions, input.topLimit),
+    queryVariables: topEntries(variables, input.topLimit),
+    examples: panelExamples
+  };
+}
+
+function mergeDashboardKnowledge(dashboards, input) {
+  const metrics = new Map();
+  const labels = new Map();
+  const functions = new Map();
+  const variables = new Map();
+  const domains = new Map();
+  let queryCount = 0;
+  let panelCount = 0;
+
+  for (const dashboard of dashboards) {
+    queryCount += dashboard.queryCount;
+    panelCount += dashboard.panelCount;
+    increment(domains, dashboard.domain);
+    for (const item of dashboard.topMetrics) increment(metrics, item.name, item.count);
+    for (const item of dashboard.topLabels) increment(labels, item.name, item.count);
+    for (const item of dashboard.promqlFunctions) increment(functions, item.name, item.count);
+    for (const item of dashboard.queryVariables) increment(variables, item.name, item.count);
+  }
+
+  return {
+    dashboardCount: dashboards.length,
+    panelCount,
+    queryCount,
+    domains: topEntries(domains, input.topLimit),
+    topMetrics: topEntries(metrics, input.topLimit),
+    topLabels: topEntries(labels, input.topLimit),
+    promqlFunctions: topEntries(functions, input.topLimit),
+    queryVariables: topEntries(variables, input.topLimit)
+  };
+}
+
+export class BdsDashboardQueryKnowledgeService {
+  constructor({ domainClassifier = defaultDomainClassifier } = {}) {
+    this.domainClassifier = domainClassifier;
+  }
+
+  async invoke(input) {
+    const keys = input.dashboard && input.dashboard !== "all"
+      ? [input.dashboard]
+      : [...new Set(Object.keys(dashboardCatalog))];
+    const dashboards = [];
+    const seenFiles = new Set();
+    for (const key of keys) {
+      const fileName = dashboardCatalog[key];
+      if (!fileName || seenFiles.has(fileName)) continue;
+      seenFiles.add(fileName);
+      dashboards.push(await scanDashboard(key, fileName, input, this.domainClassifier));
+    }
+
+    return JSON.stringify({
+      mode: "query-knowledge",
+      provider: "bds-dashboard-json",
+      dashboardDir: input.dashboardDir ?? DEFAULT_DASHBOARD_DIR,
+      renderedFor: {
+        cluster: input.cluster ?? "",
+        namespace: input.namespace ?? "",
+        source: input.source ?? "",
+        scyllaCluster: input.scyllaCluster ?? ""
+      },
+      summary: mergeDashboardKnowledge(dashboards, input),
+      dashboards
+    }, null, 2);
+  }
+}
+
+async function bdsDashboardQueryKnowledge(input) {
+  return new BdsDashboardQueryKnowledgeService().invoke(input);
+}
+
+const defaultService = new BdsDashboardQueryKnowledgeService();
+
+export default defineReadOnlyTool({
+  name: "bds_dashboard_query_knowledge",
+  description: "Scan BDS Grafana dashboard JSON files and summarize learned PromQL patterns: metrics, labels, functions, variables, domains, and representative panel queries.",
+  inputSchema: {
+    dashboard: z.enum(["all", ...Object.keys(dashboardCatalog)]).default("all"),
+    dashboardDir: z.string().trim().min(1).max(500).default(DEFAULT_DASHBOARD_DIR),
+    cluster: z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    namespace: z.string().trim().min(1).max(80).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    source: z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9_.:@/-]+$/).optional(),
+    scyllaCluster: z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    topLimit: z.number().int().positive().max(100).default(20),
+    examplesPerDashboard: z.number().int().nonnegative().max(20).default(3)
+  },
+  async handler(input) {
+    try {
+      return ok(await defaultService.invoke(input));
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export const __test = {
+  bdsDashboardQueryKnowledge,
+  metricNames,
+  labelNames,
+  functionNames,
+  variableNames,
+  BdsDashboardDomainClassifier,
+  BdsDashboardQueryKnowledgeService
+};

package/tools/bds_dashboard_query_read.mjs

@@ -0,0 +1,120 @@
+export const description = "Read every PromQL query from a local BDS Grafana dashboard JSON, including variables and rendered expressions for supplied cluster/source values.";
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+import {
+  extractPanelQueries as extractGenericPanelQueries,
+  extractVariables
+} from "../vendor/dashboard/src/grafana-dashboard-query.mjs";
+
+export { extractVariables } from "../vendor/dashboard/src/grafana-dashboard-query.mjs";
+
+const DEFAULT_DASHBOARD_DIR = "/Users/boqiang.liang/500-work/bds-terraform/alert-manager/dashboards";
+
+export const dashboardCatalog = {
+  airflow: "bds_airflow.json",
+  cluster: "bds_clusters.json",
+  clusters: "bds_clusters.json",
+  datanode: "bds_datanodes.json",
+  hdfs: "bds_hdfs.json",
+  journalnode: "bds_jn.json",
+  k8s: "bds_k8s.json",
+  kms: "bds_kms.json",
+  migration_service: "bds_migration_service.json",
+  namenode: "bds_nn.json",
+  nodemanager: "bds_nm.json",
+  resource_manager: "bds_rm.json",
+  resourcemanager: "bds_rm.json",
+  rm: "bds_rm.json",
+  scylla_bdm: "bds_scylla_bdm.json",
+  service_proxy: "bds_scylla_service_proxy.json",
+  spark: "bds_spark.json",
+  stats: "bds_stats.json",
+  top_level: "bds_top_level.json",
+  yarn: "bds_yarn.json",
+  zookeeper: "bds_zk.json"
+};
+
+export function extractPanelQueries(dashboard, input) {
+  const variableValues = {
+    bds_cluster: input.cluster ?? "",
+    namespace: input.namespace ?? "",
+    source: input.source ?? "",
+    scylla_cluster: input.scyllaCluster ?? ""
+  };
+  return extractGenericPanelQueries(dashboard, {
+    variableValues,
+    panelTitleContains: input.panelTitleContains,
+    queryContains: input.queryContains,
+    limit: input.limit ?? 200
+  }).map((panel) => ({
+    id: panel.id,
+    title: panel.title,
+    type: panel.type,
+    description: panel.description,
+    targets: panel.targets
+      .filter((target) => target.language === "promql")
+      .map((target) => ({
+        refId: target.refId,
+        expr: target.query,
+        renderedExpr: target.renderedQuery,
+        legendFormat: target.legendFormat,
+        datasource: target.datasource
+      }))
+  })).filter((panel) => panel.targets.length);
+}
+
+export class BdsDashboardQueryReadService {
+  async invoke(input) {
+    const fileName = dashboardCatalog[input.dashboard];
+    if (!fileName) throw new Error(`Unknown BDS dashboard: ${input.dashboard}`);
+    const dashboardPath = join(input.dashboardDir ?? DEFAULT_DASHBOARD_DIR, fileName);
+    const dashboard = JSON.parse(await readFile(dashboardPath, "utf8"));
+    const panels = extractPanelQueries(dashboard, input);
+    return JSON.stringify({
+      mode: "read-only",
+      provider: "bds-dashboard-json",
+      dashboard: input.dashboard,
+      fileName,
+      dashboardPath,
+      uid: dashboard.uid ?? "",
+      title: dashboard.title ?? "",
+      variables: extractVariables(dashboard),
+      panelCount: panels.length,
+      panels
+    }, null, 2);
+  }
+}
+
+async function bdsDashboardQueryRead(input) {
+  return new BdsDashboardQueryReadService().invoke(input);
+}
+
+const defaultService = new BdsDashboardQueryReadService();
+
+export default defineReadOnlyTool({
+  name: "bds_dashboard_query_read",
+  description: "Read every PromQL query from a local BDS Grafana dashboard JSON, including variables and rendered expressions for supplied cluster/source values.",
+  inputSchema: {
+    dashboard: z.enum(Object.keys(dashboardCatalog)),
+    dashboardDir: z.string().trim().min(1).max(500).default(DEFAULT_DASHBOARD_DIR),
+    cluster: z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    namespace: z.string().trim().min(1).max(80).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    source: z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9_.:@/-]+$/).optional(),
+    scyllaCluster: z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    panelTitleContains: z.string().trim().min(1).max(120).optional(),
+    queryContains: z.string().trim().min(1).max(160).optional(),
+    limit: z.number().int().positive().max(500).default(200)
+  },
+  async handler(input) {
+    try {
+      return ok(await defaultService.invoke(input));
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export const __test = { bdsDashboardQueryRead, extractPanelQueries, extractVariables, BdsDashboardQueryReadService };