@florentleveque/mural-mcp-serveur 0.5.2

package/build/mural-client.js

@@ -0,0 +1,706 @@
+import { MuralOAuth } from './oauth.js';
+import { MuralRateLimiter } from './rate-limiter.js';
+const MURAL_API_BASE = 'https://app.mural.co/api/public/v1';
+// Global authentication promise to prevent multiple concurrent auth flows
+let globalAuthPromise = null;
+export class MuralClient {
+    oauth;
+    baseUrl;
+    rateLimiter;
+    constructor(clientId, clientSecret, redirectUri, rateLimitConfig) {
+        this.oauth = new MuralOAuth(clientId, clientSecret, redirectUri);
+        this.baseUrl = MURAL_API_BASE;
+        this.rateLimiter = new MuralRateLimiter(rateLimitConfig);
+    }
+    async getAccessToken() {
+        // If authentication is already in progress globally, wait for it
+        if (globalAuthPromise) {
+            return globalAuthPromise;
+        }
+        // Start new authentication and store globally
+        globalAuthPromise = this.oauth.getValidAccessToken();
+        try {
+            const token = await globalAuthPromise;
+            return token;
+        }
+        finally {
+            // Clear the global promise when done (success or failure)
+            globalAuthPromise = null;
+        }
+    }
+    async makeAuthenticatedRequest(endpoint, options = {}, maxRetries = 3) {
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            // Check rate limits before making request
+            const rateLimitCheck = await this.rateLimiter.canMakeRequest();
+            if (!rateLimitCheck.allowed) {
+                if (rateLimitCheck.waitTimeMs && rateLimitCheck.waitTimeMs <= 5000) {
+                    // If wait time is reasonable (≤5s), wait and retry
+                    console.warn(`Rate limit hit: ${rateLimitCheck.reason}. Waiting ${rateLimitCheck.waitTimeMs}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, rateLimitCheck.waitTimeMs));
+                    continue;
+                }
+                else {
+                    // If wait time is too long or not available, throw error
+                    throw new Error(`Rate limit exceeded: ${rateLimitCheck.reason}`);
+                }
+            }
+            // Consume rate limit token
+            const consumed = await this.rateLimiter.consumeRequest();
+            if (!consumed) {
+                throw new Error('Failed to consume rate limit token');
+            }
+            try {
+                const accessToken = await this.getAccessToken();
+                const url = `${this.baseUrl}${endpoint}`;
+                const headers = {
+                    'Authorization': `Bearer ${accessToken}`,
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    ...options.headers
+                };
+                const response = await fetch(url, {
+                    ...options,
+                    headers
+                });
+                // Handle rate limit responses from the API
+                if (response.status === 429) {
+                    const retryAfter = response.headers.get('Retry-After');
+                    const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : Math.pow(2, attempt) * 1000;
+                    if (attempt < maxRetries && waitTime <= 30000) {
+                        console.warn(`API rate limit hit (HTTP 429). Retrying after ${waitTime}ms... (attempt ${attempt + 1}/${maxRetries + 1})`);
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                        continue;
+                    }
+                    else {
+                        throw new Error(`API rate limit exceeded (HTTP 429). Max retries reached or wait time too long.`);
+                    }
+                }
+                if (!response.ok) {
+                    let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+                    try {
+                        const errorData = await response.json();
+                        if (errorData.message) {
+                            errorMessage += ` - ${errorData.message}`;
+                        }
+                        if (errorData.errors && Array.isArray(errorData.errors)) {
+                            errorMessage += ` - ${errorData.errors.join(', ')}`;
+                        }
+                    }
+                    catch {
+                        // If error response isn't JSON, use status text
+                    }
+                    // Don't retry on client errors (4xx except 429) or auth errors
+                    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+                        throw new Error(`Mural API request failed: ${errorMessage}`);
+                    }
+                    // Retry on server errors (5xx) with exponential backoff
+                    if (attempt < maxRetries && response.status >= 500) {
+                        const backoffTime = Math.pow(2, attempt) * 1000;
+                        console.warn(`Server error (${response.status}). Retrying after ${backoffTime}ms... (attempt ${attempt + 1}/${maxRetries + 1})`);
+                        await new Promise(resolve => setTimeout(resolve, backoffTime));
+                        continue;
+                    }
+                    throw new Error(`Mural API request failed: ${errorMessage}`);
+                }
+                // Some endpoints (e.g. DELETE) return 204 No Content / an empty body;
+                // calling response.json() on those would throw, so handle empty bodies.
+                if (response.status === 204) {
+                    return undefined;
+                }
+                const text = await response.text();
+                return (text ? JSON.parse(text) : undefined);
+            }
+            catch (error) {
+                // If it's our last attempt or a non-retryable error, throw
+                if (attempt === maxRetries || error instanceof Error && (error.message.includes('Rate limit exceeded') ||
+                    error.message.includes('authentication') ||
+                    error.message.includes('authorization'))) {
+                    throw error;
+                }
+                // Otherwise, wait and retry with exponential backoff
+                const backoffTime = Math.pow(2, attempt) * 1000;
+                console.warn(`Request failed: ${error}. Retrying after ${backoffTime}ms... (attempt ${attempt + 1}/${maxRetries + 1})`);
+                await new Promise(resolve => setTimeout(resolve, backoffTime));
+            }
+        }
+        throw new Error('Max retries exceeded');
+    }
+    async getWorkspaces(limit, offset) {
+        const params = new URLSearchParams();
+        if (limit !== undefined) {
+            params.append('limit', limit.toString());
+        }
+        if (offset !== undefined) {
+            params.append('offset', offset.toString());
+        }
+        const queryString = params.toString();
+        const endpoint = `/workspaces${queryString ? `?${queryString}` : ''}`;
+        try {
+            const response = await this.makeAuthenticatedRequest(endpoint);
+            // The API returns workspaces in a "value" property
+            return response.value && Array.isArray(response.value) ? response.value : [];
+        }
+        catch (error) {
+            console.error('Failed to fetch workspaces:', error);
+            throw error;
+        }
+    }
+    async getWorkspace(workspaceId) {
+        try {
+            const workspace = await this.makeAuthenticatedRequest(`/workspaces/${workspaceId}`);
+            return workspace;
+        }
+        catch (error) {
+            console.error(`Failed to fetch workspace ${workspaceId}:`, error);
+            throw error;
+        }
+    }
+    async testConnection() {
+        try {
+            await this.getWorkspaces(1);
+            return true;
+        }
+        catch (error) {
+            console.error('Connection test failed:', error);
+            return false;
+        }
+    }
+    async clearAuthentication() {
+        // Clear the global auth promise
+        globalAuthPromise = null;
+        await this.oauth.clearTokens();
+    }
+    async getRateLimitStatus() {
+        return await this.rateLimiter.getRateLimitStatus();
+    }
+    async resetRateLimits() {
+        await this.rateLimiter.reset();
+    }
+    /**
+     * Fetch every page of a cursor-paginated endpoint and return a flat array.
+     * The Mural API paginates list endpoints with `limit` + a `next` cursor.
+     * Checks the OAuth scope once, then follows `next` until exhausted or the
+     * safety cap (`maxPages`) is reached. Existing query params are preserved.
+     */
+    async fetchAllPages(basePath, scope, maxPages = 100) {
+        const scopeCheck = await this.checkScope(scope);
+        if (!scopeCheck.hasScope) {
+            throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has '${scope}' scope and re-authenticate.`);
+        }
+        const items = [];
+        const [path, existingQuery = ''] = basePath.split('?');
+        let next;
+        let page = 0;
+        do {
+            const params = new URLSearchParams(existingQuery);
+            if (next)
+                params.set('next', next);
+            const queryString = params.toString();
+            const endpoint = `${path}${queryString ? `?${queryString}` : ''}`;
+            const response = await this.makeAuthenticatedRequest(endpoint);
+            const pageItems = response.value ?? response.widgets ?? response;
+            if (Array.isArray(pageItems)) {
+                items.push(...pageItems);
+            }
+            next = response.next;
+            page++;
+        } while (next && page < maxPages);
+        if (next && page >= maxPages) {
+            console.error(`fetchAllPages: reached the ${maxPages}-page cap for ${path}; results may be truncated.`);
+        }
+        return items;
+    }
+    async getWorkspaceRooms(workspaceId, openOnly = false) {
+        try {
+            const endpoint = openOnly
+                ? `/workspaces/${workspaceId}/rooms/open`
+                : `/workspaces/${workspaceId}/rooms`;
+            return await this.fetchAllPages(endpoint, 'rooms:read');
+        }
+        catch (error) {
+            if (error instanceof Error && (error.message.includes('403') || error.message.includes('scope'))) {
+                const scopeCheck = await this.checkScope('rooms:read');
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'rooms:read' scope and re-authenticate.`);
+            }
+            console.error(`Failed to fetch rooms for workspace ${workspaceId}:`, error);
+            throw error;
+        }
+    }
+    async getWorkspaceTemplates(workspaceId, searchQuery, withoutDefault = false) {
+        try {
+            let endpoint;
+            if (searchQuery && searchQuery.trim()) {
+                endpoint = `/search/${workspaceId}/templates?q=${encodeURIComponent(searchQuery.trim())}`;
+            }
+            else {
+                endpoint = `/workspaces/${workspaceId}/templates`;
+                if (withoutDefault) {
+                    endpoint += '?withoutDefault=true';
+                }
+            }
+            return await this.fetchAllPages(endpoint, 'templates:read');
+        }
+        catch (error) {
+            if (error instanceof Error && (error.message.includes('403') || error.message.includes('scope'))) {
+                const scopeCheck = await this.checkScope('templates:read');
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'templates:read' scope and re-authenticate.`);
+            }
+            console.error(`Failed to fetch templates for workspace ${workspaceId}:`, error);
+            throw error;
+        }
+    }
+    async createMuralFromTemplate(templateId, title, roomId, folderId) {
+        try {
+            const scopeCheck = await this.checkScope('murals:write');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+            }
+            const body = { title, roomId };
+            if (folderId) {
+                body.folderId = folderId;
+            }
+            const response = await this.makeAuthenticatedRequest(`/templates/${encodeURIComponent(templateId)}/murals`, {
+                method: 'POST',
+                body: JSON.stringify(body)
+            });
+            return response.value || response;
+        }
+        catch (error) {
+            console.error(`Failed to create mural from template ${templateId}:`, error);
+            throw error;
+        }
+    }
+    async createRoom(workspaceId, name, type, description, confidential) {
+        try {
+            const scopeCheck = await this.checkScope('rooms:write');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'rooms:write' scope and re-authenticate.`);
+            }
+            const body = { name, type, workspaceId };
+            if (description !== undefined) {
+                body.description = description;
+            }
+            if (confidential !== undefined) {
+                body.confidential = confidential;
+            }
+            const response = await this.makeAuthenticatedRequest('/rooms', {
+                method: 'POST',
+                body: JSON.stringify(body)
+            });
+            return response.value || response;
+        }
+        catch (error) {
+            console.error(`Failed to create room "${name}" in workspace ${workspaceId}:`, error);
+            throw error;
+        }
+    }
+    async createMural(roomId, options = {}) {
+        try {
+            const scopeCheck = await this.checkScope('murals:write');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+            }
+            const body = { roomId, ...options };
+            const response = await this.makeAuthenticatedRequest('/murals', {
+                method: 'POST',
+                body: JSON.stringify(body)
+            });
+            return response.value || response;
+        }
+        catch (error) {
+            console.error(`Failed to create mural in room ${roomId}:`, error);
+            throw error;
+        }
+    }
+    async updateMural(muralId, updates) {
+        try {
+            const scopeCheck = await this.checkScope('murals:write');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+            }
+            const response = await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}`, {
+                method: 'PATCH',
+                body: JSON.stringify(updates)
+            });
+            return response.value || response;
+        }
+        catch (error) {
+            console.error(`Failed to update mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    async deleteMural(muralId) {
+        try {
+            const scopeCheck = await this.checkScope('murals:write');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+            }
+            await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}`, { method: 'DELETE' });
+        }
+        catch (error) {
+            console.error(`Failed to delete mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    async duplicateMural(muralId, roomId, title, options = {}) {
+        try {
+            const scopeCheck = await this.checkScope('murals:write');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+            }
+            const body = { roomId, title, ...options };
+            const response = await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}/duplicate`, {
+                method: 'POST',
+                body: JSON.stringify(body)
+            });
+            return response.value || response;
+        }
+        catch (error) {
+            console.error(`Failed to duplicate mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    async exportMural(muralId, downloadFormat) {
+        try {
+            const scopeCheck = await this.checkScope('murals:read');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:read' scope and re-authenticate.`);
+            }
+            const response = await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}/export`, {
+                method: 'POST',
+                body: JSON.stringify({ downloadFormat })
+            });
+            return response.value || response;
+        }
+        catch (error) {
+            console.error(`Failed to export mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    async getWorkspaceMurals(workspaceId) {
+        try {
+            // Check if user has required scope first
+            const scopeCheck = await this.checkScope('murals:read');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:read' scope and re-authenticate.`);
+            }
+            // Try RESTful endpoint (legacy endpoints appear to be deprecated/non-existent)
+            const response = await this.makeAuthenticatedRequest(`/workspaces/${workspaceId}/murals`);
+            // The API response structure may vary, handle both direct array and wrapped response
+            const murals = response.value || response.murals || response;
+            return Array.isArray(murals) ? murals : [];
+        }
+        catch (error) {
+            // Check if error is scope-related and provide helpful message
+            if (error instanceof Error) {
+                if (error.message.includes('403') || error.message.includes('scope')) {
+                    const scopeCheck = await this.checkScope('murals:read');
+                    throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:read' scope and re-authenticate.`);
+                }
+            }
+            console.error(`Failed to fetch murals for workspace ${workspaceId}:`, error);
+            throw error;
+        }
+    }
+    async getRoomMurals(roomId) {
+        try {
+            // Check if user has required scope first
+            const scopeCheck = await this.checkScope('murals:read');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:read' scope and re-authenticate.`);
+            }
+            // Try RESTful endpoint (legacy endpoints appear to be deprecated/non-existent)
+            const response = await this.makeAuthenticatedRequest(`/rooms/${roomId}/murals`);
+            // The API response structure may vary, handle both direct array and wrapped response
+            const murals = response.value || response.murals || response;
+            return Array.isArray(murals) ? murals : [];
+        }
+        catch (error) {
+            // Check if error is scope-related and provide helpful message
+            if (error instanceof Error) {
+                if (error.message.includes('403') || error.message.includes('scope')) {
+                    const scopeCheck = await this.checkScope('murals:read');
+                    throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:read' scope and re-authenticate.`);
+                }
+            }
+            console.error(`Failed to fetch murals for room ${roomId}:`, error);
+            throw error;
+        }
+    }
+    async getMural(muralId) {
+        try {
+            // Check if user has required scope first
+            const scopeCheck = await this.checkScope('murals:read');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:read' scope and re-authenticate.`);
+            }
+            const mural = await this.makeAuthenticatedRequest(`/murals/${muralId}`);
+            return mural;
+        }
+        catch (error) {
+            // Check if error is scope-related and provide helpful message
+            if (error instanceof Error) {
+                if (error.message.includes('403') || error.message.includes('scope')) {
+                    const scopeCheck = await this.checkScope('murals:read');
+                    throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:read' scope and re-authenticate.`);
+                }
+            }
+            console.error(`Failed to fetch mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    async getCurrentUser() {
+        try {
+            const user = await this.makeAuthenticatedRequest(`/users/me`);
+            return user;
+        }
+        catch (error) {
+            console.error('Failed to fetch current user:', error);
+            throw error;
+        }
+    }
+    async getUserScopes() {
+        try {
+            // Extract scopes from the stored OAuth token (primary method)
+            const tokens = await this.oauth.getStoredTokens();
+            if (!tokens) {
+                return [];
+            }
+            // First check if scopes are in the top-level scope field
+            if (tokens.scope) {
+                return tokens.scope.split(' ').filter(scope => scope.trim() !== '');
+            }
+            // If no top-level scope field, try to decode JWT access token
+            if (tokens.access_token) {
+                try {
+                    // Decode JWT payload (without verification - just for scope extraction)
+                    const payloadPart = tokens.access_token.split('.')[1];
+                    if (payloadPart) {
+                        const payload = JSON.parse(Buffer.from(payloadPart, 'base64url').toString());
+                        if (payload.scopes && Array.isArray(payload.scopes)) {
+                            return payload.scopes;
+                        }
+                    }
+                }
+                catch (jwtError) {
+                    console.warn('Failed to decode JWT for scope extraction:', jwtError);
+                }
+            }
+            // If no stored tokens or scope information, return empty array
+            // Don't try to fetch from API as that might require scopes we don't have
+            return [];
+        }
+        catch (error) {
+            console.error('Failed to get user scopes:', error);
+            return [];
+        }
+    }
+    async checkScope(requiredScope) {
+        try {
+            const availableScopes = await this.getUserScopes();
+            const hasScope = availableScopes.includes(requiredScope);
+            return {
+                hasScope,
+                requiredScope,
+                availableScopes,
+                message: hasScope
+                    ? `User has required scope: ${requiredScope}`
+                    : `User missing required scope: ${requiredScope}. Available scopes: ${availableScopes.join(', ') || 'none'}`
+            };
+        }
+        catch (error) {
+            return {
+                hasScope: false,
+                requiredScope,
+                availableScopes: [],
+                message: `Failed to check scopes: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    async debugWorkspacesAPI() {
+        const accessToken = await this.oauth.getValidAccessToken();
+        const url = `${this.baseUrl}/workspaces`;
+        const headers = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Accept': 'application/json',
+            'Content-Type': 'application/json'
+        };
+        try {
+            const response = await fetch(url, { headers });
+            const debugInfo = {
+                url,
+                status: response.status,
+                statusText: response.statusText,
+                headers: Object.fromEntries(response.headers.entries()),
+                timestamp: new Date().toISOString()
+            };
+            let responseData;
+            try {
+                responseData = await response.json();
+            }
+            catch (e) {
+                responseData = await response.text();
+            }
+            return {
+                request: debugInfo,
+                response: {
+                    value: responseData,
+                    raw: responseData
+                },
+                success: response.ok
+            };
+        }
+        catch (error) {
+            return {
+                request: { url, headers: { ...headers, Authorization: '[REDACTED]' } },
+                error: error instanceof Error ? error.message : 'Unknown error',
+                success: false
+            };
+        }
+    }
+    // ============================================================================
+    // CONTENT API METHODS
+    // ============================================================================
+    // Widget operations
+    async getMuralWidgets(muralId) {
+        try {
+            // Paginated: follows the API's `next` cursor so all widgets are returned
+            // (the endpoint pages at ~100 widgets).
+            return await this.fetchAllPages(`/murals/${encodeURIComponent(muralId)}/widgets`, 'murals:read');
+        }
+        catch (error) {
+            if (error instanceof Error && (error.message.includes('403') || error.message.includes('scope'))) {
+                const scopeCheck = await this.checkScope('murals:read');
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:read' scope and re-authenticate.`);
+            }
+            console.error(`Failed to fetch widgets for mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    async getMuralWidget(muralId, widgetId) {
+        try {
+            const scopeCheck = await this.checkScope('murals:read');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:read' scope and re-authenticate.`);
+            }
+            const response = await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}/widgets/${encodeURIComponent(widgetId)}`);
+            return response;
+        }
+        catch (error) {
+            console.error(`Failed to fetch widget ${widgetId} from mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    async deleteWidget(muralId, widgetId) {
+        try {
+            const scopeCheck = await this.checkScope('murals:write');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+            }
+            await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}/widgets/${encodeURIComponent(widgetId)}`, {
+                method: 'DELETE'
+            });
+        }
+        catch (error) {
+            console.error(`Failed to delete widget ${widgetId} from mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    // Widget creation methods
+    async createStickyNotes(muralId, stickyNotes) {
+        try {
+            const scopeCheck = await this.checkScope('murals:write');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+            }
+            if (stickyNotes.length > 1000) {
+                throw new Error('Maximum 1000 sticky notes per request');
+            }
+            const response = await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}/widgets/sticky-note`, {
+                method: 'POST',
+                body: JSON.stringify(stickyNotes)
+            });
+            return response.value || response || [];
+        }
+        catch (error) {
+            console.error(`Failed to create sticky notes for mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    // ============================================================================
+    // WIDGET UPDATE METHODS (PATCH OPERATIONS)
+    // ============================================================================
+    async updateStickyNote(muralId, widgetId, updates) {
+        try {
+            const scopeCheck = await this.checkScope('murals:write');
+            if (!scopeCheck.hasScope) {
+                throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+            }
+            const response = await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}/widgets/sticky-note/${encodeURIComponent(widgetId)}`, {
+                method: 'PATCH',
+                body: JSON.stringify(updates)
+            });
+            return response.value || response;
+        }
+        catch (error) {
+            console.error(`Failed to update sticky note ${widgetId} in mural ${muralId}:`, error);
+            throw error;
+        }
+    }
+    // ============================================================================
+    // GENERIC WIDGET CREATION / UPDATE (used by shape, arrow, text-box, title, area)
+    // ============================================================================
+    async createWidgetsOfKind(muralId, kind, widgets) {
+        const scopeCheck = await this.checkScope('murals:write');
+        if (!scopeCheck.hasScope) {
+            throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+        }
+        const response = await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}/widgets/${kind}`, {
+            method: 'POST',
+            body: JSON.stringify(widgets),
+        });
+        return response.value || response || [];
+    }
+    async updateWidgetOfKind(muralId, kind, widgetId, updates) {
+        const scopeCheck = await this.checkScope('murals:write');
+        if (!scopeCheck.hasScope) {
+            throw new Error(`Permission denied: ${scopeCheck.message}. Please ensure your Mural OAuth app has 'murals:write' scope and re-authenticate.`);
+        }
+        const response = await this.makeAuthenticatedRequest(`/murals/${encodeURIComponent(muralId)}/widgets/${kind}/${encodeURIComponent(widgetId)}`, {
+            method: 'PATCH',
+            body: JSON.stringify(updates),
+        });
+        return response.value || response;
+    }
+    async createShapes(muralId, shapes) {
+        return this.createWidgetsOfKind(muralId, 'shape', shapes);
+    }
+    async createArrows(muralId, arrows) {
+        return this.createWidgetsOfKind(muralId, 'arrow', arrows);
+    }
+    async createTextBoxes(muralId, textBoxes) {
+        return this.createWidgetsOfKind(muralId, 'text-box', textBoxes);
+    }
+    async createTitles(muralId, titles) {
+        return this.createWidgetsOfKind(muralId, 'title', titles);
+    }
+    async createAreas(muralId, areas) {
+        return this.createWidgetsOfKind(muralId, 'area', areas);
+    }
+    async updateShape(muralId, widgetId, updates) {
+        return this.updateWidgetOfKind(muralId, 'shape', widgetId, updates);
+    }
+    async updateArrow(muralId, widgetId, updates) {
+        return this.updateWidgetOfKind(muralId, 'arrow', widgetId, updates);
+    }
+    async updateTextBox(muralId, widgetId, updates) {
+        return this.updateWidgetOfKind(muralId, 'text-box', widgetId, updates);
+    }
+    async updateTitle(muralId, widgetId, updates) {
+        return this.updateWidgetOfKind(muralId, 'title', widgetId, updates);
+    }
+    async updateArea(muralId, widgetId, updates) {
+        return this.updateWidgetOfKind(muralId, 'area', widgetId, updates);
+    }
+}
+//# sourceMappingURL=mural-client.js.map