@spacelr/mcp 0.0.4 → 0.0.6

package/dist/index.mjs

@@ -76,13 +76,13 @@ async function refreshToken(credentials) {
     clearTimeout(timer);
   }
 }
-async function resolveAuthToken() {
+async function resolveAuthToken(forceRefresh = false) {
   const envToken = process.env["SPACELR_AUTH_TOKEN"];
   if (envToken) return envToken;
   const credentials = readStoredCredentials();
   if (!credentials) return null;
   const isExpired = Date.now() >= credentials.expiresAt - 6e4;
-  if (!isExpired) return credentials.accessToken;
+  if (!forceRefresh && !isExpired) return credentials.accessToken;
   return refreshToken(credentials);
 }
 function warnIfInsecureUrl(url) {
@@ -119,6 +119,14 @@ function resolveApiUrl(credentials) {
   console.error(`Warning: No API URL configured, using default: ${defaultUrl}`);
   return defaultUrl;
 }
+function resolveApiBaseUrl() {
+  try {
+    const credentials = readStoredCredentials();
+    return resolveApiUrl(credentials);
+  } catch {
+    return null;
+  }
+}
 async function loadConfig() {
   const credentials = readStoredCredentials();
   const authToken = await resolveAuthToken();
@@ -175,9 +183,9 @@ var ApiClient = class {
   async delete(path2, opts) {
     return this.requestWithRetry("DELETE", path2, opts);
   }
-  async refreshAuthToken() {
+  async refreshAuthToken(force = false) {
     if (!this.refreshPromise) {
-      this.refreshPromise = resolveAuthToken().finally(() => {
+      this.refreshPromise = resolveAuthToken(force).finally(() => {
         this.refreshPromise = null;
       });
     }
@@ -189,7 +197,14 @@ var ApiClient = class {
     } catch (error) {
       if (error instanceof ApiError && error.status === 401) {
         const currentToken = this.headers["Authorization"];
-        const newToken = await this.refreshAuthToken();
+        let newToken = await this.refreshAuthToken();
+        const newBaseUrl = resolveApiBaseUrl();
+        if (newBaseUrl && newBaseUrl !== this.baseUrl) {
+          this.baseUrl = newBaseUrl;
+        }
+        if (newToken && `Bearer ${newToken}` === currentToken) {
+          newToken = await resolveAuthToken(true);
+        }
         if (newToken && `Bearer ${newToken}` !== currentToken) {
           this.headers["Authorization"] = `Bearer ${newToken}`;
           return this.request(method, path2, opts);
@@ -2282,6 +2297,64 @@ function registerFunctionTools(server, api) {
       }
     }
   );
+  server.registerTool(
+    "functions_get_env_vars",
+    {
+      description: "Get environment variables for a function (decrypted). Use these to store API keys and secrets.",
+      inputSchema: {
+        projectId: z7.string(),
+        functionId: z7.string()
+      }
+    },
+    async ({ projectId, functionId }) => {
+      try {
+        const result = await api.get(
+          `/projects/${encodeURIComponent(projectId)}/functions/${encodeURIComponent(functionId)}/env`
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get env vars: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "functions_set_env_vars",
+    {
+      description: "Set environment variables for a function. Merges with existing vars. Values are encrypted at rest.",
+      inputSchema: {
+        projectId: z7.string(),
+        functionId: z7.string(),
+        variables: z7.record(z7.string(), z7.string())
+      }
+    },
+    async ({ projectId, functionId, variables }) => {
+      try {
+        const existing = await api.get(
+          `/projects/${encodeURIComponent(projectId)}/functions/${encodeURIComponent(functionId)}/env`
+        );
+        const merged = { ...existing, ...variables };
+        await api.patch(
+          `/projects/${encodeURIComponent(projectId)}/functions/${encodeURIComponent(functionId)}`,
+          { body: { environmentVariables: merged } }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, keys: Object.keys(merged) }, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to set env vars: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
   server.registerTool(
     "functions_kv_list",
     {
@@ -2310,207 +2383,1337 @@ function registerFunctionTools(server, api) {
   );
 }
 
-// libs/mcp-server/src/tools/index.ts
-function registerAllTools(server, api) {
-  registerAuthTools(server, api);
-  registerProjectTools(server, api);
-  registerClientTools(server, api);
-  registerDatabaseTools(server, api);
-  registerHostingTools(server, api);
-  registerStorageTools(server, api);
-  registerFunctionTools(server, api);
-}
-
-// libs/mcp-server/src/prompts/database.ts
+// libs/mcp-server/src/tools/emailTemplates.ts
 import { z as z8 } from "zod";
-function registerDatabasePrompts(server) {
-  server.registerPrompt(
-    "setup-collection",
+function registerEmailTemplateTools(server, api) {
+  server.registerTool(
+    "email_templates_list",
     {
-      title: "Setup Database Collection",
-      description: "Guide for creating a new database collection with proper security rules. Collections MUST have rules defined before data can be inserted.",
-      argsSchema: {
-        projectId: z8.string().describe("Project ID"),
-        collectionName: z8.string().describe("Name of the collection to create"),
-        access: z8.enum(["public-read", "authenticated", "admin-only"]).optional().describe("Access level (default: admin-only)")
+      description: "List all email templates for a project (includes system defaults)",
+      inputSchema: {
+        projectId: z8.string()
       }
     },
-    async ({ projectId, collectionName, access }) => {
-      const accessLevel = access || "admin-only";
-      const rules = {
-        "public-read": {
-          ".create": "true",
-          ".read": "true",
-          ".update": "false",
-          ".delete": "auth.role === 'owner' || auth.role === 'admin'"
-        },
-        authenticated: {
-          ".create": "!!auth.uid",
-          ".read": "!!auth.uid",
-          ".update": "!!auth.uid",
-          ".delete": "auth.role === 'owner' || auth.role === 'admin'"
-        },
-        "admin-only": {
-          ".create": "auth.role === 'owner' || auth.role === 'admin'",
-          ".read": "auth.role === 'owner' || auth.role === 'admin'",
-          ".update": "auth.role === 'owner' || auth.role === 'admin'",
-          ".delete": "auth.role === 'owner' || auth.role === 'admin'"
-        }
-      };
-      const collectionRules = rules[accessLevel];
-      const rulesJson = JSON.stringify(collectionRules, null, 2);
-      return {
-        messages: [
-          {
-            role: "user",
-            content: {
-              type: "text",
-              text: [
-                `Set up a new database collection "${collectionName}" in project ${projectId}.`,
-                "",
-                "IMPORTANT WORKFLOW:",
-                "1. First, get the current rules with database_rules_get",
-                "2. Add the new collection rules to the existing rules object",
-                "3. Set the updated rules with database_rules_set \u2014 this automatically creates the collection",
-                '4. Do NOT try to insert documents before the rules are set \u2014 it will fail with "Rule denied"',
-                "",
-                `Suggested rules for "${collectionName}" (${accessLevel}):`,
-                rulesJson,
-                "",
-                "The $other catch-all rule should deny access to undefined collections:",
-                '  "$other": { ".read": "false", ".write": "false" }',
-                "",
-                "After rules are set, the collection is ready for use via:",
-                "- database_documents_insert",
-                "- database_documents_find",
-                '- Serverless functions using spacelr.db.collection("' + collectionName + '")'
-              ].join("\n")
-            }
-          }
-        ]
-      };
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/email-templates`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list email templates: ${message}` }],
+          isError: true
+        };
+      }
     }
   );
-  server.registerPrompt(
-    "database-workflow",
+  server.registerTool(
+    "email_templates_get",
     {
-      title: "Database Workflow Guide",
-      description: "Explains how the Spacelr database system works: rules-first approach, collection lifecycle, and security model.",
-      argsSchema: {
-        projectId: z8.string().describe("Project ID")
+      description: "Get a single email template by ID",
+      inputSchema: {
+        id: z8.string()
       }
     },
-    async ({ projectId }) => {
-      return {
-        messages: [
-          {
-            role: "user",
-            content: {
-              type: "text",
-              text: [
-                `Guide me through the Spacelr database system for project ${projectId}.`,
-                "",
-                "CORE CONCEPTS:",
-                "",
-                "1. RULES-FIRST: Collections are defined through security rules.",
-                "   - Use database_rules_get to see current rules",
-                "   - Use database_rules_set to add/modify collection rules",
-                "   - Setting rules automatically creates the collection definition",
-                "   - Without rules, all operations are denied by the $other catch-all",
-                "",
-                "2. SECURITY RULES SYNTAX:",
-                '   - ".create": Expression that must evaluate to true for inserts',
-                '   - ".read": Expression for reads/queries',
-                '   - ".update": Expression for document updates',
-                '   - ".delete": Expression for document deletion',
-                '   - ".validate": Per-field validation expressions',
-                '   - ".schema": Field type declarations',
-                "   Available context: auth.uid, auth.role, newData (for validation)",
-                "",
-                "3. WORKFLOW:",
-                "   a) Define rules for the collection",
-                "   b) Optionally create indexes (database_indexes_create)",
-                "   c) Insert/query documents",
-                "",
-                "4. DATA ISOLATION:",
-                "   - Each project has its own database (project_{projectId})",
-                "   - Collections are scoped to the project automatically",
-                "   - No cross-project data access is possible"
-              ].join("\n")
-            }
-          }
-        ]
-      };
+    async ({ id }) => {
+      try {
+        const result = await api.get(`/email-templates/${encodeURIComponent(id)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get email template: ${message}` }],
+          isError: true
+        };
+      }
     }
   );
-}
-
-// libs/mcp-server/src/prompts/functions.ts
-import { z as z9 } from "zod";
-function registerFunctionPrompts(server) {
-  server.registerPrompt(
-    "deploy-function",
+  server.registerTool(
+    "email_templates_create",
     {
-      title: "Deploy a Serverless Function",
-      description: "Step-by-step guide for creating, deploying, and testing a serverless function. Covers the full lifecycle from creation to execution.",
-      argsSchema: {
-        projectId: z9.string().describe("Project ID"),
-        name: z9.string().describe("Function name"),
-        useCase: z9.string().optional().describe('What the function should do (e.g. "fetch data from API and store in DB")')
+      description: 'Create a new project-specific email template. The type identifies the template purpose (e.g. "verify-email", "welcome", "invoice").',
+      inputSchema: {
+        projectId: z8.string(),
+        type: z8.string(),
+        name: z8.string(),
+        subject: z8.string(),
+        mjmlSource: z8.string(),
+        variables: z8.array(z8.string()).optional(),
+        isActive: z8.boolean().optional()
       }
     },
-    async ({ projectId, name, useCase }) => {
-      return {
-        messages: [
-          {
-            role: "user",
-            content: {
-              type: "text",
-              text: [
-                `Deploy a serverless function "${name}" in project ${projectId}.`,
-                useCase ? `Use case: ${useCase}` : "",
-                "",
-                "DEPLOYMENT WORKFLOW:",
-                "",
-                "1. CREATE the function:",
-                "   Use functions_create with name, entryPoint (default: index.js),",
-                "   timeout (ms, default: 30000), memoryLimitMb (default: 128)",
-                "   Optional: cronExpression for scheduled execution",
-                "",
-                "2. WRITE the code:",
-                "   Create an index.js file. Available APIs inside the sandbox:",
-                "",
-                "   - console.log/warn/error/info() \u2014 captured to execution logs",
-                "   - await fetch(url, options) \u2014 HTTP client (10s timeout, 5MB limit)",
-                "     Response: { status, headers, body } where body is a STRING",
-                "     Use JSON.parse(response.body) for JSON APIs",
-                "   - env.get(key) \u2014 read environment variables",
-                "   - await kv.get/set/delete/list() \u2014 Redis KV store (256KB values, 1000 keys)",
-                "   - await spacelr.db.collection(name).find/insertOne/insertMany()",
-                "   - await spacelr.storage.list/getInfo/getDownloadUrl()",
-                "",
-                "   IMPORTANT: Top-level await is supported. No imports/require available.",
-                "",
-                "3. IF USING spacelr.db:",
-                "   Database rules MUST be set BEFORE the function writes to a collection.",
-                "   Use the setup-collection prompt or manually set rules via database_rules_set.",
-                '   Without rules, inserts will fail with "Rule denied".',
-                "",
-                "4. DEPLOY the code:",
-                "   Zip the file(s) and upload via the CLI:",
-                "   spacelr functions deploy ./my-function --name " + name,
-                "   Or use the admin API: POST /projects/{projectId}/functions/{id}/deploy",
-                "",
-                "5. TRIGGER:",
-                "   Functions support multiple trigger types:",
-                "",
-                "   a) Manual: Use functions_trigger to execute on demand.",
-                "   b) Cron: Set cronExpression when creating/updating the function.",
-                "   c) Webhook: Enable with functions_enable_webhook to get a secret,",
-                "      then POST to /api/v1/functions/{projectId}/{functionId}/invoke",
-                "      with the X-Webhook-Secret header. Use functions_regenerate_webhook_secret",
-                "      to rotate the secret (old secret stops working immediately).",
-                "   d) Event: Configure event triggers to run the function in response",
+    async ({ projectId, type, name, subject, mjmlSource, variables, isActive }) => {
+      try {
+        const body = { projectId, type, name, subject, mjmlSource };
+        if (variables !== void 0) body.variables = variables;
+        if (isActive !== void 0) body.isActive = isActive;
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/email-templates`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create email template: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "email_templates_update",
+    {
+      description: "Update an existing email template",
+      inputSchema: {
+        id: z8.string(),
+        name: z8.string().optional(),
+        subject: z8.string().optional(),
+        mjmlSource: z8.string().optional(),
+        variables: z8.array(z8.string()).optional(),
+        isActive: z8.boolean().optional()
+      }
+    },
+    async ({ id, name, subject, mjmlSource, variables, isActive }) => {
+      try {
+        const body = {};
+        if (name !== void 0) body.name = name;
+        if (subject !== void 0) body.subject = subject;
+        if (mjmlSource !== void 0) body.mjmlSource = mjmlSource;
+        if (variables !== void 0) body.variables = variables;
+        if (isActive !== void 0) body.isActive = isActive;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one field must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch(`/email-templates/${encodeURIComponent(id)}`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update email template: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "email_templates_delete",
+    {
+      description: "Delete an email template. System default templates cannot be deleted.",
+      inputSchema: {
+        id: z8.string()
+      }
+    },
+    async ({ id }) => {
+      try {
+        const result = await api.delete(`/email-templates/${encodeURIComponent(id)}`);
+        return {
+          content: [{ type: "text", text: result ? JSON.stringify(result, null, 2) : "Email template deleted" }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete email template: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "email_templates_preview",
+    {
+      description: "Preview a compiled email template. Renders MJML to HTML and applies Handlebars variables.",
+      inputSchema: {
+        mjmlSource: z8.string(),
+        variables: z8.record(z8.string(), z8.unknown()).optional()
+      }
+    },
+    async ({ mjmlSource, variables }) => {
+      try {
+        const body = { mjmlSource };
+        if (variables !== void 0) body.variables = variables;
+        const result = await api.post("/email-templates/preview", { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to preview email template: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/cronJobs.ts
+import { z as z9 } from "zod";
+function registerCronJobTools(server, api) {
+  server.registerTool(
+    "cron_jobs_list",
+    {
+      description: "List all cron jobs for a project",
+      inputSchema: {
+        projectId: z9.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/cron-jobs`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list cron jobs: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "cron_jobs_get",
+    {
+      description: "Get a single cron job by ID",
+      inputSchema: {
+        projectId: z9.string(),
+        jobId: z9.string()
+      }
+    },
+    async ({ projectId, jobId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/cron-jobs/${encodeURIComponent(jobId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get cron job: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "cron_jobs_create",
+    {
+      description: 'Create a new cron job. When type is "webhook", url is required. When type is "function", functionId is required. cronExpression uses 5-field cron format (e.g. "0 0 * * *").',
+      inputSchema: {
+        projectId: z9.string(),
+        name: z9.string(),
+        cronExpression: z9.string().regex(/^(\S+\s){4}\S+$/),
+        timezone: z9.string().optional(),
+        type: z9.enum(["webhook", "function"]).optional(),
+        functionId: z9.string().optional(),
+        url: z9.string().url().optional(),
+        secret: z9.string().optional(),
+        payload: z9.record(z9.string(), z9.unknown()).optional(),
+        retryAttempts: z9.number().int().min(0).max(10).optional(),
+        timeout: z9.number().int().min(1e3).max(12e4).optional(),
+        enabled: z9.boolean().optional()
+      }
+    },
+    async ({ projectId, name, cronExpression, timezone, type, functionId, url, secret, payload, retryAttempts, timeout, enabled }) => {
+      try {
+        const body = { name, cronExpression };
+        if (timezone !== void 0) body.timezone = timezone;
+        if (type !== void 0) body.type = type;
+        if (functionId !== void 0) body.functionId = functionId;
+        if (url !== void 0) body.url = url;
+        if (secret !== void 0) body.secret = secret;
+        if (payload !== void 0) body.payload = payload;
+        if (retryAttempts !== void 0) body.retryAttempts = retryAttempts;
+        if (timeout !== void 0) body.timeout = timeout;
+        if (enabled !== void 0) body.enabled = enabled;
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/cron-jobs`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create cron job: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "cron_jobs_update",
+    {
+      description: "Update an existing cron job",
+      inputSchema: {
+        projectId: z9.string(),
+        jobId: z9.string(),
+        name: z9.string().optional(),
+        cronExpression: z9.string().regex(/^(\S+\s){4}\S+$/).optional(),
+        timezone: z9.string().optional(),
+        type: z9.enum(["webhook", "function"]).optional(),
+        functionId: z9.string().optional(),
+        url: z9.string().url().optional(),
+        secret: z9.string().optional(),
+        payload: z9.record(z9.string(), z9.unknown()).optional(),
+        retryAttempts: z9.number().int().min(0).max(10).optional(),
+        timeout: z9.number().int().min(1e3).max(12e4).optional(),
+        enabled: z9.boolean().optional()
+      }
+    },
+    async ({ projectId, jobId, name, cronExpression, timezone, type, functionId, url, secret, payload, retryAttempts, timeout, enabled }) => {
+      try {
+        const body = {};
+        if (name !== void 0) body.name = name;
+        if (cronExpression !== void 0) body.cronExpression = cronExpression;
+        if (timezone !== void 0) body.timezone = timezone;
+        if (type !== void 0) body.type = type;
+        if (functionId !== void 0) body.functionId = functionId;
+        if (url !== void 0) body.url = url;
+        if (secret !== void 0) body.secret = secret;
+        if (payload !== void 0) body.payload = payload;
+        if (retryAttempts !== void 0) body.retryAttempts = retryAttempts;
+        if (timeout !== void 0) body.timeout = timeout;
+        if (enabled !== void 0) body.enabled = enabled;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one field must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch(`/projects/${encodeURIComponent(projectId)}/cron-jobs/${encodeURIComponent(jobId)}`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update cron job: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "cron_jobs_delete",
+    {
+      description: "Delete a cron job",
+      inputSchema: {
+        projectId: z9.string(),
+        jobId: z9.string()
+      }
+    },
+    async ({ projectId, jobId }) => {
+      try {
+        const result = await api.delete(`/projects/${encodeURIComponent(projectId)}/cron-jobs/${encodeURIComponent(jobId)}`);
+        return {
+          content: [{ type: "text", text: result ? JSON.stringify(result, null, 2) : "Cron job deleted" }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete cron job: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "cron_jobs_trigger",
+    {
+      description: "Manually trigger a cron job execution",
+      inputSchema: {
+        projectId: z9.string(),
+        jobId: z9.string()
+      }
+    },
+    async ({ projectId, jobId }) => {
+      try {
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/cron-jobs/${encodeURIComponent(jobId)}/trigger`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to trigger cron job: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "cron_jobs_toggle",
+    {
+      description: "Toggle a cron job enabled/disabled",
+      inputSchema: {
+        projectId: z9.string(),
+        jobId: z9.string(),
+        enabled: z9.boolean()
+      }
+    },
+    async ({ projectId, jobId, enabled }) => {
+      try {
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/cron-jobs/${encodeURIComponent(jobId)}/toggle`, { body: { enabled } });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to toggle cron job: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "cron_jobs_executions",
+    {
+      description: "List execution history for a cron job",
+      inputSchema: {
+        projectId: z9.string(),
+        jobId: z9.string(),
+        limit: z9.number().int().min(1).max(100).optional(),
+        offset: z9.number().int().min(0).optional()
+      }
+    },
+    async ({ projectId, jobId, limit, offset }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/cron-jobs/${encodeURIComponent(jobId)}/executions`, { params: { limit, offset } });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list cron job executions: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "cron_jobs_list_all",
+    {
+      description: "List all cron jobs across projects (admin overview)",
+      inputSchema: {
+        projectId: z9.string().optional()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get("/cron/jobs", { params: { projectId } });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list all cron jobs: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "cron_jobs_status",
+    {
+      description: "Get cron queue status",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const result = await api.get("/cron/status");
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get cron status: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/webhooks.ts
+import { z as z10 } from "zod";
+var WEBHOOK_EVENT_TYPES = [
+  "user.created",
+  "user.updated",
+  "user.deleted",
+  "user.login",
+  "user.email_verified",
+  "user.password_reset_requested",
+  "user.password_reset",
+  "user.2fa_verified",
+  "database.insert",
+  "database.update",
+  "database.delete",
+  "storage.upload",
+  "storage.delete",
+  "project.created",
+  "project.updated"
+];
+function registerWebhookTools(server, api) {
+  server.registerTool(
+    "webhooks_list",
+    {
+      description: "List all webhooks for a project",
+      inputSchema: {
+        projectId: z10.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/webhooks`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list webhooks: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "webhooks_get",
+    {
+      description: "Get a single webhook by ID",
+      inputSchema: {
+        projectId: z10.string(),
+        webhookId: z10.string()
+      }
+    },
+    async ({ projectId, webhookId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/webhooks/${encodeURIComponent(webhookId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get webhook: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "webhooks_create",
+    {
+      description: "Create a new webhook for a project. WARNING: The response includes a secret that will be visible in the conversation context. Events include: user.created, user.updated, user.deleted, user.login, user.email_verified, user.password_reset_requested, user.password_reset, user.2fa_verified, database.insert, database.update, database.delete, storage.upload, storage.delete, project.created, project.updated.",
+      inputSchema: {
+        projectId: z10.string(),
+        url: z10.string().url(),
+        events: z10.array(z10.enum(WEBHOOK_EVENT_TYPES)).min(1),
+        description: z10.string().optional(),
+        headers: z10.record(z10.string(), z10.string()).optional(),
+        active: z10.boolean().optional()
+      }
+    },
+    async ({ projectId, url, events, description, headers, active }) => {
+      try {
+        const body = { url, events };
+        if (description !== void 0) body.description = description;
+        if (headers !== void 0) body.headers = headers;
+        if (active !== void 0) body.active = active;
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/webhooks`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create webhook: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "webhooks_update",
+    {
+      description: "Update an existing webhook",
+      inputSchema: {
+        projectId: z10.string(),
+        webhookId: z10.string(),
+        url: z10.string().url().optional(),
+        events: z10.array(z10.enum(WEBHOOK_EVENT_TYPES)).min(1).optional(),
+        description: z10.string().optional(),
+        headers: z10.record(z10.string(), z10.string()).optional(),
+        active: z10.boolean().optional()
+      }
+    },
+    async ({ projectId, webhookId, url, events, description, headers, active }) => {
+      try {
+        const body = {};
+        if (url !== void 0) body.url = url;
+        if (events !== void 0) body.events = events;
+        if (description !== void 0) body.description = description;
+        if (headers !== void 0) body.headers = headers;
+        if (active !== void 0) body.active = active;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one field must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch(`/projects/${encodeURIComponent(projectId)}/webhooks/${encodeURIComponent(webhookId)}`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update webhook: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "webhooks_delete",
+    {
+      description: "Delete a webhook",
+      inputSchema: {
+        projectId: z10.string(),
+        webhookId: z10.string()
+      }
+    },
+    async ({ projectId, webhookId }) => {
+      try {
+        const result = await api.delete(`/projects/${encodeURIComponent(projectId)}/webhooks/${encodeURIComponent(webhookId)}`);
+        return {
+          content: [{ type: "text", text: result ? JSON.stringify(result, null, 2) : "Webhook deleted" }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete webhook: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "webhooks_test",
+    {
+      description: "Send a test ping to a webhook",
+      inputSchema: {
+        projectId: z10.string(),
+        webhookId: z10.string()
+      }
+    },
+    async ({ projectId, webhookId }) => {
+      try {
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/webhooks/${encodeURIComponent(webhookId)}/test`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to test webhook: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "webhooks_deliveries",
+    {
+      description: "List webhook delivery logs for a project",
+      inputSchema: {
+        projectId: z10.string(),
+        webhookId: z10.string().optional(),
+        limit: z10.number().int().min(1).max(100).optional(),
+        offset: z10.number().int().min(0).optional()
+      }
+    },
+    async ({ projectId, webhookId, limit, offset }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/webhook-deliveries`, { params: { webhookId, limit, offset } });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list webhook deliveries: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "webhooks_delivery_retry",
+    {
+      description: "Retry a failed webhook delivery",
+      inputSchema: {
+        projectId: z10.string(),
+        deliveryId: z10.string()
+      }
+    },
+    async ({ projectId, deliveryId }) => {
+      try {
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/webhook-deliveries/${encodeURIComponent(deliveryId)}/retry`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to retry webhook delivery: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/notifications.ts
+import { z as z11 } from "zod";
+function registerNotificationTools(server, api) {
+  server.registerTool(
+    "notification_templates_list",
+    {
+      description: "List all notification templates for a project (includes system defaults)",
+      inputSchema: {
+        projectId: z11.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/notification-templates`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list notification templates: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notification_templates_get",
+    {
+      description: "Get a single notification template by ID",
+      inputSchema: {
+        id: z11.string()
+      }
+    },
+    async ({ id }) => {
+      try {
+        const result = await api.get(`/notification-templates/${encodeURIComponent(id)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get notification template: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notification_templates_create",
+    {
+      description: "Create a new project-specific notification template. Variables use Handlebars syntax in titleTemplate and bodyTemplate.",
+      inputSchema: {
+        projectId: z11.string(),
+        type: z11.string(),
+        name: z11.string(),
+        titleTemplate: z11.string(),
+        bodyTemplate: z11.string(),
+        icon: z11.string().optional(),
+        defaultUrl: z11.string().optional(),
+        variables: z11.array(z11.string()).optional(),
+        isActive: z11.boolean().optional()
+      }
+    },
+    async ({ projectId, type, name, titleTemplate, bodyTemplate, icon, defaultUrl, variables, isActive }) => {
+      try {
+        const body = { projectId, type, name, titleTemplate, bodyTemplate };
+        if (icon !== void 0) body.icon = icon;
+        if (defaultUrl !== void 0) body.defaultUrl = defaultUrl;
+        if (variables !== void 0) body.variables = variables;
+        if (isActive !== void 0) body.isActive = isActive;
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/notification-templates`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create notification template: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notification_templates_update",
+    {
+      description: "Update an existing notification template",
+      inputSchema: {
+        id: z11.string(),
+        name: z11.string().optional(),
+        titleTemplate: z11.string().optional(),
+        bodyTemplate: z11.string().optional(),
+        icon: z11.string().optional(),
+        defaultUrl: z11.string().optional(),
+        variables: z11.array(z11.string()).optional(),
+        isActive: z11.boolean().optional()
+      }
+    },
+    async ({ id, name, titleTemplate, bodyTemplate, icon, defaultUrl, variables, isActive }) => {
+      try {
+        const body = {};
+        if (name !== void 0) body.name = name;
+        if (titleTemplate !== void 0) body.titleTemplate = titleTemplate;
+        if (bodyTemplate !== void 0) body.bodyTemplate = bodyTemplate;
+        if (icon !== void 0) body.icon = icon;
+        if (defaultUrl !== void 0) body.defaultUrl = defaultUrl;
+        if (variables !== void 0) body.variables = variables;
+        if (isActive !== void 0) body.isActive = isActive;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one field must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch(`/notification-templates/${encodeURIComponent(id)}`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update notification template: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notification_templates_delete",
+    {
+      description: "Delete a project notification template override (reverts to system default)",
+      inputSchema: {
+        id: z11.string()
+      }
+    },
+    async ({ id }) => {
+      try {
+        const result = await api.delete(`/notification-templates/${encodeURIComponent(id)}`);
+        return {
+          content: [{ type: "text", text: result ? JSON.stringify(result, null, 2) : "Notification template deleted" }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete notification template: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notification_templates_preview",
+    {
+      description: "Preview a compiled notification template with Handlebars variables applied",
+      inputSchema: {
+        titleTemplate: z11.string(),
+        bodyTemplate: z11.string(),
+        variables: z11.record(z11.string(), z11.string())
+      }
+    },
+    async ({ titleTemplate, bodyTemplate, variables }) => {
+      try {
+        const result = await api.post("/notification-templates/preview", { body: { titleTemplate, bodyTemplate, variables } });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to preview notification template: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notification_config_get",
+    {
+      description: "Get push notification provider configuration for a project (VAPID, FCM, APNS). WARNING: Response may include sensitive credentials that will be visible in the conversation context.",
+      inputSchema: {
+        projectId: z11.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/notification-config`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get notification config: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notification_config_update",
+    {
+      description: "Update push notification provider configuration. Supports VAPID, FCM, and APNS providers. WARNING: privateKey and serviceAccountJson values are sensitive credentials that will be visible in the conversation context.",
+      inputSchema: {
+        projectId: z11.string(),
+        vapid: z11.object({
+          publicKey: z11.string().optional(),
+          privateKey: z11.string().optional(),
+          subject: z11.string().optional(),
+          enabled: z11.boolean().optional()
+        }).optional(),
+        fcm: z11.object({
+          serviceAccountJson: z11.string().optional(),
+          enabled: z11.boolean().optional()
+        }).optional(),
+        apns: z11.object({
+          keyId: z11.string().optional(),
+          teamId: z11.string().optional(),
+          privateKey: z11.string().optional(),
+          bundleId: z11.string().optional(),
+          production: z11.boolean().optional(),
+          enabled: z11.boolean().optional()
+        }).optional()
+      }
+    },
+    async ({ projectId, vapid, fcm, apns }) => {
+      try {
+        const body = {};
+        if (vapid !== void 0) body.vapid = vapid;
+        if (fcm !== void 0) body.fcm = fcm;
+        if (apns !== void 0) body.apns = apns;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one provider config must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch(`/projects/${encodeURIComponent(projectId)}/notification-config`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update notification config: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notification_config_delete",
+    {
+      description: "Delete push notification provider configuration. Specify a provider to delete only that one, or omit to delete all.",
+      inputSchema: {
+        projectId: z11.string(),
+        provider: z11.enum(["vapid", "fcm", "apns"]).optional()
+      }
+    },
+    async ({ projectId, provider }) => {
+      try {
+        const result = await api.delete(`/projects/${encodeURIComponent(projectId)}/notification-config`, { params: { provider } });
+        return {
+          content: [{ type: "text", text: result ? JSON.stringify(result, null, 2) : "Notification config deleted" }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete notification config: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notification_config_generate_vapid",
+    {
+      description: "Generate a new VAPID key pair for web push notifications. WARNING: The private key will be visible in the conversation context.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const result = await api.post("/notification-config/generate-vapid-keys");
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to generate VAPID keys: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notifications_send",
+    {
+      description: "Send a push notification to selected users",
+      inputSchema: {
+        projectId: z11.string(),
+        userIds: z11.array(z11.string()).min(1),
+        title: z11.string(),
+        body: z11.string(),
+        icon: z11.string().optional(),
+        url: z11.string().optional()
+      }
+    },
+    async ({ projectId, userIds, title, body: notifBody, icon, url }) => {
+      try {
+        const reqBody = { userIds, title, body: notifBody };
+        if (icon !== void 0) reqBody.icon = icon;
+        if (url !== void 0) reqBody.url = url;
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/notifications/send`, { body: reqBody });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to send notification: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "notifications_broadcast",
+    {
+      description: "Broadcast a push notification to all subscribed users in a project",
+      inputSchema: {
+        projectId: z11.string(),
+        title: z11.string(),
+        body: z11.string(),
+        icon: z11.string().optional(),
+        url: z11.string().optional()
+      }
+    },
+    async ({ projectId, title, body: notifBody, icon, url }) => {
+      try {
+        const reqBody = { title, body: notifBody };
+        if (icon !== void 0) reqBody.icon = icon;
+        if (url !== void 0) reqBody.url = url;
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/notifications/broadcast`, { body: reqBody });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to broadcast notification: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/auditLogs.ts
+import { z as z12 } from "zod";
+function registerAuditLogTools(server, api) {
+  server.registerTool(
+    "audit_logs_list",
+    {
+      description: "List audit logs for a project. Filter by entity type, action, and date range.",
+      inputSchema: {
+        projectId: z12.string(),
+        entityType: z12.enum(["user", "client", "project", "auth", "database", "storage"]).optional(),
+        action: z12.string().optional(),
+        startDate: z12.string().datetime().optional(),
+        endDate: z12.string().datetime().optional(),
+        limit: z12.number().int().min(1).max(100).optional(),
+        offset: z12.number().int().min(0).optional()
+      }
+    },
+    async ({ projectId, entityType, action, startDate, endDate, limit, offset }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/audit-logs`, {
+          params: { entityType, action, startDate, endDate, limit, offset }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list audit logs: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "audit_logs_get",
+    {
+      description: "Get a single audit log entry by ID",
+      inputSchema: {
+        projectId: z12.string(),
+        logId: z12.string()
+      }
+    },
+    async ({ projectId, logId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/audit-logs/${encodeURIComponent(logId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get audit log: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/index.ts
+function registerAllTools(server, api) {
+  registerAuthTools(server, api);
+  registerProjectTools(server, api);
+  registerClientTools(server, api);
+  registerDatabaseTools(server, api);
+  registerHostingTools(server, api);
+  registerStorageTools(server, api);
+  registerFunctionTools(server, api);
+  registerEmailTemplateTools(server, api);
+  registerCronJobTools(server, api);
+  registerWebhookTools(server, api);
+  registerNotificationTools(server, api);
+  registerAuditLogTools(server, api);
+}
+
+// libs/mcp-server/src/prompts/database.ts
+import { z as z13 } from "zod";
+function registerDatabasePrompts(server) {
+  server.registerPrompt(
+    "setup-collection",
+    {
+      title: "Setup Database Collection",
+      description: "Guide for creating a new database collection with proper security rules. Collections MUST have rules defined before data can be inserted.",
+      argsSchema: {
+        projectId: z13.string().describe("Project ID"),
+        collectionName: z13.string().describe("Name of the collection to create"),
+        access: z13.enum(["public-read", "authenticated", "admin-only"]).optional().describe("Access level (default: admin-only)")
+      }
+    },
+    async ({ projectId, collectionName, access }) => {
+      const accessLevel = access || "admin-only";
+      const rules = {
+        "public-read": {
+          ".create": "true",
+          ".read": "true",
+          ".update": "false",
+          ".delete": "auth.role === 'owner' || auth.role === 'admin'"
+        },
+        authenticated: {
+          ".create": "!!auth.uid",
+          ".read": "!!auth.uid",
+          ".update": "!!auth.uid",
+          ".delete": "auth.role === 'owner' || auth.role === 'admin'"
+        },
+        "admin-only": {
+          ".create": "auth.role === 'owner' || auth.role === 'admin'",
+          ".read": "auth.role === 'owner' || auth.role === 'admin'",
+          ".update": "auth.role === 'owner' || auth.role === 'admin'",
+          ".delete": "auth.role === 'owner' || auth.role === 'admin'"
+        }
+      };
+      const collectionRules = rules[accessLevel];
+      const rulesJson = JSON.stringify(collectionRules, null, 2);
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: [
+                `Set up a new database collection "${collectionName}" in project ${projectId}.`,
+                "",
+                "IMPORTANT WORKFLOW:",
+                "1. First, get the current rules with database_rules_get",
+                "2. Add the new collection rules to the existing rules object",
+                "3. Set the updated rules with database_rules_set \u2014 this automatically creates the collection",
+                '4. Do NOT try to insert documents before the rules are set \u2014 it will fail with "Rule denied"',
+                "",
+                `Suggested rules for "${collectionName}" (${accessLevel}):`,
+                rulesJson,
+                "",
+                "The $other catch-all rule should deny access to undefined collections:",
+                '  "$other": { ".read": "false", ".write": "false" }',
+                "",
+                "After rules are set, the collection is ready for use via:",
+                "- database_documents_insert",
+                "- database_documents_find",
+                '- Serverless functions using spacelr.db.collection("' + collectionName + '")'
+              ].join("\n")
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    "database-workflow",
+    {
+      title: "Database Workflow Guide",
+      description: "Explains how the Spacelr database system works: rules-first approach, collection lifecycle, and security model.",
+      argsSchema: {
+        projectId: z13.string().describe("Project ID")
+      }
+    },
+    async ({ projectId }) => {
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: [
+                `Guide me through the Spacelr database system for project ${projectId}.`,
+                "",
+                "CORE CONCEPTS:",
+                "",
+                "1. RULES-FIRST: Collections are defined through security rules.",
+                "   - Use database_rules_get to see current rules",
+                "   - Use database_rules_set to add/modify collection rules",
+                "   - Setting rules automatically creates the collection definition",
+                "   - Without rules, all operations are denied by the $other catch-all",
+                "",
+                "2. SECURITY RULES SYNTAX:",
+                '   - ".create": Expression that must evaluate to true for inserts',
+                '   - ".read": Expression for reads/queries',
+                '   - ".update": Expression for document updates',
+                '   - ".delete": Expression for document deletion',
+                '   - ".validate": Per-field validation expressions',
+                '   - ".schema": Field type declarations',
+                "   Available context: auth.uid, auth.role, newData (for validation)",
+                "",
+                "3. WORKFLOW:",
+                "   a) Define rules for the collection",
+                "   b) Optionally create indexes (database_indexes_create)",
+                "   c) Insert/query documents",
+                "",
+                "4. DATA ISOLATION:",
+                "   - Each project has its own database (project_{projectId})",
+                "   - Collections are scoped to the project automatically",
+                "   - No cross-project data access is possible"
+              ].join("\n")
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// libs/mcp-server/src/prompts/functions.ts
+import { z as z14 } from "zod";
+function registerFunctionPrompts(server) {
+  server.registerPrompt(
+    "deploy-function",
+    {
+      title: "Deploy a Serverless Function",
+      description: "Step-by-step guide for creating, deploying, and testing a serverless function. Covers the full lifecycle from creation to execution.",
+      argsSchema: {
+        projectId: z14.string().describe("Project ID"),
+        name: z14.string().describe("Function name"),
+        useCase: z14.string().optional().describe('What the function should do (e.g. "fetch data from API and store in DB")')
+      }
+    },
+    async ({ projectId, name, useCase }) => {
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: [
+                `Deploy a serverless function "${name}" in project ${projectId}.`,
+                useCase ? `Use case: ${useCase}` : "",
+                "",
+                "DEPLOYMENT WORKFLOW:",
+                "",
+                "1. CREATE the function:",
+                "   Use functions_create with name, entryPoint (default: index.js),",
+                "   timeout (ms, default: 30000), memoryLimitMb (default: 128)",
+                "   Optional: cronExpression for scheduled execution",
+                "",
+                "2. WRITE the code:",
+                "   Create an index.js file. Available APIs inside the sandbox:",
+                "",
+                "   - console.log/warn/error/info() \u2014 captured to execution logs",
+                "   - await fetch(url, options) \u2014 HTTP client (10s timeout, 5MB limit)",
+                "     Response: { status, headers, body } where body is a STRING",
+                "     Use JSON.parse(response.body) for JSON APIs",
+                "   - env.get(key) \u2014 read environment variables (API keys, secrets \u2014 set via Console UI or CLI)",
+                "   - await kv.get/set/delete/list() \u2014 Redis KV store (256KB values, 1000 keys)",
+                "   - await spacelr.db.collection(name).find/insertOne/insertMany()",
+                "   - await spacelr.storage.list/getInfo/getDownloadUrl()",
+                "   - await spacelr.email.send/sendRaw() \u2014 send template or raw emails",
+                "   - await spacelr.notifications.send/sendMany() \u2014 push notifications",
+                "",
+                "   IMPORTANT: Top-level await is supported. No imports/require available.",
+                "",
+                "3. IF USING spacelr.db:",
+                "   Database rules MUST be set BEFORE the function writes to a collection.",
+                "   Use the setup-collection prompt or manually set rules via database_rules_set.",
+                '   Without rules, inserts will fail with "Rule denied".',
+                "",
+                "4. DEPLOY the code:",
+                "   Zip the file(s) and upload via the CLI:",
+                "   spacelr functions deploy ./my-function --name " + name,
+                "   Or use the admin API: POST /projects/{projectId}/functions/{id}/deploy",
+                "",
+                "5. TRIGGER:",
+                "   Functions support multiple trigger types:",
+                "",
+                "   a) Manual: Use functions_trigger to execute on demand.",
+                "   b) Cron: Set cronExpression when creating/updating the function.",
+                "   c) Webhook: Enable with functions_enable_webhook to get a secret,",
+                "      then POST to /api/v1/functions/{projectId}/{functionId}/invoke",
+                "      with the X-Webhook-Secret header. Use functions_regenerate_webhook_secret",
+                "      to rotate the secret (old secret stops working immediately).",
+                "   d) Event: Configure event triggers to run the function in response",
                 "      to platform events (e.g. database changes, storage uploads).",
                 "",
                 "   Check results with functions_executions_list.",
@@ -2557,9 +3760,12 @@ function registerFunctionPrompts(server) {
                 "  NOTE: body is always a string \u2014 use JSON.parse(response.body) for JSON",
                 "  Limits: 10s timeout, 5MB response, no private/internal URLs (SSRF blocked)",
                 "",
-                "\u2550\u2550\u2550 ENV \u2550\u2550\u2550",
+                "\u2550\u2550\u2550 ENV (Environment Variables) \u2550\u2550\u2550",
                 "env.get(key) \u2192 string | undefined",
                 "Read-only access to function environment variables.",
+                "Use env vars to store API keys, secrets, and configuration \u2014 never hardcode them in function code.",
+                "Set via Console UI (Function Detail \u2192 Environment Variables) or CLI (spacelr functions env set).",
+                "Values are encrypted at rest and only decrypted when the function executes.",
                 "",
                 "\u2550\u2550\u2550 KV STORE \u2550\u2550\u2550",
                 "await kv.get(key) \u2192 string | null",
@@ -2582,6 +3788,24 @@ function registerFunctionPrompts(server) {
                 "await spacelr.storage.getDownloadUrl(fileId) \u2192 string",
                 "Scoped to the function's project.",
                 "",
+                "\u2550\u2550\u2550 EMAIL \u2550\u2550\u2550",
+                "await spacelr.email.send({ to, template, variables })",
+                "  Sends a template-based email using project templates (MJML + Handlebars).",
+                "  template: template name (must exist in the project)",
+                "  variables: Record<string, string> of template variables",
+                "  Returns: { messageId }",
+                "await spacelr.email.sendRaw({ to, subject, html })",
+                "  Sends a raw HTML email directly. Max 500KB HTML.",
+                "  Returns: { messageId }",
+                "Rate limit: 100 emails/hour per project (configurable via FUNCTION_EMAIL_HOURLY_LIMIT).",
+                "",
+                "\u2550\u2550\u2550 NOTIFICATIONS \u2550\u2550\u2550",
+                "await spacelr.notifications.send({ userId, title, body, data? })",
+                "  Sends a push notification to a specific user in the project.",
+                "await spacelr.notifications.sendMany({ userIds, title, body, data? })",
+                "  Sends to multiple users. Deduplicates userIds automatically.",
+                "Rate limit: 500 notifications/hour per project (configurable via FUNCTION_NOTIFICATION_HOURLY_LIMIT). Scoped to the function's project.",
+                "",
                 "\u2550\u2550\u2550 RESOURCE LIMITS \u2550\u2550\u2550",
                 "Execution timeout: 30s default, 120s max",
                 "Memory: 128MB default, 512MB max",