@atlassian-dc-mcp/confluence 0.1.3 → 0.2.0

package/src/confluence-client/services/WebhooksService.ts

@@ -0,0 +1,258 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { DetailedInvocation } from '../models/DetailedInvocation.js';
+import type { RestInvocationHistory } from '../models/RestInvocationHistory.js';
+import type { RestWebhook } from '../models/RestWebhook.js';
+import type { Webhook } from '../models/Webhook.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class WebhooksService {
+    /**
+     * Find webhooks
+     * Find webhooks. The authenticated user must be an administrator to call this resource.
+     * @param limit the limit of the number of items to return, this may be restricted by fixed system limits.
+     * @param start the start point of the collection to return
+     * @param event list of webhook event ids to filter for
+     * @param statistics if statistics should be provided for all found webhooks.
+     * @returns any returns a list of webhooks.
+     * @throws ApiError
+     */
+    public static findWebhooks(
+        limit?: string,
+        start?: string,
+        event?: string,
+        statistics?: string,
+    ): CancelablePromise<{
+        results?: Array<RestWebhook>;
+        totalCount?: number;
+        start?: number;
+        limit?: number;
+        size?: number;
+        _links?: {
+            base?: string;
+            context?: string;
+            self?: string;
+            next?: string;
+            prev?: string;
+        };
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/webhooks',
+            query: {
+                'limit': limit,
+                'start': start,
+                'event': event,
+                'statistics': statistics,
+            },
+            errors: {
+                401: `returned if the currently authenticated user has insufficient permissions to find webhooks.`,
+            },
+        });
+    }
+    /**
+     * Create webhook
+     * Create a webhook via the URL. The authenticated user must be an administrator to call this resource.
+     * @param requestBody the webhook to be created.
+     * @returns Webhook returns a created webhook.
+     * @throws ApiError
+     */
+    public static createWebhook(
+        requestBody: RestWebhook,
+    ): CancelablePromise<Webhook> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/webhooks',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `returned if The webhook parameters were invalid or not supplied.`,
+                401: `The currently authenticated user has insufficient permissions to create webhooks.`,
+            },
+        });
+    }
+    /**
+     * Get webhook
+     * Get a webhook by id. The authenticated user must be an administrator to call this resource.
+     * @param webhookId id of the webhook
+     * @param statistics
+     * @returns RestWebhook returns a webhook.
+     * @throws ApiError
+     */
+    public static getWebhook(
+        webhookId: string,
+        statistics: boolean = false,
+    ): CancelablePromise<RestWebhook> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/webhooks/{webhookId}',
+            path: {
+                'webhookId': webhookId,
+            },
+            query: {
+                'statistics': statistics,
+            },
+            errors: {
+                401: `returned if the currently authenticated user has insufficient permissions to get webhook.`,
+                404: `returned if the webhook does not exist.`,
+            },
+        });
+    }
+    /**
+     *  Update webhook
+     *  Update an existing webhook. The authenticated user must be an administrator to call this resource.
+     * @param webhookId the existing webhook id
+     * @param requestBody the representation of the updated values for the webhook
+     * @returns RestWebhook returns a webhook.
+     * @throws ApiError
+     */
+    public static updateWebhook(
+        webhookId: string,
+        requestBody: RestWebhook,
+    ): CancelablePromise<RestWebhook> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/rest/api/webhooks/{webhookId}',
+            path: {
+                'webhookId': webhookId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `returned if the currently authenticated user has insufficient permissions to update a webhook.`,
+                404: `returned if the webhook does not exist.`,
+            },
+        });
+    }
+    /**
+     * Delete webhook
+     * Delete a webhook via the URL. The authenticated user must be an administrator to call this resource.
+     * @param webhookId the id of the webhook to be deleted.
+     * @returns void
+     * @throws ApiError
+     */
+    public static deleteWebhook(
+        webhookId: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/rest/api/webhooks/{webhookId}',
+            path: {
+                'webhookId': webhookId,
+            },
+            errors: {
+                401: `returned if the currently authenticated user has insufficient permissions to delete webhooks.`,
+                404: `returned if the webhook does not exist.`,
+            },
+        });
+    }
+    /**
+     * Get latest invocations
+     * Get the latest invocations for a specific webhook. The authenticated user must be an administrator to call this resource.
+     * @param webhookId id of the webhook
+     * @param outcomes the outcome to filter for. Can be SUCCESS, FAILURE, ERROR. None specified means that the all will be considered.
+     * @param event the string id of a specific event to retrieve the last invocation for.
+     * @param outcome
+     * @returns DetailedInvocation returns a webhook invocation dataset.
+     * @throws ApiError
+     */
+    public static getLatestInvocation(
+        webhookId: string,
+        outcomes?: string,
+        event?: string,
+        outcome?: Array<string>,
+    ): CancelablePromise<DetailedInvocation> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/webhooks/{webhookId}/latest',
+            path: {
+                'webhookId': webhookId,
+            },
+            query: {
+                'outcomes': outcomes,
+                'event': event,
+                'outcome': outcome,
+            },
+            errors: {
+                401: `returned if the currently authenticated user has insufficient permissions to get webhook.`,
+                404: `returned if the webhook does not exist.`,
+            },
+        });
+    }
+    /**
+     * Get statistic
+     * Get the statistics for a specific webhook. The authenticated user must be an administrator to call this resource.
+     * @param webhookId id of the webhook
+     * @param event the string id of a specific event to retrieve the last invocation for.
+     * @returns RestInvocationHistory returns a webhook invocation dataset.
+     * @throws ApiError
+     */
+    public static getStatistics(
+        webhookId: string,
+        event?: string,
+    ): CancelablePromise<RestInvocationHistory> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/webhooks/{webhookId}/statistics',
+            path: {
+                'webhookId': webhookId,
+            },
+            query: {
+                'event': event,
+            },
+            errors: {
+                401: `returned if the currently authenticated user has insufficient permissions to get webhook.`,
+                404: `returned if the webhook does not exist.`,
+            },
+        });
+    }
+    /**
+     * Get statistics summary
+     * Get the statistics summary for a specific webhook. The authenticated user must be an administrator to call this resource.
+     * @param webhookId id of the webhook
+     * @returns RestInvocationHistory returns a webhook invocation dataset.
+     * @throws ApiError
+     */
+    public static getStatisticsSummary(
+        webhookId: string,
+    ): CancelablePromise<RestInvocationHistory> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/webhooks/{webhookId}/statistics/summary',
+            path: {
+                'webhookId': webhookId,
+            },
+            errors: {
+                401: `returned if the currently authenticated user has insufficient permissions to get webhook.`,
+                404: `returned if the webhook does not exist.`,
+            },
+        });
+    }
+    /**
+     * Test webhook
+     * Test connectivity to a specific endpoint. The authenticated user must be an administrator to call this resource.
+     * @param url the url in which to connect to
+     * @returns any returns a webhook.
+     * @throws ApiError
+     */
+    public static testWebhook(
+        url: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/webhooks/test',
+            query: {
+                'url': url,
+            },
+            errors: {
+                401: `returned if the currently authenticated user has insufficient permissions to test a connection.`,
+                404: `returned if repository does not exist.`,
+            },
+        });
+    }
+}
+
+

package/src/confluence-service.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ContentResourceService, OpenAPI, SearchService, SpaceService } from './confluence-client/index.js';
 
 export interface ConfluenceContent {
   id?: string;
@@ -21,70 +22,22 @@ export interface ConfluenceContent {
 }
 
 export class ConfluenceService {
-  private baseUrl: string;
-  private token: string;
-
   constructor(host: string, token: string) {
-    this.baseUrl = `https://${host}/rest/api`;
-    this.token = token;
+    OpenAPI.BASE = `https://${host}`;
+    OpenAPI.TOKEN = token;
+    OpenAPI.VERSION = '1.0';
   }
-
-  private async request<T>(endpoint: string, options: any = {}): Promise<{ success: boolean; data?: T; error?: string }> {
-    const url = `${this.baseUrl}${endpoint}`;
-    const headers = {
-      'Authorization': `Bearer ${this.token}`,
-      'Content-Type': 'application/json',
-      ...options.headers
-    };
-
-    try {
-      const response = await fetch(url, {
-        ...options,
-        headers
-      });
-
-      const responseData = await response.json();
-
-      if (!response.ok) {
-        return {
-          success: false,
-          error: `Confluence API error: ${response.status} ${response.statusText}`,
-          data: responseData
-        };
-      }
-
-      return {
-        success: true,
-        data: responseData
-      };
-    } catch (error) {
-      if (error instanceof Error) {
-        return {
-          success: false,
-          error: `Confluence API Error: ${error.message}`
-        };
-      }
-      return {
-        success: false,
-        error: 'Unknown Confluence API error occurred'
-      };
-    }
-  }
-
   /**
    * Get a Confluence page by ID
    * @param contentId The ID of the page to retrieve
    * @param expand Optional comma-separated list of properties to expand
    */
   async getContent(contentId: string, expand?: string) {
-    // Default expand to include body.storage to get the content
     const expandValue = expand || 'body.storage';
-    // If expand is provided but doesn't include body.storage, add it
-    const finalExpand = expand && !expand.includes('body.storage') 
-      ? `${expand},body.storage` 
+    const finalExpand = expand && !expand.includes('body.storage')
+      ? `${expand},body.storage`
       : expandValue;
-      
-    return this.request(`/content/${contentId}?expand=${finalExpand}`);
+    return this.handleApiOperation(() => ContentResourceService.getContentById(contentId, finalExpand), 'Error getting content');
   }
 
   /**
@@ -95,14 +48,10 @@ export class ConfluenceService {
    * @param expand Optional comma-separated list of properties to expand
    */
   async searchContent(cql: string, limit?: number, start?: number, expand?: string) {
-    let queryParams = new URLSearchParams();
-    queryParams.append('cql', cql);
-
-    if (limit) queryParams.append('limit', limit.toString());
-    if (start) queryParams.append('start', start.toString());
-    if (expand) queryParams.append('expand', expand);
-
-    return this.request(`/content/search?${queryParams.toString()}`);
+    return this.handleApiOperation(
+      () => SearchService.search1(undefined, expand, undefined, limit?.toString(), start?.toString(), undefined, cql),
+      'Error searching for content'
+    );
   }
 
   /**
@@ -110,10 +59,7 @@ export class ConfluenceService {
    * @param content The content object to create
    */
   async createContent(content: ConfluenceContent) {
-    return this.request('/content', {
-      method: 'POST',
-      body: JSON.stringify(content)
-    });
+    return this.handleApiOperation(() => ContentResourceService.createContent(content), 'Error creating content');
   }
 
   /**
@@ -122,16 +68,59 @@ export class ConfluenceService {
    * @param content The updated content object
    */
   async updateContent(contentId: string, content: ConfluenceContent) {
-    return this.request(`/content/${contentId}`, {
-      method: 'PUT',
-      body: JSON.stringify(content)
-    });
+    return this.handleApiOperation(() => ContentResourceService.update2(contentId, content), 'Error updating content');
+  }
+
+  /**
+   * Search for spaces by text
+   * @param searchText Text to search for in space names or descriptions
+   * @param limit Maximum number of results to return
+   * @param start Start index for pagination
+   * @param expand Optional comma-separated list of properties to expand
+   */
+  async searchSpaces(searchText: string, limit?: number, start?: number, expand?: string) {
+    // Create a CQL query that searches for spaces
+    // The correct syntax for space search is: type=space AND title ~ "searchText"
+    const cql = `type=space AND title ~ "${searchText}"`;
+
+    return this.handleApiOperation(
+      () => SearchService.search1(
+        undefined,
+        expand,
+        undefined,
+        limit?.toString(),
+        start?.toString(),
+        undefined,
+        cql
+      ),
+      'Error searching for spaces'
+    );
   }
 
   static validateConfig(): string[] {
     const requiredEnvVars = ['CONFLUENCE_HOST', 'CONFLUENCE_API_TOKEN'] as const;
     return requiredEnvVars.filter(varName => !process.env[varName]);
   }
+
+  /**
+   * Handle API errors in a consistent way
+   * @param operation Function that performs the API operation
+   * @param errorPrefix Prefix for the error message
+   */
+  private async handleApiOperation<T>(operation: () => Promise<T>, errorPrefix: string): Promise<{ success: boolean; data?: T; error?: string }> {
+    try {
+      const data = await operation();
+      return {
+        success: true,
+        data
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: `${errorPrefix}: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+  }
 }
 
 export const confluenceToolSchemas = {
@@ -158,5 +147,11 @@ export const confluenceToolSchemas = {
     content: z.string().optional().describe("New content body in storage format"),
     version: z.number().describe("New version number (must be incremented)"),
     versionComment: z.string().optional().describe("Comment for this version")
+  },
+  searchSpaces: {
+    searchText: z.string().describe("Text to search for in space names or descriptions"),
+    limit: z.number().optional().describe("Maximum number of results to return"),
+    start: z.number().optional().describe("Start index for pagination"),
+    expand: z.string().optional().describe("Comma-separated list of properties to expand")
   }
 };

package/src/index.ts

@@ -119,4 +119,17 @@ server.tool(
   }
 );
 
+server.tool('confluence_searchSpace',
+  'Search for spaces in Confluence',
+  confluenceToolSchemas.searchSpaces,
+  async ({
+           searchText,
+           limit,
+           start,
+           expand
+         }) => {
+    const result = await confluenceService.searchSpaces(searchText, limit, start, expand);
+    return formatToolResponse(result);
+  });
+
 await connectServer(server);