@spacelr/mcp 0.0.5 → 0.0.6

package/dist/index.mjs

@@ -2555,6 +2555,957 @@ function registerEmailTemplateTools(server, api) {
   );
 }
 
+// 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);
@@ -2565,10 +3516,14 @@ function registerAllTools(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 z9 } from "zod";
+import { z as z13 } from "zod";
 function registerDatabasePrompts(server) {
   server.registerPrompt(
     "setup-collection",
@@ -2576,9 +3531,9 @@ function registerDatabasePrompts(server) {
       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: z9.string().describe("Project ID"),
-        collectionName: z9.string().describe("Name of the collection to create"),
-        access: z9.enum(["public-read", "authenticated", "admin-only"]).optional().describe("Access level (default: admin-only)")
+        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 }) => {
@@ -2643,7 +3598,7 @@ function registerDatabasePrompts(server) {
       title: "Database Workflow Guide",
       description: "Explains how the Spacelr database system works: rules-first approach, collection lifecycle, and security model.",
       argsSchema: {
-        projectId: z9.string().describe("Project ID")
+        projectId: z13.string().describe("Project ID")
       }
     },
     async ({ projectId }) => {
@@ -2692,7 +3647,7 @@ function registerDatabasePrompts(server) {
 }
 
 // libs/mcp-server/src/prompts/functions.ts
-import { z as z10 } from "zod";
+import { z as z14 } from "zod";
 function registerFunctionPrompts(server) {
   server.registerPrompt(
     "deploy-function",
@@ -2700,9 +3655,9 @@ function registerFunctionPrompts(server) {
       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: z10.string().describe("Project ID"),
-        name: z10.string().describe("Function name"),
-        useCase: z10.string().optional().describe('What the function should do (e.g. "fetch data from API and store in DB")')
+        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 }) => {