@theihtisham/mcp-server-firebase 1.0.0

package/dist/tools/functions.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from './types.js';
+export declare const functionsTools: ToolDefinition[];
+//# sourceMappingURL=functions.d.ts.map

package/dist/tools/functions.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionsTools = void 0;
+const index_js_1 = require("../utils/index.js");
+// ============================================================
+// CLOUD FUNCTIONS TOOLS
+// ============================================================
+exports.functionsTools = [
+    // ── functions_list ────────────────────────────────────
+    {
+        name: 'functions_list',
+        description: 'List deployed Firebase Cloud Functions with their trigger types and status.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                region: { type: 'string', description: 'Region filter (default: us-central1)' },
+                pageSize: { type: 'number', description: 'Maximum results (default: 100)' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const projectId = process.env['FIREBASE_PROJECT_ID'];
+                if (!projectId) {
+                    throw new Error('FIREBASE_PROJECT_ID is required to list functions. ' +
+                        'Set it as an environment variable.');
+                }
+                const region = args['region'] || 'us-central1';
+                const pageSize = Math.min(args['pageSize'] || 100, 1000);
+                const { GoogleAuth } = await import('google-auth-library');
+                const auth = new GoogleAuth({
+                    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+                });
+                const client = await auth.getClient();
+                const url = `https://cloudfunctions.googleapis.com/v2/projects/${projectId}/locations/${region}/functions?pageSize=${pageSize}`;
+                const response = await client.request({ url });
+                const data = response.data;
+                const functions = (data.functions || []).map((fn) => ({
+                    name: fn.name?.split('/').pop(),
+                    fullName: fn.name,
+                    state: fn.state,
+                    updateTime: fn.updateTime,
+                    buildId: fn.buildId,
+                    eventTrigger: fn.eventTrigger ? {
+                        eventType: fn.eventTrigger.eventType,
+                        resource: fn.eventTrigger.resource,
+                    } : undefined,
+                    httpsTrigger: fn.httpsTrigger ? {
+                        uri: fn.httpsTrigger.uri,
+                    } : undefined,
+                    entryPoint: fn.entryPoint,
+                    runtime: fn.runtime,
+                }));
+                return (0, index_js_1.formatSuccess)({
+                    projectId,
+                    region,
+                    count: functions.length,
+                    functions,
+                    nextPageToken: data.nextPageToken,
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'functions', 'list');
+            }
+        },
+    },
+    // ── functions_trigger ─────────────────────────────────
+    {
+        name: 'functions_trigger',
+        description: 'Trigger an HTTP Cloud Function by URL. Sends a POST request with optional data payload.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'HTTPS trigger URL of the Cloud Function' },
+                data: { description: 'JSON payload to send with the request' },
+                method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'DELETE'], description: 'HTTP method (default: POST)' },
+            },
+            required: ['url'],
+        },
+        handler: async (args) => {
+            try {
+                const url = args['url'].trim();
+                const data = args['data'];
+                const method = args['method'] || 'POST';
+                if (!url.startsWith('https://')) {
+                    throw new Error('URL must start with "https://".');
+                }
+                const { GoogleAuth } = await import('google-auth-library');
+                const auth = new GoogleAuth();
+                const client = await auth.getIdTokenClient(url);
+                const response = await client.request({
+                    url,
+                    method,
+                    data,
+                    responseType: 'json',
+                });
+                return (0, index_js_1.formatSuccess)({
+                    status: response.status,
+                    statusText: response.statusText,
+                    data: response.data,
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'functions', 'trigger');
+            }
+        },
+    },
+    // ── functions_get_logs ────────────────────────────────
+    {
+        name: 'functions_get_logs',
+        description: 'Get recent logs for a Firebase Cloud Function. Requires FIREBASE_PROJECT_ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                functionName: { type: 'string', description: 'Name of the Cloud Function' },
+                region: { type: 'string', description: 'Region (default: us-central1)' },
+                pageSize: { type: 'number', description: 'Maximum log entries (default: 50, max 100)' },
+                filter: { type: 'string', description: 'Additional log filter expression' },
+            },
+            required: ['functionName'],
+        },
+        handler: async (args) => {
+            try {
+                const projectId = process.env['FIREBASE_PROJECT_ID'];
+                if (!projectId) {
+                    throw new Error('FIREBASE_PROJECT_ID is required to get function logs.');
+                }
+                const functionName = args['functionName'].trim();
+                const region = args['region'] || 'us-central1';
+                const pageSize = Math.min(args['pageSize'] || 50, 100);
+                const additionalFilter = args['filter'] || '';
+                const { GoogleAuth } = await import('google-auth-library');
+                const auth = new GoogleAuth({
+                    scopes: ['https://www.googleapis.com/auth/logging.read'],
+                });
+                const client = await auth.getClient();
+                const filter = `resource.type="cloud_function" resource.labels.function_name="${functionName}" resource.labels.region="${region}"${additionalFilter ? ` ${additionalFilter}` : ''}`;
+                const url = 'https://logging.googleapis.com/v2/entries:list';
+                const response = await client.request({
+                    url,
+                    method: 'POST',
+                    data: {
+                        resourceNames: [`projects/${projectId}`],
+                        filter,
+                        orderBy: 'timestamp desc',
+                        pageSize,
+                    },
+                });
+                const data = response.data;
+                const logs = (data.entries || []).map((entry) => ({
+                    timestamp: entry.timestamp,
+                    severity: entry.severity,
+                    textPayload: entry.textPayload,
+                    jsonPayload: entry.jsonPayload,
+                }));
+                return (0, index_js_1.formatSuccess)({
+                    functionName,
+                    region,
+                    count: logs.length,
+                    logs,
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'functions', 'get_logs');
+            }
+        },
+    },
+];
+//# sourceMappingURL=functions.js.map

package/dist/tools/index.d.ts

@@ -0,0 +1,10 @@
+export type { ToolDefinition } from './types.js';
+export { firestoreTools } from './firestore.js';
+export { authTools } from './auth.js';
+export { storageTools } from './storage.js';
+export { realtimeDbTools } from './realtime-db.js';
+export { functionsTools } from './functions.js';
+export { messagingTools } from './messaging.js';
+import type { ToolDefinition } from './types.js';
+export declare const allTools: ToolDefinition[];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allTools = exports.messagingTools = exports.functionsTools = exports.realtimeDbTools = exports.storageTools = exports.authTools = exports.firestoreTools = void 0;
+var firestore_js_1 = require("./firestore.js");
+Object.defineProperty(exports, "firestoreTools", { enumerable: true, get: function () { return firestore_js_1.firestoreTools; } });
+var auth_js_1 = require("./auth.js");
+Object.defineProperty(exports, "authTools", { enumerable: true, get: function () { return auth_js_1.authTools; } });
+var storage_js_1 = require("./storage.js");
+Object.defineProperty(exports, "storageTools", { enumerable: true, get: function () { return storage_js_1.storageTools; } });
+var realtime_db_js_1 = require("./realtime-db.js");
+Object.defineProperty(exports, "realtimeDbTools", { enumerable: true, get: function () { return realtime_db_js_1.realtimeDbTools; } });
+var functions_js_1 = require("./functions.js");
+Object.defineProperty(exports, "functionsTools", { enumerable: true, get: function () { return functions_js_1.functionsTools; } });
+var messaging_js_1 = require("./messaging.js");
+Object.defineProperty(exports, "messagingTools", { enumerable: true, get: function () { return messaging_js_1.messagingTools; } });
+const firestore_js_2 = require("./firestore.js");
+const auth_js_2 = require("./auth.js");
+const storage_js_2 = require("./storage.js");
+const realtime_db_js_2 = require("./realtime-db.js");
+const functions_js_2 = require("./functions.js");
+const messaging_js_2 = require("./messaging.js");
+exports.allTools = [
+    ...firestore_js_2.firestoreTools,
+    ...auth_js_2.authTools,
+    ...storage_js_2.storageTools,
+    ...realtime_db_js_2.realtimeDbTools,
+    ...functions_js_2.functionsTools,
+    ...messaging_js_2.messagingTools,
+];
+//# sourceMappingURL=index.js.map

package/dist/tools/messaging.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from './types.js';
+export declare const messagingTools: ToolDefinition[];
+//# sourceMappingURL=messaging.d.ts.map

package/dist/tools/messaging.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messagingTools = void 0;
+const firebase_js_1 = require("../services/firebase.js");
+const index_js_1 = require("../utils/index.js");
+// ============================================================
+// MESSAGING (FCM) TOOLS
+// ============================================================
+exports.messagingTools = [
+    // ── messaging_send ────────────────────────────────────
+    {
+        name: 'messaging_send',
+        description: 'Send a push notification to a specific device via FCM token or to a topic.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                token: { type: 'string', description: 'FCM device registration token' },
+                topic: { type: 'string', description: 'Topic name (alternative to token)' },
+                condition: { type: 'string', description: 'Condition expression (alternative to token/topic)' },
+                notification: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', description: 'Notification title' },
+                        body: { type: 'string', description: 'Notification body text' },
+                        imageUrl: { type: 'string', description: 'Notification image URL' },
+                    },
+                    description: 'Notification payload',
+                },
+                data: {
+                    type: 'object',
+                    description: 'Custom data payload (key-value pairs)',
+                },
+                android: {
+                    type: 'object',
+                    properties: {
+                        priority: { type: 'string', enum: ['high', 'normal'], description: 'Message priority' },
+                        ttl: { type: 'number', description: 'Time to live in seconds' },
+                    },
+                    description: 'Android-specific options',
+                },
+                apns: {
+                    type: 'object',
+                    properties: {
+                        badge: { type: 'number', description: 'Badge count' },
+                        sound: { type: 'string', description: 'Sound file name' },
+                    },
+                    description: 'APNs-specific options',
+                },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const messaging = (0, firebase_js_1.getMessaging)();
+                const hasToken = !!args['token'];
+                const hasTopic = !!args['topic'];
+                const hasCondition = !!args['condition'];
+                if ([hasToken, hasTopic, hasCondition].filter(Boolean).length > 1) {
+                    throw new Error('Provide exactly one of: token, topic, or condition.');
+                }
+                if (!hasToken && !hasTopic && !hasCondition) {
+                    throw new Error('Must provide one of: token, topic, or condition.');
+                }
+                // Build message using the appropriate type
+                // We need to construct the message based on the target type
+                let message;
+                if (hasToken) {
+                    message = { token: args['token'].trim() };
+                }
+                else if (hasTopic) {
+                    message = { topic: args['topic'].trim() };
+                }
+                else {
+                    message = { condition: args['condition'].trim() };
+                }
+                // Notification
+                if (args['notification']) {
+                    const notif = args['notification'];
+                    message.notification = {
+                        title: notif.title || '',
+                        body: notif.body || '',
+                        ...(notif.imageUrl && { imageUrl: notif.imageUrl }),
+                    };
+                }
+                // Data payload (values must be strings for FCM)
+                if (args['data']) {
+                    const rawData = args['data'];
+                    const stringData = {};
+                    for (const [key, value] of Object.entries(rawData)) {
+                        stringData[key] = String(value);
+                    }
+                    message.data = stringData;
+                }
+                // Android config
+                if (args['android']) {
+                    const android = args['android'];
+                    message.android = {
+                        priority: android.priority || 'high',
+                        ...(android.ttl !== undefined && { ttl: android.ttl * 1000 }),
+                    };
+                }
+                // APNs config
+                if (args['apns']) {
+                    const apns = args['apns'];
+                    message.apns = {
+                        payload: {
+                            aps: {
+                                ...(apns.badge !== undefined && { badge: apns.badge }),
+                                ...(apns.sound && { sound: apns.sound }),
+                            },
+                        },
+                    };
+                }
+                const messageId = await messaging.send(message);
+                return (0, index_js_1.formatSuccess)({
+                    messageId,
+                    target: hasToken ? `token:${args['token'].substring(0, 10)}...` :
+                        hasTopic ? `topic:${args['topic']}` :
+                            `condition:${args['condition']}`,
+                    message: 'Notification sent successfully.',
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'messaging', 'send');
+            }
+        },
+    },
+    // ── messaging_send_multicast ──────────────────────────
+    {
+        name: 'messaging_send_multicast',
+        description: 'Send a push notification to multiple devices (up to 500 tokens) in a single request.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tokens: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of FCM device tokens (max 500)',
+                },
+                notification: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string' },
+                        body: { type: 'string' },
+                        imageUrl: { type: 'string' },
+                    },
+                    description: 'Notification payload',
+                },
+                data: { type: 'object', description: 'Custom data payload' },
+            },
+            required: ['tokens'],
+        },
+        handler: async (args) => {
+            try {
+                const tokens = args['tokens'];
+                if (!tokens || tokens.length === 0) {
+                    throw new Error('Tokens array cannot be empty.');
+                }
+                if (tokens.length > 500) {
+                    throw new Error(`Too many tokens: ${tokens.length}. Maximum is 500 per multicast. ` +
+                        'Split into multiple batches.');
+                }
+                const messaging = (0, firebase_js_1.getMessaging)();
+                const message = {
+                    tokens: tokens.map((t) => t.trim()),
+                };
+                if (args['notification']) {
+                    const notif = args['notification'];
+                    message.notification = {
+                        title: notif.title || '',
+                        body: notif.body || '',
+                        ...(notif.imageUrl && { imageUrl: notif.imageUrl }),
+                    };
+                }
+                if (args['data']) {
+                    const rawData = args['data'];
+                    const stringData = {};
+                    for (const [key, value] of Object.entries(rawData)) {
+                        stringData[key] = String(value);
+                    }
+                    message.data = stringData;
+                }
+                const batchResponse = await messaging.sendEachForMulticast(message);
+                const failedTokens = [];
+                if (batchResponse.failureCount > 0) {
+                    batchResponse.responses.forEach((resp, idx) => {
+                        if (!resp.success) {
+                            failedTokens.push(tokens[idx]);
+                        }
+                    });
+                }
+                return (0, index_js_1.formatSuccess)({
+                    successCount: batchResponse.successCount,
+                    failureCount: batchResponse.failureCount,
+                    totalSent: tokens.length,
+                    ...(failedTokens.length > 0 && {
+                        failedTokens: failedTokens.slice(0, 50),
+                        message: `${batchResponse.successCount} succeeded, ${batchResponse.failureCount} failed.`,
+                    }),
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'messaging', 'send_multicast');
+            }
+        },
+    },
+    // ── messaging_subscribe_topic ─────────────────────────
+    {
+        name: 'messaging_subscribe_topic',
+        description: 'Subscribe device tokens to an FCM topic for topic-based messaging.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tokens: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of FCM tokens to subscribe (max 1000)',
+                },
+                topic: { type: 'string', description: 'Topic name to subscribe to' },
+            },
+            required: ['tokens', 'topic'],
+        },
+        handler: async (args) => {
+            try {
+                const tokens = args['tokens'];
+                const topic = args['topic'].trim();
+                if (!tokens || tokens.length === 0) {
+                    throw new Error('Tokens array cannot be empty.');
+                }
+                if (tokens.length > 1000) {
+                    throw new Error('Maximum 1000 tokens per subscribe request.');
+                }
+                if (!topic) {
+                    throw new Error('Topic name cannot be empty.');
+                }
+                if (!/^[a-zA-Z0-9-_.~%]+$/.test(topic)) {
+                    throw new Error(`Invalid topic name: "${topic}". ` +
+                        'Topic names must match: [a-zA-Z0-9-_.~%]+');
+                }
+                const messaging = (0, firebase_js_1.getMessaging)();
+                const response = await messaging.subscribeToTopic(tokens, topic);
+                return (0, index_js_1.formatSuccess)({
+                    successCount: response.successCount,
+                    failureCount: response.failureCount,
+                    topic,
+                    tokensRequested: tokens.length,
+                    message: `${response.successCount} tokens subscribed to "${topic}".`,
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'messaging', 'subscribe_topic');
+            }
+        },
+    },
+    // ── messaging_unsubscribe_topic ───────────────────────
+    {
+        name: 'messaging_unsubscribe_topic',
+        description: 'Unsubscribe device tokens from an FCM topic.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tokens: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of FCM tokens to unsubscribe (max 1000)',
+                },
+                topic: { type: 'string', description: 'Topic name to unsubscribe from' },
+            },
+            required: ['tokens', 'topic'],
+        },
+        handler: async (args) => {
+            try {
+                const tokens = args['tokens'];
+                const topic = args['topic'].trim();
+                if (!tokens || tokens.length === 0) {
+                    throw new Error('Tokens array cannot be empty.');
+                }
+                if (!topic) {
+                    throw new Error('Topic name cannot be empty.');
+                }
+                const messaging = (0, firebase_js_1.getMessaging)();
+                const response = await messaging.unsubscribeFromTopic(tokens, topic);
+                return (0, index_js_1.formatSuccess)({
+                    successCount: response.successCount,
+                    failureCount: response.failureCount,
+                    topic,
+                    tokensRequested: tokens.length,
+                    message: `${response.successCount} tokens unsubscribed from "${topic}".`,
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'messaging', 'unsubscribe_topic');
+            }
+        },
+    },
+];
+//# sourceMappingURL=messaging.js.map

package/dist/tools/realtime-db.d.ts

@@ -0,0 +1,4 @@
+import type { ToolDefinition } from './types.js';
+export declare function validateRtdbPath(path: string): string;
+export declare const realtimeDbTools: ToolDefinition[];
+//# sourceMappingURL=realtime-db.d.ts.map