@dudamel/mcp-integrations 2026.917.2

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createServer } from './server.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,289 @@
+// ../common/dist/http-client.js
+function parseApiErrorBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null || !("error" in parsed))
+      return void 0;
+    const error = parsed.error;
+    if (typeof error === "object" && error !== null && typeof error.code === "string" && typeof error.message === "string") {
+      return error;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+var DudamelApiError = class extends Error {
+  status;
+  statusText;
+  body;
+  /** Stable machine-readable code from the API error body, or 'UNKNOWN' for non-conforming bodies. */
+  code;
+  /** Per-field validation errors, when the API provided them. */
+  details;
+  /** Extra machine-readable data (e.g. `inputsSchema` on execute validation failures). */
+  context;
+  constructor(status, statusText, body) {
+    const apiError = parseApiErrorBody(body);
+    const lines = [
+      apiError ? `Dudamel API error ${status} ${statusText}: ${apiError.code}: ${apiError.message}` : `Dudamel API error ${status} ${statusText}: ${body}`
+    ];
+    if (apiError?.details?.length) {
+      lines.push(...apiError.details.map((d) => `  - ${d.path}: ${d.message}`));
+    }
+    if (apiError?.context?.["inputsSchema"] !== void 0) {
+      lines.push(`Expected inputs schema: ${JSON.stringify(apiError.context["inputsSchema"])}`);
+    }
+    super(lines.join("\n"));
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "DudamelApiError";
+    this.code = apiError?.code ?? "UNKNOWN";
+    this.details = apiError?.details;
+    this.context = apiError?.context;
+  }
+};
+var DudamelApiClient = class {
+  baseUrl;
+  headers;
+  constructor(baseUrl, apiKey, authScheme) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.headers = {
+      Authorization: `${authScheme ?? "ApiKey"} ${apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "GET" });
+  }
+  async post(path, body) {
+    const url = this.buildUrl(path);
+    return this.request(url, {
+      method: "POST",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(path, body) {
+    const url = this.buildUrl(path);
+    return this.request(url, {
+      method: "PUT",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path) {
+    const url = this.buildUrl(path);
+    return this.request(url, { method: "DELETE" });
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== "") {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return url.toString();
+  }
+  async request(url, init) {
+    const response = await fetch(url, {
+      ...init,
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new DudamelApiError(response.status, response.statusText, body);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+};
+
+// ../common/dist/read-only-filter.js
+function withReadOnlyFilter(server, readOnly) {
+  if (!readOnly)
+    return server;
+  const original = server.registerTool.bind(server);
+  const filtered = (...args) => {
+    const config = args[1];
+    if (config?.annotations?.readOnlyHint === false) {
+      return void 0;
+    }
+    return original(...args);
+  };
+  return new Proxy(server, {
+    get(target, prop, receiver) {
+      if (prop === "registerTool")
+        return filtered;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// ../common/dist/create-server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function createSurfaceServer(opts) {
+  const { config } = opts;
+  const server = new McpServer({ name: opts.name, version: "0.1.0" }, {
+    capabilities: { tools: {} },
+    instructions: opts.instructions
+  });
+  const client = new DudamelApiClient(config.apiUrl, config.apiKey, config.authScheme);
+  const ctx = {
+    role: config.role,
+    readOnly: config.readOnly ?? false,
+    agentName: config.agentName,
+    callChain: config.callChain,
+    turnId: config.turnId,
+    rootTurnId: config.rootTurnId,
+    conversationId: config.conversationId,
+    requesterUserId: config.requesterUserId,
+    responseTarget: config.responseTarget
+  };
+  const host = withReadOnlyFilter(server, ctx.readOnly);
+  for (const register of opts.registrars)
+    register(host, client, ctx);
+  return server;
+}
+
+// ../common/dist/util.js
+function jsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+
+// src/tools/integrations.ts
+import { z } from "zod";
+function registerIntegrationTools(server, client, ctx) {
+  server.registerTool(
+    "list-integrations",
+    {
+      description: "List all integration instances (Slack, GitHub, Trello, etc.) with their status and configuration.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/integrations");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server.registerTool(
+    "list-integration-types",
+    {
+      description: "List available integration types that can be configured (e.g. slack, github, trello).",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/integration-types");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  if (ctx.readOnly || ctx.role !== "admin") return;
+  server.registerTool(
+    "activate-integration",
+    {
+      description: "Activate an integration instance.",
+      inputSchema: {
+        id: z.string().describe("Integration instance ID (UUID)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id }) => {
+      const result = await client.post(`/api/integrations/${id}/activate`);
+      return jsonResult(result);
+    }
+  );
+  server.registerTool(
+    "deactivate-integration",
+    {
+      description: "Deactivate an integration instance.",
+      inputSchema: {
+        id: z.string().describe("Integration instance ID (UUID)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id }) => {
+      const result = await client.post(`/api/integrations/${id}/deactivate`);
+      return jsonResult(result);
+    }
+  );
+}
+
+// src/tools/mcp-servers.ts
+import { z as z2 } from "zod";
+function registerMcpServerTools(server, client, ctx) {
+  server.registerTool(
+    "list-mcp-servers",
+    {
+      description: "List all configured MCP server instances. Returns id, name, description, serverType, authMode, and OAuth status.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/mcp-servers");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server.registerTool(
+    "get-mcp-server-secrets",
+    {
+      description: "List the secret key names configured for an MCP server. Does not reveal secret values.",
+      inputSchema: {
+        id: z2.string().describe("MCP Server ID (UUID)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ id }) => {
+      const secrets = await client.get(`/api/mcp-servers/${id}/secrets`);
+      return jsonResult(secrets);
+    }
+  );
+  if (ctx.readOnly || ctx.role !== "admin") return;
+  server.registerTool(
+    "set-mcp-server-secrets",
+    {
+      description: "Set or update the service account secrets for an MCP server.",
+      inputSchema: {
+        id: z2.string().describe("MCP Server ID (UUID)"),
+        secrets: z2.record(z2.string()).describe("Key-value pairs of secret names and values")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id, secrets }) => {
+      const result = await client.put(`/api/mcp-servers/${id}/secrets`, secrets);
+      return jsonResult(result);
+    }
+  );
+}
+
+// src/tools/mcp-catalog.ts
+function registerMcpCatalogTools(server, client, _ctx) {
+  server.registerTool(
+    "list-mcp-catalog",
+    {
+      description: "List the catalog of pre-curated MCP servers available for installation. Returns server type, connection methods, permission modes, and setup guides.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/mcp-catalog");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+}
+
+// src/server.ts
+function createServer(config) {
+  return createSurfaceServer({
+    name: "dudamel-integrations",
+    instructions: `Dudamel Integrations MCP \u2014 manage integration instances, MCP servers, and the MCP catalog. Running as role=${config.role}, readOnly=${config.readOnly ?? false}.`,
+    registrars: [registerIntegrationTools, registerMcpServerTools, registerMcpCatalogTools],
+    config
+  });
+}
+export {
+  createServer
+};

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import type { McpCommonConfig } from '@dudamel/mcp-common';
+export declare function createServer(config: McpCommonConfig): import("@modelcontextprotocol/sdk/server/mcp").McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAK3D,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,4DASnD"}

package/dist/stdio-server.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=stdio-server.d.ts.map

package/dist/stdio-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio-server.d.ts","sourceRoot":"","sources":["../src/stdio-server.ts"],"names":[],"mappings":""}

package/dist/stdio-server.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+
+// src/stdio-server.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../common/dist/http-client.js
+function parseApiErrorBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null || !("error" in parsed))
+      return void 0;
+    const error = parsed.error;
+    if (typeof error === "object" && error !== null && typeof error.code === "string" && typeof error.message === "string") {
+      return error;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+var DudamelApiError = class extends Error {
+  status;
+  statusText;
+  body;
+  /** Stable machine-readable code from the API error body, or 'UNKNOWN' for non-conforming bodies. */
+  code;
+  /** Per-field validation errors, when the API provided them. */
+  details;
+  /** Extra machine-readable data (e.g. `inputsSchema` on execute validation failures). */
+  context;
+  constructor(status, statusText, body) {
+    const apiError = parseApiErrorBody(body);
+    const lines = [
+      apiError ? `Dudamel API error ${status} ${statusText}: ${apiError.code}: ${apiError.message}` : `Dudamel API error ${status} ${statusText}: ${body}`
+    ];
+    if (apiError?.details?.length) {
+      lines.push(...apiError.details.map((d) => `  - ${d.path}: ${d.message}`));
+    }
+    if (apiError?.context?.["inputsSchema"] !== void 0) {
+      lines.push(`Expected inputs schema: ${JSON.stringify(apiError.context["inputsSchema"])}`);
+    }
+    super(lines.join("\n"));
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "DudamelApiError";
+    this.code = apiError?.code ?? "UNKNOWN";
+    this.details = apiError?.details;
+    this.context = apiError?.context;
+  }
+};
+var DudamelApiClient = class {
+  baseUrl;
+  headers;
+  constructor(baseUrl, apiKey, authScheme) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.headers = {
+      Authorization: `${authScheme ?? "ApiKey"} ${apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "GET" });
+  }
+  async post(path, body) {
+    const url = this.buildUrl(path);
+    return this.request(url, {
+      method: "POST",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(path, body) {
+    const url = this.buildUrl(path);
+    return this.request(url, {
+      method: "PUT",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path) {
+    const url = this.buildUrl(path);
+    return this.request(url, { method: "DELETE" });
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== "") {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return url.toString();
+  }
+  async request(url, init) {
+    const response = await fetch(url, {
+      ...init,
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new DudamelApiError(response.status, response.statusText, body);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+};
+
+// ../common/dist/resolve-role.js
+var WHOAMI_TIMEOUT_MS = 5e3;
+function isSystemRole(value) {
+  return value === "admin" || value === "user";
+}
+async function resolveSystemRole(options) {
+  if (isSystemRole(options.envRole))
+    return options.envRole;
+  const doFetch = options.fetchImpl ?? fetch;
+  const url = `${options.apiUrl.replace(/\/+$/, "")}/api/users/me`;
+  try {
+    const response = await doFetch(url, {
+      method: "GET",
+      headers: { Authorization: `ApiKey ${options.apiKey}` },
+      signal: AbortSignal.timeout(WHOAMI_TIMEOUT_MS)
+    });
+    if (!response.ok)
+      return "user";
+    const body = await response.json();
+    const role2 = body?.systemRole;
+    return isSystemRole(role2) ? role2 : "user";
+  } catch {
+    return "user";
+  }
+}
+
+// ../common/dist/read-only-filter.js
+function withReadOnlyFilter(server2, readOnly) {
+  if (!readOnly)
+    return server2;
+  const original = server2.registerTool.bind(server2);
+  const filtered = (...args) => {
+    const config = args[1];
+    if (config?.annotations?.readOnlyHint === false) {
+      return void 0;
+    }
+    return original(...args);
+  };
+  return new Proxy(server2, {
+    get(target, prop, receiver) {
+      if (prop === "registerTool")
+        return filtered;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// ../common/dist/create-server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function createSurfaceServer(opts) {
+  const { config } = opts;
+  const server2 = new McpServer({ name: opts.name, version: "0.1.0" }, {
+    capabilities: { tools: {} },
+    instructions: opts.instructions
+  });
+  const client = new DudamelApiClient(config.apiUrl, config.apiKey, config.authScheme);
+  const ctx2 = {
+    role: config.role,
+    readOnly: config.readOnly ?? false,
+    agentName: config.agentName,
+    callChain: config.callChain,
+    turnId: config.turnId,
+    rootTurnId: config.rootTurnId,
+    conversationId: config.conversationId,
+    requesterUserId: config.requesterUserId,
+    responseTarget: config.responseTarget
+  };
+  const host = withReadOnlyFilter(server2, ctx2.readOnly);
+  for (const register of opts.registrars)
+    register(host, client, ctx2);
+  return server2;
+}
+
+// ../common/dist/stdio.js
+function resolveStdioContext() {
+  let responseTarget;
+  const rawTarget = process.env["DUDAMEL_RESPONSE_TARGET"];
+  if (rawTarget) {
+    try {
+      responseTarget = JSON.parse(rawTarget);
+    } catch {
+      process.stderr.write("Warning: DUDAMEL_RESPONSE_TARGET is not valid JSON \u2014 ignoring.\n");
+    }
+  }
+  return {
+    apiUrl: process.env["DUDAMEL_API_URL"] ?? "http://localhost:3000",
+    apiKey: process.env["DUDAMEL_API_KEY"],
+    envRole: process.env["DUDAMEL_USER_ROLE"],
+    // read/write access is per agent-assignment (Plan 52); the spawner injects the mode.
+    readOnly: process.env["DUDAMEL_MCP_MODE"] === "readonly",
+    agentName: process.env["DUDAMEL_AGENT_NAME"],
+    callChain: (process.env["DUDAMEL_CALL_CHAIN"] ?? "").split(",").map((s) => s.trim()).filter(Boolean),
+    turnId: process.env["DUDAMEL_TURN_ID"],
+    rootTurnId: process.env["DUDAMEL_ROOT_TURN_ID"],
+    conversationId: process.env["DUDAMEL_CONVERSATION_ID"],
+    requesterUserId: process.env["DUDAMEL_REQUESTER_USER_ID"],
+    responseTarget
+  };
+}
+
+// ../common/dist/util.js
+function jsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+
+// src/tools/integrations.ts
+import { z } from "zod";
+function registerIntegrationTools(server2, client, ctx2) {
+  server2.registerTool(
+    "list-integrations",
+    {
+      description: "List all integration instances (Slack, GitHub, Trello, etc.) with their status and configuration.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/integrations");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server2.registerTool(
+    "list-integration-types",
+    {
+      description: "List available integration types that can be configured (e.g. slack, github, trello).",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/integration-types");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  if (ctx2.readOnly || ctx2.role !== "admin") return;
+  server2.registerTool(
+    "activate-integration",
+    {
+      description: "Activate an integration instance.",
+      inputSchema: {
+        id: z.string().describe("Integration instance ID (UUID)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id }) => {
+      const result = await client.post(`/api/integrations/${id}/activate`);
+      return jsonResult(result);
+    }
+  );
+  server2.registerTool(
+    "deactivate-integration",
+    {
+      description: "Deactivate an integration instance.",
+      inputSchema: {
+        id: z.string().describe("Integration instance ID (UUID)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id }) => {
+      const result = await client.post(`/api/integrations/${id}/deactivate`);
+      return jsonResult(result);
+    }
+  );
+}
+
+// src/tools/mcp-servers.ts
+import { z as z2 } from "zod";
+function registerMcpServerTools(server2, client, ctx2) {
+  server2.registerTool(
+    "list-mcp-servers",
+    {
+      description: "List all configured MCP server instances. Returns id, name, description, serverType, authMode, and OAuth status.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/mcp-servers");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server2.registerTool(
+    "get-mcp-server-secrets",
+    {
+      description: "List the secret key names configured for an MCP server. Does not reveal secret values.",
+      inputSchema: {
+        id: z2.string().describe("MCP Server ID (UUID)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ id }) => {
+      const secrets = await client.get(`/api/mcp-servers/${id}/secrets`);
+      return jsonResult(secrets);
+    }
+  );
+  if (ctx2.readOnly || ctx2.role !== "admin") return;
+  server2.registerTool(
+    "set-mcp-server-secrets",
+    {
+      description: "Set or update the service account secrets for an MCP server.",
+      inputSchema: {
+        id: z2.string().describe("MCP Server ID (UUID)"),
+        secrets: z2.record(z2.string()).describe("Key-value pairs of secret names and values")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id, secrets }) => {
+      const result = await client.put(`/api/mcp-servers/${id}/secrets`, secrets);
+      return jsonResult(result);
+    }
+  );
+}
+
+// src/tools/mcp-catalog.ts
+function registerMcpCatalogTools(server2, client, _ctx) {
+  server2.registerTool(
+    "list-mcp-catalog",
+    {
+      description: "List the catalog of pre-curated MCP servers available for installation. Returns server type, connection methods, permission modes, and setup guides.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/mcp-catalog");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+}
+
+// src/server.ts
+function createServer(config) {
+  return createSurfaceServer({
+    name: "dudamel-integrations",
+    instructions: `Dudamel Integrations MCP \u2014 manage integration instances, MCP servers, and the MCP catalog. Running as role=${config.role}, readOnly=${config.readOnly ?? false}.`,
+    registrars: [registerIntegrationTools, registerMcpServerTools, registerMcpCatalogTools],
+    config
+  });
+}
+
+// src/stdio-server.ts
+var ctx = resolveStdioContext();
+if (!ctx.apiKey) {
+  process.stderr.write("Error: DUDAMEL_API_KEY environment variable is required.\n");
+  process.exit(1);
+}
+var role = await resolveSystemRole({
+  apiUrl: ctx.apiUrl,
+  apiKey: ctx.apiKey,
+  envRole: ctx.envRole
+});
+var server = createServer({ ...ctx, apiKey: ctx.apiKey, role });
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/integrations.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DudamelApiClient } from '@dudamel/mcp-common';
+import type { ToolContext } from '@dudamel/mcp-common';
+export declare function registerIntegrationTools(server: McpServer, client: DudamelApiClient, ctx: ToolContext): void;
+//# sourceMappingURL=integrations.d.ts.map

package/dist/tools/integrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrations.d.ts","sourceRoot":"","sources":["../../src/tools/integrations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,WAAW,GACf,IAAI,CA8DN"}

package/dist/tools/mcp-catalog.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DudamelApiClient } from '@dudamel/mcp-common';
+import type { ToolContext } from '@dudamel/mcp-common';
+/**
+ * `list-mcp-catalog` for the `integrations` surface (Plan 52 Parte C) — the
+ * catalog of pre-curated MCP servers (how the platform connects to external
+ * tools). Read-only, user-visible (moved out of the old `system` tool group).
+ */
+export declare function registerMcpCatalogTools(server: McpServer, client: DudamelApiClient, _ctx: ToolContext): void;
+//# sourceMappingURL=mcp-catalog.d.ts.map

package/dist/tools/mcp-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-catalog.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,WAAW,GAChB,IAAI,CAaN"}

package/dist/tools/mcp-servers.d.ts

@@ -0,0 +1,15 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DudamelApiClient } from '@dudamel/mcp-common';
+import type { ToolContext } from '@dudamel/mcp-common';
+/**
+ * MCP-server tools for the `integrations` surface (Plan 52 Parte C). Scoped to the
+ * integration-backed servers: listing them and managing their service secrets.
+ *
+ * The standalone MCP-server management path (create/update/delete) was pruned: it
+ * has no dashboard UI, `remote` servers don't spawn, and integration-less rows are
+ * world-visible without a permission model. `install-mcp-server` /
+ * `get-mcp-server-status` were mcp-runner leftovers (endpoints no longer exist).
+ * Agent↔MCP assignment lives in the `agents` surface (see agent-mcp.ts).
+ */
+export declare function registerMcpServerTools(server: McpServer, client: DudamelApiClient, ctx: ToolContext): void;
+//# sourceMappingURL=mcp-servers.d.ts.map

package/dist/tools/mcp-servers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-servers.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-servers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,WAAW,GACf,IAAI,CAiDN"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@dudamel/mcp-integrations",
+  "version": "2026.917.2",
+  "description": "Dudamel integrations MCP — stdio client for Dudamel's integrations management surface over its REST API.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "dudamel-mcp-integrations": "./dist/stdio-server.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agents-squad/dudamel.git",
+    "directory": "packages/mcp/integrations"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.0",
+    "@dudamel/contracts": "0.1.0",
+    "@dudamel/mcp-common": "0.1.0"
+  },
+  "scripts": {
+    "build": "esbuild src/stdio-server.ts src/index.ts --bundle --platform=node --target=node20 --format=esm --outdir=dist --external:@modelcontextprotocol/sdk --external:zod && tsc --emitDeclarationOnly",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist"
+  }
+}