@theihtisham/mcp-server-firebase 1.0.0

package/dist/tools/auth.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authTools = void 0;
+const firebase_js_1 = require("../services/firebase.js");
+const index_js_1 = require("../utils/index.js");
+// ============================================================
+// AUTH TOOLS
+// ============================================================
+exports.authTools = [
+    // ── auth_create_user ──────────────────────────────────
+    {
+        name: 'auth_create_user',
+        description: 'Create a new Firebase Authentication user. At minimum provide email or phoneNumber.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                email: { type: 'string', description: 'User email address' },
+                emailVerified: { type: 'boolean', description: 'Whether email is verified (default: false)' },
+                phoneNumber: { type: 'string', description: 'Phone number in E.164 format (e.g., "+15555550100")' },
+                password: { type: 'string', description: 'Password (min 6 characters)' },
+                displayName: { type: 'string', description: 'Display name' },
+                photoURL: { type: 'string', description: 'Photo URL' },
+                disabled: { type: 'boolean', description: 'Whether account is disabled (default: false)' },
+                uid: { type: 'string', description: 'Custom UID (auto-generated if not provided)' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const auth = (0, firebase_js_1.getAuth)();
+                const createOptions = {};
+                if (args['email']) {
+                    createOptions.email = (0, index_js_1.validateEmail)(args['email']);
+                }
+                if (args['emailVerified'] !== undefined) {
+                    createOptions.emailVerified = args['emailVerified'];
+                }
+                if (args['phoneNumber']) {
+                    createOptions.phoneNumber = args['phoneNumber'].trim();
+                }
+                if (args['password']) {
+                    const password = args['password'];
+                    if (password.length < 6) {
+                        throw new Error('Password must be at least 6 characters long.');
+                    }
+                    createOptions.password = password;
+                }
+                if (args['displayName']) {
+                    createOptions.displayName = args['displayName'].trim();
+                }
+                if (args['photoURL']) {
+                    createOptions.photoURL = args['photoURL'].trim();
+                }
+                if (args['disabled'] !== undefined) {
+                    createOptions.disabled = args['disabled'];
+                }
+                if (args['uid']) {
+                    createOptions.uid = (0, index_js_1.validateUid)(args['uid']);
+                }
+                const userRecord = await auth.createUser(createOptions);
+                return (0, index_js_1.formatSuccess)({
+                    uid: userRecord.uid,
+                    email: userRecord.email,
+                    phoneNumber: userRecord.phoneNumber,
+                    displayName: userRecord.displayName,
+                    photoURL: userRecord.photoURL,
+                    disabled: userRecord.disabled,
+                    emailVerified: userRecord.emailVerified,
+                    metadata: {
+                        creationTime: userRecord.metadata.creationTime,
+                        lastSignInTime: userRecord.metadata.lastSignInTime,
+                    },
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'auth', 'create_user');
+            }
+        },
+    },
+    // ── auth_get_user ─────────────────────────────────────
+    {
+        name: 'auth_get_user',
+        description: 'Get a Firebase user by UID, email, or phone number.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uid: { type: 'string', description: 'User UID' },
+                email: { type: 'string', description: 'User email (alternative to uid)' },
+                phoneNumber: { type: 'string', description: 'User phone number (alternative to uid)' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const auth = (0, firebase_js_1.getAuth)();
+                let userRecord;
+                if (args['uid']) {
+                    userRecord = await auth.getUser((0, index_js_1.validateUid)(args['uid']));
+                }
+                else if (args['email']) {
+                    userRecord = await auth.getUserByEmail((0, index_js_1.validateEmail)(args['email']));
+                }
+                else if (args['phoneNumber']) {
+                    userRecord = await auth.getUserByPhoneNumber(args['phoneNumber'].trim());
+                }
+                else {
+                    throw new Error('Provide at least one of: uid, email, or phoneNumber.');
+                }
+                return (0, index_js_1.formatSuccess)({
+                    uid: userRecord.uid,
+                    email: userRecord.email,
+                    phoneNumber: userRecord.phoneNumber,
+                    displayName: userRecord.displayName,
+                    photoURL: userRecord.photoURL,
+                    disabled: userRecord.disabled,
+                    emailVerified: userRecord.emailVerified,
+                    customClaims: userRecord.customClaims,
+                    tenantId: userRecord.tenantId,
+                    providerData: userRecord.providerData.map((p) => ({
+                        providerId: p.providerId,
+                        uid: p.uid,
+                        email: p.email,
+                        displayName: p.displayName,
+                        phoneNumber: p.phoneNumber,
+                        photoURL: p.photoURL,
+                    })),
+                    metadata: {
+                        creationTime: userRecord.metadata.creationTime,
+                        lastSignInTime: userRecord.metadata.lastSignInTime,
+                    },
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'auth', 'get_user');
+            }
+        },
+    },
+    // ── auth_list_users ───────────────────────────────────
+    {
+        name: 'auth_list_users',
+        description: 'List Firebase Auth users with pagination. Returns user summaries.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pageSize: { type: 'number', description: 'Results per page (1-1000, default 100)' },
+                pageToken: { type: 'string', description: 'Next page token from previous result' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const auth = (0, firebase_js_1.getAuth)();
+                const pageSize = (0, index_js_1.validatePageSize)(args['pageSize'] || 100);
+                const pageToken = args['pageToken'];
+                const result = await auth.listUsers(pageSize, pageToken);
+                const users = result.users.map((u) => ({
+                    uid: u.uid,
+                    email: u.email,
+                    displayName: u.displayName,
+                    disabled: u.disabled,
+                    emailVerified: u.emailVerified,
+                    creationTime: u.metadata.creationTime,
+                    lastSignInTime: u.metadata.lastSignInTime,
+                }));
+                return (0, index_js_1.formatListResult)(users, result.pageToken);
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'auth', 'list_users');
+            }
+        },
+    },
+    // ── auth_update_user ──────────────────────────────────
+    {
+        name: 'auth_update_user',
+        description: 'Update an existing Firebase user. Only provided fields are updated.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uid: { type: 'string', description: 'User UID to update' },
+                email: { type: 'string', description: 'New email address' },
+                emailVerified: { type: 'boolean', description: 'Email verification status' },
+                phoneNumber: { type: 'string', description: 'New phone number (null to remove)' },
+                password: { type: 'string', description: 'New password (min 6 characters)' },
+                displayName: { type: 'string', description: 'New display name' },
+                photoURL: { type: 'string', description: 'New photo URL' },
+                disabled: { type: 'boolean', description: 'Whether to disable the account' },
+            },
+            required: ['uid'],
+        },
+        handler: async (args) => {
+            try {
+                const auth = (0, firebase_js_1.getAuth)();
+                const uid = (0, index_js_1.validateUid)(args['uid']);
+                const updateOptions = {};
+                if (args['email'] !== undefined) {
+                    updateOptions.email = (0, index_js_1.validateEmail)(args['email']);
+                }
+                if (args['emailVerified'] !== undefined) {
+                    updateOptions.emailVerified = args['emailVerified'];
+                }
+                if (args['phoneNumber'] !== undefined) {
+                    updateOptions.phoneNumber = args['phoneNumber'];
+                }
+                if (args['password'] !== undefined) {
+                    const password = args['password'];
+                    if (password.length < 6) {
+                        throw new Error('Password must be at least 6 characters long.');
+                    }
+                    updateOptions.password = password;
+                }
+                if (args['displayName'] !== undefined) {
+                    updateOptions.displayName = args['displayName'];
+                }
+                if (args['photoURL'] !== undefined) {
+                    updateOptions.photoURL = args['photoURL'];
+                }
+                if (args['disabled'] !== undefined) {
+                    updateOptions.disabled = args['disabled'];
+                }
+                const userRecord = await auth.updateUser(uid, updateOptions);
+                return (0, index_js_1.formatSuccess)({
+                    uid: userRecord.uid,
+                    email: userRecord.email,
+                    displayName: userRecord.displayName,
+                    photoURL: userRecord.photoURL,
+                    disabled: userRecord.disabled,
+                    emailVerified: userRecord.emailVerified,
+                    message: `User "${uid}" updated successfully.`,
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'auth', 'update_user');
+            }
+        },
+    },
+    // ── auth_delete_user ──────────────────────────────────
+    {
+        name: 'auth_delete_user',
+        description: 'Delete a Firebase user by UID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uid: { type: 'string', description: 'User UID to delete' },
+            },
+            required: ['uid'],
+        },
+        handler: async (args) => {
+            try {
+                const auth = (0, firebase_js_1.getAuth)();
+                const uid = (0, index_js_1.validateUid)(args['uid']);
+                await auth.deleteUser(uid);
+                return (0, index_js_1.formatSuccess)({
+                    uid,
+                    message: `User "${uid}" deleted successfully.`,
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'auth', 'delete_user');
+            }
+        },
+    },
+    // ── auth_verify_token ─────────────────────────────────
+    {
+        name: 'auth_verify_token',
+        description: 'Verify a Firebase ID token and return the decoded token with user info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idToken: { type: 'string', description: 'Firebase ID token to verify' },
+                checkRevoked: { type: 'boolean', description: 'Check if token was revoked (default: true)' },
+            },
+            required: ['idToken'],
+        },
+        handler: async (args) => {
+            try {
+                const auth = (0, firebase_js_1.getAuth)();
+                const idToken = args['idToken'].trim();
+                const checkRevoked = args['checkRevoked'] ?? true;
+                if (idToken.length === 0) {
+                    throw new Error('ID token cannot be empty.');
+                }
+                const decodedToken = await auth.verifyIdToken(idToken, checkRevoked);
+                return (0, index_js_1.formatSuccess)({
+                    uid: decodedToken.uid,
+                    email: decodedToken.email,
+                    emailVerified: decodedToken.email_verified,
+                    name: decodedToken.name,
+                    picture: decodedToken.picture,
+                    iss: decodedToken.iss,
+                    aud: decodedToken.aud,
+                    authTime: new Date(decodedToken.auth_time * 1000).toISOString(),
+                    issuedAt: new Date(decodedToken.iat * 1000).toISOString(),
+                    expiresAt: new Date(decodedToken.exp * 1000).toISOString(),
+                    signInProvider: decodedToken.firebase?.sign_in_provider,
+                    valid: true,
+                });
+            }
+            catch (err) {
+                const error = err;
+                return (0, index_js_1.formatSuccess)({
+                    valid: false,
+                    error: error.message,
+                    suggestion: 'Ensure the token is a valid, non-expired Firebase ID token.',
+                });
+            }
+        },
+    },
+    // ── auth_set_custom_claims ────────────────────────────
+    {
+        name: 'auth_set_custom_claims',
+        description: 'Set custom claims on a user for role-based access control.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uid: { type: 'string', description: 'User UID' },
+                customClaims: { type: 'object', description: 'Custom claims object (max 1000 bytes serialized)' },
+            },
+            required: ['uid', 'customClaims'],
+        },
+        handler: async (args) => {
+            try {
+                const auth = (0, firebase_js_1.getAuth)();
+                const uid = (0, index_js_1.validateUid)(args['uid']);
+                const customClaims = args['customClaims'];
+                const claimsSize = Buffer.byteLength(JSON.stringify(customClaims));
+                if (claimsSize > 1000) {
+                    throw new Error(`Custom claims exceed 1000 bytes (got ${claimsSize}). ` +
+                        'Reduce the number or size of claims.');
+                }
+                const reservedKeys = ['iss', 'aud', 'auth_time', 'sub', 'iat', 'exp', 'email', 'email_verified', 'firebase'];
+                for (const key of Object.keys(customClaims)) {
+                    if (reservedKeys.includes(key)) {
+                        throw new Error(`Cannot set reserved claim key: "${key}".`);
+                    }
+                }
+                await auth.setCustomUserClaims(uid, customClaims);
+                return (0, index_js_1.formatSuccess)({
+                    uid,
+                    customClaims,
+                    message: `Custom claims set for user "${uid}". Claims take effect on next token refresh.`,
+                });
+            }
+            catch (err) {
+                (0, index_js_1.handleFirebaseError)(err, 'auth', 'set_custom_claims');
+            }
+        },
+    },
+];
+//# sourceMappingURL=auth.js.map

package/dist/tools/firestore.d.ts

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