@burdenoff/mcp-libs 2026.522.1 → 2026.525.1

package/dist/modules/integrations/index.js

@@ -52,6 +52,109 @@ var GET_INTEGRATION_LOGS = `
     }
   }
 `;
+var UPDATE_CONNECTION = `
+  mutation UpdateConnection($id: ID!, $input: UpdateConnectionInput!) {
+    updateConnection(id: $id, input: $input) { id name status }
+  }
+`;
+var REVOKE_CONNECTION = `
+  mutation RevokeConnection($connectionId: ID!) {
+    revokeConnection(connectionId: $connectionId) { id name status }
+  }
+`;
+var TEST_CONNECTION = `
+  mutation TestConnection($connectionId: ID!) {
+    testConnection(connectionId: $connectionId) { success message latencyMs }
+  }
+`;
+var LINK_INTEGRATION_TO_CHANNEL = `
+  mutation LinkIntegrationToChannel($channelId: String!, $connectionId: ID!, $organizationId: String!) {
+    linkIntegrationToChannel(channelId: $channelId, connectionId: $connectionId, organizationId: $organizationId) {
+      id name status channelId organizationId
+    }
+  }
+`;
+var REFRESH_CONNECTION_TOKEN = `
+  mutation RefreshConnectionToken($connectionId: ID!) {
+    refreshConnectionToken(connectionId: $connectionId) { id status }
+  }
+`;
+var AUTHENTICATE_API_KEY = `
+  mutation AuthenticateWithApiKey($input: ApiKeyAuthInput!) {
+    authenticateWithApiKey(input: $input) { id name status }
+  }
+`;
+var AUTHENTICATE_BASIC = `
+  mutation AuthenticateWithBasicAuth($input: BasicAuthInput!) {
+    authenticateWithBasicAuth(input: $input) { id name status }
+  }
+`;
+var AUTHENTICATE_BEARER = `
+  mutation AuthenticateWithBearerToken($input: BearerTokenAuthInput!) {
+    authenticateWithBearerToken(input: $input) { id name status }
+  }
+`;
+var INITIATE_OAUTH = `
+  mutation InitiateOAuth($input: InitiateOAuthInput!) {
+    initiateOAuth(input: $input) { redirectUrl state }
+  }
+`;
+var COMPLETE_OAUTH = `
+  mutation CompleteOAuth($input: CompleteOAuthInput!) {
+    completeOAuth(input: $input) { id name status }
+  }
+`;
+var GET_PROVIDER_BY_KEY = `
+  query GetProviderByKey($key: String!) {
+    getProviderByKey(key: $key) { id key name authType category connectionCount isEnabled }
+  }
+`;
+var GET_PROVIDER_CATALOG = `
+  query GetProviderCatalog($pagination: IntegrationsPaginationInput) {
+    getProviderCatalog(pagination: $pagination) {
+      items { id key name category authType isEnabled }
+      total hasMore
+    }
+  }
+`;
+var GET_CONNECTIONS_BY_PROVIDER = `
+  query GetConnectionsByProvider($providerId: ID!, $pagination: IntegrationsPaginationInput) {
+    getConnectionsByProvider(providerId: $providerId, pagination: $pagination) {
+      items { id name providerId status grantedScopes }
+      total hasMore
+    }
+  }
+`;
+var ENABLE_PROVIDER = `
+  mutation EnableProvider($id: ID!) {
+    enableProvider(id: $id) { id key name isEnabled }
+  }
+`;
+var DISABLE_PROVIDER = `
+  mutation DisableProvider($id: ID!) {
+    disableProvider(id: $id) { id key name isEnabled }
+  }
+`;
+var TAG_CONNECTION = `
+  mutation TagConnection($input: TagConnectionInput!) {
+    tagConnection(input: $input) { id entityId tagId source }
+  }
+`;
+var UNTAG_CONNECTION = `
+  mutation UntagConnection($input: UntagConnectionInput!) {
+    untagConnection(input: $input)
+  }
+`;
+var REPLACE_CONNECTION_TAGS = `
+  mutation ReplaceConnectionTags($input: ReplaceConnectionTagsInput!) {
+    replaceConnectionTags(input: $input) { id entityId tagId source }
+  }
+`;
+var GET_CONNECTION_TAGS = `
+  query GetConnectionTags($input: GetConnectionTagsInput!) {
+    getConnectionTags(input: $input) { id entityId tagId source assignedAt }
+  }
+`;
 
 // src/modules/integrations/tools.ts
 function registerIntegrationsTools(server, ctx, track) {
@@ -212,6 +315,442 @@ function registerIntegrationsTools(server, ctx, track) {
       }
     }
   );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_connections_update")),
+    {
+      title: "Update Connection",
+      description: "Update a connection (name, description, config JSON object).",
+      inputSchema: {
+        id: z.string().describe("Connection ID"),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        config: z.record(z.string(), z.unknown()).optional()
+      }
+    },
+    async ({ id, name, description, config }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (config !== void 0) input.config = config;
+        if (Object.keys(input).length === 0) {
+          return errorResult("Provide at least one of name, description, config");
+        }
+        const data = await ctx.gql.workspace.request(
+          UPDATE_CONNECTION,
+          { id, input }
+        );
+        return jsonResult(data.updateConnection);
+      } catch (error) {
+        ctx.logger.error("integrations_connections_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update connection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_connections_revoke")),
+    {
+      title: "Revoke Connection",
+      description: "Revoke a connection \u2014 invalidates tokens and marks as REVOKED.",
+      inputSchema: { connectionId: z.string().describe("Connection ID") }
+    },
+    async ({ connectionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REVOKE_CONNECTION,
+          { connectionId }
+        );
+        return jsonResult(data.revokeConnection);
+      } catch (error) {
+        ctx.logger.error("integrations_connections_revoke failed", { error: String(error) });
+        return errorResult(
+          `Failed to revoke connection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_connections_test")),
+    {
+      title: "Test Connection",
+      description: "Health/auth probe for a connection; returns success/message/latencyMs.",
+      inputSchema: { connectionId: z.string().describe("Connection ID") }
+    },
+    async ({ connectionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TEST_CONNECTION, { connectionId });
+        return jsonResult(data.testConnection);
+      } catch (error) {
+        ctx.logger.error("integrations_connections_test failed", { error: String(error) });
+        return errorResult(
+          `Failed to test connection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_connections_link_channel")),
+    {
+      title: "Link Connection to Channel",
+      description: "Link an integration connection to a channel for DM/notification routing.",
+      inputSchema: {
+        channelId: z.string(),
+        connectionId: z.string(),
+        organizationId: z.string()
+      }
+    },
+    async ({ channelId, connectionId, organizationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LINK_INTEGRATION_TO_CHANNEL, { channelId, connectionId, organizationId });
+        return jsonResult(data.linkIntegrationToChannel);
+      } catch (error) {
+        ctx.logger.error("integrations_connections_link_channel failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to link connection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_connections_refresh_token")),
+    {
+      title: "Refresh Connection Token",
+      description: "Force a token refresh for an OAuth connection.",
+      inputSchema: { connectionId: z.string() }
+    },
+    async ({ connectionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REFRESH_CONNECTION_TOKEN, { connectionId });
+        return jsonResult(data.refreshConnectionToken);
+      } catch (error) {
+        ctx.logger.error("integrations_connections_refresh_token failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to refresh token: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_auth_api_key")),
+    {
+      title: "Authenticate Connection (API Key)",
+      description: "Attach an API key to an existing connection.",
+      inputSchema: { connectionId: z.string(), apiKey: z.string() }
+    },
+    async ({ connectionId, apiKey }) => {
+      try {
+        const data = await ctx.gql.workspace.request(AUTHENTICATE_API_KEY, { input: { connectionId, apiKey } });
+        return jsonResult(data.authenticateWithApiKey);
+      } catch (error) {
+        ctx.logger.error("integrations_auth_api_key failed", { error: String(error) });
+        return errorResult(
+          `Failed to authenticate: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_auth_basic")),
+    {
+      title: "Authenticate Connection (Basic Auth)",
+      description: "Attach Basic Auth credentials to an existing connection.",
+      inputSchema: {
+        connectionId: z.string(),
+        username: z.string(),
+        password: z.string()
+      }
+    },
+    async ({ connectionId, username, password }) => {
+      try {
+        const data = await ctx.gql.workspace.request(AUTHENTICATE_BASIC, { input: { connectionId, username, password } });
+        return jsonResult(data.authenticateWithBasicAuth);
+      } catch (error) {
+        ctx.logger.error("integrations_auth_basic failed", { error: String(error) });
+        return errorResult(
+          `Failed to authenticate: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_auth_bearer")),
+    {
+      title: "Authenticate Connection (Bearer Token)",
+      description: "Attach a Bearer token to an existing connection.",
+      inputSchema: { connectionId: z.string(), token: z.string() }
+    },
+    async ({ connectionId, token }) => {
+      try {
+        const data = await ctx.gql.workspace.request(AUTHENTICATE_BEARER, { input: { connectionId, token } });
+        return jsonResult(data.authenticateWithBearerToken);
+      } catch (error) {
+        ctx.logger.error("integrations_auth_bearer failed", { error: String(error) });
+        return errorResult(
+          `Failed to authenticate: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_auth_oauth_start")),
+    {
+      title: "Initiate OAuth Flow",
+      description: "Start an OAuth flow; returns redirectUrl + state for the client to use.",
+      inputSchema: {
+        connectionId: z.string(),
+        redirectUri: z.string(),
+        scopes: z.array(z.string()).optional()
+      }
+    },
+    async ({ connectionId, redirectUri, scopes }) => {
+      try {
+        const input = { connectionId, redirectUri };
+        if (scopes !== void 0) input.scopes = scopes;
+        const data = await ctx.gql.workspace.request(INITIATE_OAUTH, { input });
+        return jsonResult(data.initiateOAuth);
+      } catch (error) {
+        ctx.logger.error("integrations_auth_oauth_start failed", { error: String(error) });
+        return errorResult(
+          `Failed to initiate OAuth: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_auth_oauth_complete")),
+    {
+      title: "Complete OAuth Flow",
+      description: "Complete an OAuth flow with code+state returned by the IdP.",
+      inputSchema: {
+        connectionId: z.string(),
+        code: z.string(),
+        redirectUri: z.string(),
+        state: z.string()
+      }
+    },
+    async ({ connectionId, code, redirectUri, state }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          COMPLETE_OAUTH,
+          { input: { connectionId, code, redirectUri, state } }
+        );
+        return jsonResult(data.completeOAuth);
+      } catch (error) {
+        ctx.logger.error("integrations_auth_oauth_complete failed", { error: String(error) });
+        return errorResult(
+          `Failed to complete OAuth: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_providers_get_by_key")),
+    {
+      title: "Get Provider By Key",
+      description: "Look up an integration provider by its string key (e.g. github, slack).",
+      inputSchema: { key: z.string() }
+    },
+    async ({ key }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          GET_PROVIDER_BY_KEY,
+          { key }
+        );
+        if (!data.getProviderByKey) return errorResult(`Provider ${key} not found`);
+        return jsonResult(data.getProviderByKey);
+      } catch (error) {
+        ctx.logger.error("integrations_providers_get_by_key failed", { error: String(error) });
+        return errorResult(
+          `Failed to get provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_providers_catalog")),
+    {
+      title: "Provider Catalog",
+      description: "Browseable catalog of integration providers (paginated).",
+      inputSchema: { limit: z.number().optional() }
+    },
+    async ({ limit }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROVIDER_CATALOG, { pagination: { limit: limit ?? 100, offset: 0 } });
+        return jsonResult(data.getProviderCatalog);
+      } catch (error) {
+        ctx.logger.error("integrations_providers_catalog failed", { error: String(error) });
+        return errorResult(
+          `Failed to get catalog: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_providers_connections")),
+    {
+      title: "Connections By Provider",
+      description: "List all connections that belong to a given provider.",
+      inputSchema: { providerId: z.string(), limit: z.number().optional() }
+    },
+    async ({ providerId, limit }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_CONNECTIONS_BY_PROVIDER, {
+          providerId,
+          pagination: { limit: limit ?? 100, offset: 0 }
+        });
+        return jsonResult(data.getConnectionsByProvider);
+      } catch (error) {
+        ctx.logger.error("integrations_providers_connections failed", { error: String(error) });
+        return errorResult(
+          `Failed to list: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_providers_enable")),
+    {
+      title: "Enable Provider",
+      description: "Enable an integration provider in this workspace.",
+      inputSchema: { id: z.string() }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ENABLE_PROVIDER,
+          { id }
+        );
+        return jsonResult(data.enableProvider);
+      } catch (error) {
+        ctx.logger.error("integrations_providers_enable failed", { error: String(error) });
+        return errorResult(
+          `Failed to enable: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_providers_disable")),
+    {
+      title: "Disable Provider",
+      description: "Disable an integration provider in this workspace.",
+      inputSchema: { id: z.string() }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DISABLE_PROVIDER,
+          { id }
+        );
+        return jsonResult(data.disableProvider);
+      } catch (error) {
+        ctx.logger.error("integrations_providers_disable failed", { error: String(error) });
+        return errorResult(
+          `Failed to disable: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_connections_tag_add")),
+    {
+      title: "Tag Connection",
+      description: "Add a tag assignment to a connection.",
+      inputSchema: {
+        entityId: z.string(),
+        tagId: z.string(),
+        source: z.string().optional()
+      }
+    },
+    async ({ entityId, tagId, source }) => {
+      try {
+        const input = { entityId, tagId };
+        if (source !== void 0) input.source = source;
+        const data = await ctx.gql.workspace.request(
+          TAG_CONNECTION,
+          { input }
+        );
+        return jsonResult(data.tagConnection);
+      } catch (error) {
+        ctx.logger.error("integrations_connections_tag_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to tag: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_connections_tag_remove")),
+    {
+      title: "Untag Connection",
+      description: "Remove a tag assignment from a connection.",
+      inputSchema: { entityId: z.string(), tagId: z.string() }
+    },
+    async ({ entityId, tagId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          UNTAG_CONNECTION,
+          { input: { entityId, tagId } }
+        );
+        return jsonResult({ removed: data.untagConnection });
+      } catch (error) {
+        ctx.logger.error("integrations_connections_tag_remove failed", { error: String(error) });
+        return errorResult(
+          `Failed to untag: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_connections_tag_replace")),
+    {
+      title: "Replace Connection Tags",
+      description: "Replace all tag assignments on a connection.",
+      inputSchema: { entityId: z.string(), tagIds: z.array(z.string()) }
+    },
+    async ({ entityId, tagIds }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REPLACE_CONNECTION_TAGS,
+          { input: { entityId, tagIds } }
+        );
+        return jsonResult(data.replaceConnectionTags);
+      } catch (error) {
+        ctx.logger.error("integrations_connections_tag_replace failed", { error: String(error) });
+        return errorResult(
+          `Failed to replace tags: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "integrations_connections_tag_list")),
+    {
+      title: "List Connection Tags",
+      description: "List tag assignments on a connection.",
+      inputSchema: { entityId: z.string() }
+    },
+    async ({ entityId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          GET_CONNECTION_TAGS,
+          { input: { entityId } }
+        );
+        return jsonResult(data.getConnectionTags);
+      } catch (error) {
+        ctx.logger.error("integrations_connections_tag_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list tags: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
   server.registerTool(
     track(mcpToolName(ctx.productName, "integrations_logs")),
     {