@tool-bridge/server 0.1.1 → 0.3.0

package/dist/metabase-SRYDSDJ6.js

@@ -0,0 +1,365 @@
+import {
+  assertPublicHttpUrl,
+  createProviderPlugin,
+  guardedFetch,
+  requireApiKey,
+  upstreamError
+} from "./chunk-CSJEZHQO.js";
+import "./chunk-K7FVSFUX.js";
+import {
+  TBError,
+  external_exports
+} from "./chunk-JLTYA2B3.js";
+import "./chunk-MLKGABMK.js";
+
+// ../plugins/src/metabase/api.ts
+var SERVICE = "metabase";
+var API_PATH_PREFIX = "/api";
+var CURRENT_USER_PATH = "/user/current";
+function text(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function configError(message) {
+  return new TBError("invalid_argument", `${SERVICE} \u7684 ${message}`);
+}
+function resolveApiBase(ctx) {
+  const configured = ctx.config?.instanceUrl;
+  if (configured !== void 0 && typeof configured !== "string") {
+    throw configError("instanceUrl \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+  }
+  const raw = text(configured);
+  if (raw === void 0) {
+    throw configError("instanceUrl \u5FC5\u586B:\u7ED9\u6302\u8F7D\u8282\u70B9\u914D config.instanceUrl \u6307\u5411\u4F60\u7684 Metabase \u5B9E\u4F8B");
+  }
+  const url = assertPublicHttpUrl(raw.includes("://") ? raw : `https://${raw}`);
+  if (url.protocol !== "https:") throw configError("instanceUrl \u5FC5\u987B\u7528 https");
+  if (url.username !== "" || url.password !== "") {
+    throw configError("instanceUrl \u4E0D\u80FD\u5E26\u7528\u6237\u540D\u5BC6\u7801");
+  }
+  url.search = "";
+  url.hash = "";
+  let pathname = url.pathname === "/" ? "" : url.pathname.replace(/\/+$/, "");
+  if (pathname.endsWith(API_PATH_PREFIX)) pathname = pathname.slice(0, -API_PATH_PREFIX.length);
+  url.pathname = pathname;
+  const instanceUrl = url.toString().replace(/\/+$/, "");
+  return `${instanceUrl}${API_PATH_PREFIX}`;
+}
+function pathSegment(value, field) {
+  const segment = value === void 0 ? "" : String(value);
+  if (segment === "" || segment.includes("/") || segment.includes("?") || segment.includes("#")) {
+    throw new TBError("invalid_argument", `${field} \u5FC5\u987B\u662F\u4E00\u4E2A Metabase \u8DEF\u5F84\u6BB5`);
+  }
+  return encodeURIComponent(segment);
+}
+function errorMessage(payload, status) {
+  const body = record(payload);
+  const errors = body?.errors;
+  const serialized = typeof errors === "object" && errors !== null ? JSON.stringify(errors) : void 0;
+  return text(body?.message) ?? text(body?.error) ?? text(body?.cause) ?? serialized ?? `Metabase \u8FD4\u56DE HTTP ${status}`;
+}
+async function request(ctx, path, query) {
+  const apiKey = requireApiKey(ctx, SERVICE);
+  const url = new URL(`${resolveApiBase(ctx)}${path}`);
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) url.searchParams.append(key, item);
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+  let response;
+  try {
+    response = await guardedFetch(url.toString(), {
+      method: "GET",
+      headers: { "accept": "application/json", "x-api-key": apiKey }
+    });
+  } catch (error) {
+    if (error instanceof TBError) throw error;
+    throw upstreamError(502, `Metabase \u8BF7\u6C42\u5931\u8D25:${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`);
+  }
+  const raw = await response.text().catch(() => "");
+  let payload = null;
+  if (raw !== "") {
+    try {
+      payload = JSON.parse(raw);
+    } catch {
+      if (response.ok) throw upstreamError(502, "Metabase \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94");
+      payload = { message: raw };
+    }
+  }
+  if (!response.ok) throw upstreamError(response.status, errorMessage(payload, response.status));
+  return payload;
+}
+function requireObject(payload, label) {
+  const object = record(payload);
+  if (object === void 0) {
+    throw new TBError("unavailable", `${label} \u54CD\u5E94\u4E0D\u662F\u5BF9\u8C61`, { retryable: true });
+  }
+  return object;
+}
+function listItems(payload) {
+  const body = record(payload);
+  const data = body?.data;
+  const candidate = Array.isArray(payload) ? payload : Array.isArray(data) ? data : [];
+  return candidate.map((item) => record(item) ?? { value: item });
+}
+function rawObject(payload) {
+  return record(payload) ?? { data: payload };
+}
+async function getCurrentUser(_input, ctx) {
+  const payload = await request(ctx, CURRENT_USER_PATH);
+  return { user: requireObject(payload, "Metabase \u7528\u6237"), raw: rawObject(payload) };
+}
+async function listDatabases(input, ctx) {
+  const payload = await request(ctx, "/database", {
+    "include": text(input.include),
+    "include_analytics": input.includeAnalytics,
+    "saved": input.saved,
+    "include_editable_data_model": input.includeEditableDataModel,
+    "exclude_uneditable_details": input.excludeUneditableDetails,
+    "include_only_uploadable": input.includeOnlyUploadable,
+    "router_database_id": input.routerDatabaseId,
+    // 这两个是 kebab-case,不是 snake_case —— Metabase 的 query 参数命名不统一。
+    "can-query": input.canQuery,
+    "can-write-metadata": input.canWriteMetadata
+  });
+  return { databases: listItems(payload), raw: rawObject(payload) };
+}
+async function getDatabase(input, ctx) {
+  const payload = await request(ctx, `/database/${pathSegment(input.id, "id")}`, {
+    include: text(input.include),
+    include_editable_data_model: input.includeEditableDataModel,
+    exclude_uneditable_details: input.excludeUneditableDetails
+  });
+  return { database: requireObject(payload, "Metabase \u6570\u636E\u5E93"), raw: rawObject(payload) };
+}
+async function listCollections(input, ctx) {
+  const payload = await request(ctx, "/collection", {
+    "archived": input.archived,
+    "exclude-other-user-collections": input.excludeOtherUserCollections,
+    "namespace": text(input.namespace),
+    "personal-only": input.personalOnly
+  });
+  return { collections: listItems(payload), raw: rawObject(payload) };
+}
+async function getCollection(input, ctx) {
+  const payload = await request(ctx, `/collection/${pathSegment(input.id, "id")}`);
+  return { collection: requireObject(payload, "Metabase \u96C6\u5408"), raw: rawObject(payload) };
+}
+async function listCards(input, ctx) {
+  const payload = await request(ctx, "/card", { f: text(input.filter), model_id: input.modelId });
+  return { cards: listItems(payload), raw: rawObject(payload) };
+}
+async function getCard(input, ctx) {
+  const payload = await request(ctx, `/card/${pathSegment(input.id, "id")}`, { "legacy-mbql": input.legacyMbql });
+  return { card: requireObject(payload, "Metabase \u5361\u7247"), raw: rawObject(payload) };
+}
+async function listDashboards(input, ctx) {
+  const payload = await request(ctx, "/dashboard", { f: text(input.filter) });
+  return { dashboards: listItems(payload), raw: rawObject(payload) };
+}
+async function getDashboard(input, ctx) {
+  const payload = await request(ctx, `/dashboard/${pathSegment(input.id, "id")}`);
+  return { dashboard: requireObject(payload, "Metabase \u4EEA\u8868\u76D8"), raw: rawObject(payload) };
+}
+async function search(input, ctx) {
+  const payload = await request(ctx, "/search", {
+    // 线上参数名是 `q`;`collection` / `table_db_id` 也与入参名不同。
+    q: text(input.query),
+    context: text(input.context),
+    archived: input.archived,
+    collection: input.collectionId,
+    table_db_id: input.tableDatabaseId,
+    models: input.models,
+    include_dashboard_questions: input.includeDashboardQuestions,
+    include_metadata: input.includeMetadata
+  });
+  return { results: listItems(payload), raw: rawObject(payload) };
+}
+
+// ../plugins/src/metabase/schema.ts
+var getCurrentUserInput = external_exports.strictObject({}).describe("No input parameters are required.");
+var getCurrentUserOutput = external_exports.strictObject({
+  user: external_exports.looseObject({}).describe("A Metabase entity object.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for the current Metabase user.");
+var listDatabasesInput = external_exports.strictObject({
+  include: external_exports.enum(["tables", "schemas"]).describe("Related database data to include.").optional(),
+  includeAnalytics: external_exports.boolean().describe("Whether to include analytics database metadata.").optional(),
+  saved: external_exports.boolean().describe("Whether to return saved query databases.").optional(),
+  includeEditableDataModel: external_exports.boolean().describe("Whether to include editable data model metadata.").optional(),
+  excludeUneditableDetails: external_exports.boolean().describe("Whether to exclude details the API key cannot edit.").optional(),
+  includeOnlyUploadable: external_exports.boolean().describe("Whether to return only uploadable databases.").optional(),
+  routerDatabaseId: external_exports.int().min(1).describe("Router database ID to filter by.").optional(),
+  canQuery: external_exports.boolean().describe("Whether to return databases the API key can query.").optional(),
+  canWriteMetadata: external_exports.boolean().describe("Whether to return databases the API key can edit metadata for.").optional()
+}).describe("Query parameters for listing Metabase databases.");
+var listDatabasesOutput = external_exports.strictObject({
+  databases: external_exports.array(external_exports.looseObject({}).describe("A Metabase entity object.")).describe("Metabase databases returned by the API.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for Metabase databases.");
+var getDatabaseInput = external_exports.strictObject({
+  id: external_exports.union([external_exports.int().min(1).describe("A positive numeric Metabase ID."), external_exports.string().min(1).describe("A Metabase entity ID string.")]).describe("A Metabase numeric ID or entity ID string."),
+  include: external_exports.enum(["tables", "tables.fields"]).describe("Related database data to include.").optional(),
+  includeEditableDataModel: external_exports.boolean().describe("Whether to include editable data model metadata.").optional(),
+  excludeUneditableDetails: external_exports.boolean().describe("Whether to exclude details the API key cannot edit.").optional()
+}).describe("Input parameters for retrieving one Metabase database.");
+var getDatabaseOutput = external_exports.strictObject({
+  database: external_exports.looseObject({}).describe("A Metabase entity object.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for one Metabase database.");
+var listCollectionsInput = external_exports.strictObject({
+  archived: external_exports.boolean().describe("Whether to include archived collections.").optional(),
+  excludeOtherUserCollections: external_exports.boolean().describe("Whether to exclude other users' personal collections.").optional(),
+  namespace: external_exports.string().min(1).describe("Collection namespace to filter by.").optional(),
+  personalOnly: external_exports.boolean().describe("Whether to return only personal collections.").optional()
+}).describe("Query parameters for listing Metabase collections.");
+var listCollectionsOutput = external_exports.strictObject({
+  collections: external_exports.array(external_exports.looseObject({}).describe("A Metabase entity object.")).describe("Metabase collections returned by the API.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for Metabase collections.");
+var getCollectionInput = external_exports.strictObject({
+  id: external_exports.union([external_exports.int().min(1).describe("A positive numeric Metabase ID."), external_exports.string().min(1).describe("A Metabase entity ID string.")]).describe("A Metabase numeric ID or entity ID string.").optional()
+}).describe("Input parameters for retrieving one Metabase collection.");
+var getCollectionOutput = external_exports.strictObject({
+  collection: external_exports.looseObject({}).describe("A Metabase entity object.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for one Metabase collection.");
+var listCardsInput = external_exports.strictObject({
+  filter: external_exports.enum(["archived", "table", "using_model", "bookmarked", "using_segment", "all", "mine", "database"]).describe("Card list filter.").optional(),
+  modelId: external_exports.int().min(1).describe("Model ID to filter cards by.").optional()
+}).describe("Query parameters for listing Metabase cards.");
+var listCardsOutput = external_exports.strictObject({
+  cards: external_exports.array(external_exports.looseObject({}).describe("A Metabase entity object.")).describe("Metabase cards returned by the API.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for Metabase cards.");
+var getCardInput = external_exports.strictObject({
+  id: external_exports.union([external_exports.int().min(1).describe("A positive numeric Metabase ID."), external_exports.string().min(1).describe("A Metabase entity ID string.")]).describe("A Metabase numeric ID or entity ID string."),
+  legacyMbql: external_exports.boolean().describe("Whether to request the legacy MBQL response shape.").optional()
+}).describe("Input parameters for retrieving one Metabase card.");
+var getCardOutput = external_exports.strictObject({
+  card: external_exports.looseObject({}).describe("A Metabase entity object.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for one Metabase card.");
+var listDashboardsInput = external_exports.strictObject({
+  filter: external_exports.enum(["all", "mine", "archived"]).describe("Dashboard list filter.").optional()
+}).describe("Query parameters for listing Metabase dashboards.");
+var listDashboardsOutput = external_exports.strictObject({
+  dashboards: external_exports.array(external_exports.looseObject({}).describe("A Metabase entity object.")).describe("Metabase dashboards returned by the API.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for Metabase dashboards.");
+var getDashboardInput = external_exports.strictObject({
+  id: external_exports.union([external_exports.int().min(1).describe("A positive numeric Metabase ID."), external_exports.string().min(1).describe("A Metabase entity ID string.")]).describe("A Metabase numeric ID or entity ID string.").optional()
+}).describe("Input parameters for retrieving one Metabase dashboard.");
+var getDashboardOutput = external_exports.strictObject({
+  dashboard: external_exports.looseObject({}).describe("A Metabase entity object.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for one Metabase dashboard.");
+var searchInput = external_exports.strictObject({
+  query: external_exports.string().min(1).describe("Search text.").optional(),
+  context: external_exports.enum(["search-bar", "search-app", "command-palette", "entity-picker", "data-picker", "type-filter", "basic-actions", "browse", "embedding-setup", "document", "library", "dependencies", "model-migration", "api", "metabot"]).describe("Metabase search context.").optional(),
+  archived: external_exports.boolean().describe("Whether to search archived content.").optional(),
+  collectionId: external_exports.int().min(1).describe("Collection ID to search within.").optional(),
+  tableDatabaseId: external_exports.int().min(1).describe("Database ID to filter table search results by.").optional(),
+  models: external_exports.array(external_exports.enum(["dashboard", "table", "dataset", "segment", "collection", "measure", "transform", "document", "database", "action", "indexed-entity", "metric", "card"]).describe("Metabase model type to include in search results.")).describe("Metabase model types to include.").optional(),
+  includeDashboardQuestions: external_exports.boolean().describe("Whether to include dashboard questions.").optional(),
+  includeMetadata: external_exports.boolean().describe("Whether to include result metadata.").optional()
+}).describe("Query parameters for searching Metabase content.");
+var searchOutput = external_exports.strictObject({
+  results: external_exports.array(external_exports.looseObject({}).describe("A Metabase entity object.")).describe("Metabase search results returned by the API.").optional(),
+  raw: external_exports.looseObject({}).describe("The raw Metabase API response object.").optional()
+}).describe("Output payload for Metabase search results.");
+var metabaseActions = {
+  get_current_user: {
+    description: "Get the Metabase user associated with the API key.",
+    effect: "read",
+    inputSchema: getCurrentUserInput,
+    outputSchema: external_exports.toJSONSchema(getCurrentUserOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_databases: {
+    description: "List Metabase databases visible to the API key.",
+    effect: "read",
+    inputSchema: listDatabasesInput,
+    outputSchema: external_exports.toJSONSchema(listDatabasesOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_database: {
+    description: "Retrieve one Metabase database by ID.",
+    effect: "read",
+    inputSchema: getDatabaseInput,
+    outputSchema: external_exports.toJSONSchema(getDatabaseOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_collections: {
+    description: "List Metabase collections visible to the API key.",
+    effect: "read",
+    inputSchema: listCollectionsInput,
+    outputSchema: external_exports.toJSONSchema(listCollectionsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_collection: {
+    description: "Retrieve one Metabase collection by ID.",
+    effect: "read",
+    inputSchema: getCollectionInput,
+    outputSchema: external_exports.toJSONSchema(getCollectionOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_cards: {
+    description: "List Metabase cards, also known as questions.",
+    effect: "read",
+    inputSchema: listCardsInput,
+    outputSchema: external_exports.toJSONSchema(listCardsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_card: {
+    description: "Retrieve one Metabase card by ID.",
+    effect: "read",
+    inputSchema: getCardInput,
+    outputSchema: external_exports.toJSONSchema(getCardOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_dashboards: {
+    description: "List Metabase dashboards visible to the API key.",
+    effect: "read",
+    inputSchema: listDashboardsInput,
+    outputSchema: external_exports.toJSONSchema(listDashboardsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_dashboard: {
+    description: "Retrieve one Metabase dashboard by ID.",
+    effect: "read",
+    inputSchema: getDashboardInput,
+    outputSchema: external_exports.toJSONSchema(getDashboardOutput, { io: "output", unrepresentable: "any" })
+  },
+  search: {
+    description: "Search Metabase content visible to the API key.",
+    effect: "write",
+    inputSchema: searchInput,
+    outputSchema: external_exports.toJSONSchema(searchOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/metabase/index.ts
+function createMetabasePlugin() {
+  return createProviderPlugin({
+    description: "Metabase",
+    actions: metabaseActions,
+    credentialProbe: "get_current_user",
+    handlers: {
+      get_current_user: getCurrentUser,
+      list_databases: listDatabases,
+      get_database: getDatabase,
+      list_collections: listCollections,
+      get_collection: getCollection,
+      list_cards: listCards,
+      get_card: getCard,
+      list_dashboards: listDashboards,
+      get_dashboard: getDashboard,
+      search
+    }
+  });
+}
+var metabase_default = createMetabasePlugin();
+export {
+  createMetabasePlugin,
+  metabase_default as default
+};