@zyphr-dev/mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,2315 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/config.ts
+function loadToolGuards() {
+  const readOnly = process.env.ZYPHR_READ_ONLY === "true" || process.env.ZYPHR_READ_ONLY === "1";
+  const raw = process.env.ZYPHR_ALLOWED_TOOLS;
+  const allowedTools = raw ? new Set(
+    raw.split(",").map((s) => s.trim()).filter(Boolean)
+  ) : null;
+  return { readOnly, allowedTools };
+}
+function isToolEnabled(tool, guards) {
+  if (guards.allowedTools) {
+    return guards.allowedTools.has(tool.name);
+  }
+  if (guards.readOnly && tool.mutates) {
+    return false;
+  }
+  return true;
+}
+
+// src/client.ts
+import { Zyphr } from "@zyphr-dev/node-sdk";
+var DEFAULT_BASE_URL = "https://api.zyphr.dev/v1";
+var cached;
+function getZyphrClient() {
+  if (cached) return cached;
+  const apiKey = process.env.ZYPHR_API_KEY;
+  if (!apiKey) {
+    process.stderr.write(
+      "[zyphr-mcp] ZYPHR_API_KEY is not set. Provide a zy_live_* or zy_test_* key via the `env` block of your MCP client config.\n"
+    );
+    process.exit(1);
+  }
+  const baseUrl = process.env.ZYPHR_BASE_URL || DEFAULT_BASE_URL;
+  cached = new Zyphr({ apiKey, baseUrl });
+  return cached;
+}
+function getBaseUrl() {
+  return process.env.ZYPHR_BASE_URL || DEFAULT_BASE_URL;
+}
+
+// src/result.ts
+import { ZyphrError, ZyphrRateLimitError } from "@zyphr-dev/node-sdk";
+function toolResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+async function runTool(fn) {
+  try {
+    const data = await fn();
+    return toolResult(data);
+  } catch (err) {
+    return await renderApiError(err);
+  }
+}
+function errorPayload(content) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify(content, null, 2) }]
+  };
+}
+async function renderApiError(err) {
+  if (err instanceof ZyphrError) {
+    const payload = {
+      name: err.name,
+      message: err.message,
+      status: err.status
+    };
+    if (err.code) payload.code = err.code;
+    if (err.requestId) payload.requestId = err.requestId;
+    if (err.details) payload.details = err.details;
+    if (err instanceof ZyphrRateLimitError && err.retryAfter !== void 0) {
+      payload.retryAfter = err.retryAfter;
+    }
+    return errorPayload(payload);
+  }
+  if (err && typeof err === "object" && "response" in err) {
+    const response = err.response;
+    if (response && typeof response.text === "function") {
+      try {
+        const text = await response.text();
+        let parsed = text;
+        try {
+          parsed = JSON.parse(text);
+        } catch {
+        }
+        return errorPayload({ status: response.status, body: parsed });
+      } catch {
+      }
+    }
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  const name = err instanceof Error ? err.name : "Error";
+  return errorPayload({ name, message });
+}
+
+// src/schemas.ts
+import { z } from "zod";
+var emailAddress = z.object({
+  email: z.string().email(),
+  name: z.string().optional()
+});
+var recipient = z.union([z.string().email(), emailAddress]);
+var sendEmailShape = {
+  to: z.union([recipient, z.array(recipient).min(1)]).describe("Recipient email address (string or {email,name}) or an array of them"),
+  from: z.union([z.string().email(), emailAddress]).optional().describe('Sender address. Defaults to the account-level "from" address.'),
+  replyTo: z.union([z.string().email(), emailAddress]).optional(),
+  cc: z.array(z.string().email()).optional(),
+  bcc: z.array(z.string().email()).optional(),
+  subject: z.string().min(1),
+  html: z.string().optional().describe("Rendered HTML body. Mutually exclusive with templateId."),
+  text: z.string().optional().describe("Plain-text body. Mutually exclusive with templateId."),
+  templateId: z.string().optional().describe("Template ID. When set, html/text are ignored."),
+  templateData: z.record(z.unknown()).optional().describe("Variables to interpolate into the template"),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.unknown()).optional(),
+  subscriberId: z.string().optional(),
+  category: z.string().optional(),
+  scheduledAt: z.string().datetime().optional().describe("ISO 8601 timestamp for scheduled delivery")
+};
+var sendPushShape = {
+  userId: z.string().optional().describe("Send to all devices for this user/subscriber"),
+  deviceId: z.string().optional().describe("Send to a specific device only"),
+  title: z.string().optional(),
+  body: z.string().optional(),
+  data: z.record(z.unknown()).optional().describe("Custom data payload delivered to the device"),
+  badge: z.number().int().nonnegative().optional(),
+  sound: z.string().optional(),
+  imageUrl: z.string().url().optional(),
+  contentAvailable: z.boolean().optional().describe("Silent/background push"),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.unknown()).optional(),
+  collapseKey: z.string().optional(),
+  subscriberId: z.string().optional(),
+  subscriberExternalId: z.string().optional(),
+  category: z.string().optional(),
+  force: z.boolean().optional().describe("Skip subscriber preference checks"),
+  sendAt: z.string().datetime().optional(),
+  delay: z.number().int().nonnegative().optional()
+};
+var sendSmsShape = {
+  to: z.string().min(1).describe("Recipient phone number in E.164 format (e.g. +14155551234)"),
+  from: z.string().optional().describe("Sender phone number or sender ID"),
+  body: z.string().min(1),
+  subscriberId: z.string().optional(),
+  scheduledAt: z.string().datetime().optional(),
+  metadata: z.record(z.unknown()).optional()
+};
+var sdkLanguages = ["node", "python", "ruby", "go", "php", "csharp"];
+var quickstartChannels = ["email", "push", "sms", "inbox", "webhook"];
+var getQuickstartShape = {
+  channel: z.enum(quickstartChannels).describe("Which Zyphr channel to wire up"),
+  language: z.enum(["node", "python", "ruby", "go", "php", "csharp"]).describe("Target language for the integration"),
+  framework: z.string().optional().describe(
+    'Optional framework hint (e.g. "express", "nextjs", "flask", "fastapi", "rails", "gin", "laravel", "aspnetcore"). Falls back to plain SDK code when unrecognized.'
+  )
+};
+var getSdkInstallShape = {
+  language: z.enum(sdkLanguages).describe("Target language for the integration"),
+  packageManager: z.string().optional().describe(
+    'Optional package manager override (e.g. "yarn" instead of "npm"). When recognized, only that manager is returned; otherwise the full list is returned.'
+  )
+};
+var listTemplatesShape = {
+  limit: z.number().int().positive().max(200).optional(),
+  offset: z.number().int().nonnegative().optional()
+};
+var getTemplateShape = {
+  id: z.string().min(1).describe("Template ID")
+};
+var renderTemplateShape = {
+  id: z.string().min(1).describe("Template ID"),
+  variables: z.record(z.unknown()).describe("Key/value variables to interpolate into the template")
+};
+var createTemplateShape = {
+  name: z.string().min(1),
+  description: z.string().optional(),
+  subject: z.string().optional().describe("Default subject (email templates)"),
+  html: z.string().optional(),
+  text: z.string().optional()
+};
+var findSubscriberShape = {
+  externalId: z.string().min(1).describe("Subscriber external ID (your application user/customer ID)")
+};
+var listSubscribersShape = {
+  status: z.enum(["active", "inactive"]).optional(),
+  email: z.string().email().optional(),
+  limit: z.number().int().positive().max(200).optional(),
+  offset: z.number().int().nonnegative().optional()
+};
+var createSubscriberShape = {
+  externalId: z.string().min(1).describe("Your application user/customer ID"),
+  email: z.string().email().optional(),
+  phone: z.string().optional(),
+  name: z.string().optional(),
+  avatarUrl: z.string().url().optional(),
+  timezone: z.string().optional(),
+  locale: z.string().optional(),
+  metadata: z.record(z.unknown()).optional()
+};
+var updateSubscriberShape = {
+  id: z.string().min(1).describe("Zyphr subscriber ID"),
+  email: z.string().email().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  name: z.string().nullable().optional(),
+  avatarUrl: z.string().url().nullable().optional(),
+  timezone: z.string().optional(),
+  locale: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+  status: z.enum(["active", "inactive"]).optional()
+};
+var setSubscriberPreferencesShape = {
+  id: z.string().min(1).describe("Zyphr subscriber ID"),
+  preferences: z.array(
+    z.object({
+      categoryId: z.string().optional(),
+      channel: z.string().optional().describe("email | push | sms | in_app"),
+      enabled: z.boolean().optional()
+    })
+  ).min(1)
+};
+var listWebhooksShape = {
+  limit: z.number().int().positive().max(200).optional(),
+  offset: z.number().int().nonnegative().optional()
+};
+var createWebhookShape = {
+  url: z.string().url().describe("Receiver URL that Zyphr will POST events to"),
+  events: z.array(z.string().min(1)).min(1).describe('Event types to subscribe to (e.g. ["email.*", "subscriber.created"])'),
+  description: z.string().optional(),
+  secret: z.string().optional().describe("Optional secret used to sign payloads. If omitted, Zyphr generates one."),
+  metadata: z.record(z.unknown()).optional(),
+  headers: z.record(z.string()).optional().describe("Custom headers to send with every delivery"),
+  version: z.string().optional(),
+  rateLimit: z.number().int().positive().optional()
+};
+var getWebhookDeliveriesShape = {
+  webhookId: z.string().min(1).describe("Webhook endpoint ID"),
+  status: z.enum(["pending", "delivering", "delivered", "failed", "exhausted"]).optional(),
+  eventType: z.string().optional(),
+  search: z.string().optional(),
+  startDate: z.string().datetime().optional(),
+  endDate: z.string().datetime().optional(),
+  limit: z.number().int().positive().max(200).optional(),
+  offset: z.number().int().nonnegative().optional()
+};
+var sendInboxMessageShape = {
+  subscriberId: z.string().min(1).describe("Subscriber to deliver the in-app message to"),
+  title: z.string().min(1),
+  body: z.string().optional(),
+  actionUrl: z.string().url().optional(),
+  actionLabel: z.string().optional(),
+  imageUrl: z.string().url().optional(),
+  icon: z.string().optional(),
+  category: z.string().optional(),
+  priority: z.enum(["low", "normal", "high", "urgent"]).optional(),
+  data: z.record(z.unknown()).optional(),
+  tags: z.array(z.string()).optional(),
+  expiresAt: z.string().datetime().optional()
+};
+
+// src/tools/send.ts
+function normalizeEmailAddress(value) {
+  if (typeof value === "string") return { email: value };
+  if (value && typeof value === "object" && "email" in value) {
+    return value;
+  }
+  return void 0;
+}
+function normalizeRecipients(to) {
+  if (Array.isArray(to)) {
+    return to.map(normalizeEmailAddress).filter((v) => Boolean(v));
+  }
+  const one = normalizeEmailAddress(to);
+  return one ? [one] : [];
+}
+function registerSendTools(server, guards) {
+  if (isToolEnabled({ name: "send_email", mutates: true }, guards)) {
+    server.registerTool(
+      "send_email",
+      {
+        title: "Send email",
+        description: "Send a transactional email via Zyphr. Use either html/text OR templateId+templateData, not both.",
+        inputSchema: sendEmailShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.emails.sendEmail({
+            to: normalizeRecipients(args.to),
+            from: normalizeEmailAddress(args.from),
+            replyTo: normalizeEmailAddress(args.replyTo),
+            cc: args.cc,
+            bcc: args.bcc,
+            subject: args.subject,
+            html: args.html,
+            text: args.text,
+            templateId: args.templateId,
+            templateData: args.templateData,
+            tags: args.tags,
+            metadata: args.metadata,
+            subscriberId: args.subscriberId,
+            category: args.category,
+            scheduledAt: args.scheduledAt ? new Date(args.scheduledAt) : void 0
+          });
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "send_push", mutates: true }, guards)) {
+    server.registerTool(
+      "send_push",
+      {
+        title: "Send push notification",
+        description: "Send a push notification. Target one of: userId (all devices for a user), deviceId (specific device), subscriberId, or subscriberExternalId.",
+        inputSchema: sendPushShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.push.sendPush({
+            userId: args.userId,
+            deviceId: args.deviceId,
+            title: args.title,
+            body: args.body,
+            data: args.data,
+            badge: args.badge,
+            sound: args.sound,
+            imageUrl: args.imageUrl,
+            contentAvailable: args.contentAvailable,
+            tags: args.tags,
+            metadata: args.metadata,
+            collapseKey: args.collapseKey,
+            subscriberId: args.subscriberId,
+            subscriberExternalId: args.subscriberExternalId,
+            category: args.category,
+            force: args.force,
+            sendAt: args.sendAt ? new Date(args.sendAt) : void 0,
+            delay: args.delay
+          });
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "send_sms", mutates: true }, guards)) {
+    server.registerTool(
+      "send_sms",
+      {
+        title: "Send SMS",
+        description: "Send an SMS message via Zyphr. The recipient must be in E.164 format.",
+        inputSchema: sendSmsShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.sms.sendSms({
+            to: args.to,
+            from: args.from,
+            body: args.body,
+            subscriberId: args.subscriberId,
+            scheduledAt: args.scheduledAt ? new Date(args.scheduledAt) : void 0,
+            metadata: args.metadata
+          });
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "send_inbox_message", mutates: true }, guards)) {
+    server.registerTool(
+      "send_inbox_message",
+      {
+        title: "Send in-app inbox message",
+        description: "Deliver an in-app inbox notification to a Zyphr subscriber.",
+        inputSchema: sendInboxMessageShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.inbox.sendInApp({
+            subscriberId: args.subscriberId,
+            title: args.title,
+            body: args.body,
+            actionUrl: args.actionUrl,
+            actionLabel: args.actionLabel,
+            imageUrl: args.imageUrl,
+            icon: args.icon,
+            category: args.category,
+            priority: args.priority,
+            data: args.data,
+            tags: args.tags,
+            expiresAt: args.expiresAt ? new Date(args.expiresAt) : void 0
+          });
+        });
+      }
+    );
+  }
+}
+
+// src/tools/subscribers.ts
+function registerSubscriberTools(server, guards) {
+  if (isToolEnabled({ name: "find_subscriber", mutates: false }, guards)) {
+    server.registerTool(
+      "find_subscriber",
+      {
+        title: "Find subscriber by external ID",
+        description: "Look up a subscriber by the external ID you assigned (typically your application user/customer ID).",
+        inputSchema: findSubscriberShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.subscribers.getSubscriberByExternalId(args.externalId);
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "list_subscribers", mutates: false }, guards)) {
+    server.registerTool(
+      "list_subscribers",
+      {
+        title: "List subscribers",
+        description: "List subscribers, optionally filtered by status or email.",
+        inputSchema: listSubscribersShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.subscribers.listSubscribers(
+            args.status,
+            args.email,
+            args.limit,
+            args.offset
+          );
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "create_subscriber", mutates: true }, guards)) {
+    server.registerTool(
+      "create_subscriber",
+      {
+        title: "Create subscriber",
+        description: "Create a new subscriber. `externalId` must be unique within your account.",
+        inputSchema: createSubscriberShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.subscribers.createSubscriber({
+            externalId: args.externalId,
+            email: args.email,
+            phone: args.phone,
+            name: args.name,
+            avatarUrl: args.avatarUrl,
+            timezone: args.timezone,
+            locale: args.locale,
+            metadata: args.metadata
+          });
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "update_subscriber", mutates: true }, guards)) {
+    server.registerTool(
+      "update_subscriber",
+      {
+        title: "Update subscriber",
+        description: "Update a subscriber by Zyphr ID. Pass null for email/phone/name/avatarUrl to clear those fields.",
+        inputSchema: updateSubscriberShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.subscribers.updateSubscriber(args.id, {
+            email: args.email ?? void 0,
+            phone: args.phone ?? void 0,
+            name: args.name ?? void 0,
+            avatarUrl: args.avatarUrl ?? void 0,
+            timezone: args.timezone,
+            locale: args.locale,
+            metadata: args.metadata,
+            status: args.status
+          });
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "set_subscriber_preferences", mutates: true }, guards)) {
+    server.registerTool(
+      "set_subscriber_preferences",
+      {
+        title: "Set subscriber preferences",
+        description: "Set notification preferences for a subscriber. Each preference targets a category and/or channel and toggles `enabled`.",
+        inputSchema: setSubscriberPreferencesShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.subscribers.setSubscriberPreferences(args.id, {
+            preferences: args.preferences
+          });
+        });
+      }
+    );
+  }
+}
+
+// src/tools/templates.ts
+function registerTemplateTools(server, guards) {
+  if (isToolEnabled({ name: "list_templates", mutates: false }, guards)) {
+    server.registerTool(
+      "list_templates",
+      {
+        title: "List templates",
+        description: "List notification templates in the account.",
+        inputSchema: listTemplatesShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.templates.listTemplates(args.limit, args.offset);
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "get_template", mutates: false }, guards)) {
+    server.registerTool(
+      "get_template",
+      {
+        title: "Get template",
+        description: "Fetch a single template by ID.",
+        inputSchema: getTemplateShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.templates.getTemplate(args.id);
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "render_template", mutates: false }, guards)) {
+    server.registerTool(
+      "render_template",
+      {
+        title: "Render template",
+        description: "Preview a template with the given variables WITHOUT sending. Returns the rendered subject/html/text so the AI can show the user what would be sent.",
+        inputSchema: renderTemplateShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.templates.renderTemplate(args.id, { variables: args.variables });
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "create_template", mutates: true }, guards)) {
+    server.registerTool(
+      "create_template",
+      {
+        title: "Create template",
+        description: "Create a new notification template.",
+        inputSchema: createTemplateShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.templates.createTemplate({
+            name: args.name,
+            description: args.description,
+            subject: args.subject,
+            html: args.html,
+            text: args.text
+          });
+        });
+      }
+    );
+  }
+}
+
+// src/integration/quickstart/email.ts
+var DOCS = "https://docs.zyphr.dev/channels/email";
+var ENV = ["ZYPHR_API_KEY"];
+var NEXT_STEPS = [
+  "Add ZYPHR_API_KEY to your .env file (run get_sdk_install_for_language to confirm the install).",
+  "Wire the new service into your app entrypoint.",
+  "Verify your sender domain in the Zyphr dashboard before sending to real recipients."
+];
+var emailChannel = {
+  node: {
+    sdk: {
+      channel: "email",
+      language: "node",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "src/lib/zyphr.ts",
+          purpose: "Zyphr SDK client singleton",
+          contents: "import { Zyphr } from '@zyphr-dev/node-sdk';\n\nexport const zyphr = new Zyphr({ apiKey: process.env.ZYPHR_API_KEY! });\n",
+          overwrite: false
+        },
+        {
+          path: "src/services/notify.ts",
+          purpose: "Sends a transactional email through Zyphr",
+          contents: "import { zyphr } from '../lib/zyphr.js';\n\nexport async function sendWelcomeEmail(to: string, name: string) {\n  return await zyphr.emails.sendEmail({\n    to: [{ email: to, name }],\n    subject: `Welcome, ${name}!`,\n    html: `<h1>Welcome aboard, ${name}!</h1><p>Glad you're here.</p>`,\n  });\n}\n",
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV,
+      nextSteps: NEXT_STEPS,
+      docsUrl: DOCS
+    },
+    frameworks: {
+      express: {
+        channel: "email",
+        language: "node",
+        framework: "express",
+        variant: "sdk",
+        files: [
+          {
+            path: "src/lib/zyphr.ts",
+            purpose: "Zyphr SDK client singleton",
+            contents: "import { Zyphr } from '@zyphr-dev/node-sdk';\n\nexport const zyphr = new Zyphr({ apiKey: process.env.ZYPHR_API_KEY! });\n",
+            overwrite: false
+          },
+          {
+            path: "src/routes/notify.ts",
+            purpose: "Express route that sends a welcome email",
+            contents: "import { Router } from 'express';\nimport { zyphr } from '../lib/zyphr.js';\n\nexport const notifyRouter = Router();\n\nnotifyRouter.post('/notify', async (req, res, next) => {\n  try {\n    const { to, name } = req.body as { to: string; name: string };\n    const result = await zyphr.emails.sendEmail({\n      to: [{ email: to, name }],\n      subject: `Welcome, ${name}!`,\n      html: `<h1>Welcome, ${name}!</h1>`,\n    });\n    res.json(result);\n  } catch (err) {\n    next(err);\n  }\n});\n",
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV,
+        nextSteps: [
+          ...NEXT_STEPS,
+          "Mount the router in app.ts: app.use('/api', notifyRouter)",
+          `Test: curl -X POST http://localhost:3000/api/notify -d '{"to":"you@example.com","name":"You"}' -H "Content-Type: application/json"`
+        ],
+        docsUrl: DOCS
+      },
+      nextjs: {
+        channel: "email",
+        language: "node",
+        framework: "nextjs",
+        variant: "sdk",
+        files: [
+          {
+            path: "src/lib/zyphr.ts",
+            purpose: "Zyphr SDK client singleton (server-only)",
+            contents: "import 'server-only';\nimport { Zyphr } from '@zyphr-dev/node-sdk';\n\nexport const zyphr = new Zyphr({ apiKey: process.env.ZYPHR_API_KEY! });\n",
+            overwrite: false
+          },
+          {
+            path: "src/app/api/notify/route.ts",
+            purpose: "Next.js App Router route handler that sends a welcome email",
+            contents: "import { NextResponse } from 'next/server';\nimport { zyphr } from '@/lib/zyphr';\n\nexport async function POST(req: Request) {\n  const { to, name } = (await req.json()) as { to: string; name: string };\n  const result = await zyphr.emails.sendEmail({\n    to: [{ email: to, name }],\n    subject: `Welcome, ${name}!`,\n    html: `<h1>Welcome, ${name}!</h1>`,\n  });\n  return NextResponse.json(result);\n}\n",
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV,
+        nextSteps: [
+          ...NEXT_STEPS,
+          `Test: curl -X POST http://localhost:3000/api/notify -d '{"to":"you@example.com","name":"You"}' -H "Content-Type: application/json"`
+        ],
+        docsUrl: DOCS
+      }
+    }
+  },
+  python: {
+    sdk: {
+      channel: "email",
+      language: "python",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/zyphr_client.py",
+          purpose: "REST helper for the Zyphr API",
+          contents: 'import os\nimport requests\n\nZYPHR_API_KEY = os.environ["ZYPHR_API_KEY"]\nBASE_URL = "https://api.zyphr.dev/v1"\n\nheaders = {\n    "X-API-Key": ZYPHR_API_KEY,\n    "Content-Type": "application/json",\n}\n\ndef zyphr_request(method, path, json=None, params=None):\n    response = requests.request(\n        method, f"{BASE_URL}{path}", headers=headers, json=json, params=params,\n    )\n    response.raise_for_status()\n    return response.json()\n',
+          overwrite: false
+        },
+        {
+          path: "app/notify.py",
+          purpose: "Send a welcome email through Zyphr",
+          contents: 'from .zyphr_client import zyphr_request\n\ndef send_welcome_email(to: str, name: str) -> dict:\n    return zyphr_request("POST", "/emails", json={\n        "to": [{"email": to, "name": name}],\n        "subject": f"Welcome, {name}!",\n        "html": f"<h1>Welcome, {name}!</h1>",\n    })\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV,
+      nextSteps: NEXT_STEPS,
+      docsUrl: DOCS
+    },
+    frameworks: {
+      flask: {
+        channel: "email",
+        language: "python",
+        framework: "flask",
+        variant: "sdk",
+        files: [
+          {
+            path: "app/zyphr_client.py",
+            purpose: "REST helper for the Zyphr API",
+            contents: 'import os\nimport requests\n\nBASE_URL = "https://api.zyphr.dev/v1"\n\ndef zyphr_request(method, path, json=None, params=None):\n    response = requests.request(\n        method, f"{BASE_URL}{path}",\n        headers={"X-API-Key": os.environ["ZYPHR_API_KEY"], "Content-Type": "application/json"},\n        json=json, params=params,\n    )\n    response.raise_for_status()\n    return response.json()\n',
+            overwrite: false
+          },
+          {
+            path: "app/routes/notify.py",
+            purpose: "Flask blueprint that sends a welcome email",
+            contents: `from flask import Blueprint, request, jsonify
+from ..zyphr_client import zyphr_request
+
+notify_bp = Blueprint("notify", __name__)
+
+@notify_bp.route("/notify", methods=["POST"])
+def notify():
+    body = request.get_json() or {}
+    result = zyphr_request("POST", "/emails", json={
+        "to": [{"email": body["to"], "name": body.get("name", "")}],
+        "subject": f"Welcome, {body.get('name', 'friend')}!",
+        "html": f"<h1>Welcome!</h1>",
+    })
+    return jsonify(result)
+`,
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV,
+        nextSteps: [
+          ...NEXT_STEPS,
+          'Register the blueprint: app.register_blueprint(notify_bp, url_prefix="/api")'
+        ],
+        docsUrl: DOCS
+      },
+      fastapi: {
+        channel: "email",
+        language: "python",
+        framework: "fastapi",
+        variant: "sdk",
+        files: [
+          {
+            path: "app/zyphr_client.py",
+            purpose: "REST helper for the Zyphr API",
+            contents: 'import os\nimport httpx\n\nBASE_URL = "https://api.zyphr.dev/v1"\n\nasync def zyphr_request(method: str, path: str, json: dict | None = None) -> dict:\n    async with httpx.AsyncClient() as client:\n        resp = await client.request(\n            method, f"{BASE_URL}{path}",\n            headers={"X-API-Key": os.environ["ZYPHR_API_KEY"], "Content-Type": "application/json"},\n            json=json,\n        )\n        resp.raise_for_status()\n        return resp.json()\n',
+            overwrite: false
+          },
+          {
+            path: "app/routers/notify.py",
+            purpose: "FastAPI router that sends a welcome email",
+            contents: 'from fastapi import APIRouter\nfrom pydantic import BaseModel, EmailStr\nfrom ..zyphr_client import zyphr_request\n\nrouter = APIRouter()\n\nclass NotifyIn(BaseModel):\n    to: EmailStr\n    name: str\n\n@router.post("/notify")\nasync def notify(body: NotifyIn):\n    return await zyphr_request("POST", "/emails", json={\n        "to": [{"email": body.to, "name": body.name}],\n        "subject": f"Welcome, {body.name}!",\n        "html": f"<h1>Welcome, {body.name}!</h1>",\n    })\n',
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV,
+        nextSteps: [
+          ...NEXT_STEPS,
+          "Install httpx: `pip install httpx` (or `poetry add httpx`)",
+          'Mount the router: app.include_router(router, prefix="/api")'
+        ],
+        docsUrl: DOCS
+      }
+    }
+  },
+  ruby: {
+    sdk: {
+      channel: "email",
+      language: "ruby",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "config/initializers/zyphr.rb",
+          purpose: "Zyphr SDK configuration",
+          contents: "require 'zyphr'\n\nZyphr.configure do |config|\n  config.api_key['X-API-Key'] = ENV.fetch('ZYPHR_API_KEY')\nend\n",
+          overwrite: false
+        },
+        {
+          path: "app/services/notify_service.rb",
+          purpose: "Service object that sends a welcome email",
+          contents: 'class NotifyService\n  def self.send_welcome_email(to:, name:)\n    Zyphr::EmailsApi.new.send_email(\n      Zyphr::SendEmailRequest.new(\n        to: [{ email: to, name: name }],\n        subject: "Welcome, #{name}!",\n        html: "<h1>Welcome, #{name}!</h1>"\n      )\n    )\n  end\nend\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV,
+      nextSteps: NEXT_STEPS,
+      docsUrl: DOCS
+    },
+    frameworks: {
+      rails: {
+        channel: "email",
+        language: "ruby",
+        framework: "rails",
+        variant: "sdk",
+        files: [
+          {
+            path: "config/initializers/zyphr.rb",
+            purpose: "Zyphr SDK configuration",
+            contents: "require 'zyphr'\n\nZyphr.configure do |config|\n  config.api_key['X-API-Key'] = ENV.fetch('ZYPHR_API_KEY')\nend\n",
+            overwrite: false
+          },
+          {
+            path: "app/controllers/notify_controller.rb",
+            purpose: "Rails controller that sends a welcome email",
+            contents: 'class NotifyController < ApplicationController\n  def create\n    result = Zyphr::EmailsApi.new.send_email(\n      Zyphr::SendEmailRequest.new(\n        to: [{ email: params.require(:to), name: params[:name] }],\n        subject: "Welcome, #{params[:name]}!",\n        html: "<h1>Welcome, #{params[:name]}!</h1>"\n      )\n    )\n    render json: result\n  end\nend\n',
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV,
+        nextSteps: [
+          ...NEXT_STEPS,
+          "Add a route in config/routes.rb: post '/notify', to: 'notify#create'"
+        ],
+        docsUrl: DOCS
+      }
+    }
+  },
+  go: {
+    sdk: {
+      channel: "email",
+      language: "go",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "internal/zyphr/client.go",
+          purpose: "Thin REST client for the Zyphr API",
+          contents: 'package zyphr\n\nimport (\n	"bytes"\n	"encoding/json"\n	"fmt"\n	"io"\n	"net/http"\n	"os"\n)\n\nconst baseURL = "https://api.zyphr.dev/v1"\n\ntype Client struct {\n	APIKey     string\n	HTTPClient *http.Client\n}\n\nfunc NewClient() *Client {\n	return &Client{APIKey: os.Getenv("ZYPHR_API_KEY"), HTTPClient: &http.Client{}}\n}\n\nfunc (c *Client) Do(method, path string, body any) ([]byte, error) {\n	var buf io.Reader\n	if body != nil {\n		b, err := json.Marshal(body)\n		if err != nil { return nil, fmt.Errorf("marshal: %w", err) }\n		buf = bytes.NewReader(b)\n	}\n	req, _ := http.NewRequest(method, baseURL+path, buf)\n	req.Header.Set("X-API-Key", c.APIKey)\n	req.Header.Set("Content-Type", "application/json")\n	resp, err := c.HTTPClient.Do(req)\n	if err != nil { return nil, err }\n	defer resp.Body.Close()\n	data, _ := io.ReadAll(resp.Body)\n	if resp.StatusCode >= 400 { return nil, fmt.Errorf("zyphr %d: %s", resp.StatusCode, data) }\n	return data, nil\n}\n',
+          overwrite: false
+        },
+        {
+          path: "internal/notify/notify.go",
+          purpose: "Send a welcome email through Zyphr",
+          contents: 'package notify\n\nimport "yourapp/internal/zyphr"\n\nfunc SendWelcomeEmail(client *zyphr.Client, to, name string) ([]byte, error) {\n	return client.Do("POST", "/emails", map[string]any{\n		"to":      []map[string]string{{"email": to, "name": name}},\n		"subject": "Welcome, " + name + "!",\n		"html":    "<h1>Welcome, " + name + "!</h1>",\n	})\n}\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV,
+      nextSteps: NEXT_STEPS,
+      docsUrl: DOCS
+    }
+  },
+  php: {
+    sdk: {
+      channel: "email",
+      language: "php",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/Services/ZyphrClient.php",
+          purpose: "Guzzle-backed Zyphr client",
+          contents: `<?php
+
+namespace App\\Services;
+
+use GuzzleHttp\\Client;
+
+class ZyphrClient
+{
+    private Client $http;
+
+    public function __construct()
+    {
+        $this->http = new Client([
+            'base_uri' => 'https://api.zyphr.dev/v1/',
+            'headers' => [
+                'X-API-Key' => getenv('ZYPHR_API_KEY'),
+                'Content-Type' => 'application/json',
+            ],
+        ]);
+    }
+
+    public function sendWelcomeEmail(string $to, string $name): array
+    {
+        $response = $this->http->post('emails', [
+            'json' => [
+                'to' => [['email' => $to, 'name' => $name]],
+                'subject' => "Welcome, {$name}!",
+                'html' => "<h1>Welcome, {$name}!</h1>",
+            ],
+        ]);
+        return json_decode((string) $response->getBody(), true);
+    }
+}
+`,
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV,
+      nextSteps: NEXT_STEPS,
+      docsUrl: DOCS
+    },
+    frameworks: {
+      laravel: {
+        channel: "email",
+        language: "php",
+        framework: "laravel",
+        variant: "sdk",
+        files: [
+          {
+            path: "app/Services/ZyphrClient.php",
+            purpose: "Laravel-friendly Zyphr client",
+            contents: `<?php
+
+namespace App\\Services;
+
+use Illuminate\\Support\\Facades\\Http;
+
+class ZyphrClient
+{
+    public function sendWelcomeEmail(string $to, string $name): array
+    {
+        $response = Http::withHeaders([
+            'X-API-Key' => config('services.zyphr.api_key'),
+            'Content-Type' => 'application/json',
+        ])->post('https://api.zyphr.dev/v1/emails', [
+            'to' => [['email' => $to, 'name' => $name]],
+            'subject' => "Welcome, {$name}!",
+            'html' => "<h1>Welcome, {$name}!</h1>",
+        ]);
+        $response->throw();
+        return $response->json();
+    }
+}
+`,
+            overwrite: false
+          },
+          {
+            path: "config/services.php (snippet)",
+            purpose: "Register the Zyphr API key under services config",
+            contents: "'zyphr' => [\n    'api_key' => env('ZYPHR_API_KEY'),\n],\n",
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV,
+        nextSteps: NEXT_STEPS,
+        docsUrl: DOCS
+      }
+    }
+  },
+  csharp: {
+    sdk: {
+      channel: "email",
+      language: "csharp",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "Services/ZyphrClient.cs",
+          purpose: "Singleton-style Zyphr client wrapper",
+          contents: 'using ZyphrDev.SDK.Api;\nusing ZyphrDev.SDK.Client;\nusing ZyphrDev.SDK.Model;\n\nnamespace YourApp.Services;\n\npublic class ZyphrClient\n{\n    private readonly EmailsApi _emails;\n\n    public ZyphrClient()\n    {\n        var config = new Configuration\n        {\n            ApiKey = new Dictionary<string, string>\n            {\n                { "X-API-Key", Environment.GetEnvironmentVariable("ZYPHR_API_KEY")! }\n            }\n        };\n        _emails = new EmailsApi(config);\n    }\n\n    public async Task<SendEmailResponse> SendWelcomeEmailAsync(string to, string name)\n    {\n        return await _emails.SendEmailAsync(new SendEmailRequest(\n            to: new List<EmailAddress> { new() { Email = to, Name = name } },\n            subject: $"Welcome, {name}!",\n            html: $"<h1>Welcome, {name}!</h1>"\n        ));\n    }\n}\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV,
+      nextSteps: NEXT_STEPS,
+      docsUrl: DOCS
+    },
+    frameworks: {
+      aspnetcore: {
+        channel: "email",
+        language: "csharp",
+        framework: "aspnetcore",
+        variant: "sdk",
+        files: [
+          {
+            path: "Services/ZyphrClient.cs",
+            purpose: "DI-friendly Zyphr client",
+            contents: 'using ZyphrDev.SDK.Api;\nusing ZyphrDev.SDK.Client;\nusing ZyphrDev.SDK.Model;\n\nnamespace YourApp.Services;\n\npublic class ZyphrClient\n{\n    public EmailsApi Emails { get; }\n\n    public ZyphrClient(IConfiguration cfg)\n    {\n        var config = new Configuration\n        {\n            ApiKey = new Dictionary<string, string>\n            {\n                { "X-API-Key", cfg["Zyphr:ApiKey"]! }\n            }\n        };\n        Emails = new EmailsApi(config);\n    }\n}\n',
+            overwrite: false
+          },
+          {
+            path: "Controllers/NotifyController.cs",
+            purpose: "ASP.NET Core controller that sends a welcome email",
+            contents: 'using Microsoft.AspNetCore.Mvc;\nusing YourApp.Services;\nusing ZyphrDev.SDK.Model;\n\n[ApiController]\n[Route("api/[controller]")]\npublic class NotifyController : ControllerBase\n{\n    private readonly ZyphrClient _zyphr;\n    public NotifyController(ZyphrClient zyphr) => _zyphr = zyphr;\n\n    public record NotifyIn(string To, string Name);\n\n    [HttpPost]\n    public async Task<IActionResult> Post([FromBody] NotifyIn body)\n    {\n        var result = await _zyphr.Emails.SendEmailAsync(new SendEmailRequest(\n            to: new List<EmailAddress> { new() { Email = body.To, Name = body.Name } },\n            subject: $"Welcome, {body.Name}!",\n            html: $"<h1>Welcome, {body.Name}!</h1>"\n        ));\n        return Ok(result);\n    }\n}\n',
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV,
+        nextSteps: [
+          ...NEXT_STEPS,
+          "Register the client in Program.cs: builder.Services.AddSingleton<ZyphrClient>();"
+        ],
+        docsUrl: DOCS
+      }
+    }
+  }
+};
+
+// src/integration/quickstart/inbox.ts
+var DOCS2 = "https://docs.zyphr.dev/channels/in-app-messaging";
+var ENV2 = ["ZYPHR_API_KEY"];
+var NEXT_STEPS2 = [
+  "Add ZYPHR_API_KEY to your .env file.",
+  "Use the matching subscriberId on the client (e.g. @zyphr-dev/inbox-react) to display the message."
+];
+var inboxChannel = {
+  node: {
+    sdk: {
+      channel: "inbox",
+      language: "node",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "src/services/inbox.ts",
+          purpose: "Send an in-app inbox message through Zyphr",
+          contents: "import { Zyphr } from '@zyphr-dev/node-sdk';\n\nconst zyphr = new Zyphr({ apiKey: process.env.ZYPHR_API_KEY! });\n\nexport async function notifyReportReady(subscriberId: string, reportId: string) {\n  return await zyphr.inbox.sendInApp({\n    subscriberId,\n    title: 'New report ready',\n    body: 'Your report finished processing \u2014 click to view.',\n    actionUrl: `/reports/${reportId}`,\n    actionLabel: 'View report',\n  });\n}\n",
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV2,
+      nextSteps: NEXT_STEPS2,
+      docsUrl: DOCS2
+    }
+  },
+  python: {
+    sdk: {
+      channel: "inbox",
+      language: "python",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/inbox.py",
+          purpose: "Send an in-app inbox message through Zyphr",
+          contents: 'from .zyphr_client import zyphr_request\n\ndef notify_report_ready(subscriber_id: str, report_id: str) -> dict:\n    return zyphr_request("POST", "/inbox", json={\n        "subscriberId": subscriber_id,\n        "title": "New report ready",\n        "body": "Your report finished processing \u2014 click to view.",\n        "actionUrl": f"/reports/{report_id}",\n        "actionLabel": "View report",\n    })\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV2,
+      nextSteps: NEXT_STEPS2,
+      docsUrl: DOCS2
+    }
+  },
+  ruby: {
+    sdk: {
+      channel: "inbox",
+      language: "ruby",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/services/inbox_service.rb",
+          purpose: "Send an in-app inbox message through Zyphr",
+          contents: `class InboxService
+  def self.notify_report_ready(subscriber_id:, report_id:)
+    Zyphr::InboxApi.new.send_in_app(
+      Zyphr::SendInAppRequest.new(
+        subscriber_id: subscriber_id,
+        title: 'New report ready',
+        body: 'Your report finished processing \u2014 click to view.',
+        action_url: "/reports/#{report_id}",
+        action_label: 'View report'
+      )
+    )
+  end
+end
+`,
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV2,
+      nextSteps: NEXT_STEPS2,
+      docsUrl: DOCS2
+    }
+  },
+  go: {
+    sdk: {
+      channel: "inbox",
+      language: "go",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "internal/notify/inbox.go",
+          purpose: "Send an in-app inbox message through Zyphr",
+          contents: 'package notify\n\nimport "yourapp/internal/zyphr"\n\nfunc NotifyReportReady(client *zyphr.Client, subscriberID, reportID string) ([]byte, error) {\n	return client.Do("POST", "/inbox", map[string]any{\n		"subscriberId": subscriberID,\n		"title":        "New report ready",\n		"body":         "Your report finished processing \u2014 click to view.",\n		"actionUrl":    "/reports/" + reportID,\n		"actionLabel":  "View report",\n	})\n}\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV2,
+      nextSteps: NEXT_STEPS2,
+      docsUrl: DOCS2
+    }
+  },
+  php: {
+    sdk: {
+      channel: "inbox",
+      language: "php",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/Services/InboxService.php",
+          purpose: "Send an in-app inbox message through Zyphr",
+          contents: `<?php
+
+namespace App\\Services;
+
+use GuzzleHttp\\Client;
+
+class InboxService
+{
+    public function notifyReportReady(string $subscriberId, string $reportId): array
+    {
+        $http = new Client([
+            'base_uri' => 'https://api.zyphr.dev/v1/',
+            'headers' => [
+                'X-API-Key' => getenv('ZYPHR_API_KEY'),
+                'Content-Type' => 'application/json',
+            ],
+        ]);
+        $r = $http->post('inbox', ['json' => [
+            'subscriberId' => $subscriberId,
+            'title' => 'New report ready',
+            'body' => 'Your report finished processing \u2014 click to view.',
+            'actionUrl' => "/reports/{$reportId}",
+            'actionLabel' => 'View report',
+        ]]);
+        return json_decode((string) $r->getBody(), true);
+    }
+}
+`,
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV2,
+      nextSteps: NEXT_STEPS2,
+      docsUrl: DOCS2
+    }
+  },
+  csharp: {
+    sdk: {
+      channel: "inbox",
+      language: "csharp",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "Services/InboxService.cs",
+          purpose: "Send an in-app inbox message through Zyphr",
+          contents: 'using ZyphrDev.SDK.Api;\nusing ZyphrDev.SDK.Client;\nusing ZyphrDev.SDK.Model;\n\nnamespace YourApp.Services;\n\npublic class InboxService\n{\n    private readonly InboxApi _inbox;\n    public InboxService()\n    {\n        var config = new Configuration\n        {\n            ApiKey = new Dictionary<string, string>\n            {\n                { "X-API-Key", Environment.GetEnvironmentVariable("ZYPHR_API_KEY")! }\n            }\n        };\n        _inbox = new InboxApi(config);\n    }\n\n    public Task<SendInAppResponse> NotifyReportReadyAsync(string subscriberId, string reportId)\n    {\n        return _inbox.SendInAppAsync(new SendInAppRequest(\n            subscriberId: subscriberId,\n            title: "New report ready",\n            body: "Your report finished processing \u2014 click to view.",\n            actionUrl: $"/reports/{reportId}",\n            actionLabel: "View report"\n        ));\n    }\n}\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV2,
+      nextSteps: NEXT_STEPS2,
+      docsUrl: DOCS2
+    }
+  }
+};
+
+// src/integration/quickstart/push.ts
+var DOCS3 = "https://docs.zyphr.dev/channels/push-notifications";
+var ENV3 = ["ZYPHR_API_KEY"];
+var NEXT_STEPS3 = [
+  "Add ZYPHR_API_KEY to your .env file.",
+  "Register at least one device for the target subscriber (via the SDK or dashboard) before sending.",
+  "Verify your push provider credentials (APNs/FCM) are configured in the Zyphr dashboard."
+];
+var pushChannel = {
+  node: {
+    sdk: {
+      channel: "push",
+      language: "node",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "src/services/push.ts",
+          purpose: "Send a push notification through Zyphr",
+          contents: "import { Zyphr } from '@zyphr-dev/node-sdk';\n\nconst zyphr = new Zyphr({ apiKey: process.env.ZYPHR_API_KEY! });\n\nexport async function pushOrderShipped(subscriberId: string, orderId: string) {\n  return await zyphr.push.sendPush({\n    subscriberId,\n    title: 'Order shipped',\n    body: `Order ${orderId} is on its way.`,\n    data: { orderId },\n  });\n}\n",
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV3,
+      nextSteps: NEXT_STEPS3,
+      docsUrl: DOCS3
+    }
+  },
+  python: {
+    sdk: {
+      channel: "push",
+      language: "python",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/push.py",
+          purpose: "Send a push notification through Zyphr",
+          contents: 'from .zyphr_client import zyphr_request\n\ndef push_order_shipped(subscriber_id: str, order_id: str) -> dict:\n    return zyphr_request("POST", "/push", json={\n        "subscriberId": subscriber_id,\n        "title": "Order shipped",\n        "body": f"Order {order_id} is on its way.",\n        "data": {"orderId": order_id},\n    })\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV3,
+      nextSteps: NEXT_STEPS3,
+      docsUrl: DOCS3
+    }
+  },
+  ruby: {
+    sdk: {
+      channel: "push",
+      language: "ruby",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/services/push_service.rb",
+          purpose: "Send a push notification through Zyphr",
+          contents: `class PushService
+  def self.order_shipped(subscriber_id:, order_id:)
+    Zyphr::PushApi.new.send_push(
+      Zyphr::SendPushRequest.new(
+        subscriber_id: subscriber_id,
+        title: 'Order shipped',
+        body: "Order #{order_id} is on its way.",
+        data: { orderId: order_id }
+      )
+    )
+  end
+end
+`,
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV3,
+      nextSteps: NEXT_STEPS3,
+      docsUrl: DOCS3
+    }
+  },
+  go: {
+    sdk: {
+      channel: "push",
+      language: "go",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "internal/notify/push.go",
+          purpose: "Send a push notification through Zyphr",
+          contents: 'package notify\n\nimport "yourapp/internal/zyphr"\n\nfunc PushOrderShipped(client *zyphr.Client, subscriberID, orderID string) ([]byte, error) {\n	return client.Do("POST", "/push", map[string]any{\n		"subscriberId": subscriberID,\n		"title":        "Order shipped",\n		"body":         "Order " + orderID + " is on its way.",\n		"data":         map[string]string{"orderId": orderID},\n	})\n}\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV3,
+      nextSteps: NEXT_STEPS3,
+      docsUrl: DOCS3
+    }
+  },
+  php: {
+    sdk: {
+      channel: "push",
+      language: "php",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/Services/PushService.php",
+          purpose: "Send a push notification through Zyphr",
+          contents: `<?php
+
+namespace App\\Services;
+
+use GuzzleHttp\\Client;
+
+class PushService
+{
+    public function orderShipped(string $subscriberId, string $orderId): array
+    {
+        $http = new Client([
+            'base_uri' => 'https://api.zyphr.dev/v1/',
+            'headers' => [
+                'X-API-Key' => getenv('ZYPHR_API_KEY'),
+                'Content-Type' => 'application/json',
+            ],
+        ]);
+        $r = $http->post('push', ['json' => [
+            'subscriberId' => $subscriberId,
+            'title' => 'Order shipped',
+            'body' => "Order {$orderId} is on its way.",
+            'data' => ['orderId' => $orderId],
+        ]]);
+        return json_decode((string) $r->getBody(), true);
+    }
+}
+`,
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV3,
+      nextSteps: NEXT_STEPS3,
+      docsUrl: DOCS3
+    }
+  },
+  csharp: {
+    sdk: {
+      channel: "push",
+      language: "csharp",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "Services/PushService.cs",
+          purpose: "Send a push notification through Zyphr",
+          contents: 'using ZyphrDev.SDK.Api;\nusing ZyphrDev.SDK.Client;\nusing ZyphrDev.SDK.Model;\n\nnamespace YourApp.Services;\n\npublic class PushService\n{\n    private readonly PushApi _push;\n    public PushService()\n    {\n        var config = new Configuration\n        {\n            ApiKey = new Dictionary<string, string>\n            {\n                { "X-API-Key", Environment.GetEnvironmentVariable("ZYPHR_API_KEY")! }\n            }\n        };\n        _push = new PushApi(config);\n    }\n\n    public Task<SendPushResponse> OrderShippedAsync(string subscriberId, string orderId)\n    {\n        return _push.SendPushAsync(new SendPushRequest(\n            subscriberId: subscriberId,\n            title: "Order shipped",\n            body: $"Order {orderId} is on its way."\n        ));\n    }\n}\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV3,
+      nextSteps: NEXT_STEPS3,
+      docsUrl: DOCS3
+    }
+  }
+};
+
+// src/integration/quickstart/sms.ts
+var DOCS4 = "https://docs.zyphr.dev/channels/sms";
+var ENV4 = ["ZYPHR_API_KEY"];
+var NEXT_STEPS4 = [
+  "Add ZYPHR_API_KEY to your .env file.",
+  "Recipients MUST be in E.164 format (e.g. +14155551234).",
+  "Provision your SMS sender (phone number or alphanumeric sender ID) in the Zyphr dashboard."
+];
+var smsChannel = {
+  node: {
+    sdk: {
+      channel: "sms",
+      language: "node",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "src/services/sms.ts",
+          purpose: "Send an SMS through Zyphr",
+          contents: "import { Zyphr } from '@zyphr-dev/node-sdk';\n\nconst zyphr = new Zyphr({ apiKey: process.env.ZYPHR_API_KEY! });\n\nexport async function sendOtp(to: string, code: string) {\n  return await zyphr.sms.sendSms({\n    to,\n    body: `Your verification code is ${code}. Expires in 5 minutes.`,\n  });\n}\n",
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV4,
+      nextSteps: NEXT_STEPS4,
+      docsUrl: DOCS4
+    }
+  },
+  python: {
+    sdk: {
+      channel: "sms",
+      language: "python",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/sms.py",
+          purpose: "Send an SMS through Zyphr",
+          contents: 'from .zyphr_client import zyphr_request\n\ndef send_otp(to: str, code: str) -> dict:\n    return zyphr_request("POST", "/sms", json={\n        "to": to,\n        "body": f"Your verification code is {code}. Expires in 5 minutes.",\n    })\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV4,
+      nextSteps: NEXT_STEPS4,
+      docsUrl: DOCS4
+    }
+  },
+  ruby: {
+    sdk: {
+      channel: "sms",
+      language: "ruby",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/services/sms_service.rb",
+          purpose: "Send an SMS through Zyphr",
+          contents: 'class SmsService\n  def self.send_otp(to:, code:)\n    Zyphr::SMSApi.new.send_sms(\n      Zyphr::SendSmsRequest.new(\n        to: to,\n        body: "Your verification code is #{code}. Expires in 5 minutes."\n      )\n    )\n  end\nend\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV4,
+      nextSteps: NEXT_STEPS4,
+      docsUrl: DOCS4
+    }
+  },
+  go: {
+    sdk: {
+      channel: "sms",
+      language: "go",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "internal/notify/sms.go",
+          purpose: "Send an SMS through Zyphr",
+          contents: 'package notify\n\nimport "yourapp/internal/zyphr"\n\nfunc SendOtp(client *zyphr.Client, to, code string) ([]byte, error) {\n	return client.Do("POST", "/sms", map[string]any{\n		"to":   to,\n		"body": "Your verification code is " + code + ". Expires in 5 minutes.",\n	})\n}\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV4,
+      nextSteps: NEXT_STEPS4,
+      docsUrl: DOCS4
+    }
+  },
+  php: {
+    sdk: {
+      channel: "sms",
+      language: "php",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "app/Services/SmsService.php",
+          purpose: "Send an SMS through Zyphr",
+          contents: `<?php
+
+namespace App\\Services;
+
+use GuzzleHttp\\Client;
+
+class SmsService
+{
+    public function sendOtp(string $to, string $code): array
+    {
+        $http = new Client([
+            'base_uri' => 'https://api.zyphr.dev/v1/',
+            'headers' => [
+                'X-API-Key' => getenv('ZYPHR_API_KEY'),
+                'Content-Type' => 'application/json',
+            ],
+        ]);
+        $r = $http->post('sms', ['json' => [
+            'to' => $to,
+            'body' => "Your verification code is {$code}. Expires in 5 minutes.",
+        ]]);
+        return json_decode((string) $r->getBody(), true);
+    }
+}
+`,
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV4,
+      nextSteps: NEXT_STEPS4,
+      docsUrl: DOCS4
+    }
+  },
+  csharp: {
+    sdk: {
+      channel: "sms",
+      language: "csharp",
+      framework: null,
+      variant: "sdk",
+      files: [
+        {
+          path: "Services/SmsService.cs",
+          purpose: "Send an SMS through Zyphr",
+          contents: 'using ZyphrDev.SDK.Api;\nusing ZyphrDev.SDK.Client;\nusing ZyphrDev.SDK.Model;\n\nnamespace YourApp.Services;\n\npublic class SmsService\n{\n    private readonly SMSApi _sms;\n    public SmsService()\n    {\n        var config = new Configuration\n        {\n            ApiKey = new Dictionary<string, string>\n            {\n                { "X-API-Key", Environment.GetEnvironmentVariable("ZYPHR_API_KEY")! }\n            }\n        };\n        _sms = new SMSApi(config);\n    }\n\n    public Task<SendSmsResponse> SendOtpAsync(string to, string code)\n    {\n        return _sms.SendSmsAsync(new SendSmsRequest(\n            to: to,\n            body: $"Your verification code is {code}. Expires in 5 minutes."\n        ));\n    }\n}\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV4,
+      nextSteps: NEXT_STEPS4,
+      docsUrl: DOCS4
+    }
+  }
+};
+
+// src/integration/quickstart/webhook.ts
+var DOCS5 = "https://docs.zyphr.dev/features/webhooks-security";
+var ENV5 = ["ZYPHR_WEBHOOK_SECRET"];
+var NEXT_STEPS5 = [
+  "Add ZYPHR_WEBHOOK_SECRET to your .env file \u2014 get it from `zyphr.webhooks.rotateWebhookSecret(id)` or the Zyphr dashboard.",
+  "Configure the webhook endpoint URL in the Zyphr dashboard or via `create_webhook`.",
+  "ALWAYS verify signatures before processing payloads \u2014 never trust an unverified webhook.",
+  "Reject deliveries whose timestamp is more than 5 minutes from now to prevent replay attacks."
+];
+var webhookChannel = {
+  node: {
+    sdk: {
+      channel: "webhook",
+      language: "node",
+      framework: null,
+      variant: "webhook-handler",
+      files: [
+        {
+          path: "src/lib/verifyZyphrWebhook.ts",
+          purpose: "Standard Webhooks (HMAC-SHA256) signature + timestamp verification. Mirrors the canonical snippet in apps/docs/docs/features/webhooks-security.md.",
+          contents: "import crypto from 'crypto';\n\nexport function verifyZyphrWebhook(\n  payload: string,\n  headers: { 'webhook-id': string; 'webhook-timestamp': string; 'webhook-signature': string },\n  secret: string,\n): boolean {\n  const msgId = headers['webhook-id'];\n  const timestamp = parseInt(headers['webhook-timestamp'], 10);\n  const signatures = headers['webhook-signature'];\n\n  const now = Math.floor(Date.now() / 1000);\n  if (Math.abs(now - timestamp) > 300) return false;\n\n  const signedContent = `${msgId}.${timestamp}.${payload}`;\n  const secretBytes = Buffer.from(\n    secret.startsWith('whsec_') ? secret.slice(6) : secret,\n    'hex',\n  );\n  const expected = crypto\n    .createHmac('sha256', secretBytes)\n    .update(signedContent)\n    .digest('base64');\n\n  for (const sig of signatures.split(' ')) {\n    const sigValue = sig.slice(3);\n    if (\n      sigValue.length === expected.length &&\n      crypto.timingSafeEqual(Buffer.from(sigValue), Buffer.from(expected))\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n",
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV5,
+      nextSteps: NEXT_STEPS5,
+      docsUrl: DOCS5
+    },
+    frameworks: {
+      express: {
+        channel: "webhook",
+        language: "node",
+        framework: "express",
+        variant: "webhook-handler",
+        files: [
+          {
+            path: "src/lib/verifyZyphrWebhook.ts",
+            purpose: "Standard Webhooks signature verification helper",
+            contents: "import crypto from 'crypto';\n\nexport function verifyZyphrWebhook(payload: string, headers: Record<string,string>, secret: string): boolean {\n  const msgId = headers['webhook-id'];\n  const timestamp = parseInt(headers['webhook-timestamp'], 10);\n  const signatures = headers['webhook-signature'] || '';\n  const now = Math.floor(Date.now() / 1000);\n  if (Math.abs(now - timestamp) > 300) return false;\n  const signedContent = `${msgId}.${timestamp}.${payload}`;\n  const secretBytes = Buffer.from(secret.startsWith('whsec_') ? secret.slice(6) : secret, 'hex');\n  const expected = crypto.createHmac('sha256', secretBytes).update(signedContent).digest('base64');\n  return signatures.split(' ').some((sig) => {\n    const v = sig.slice(3);\n    return v.length === expected.length && crypto.timingSafeEqual(Buffer.from(v), Buffer.from(expected));\n  });\n}\n",
+            overwrite: false
+          },
+          {
+            path: "src/routes/zyphrWebhook.ts",
+            purpose: "Express route that VERIFIES the signature before processing the webhook. Uses express.raw() so we can hash the exact bytes.",
+            contents: "import { Router, raw } from 'express';\nimport { verifyZyphrWebhook } from '../lib/verifyZyphrWebhook.js';\n\nexport const zyphrWebhookRouter = Router();\n\nzyphrWebhookRouter.post('/zyphr', raw({ type: 'application/json' }), (req, res) => {\n  const payload = (req.body as Buffer).toString();\n  const headers = req.headers as Record<string, string>;\n  if (!verifyZyphrWebhook(payload, headers, process.env.ZYPHR_WEBHOOK_SECRET!)) {\n    return res.status(401).send('invalid signature');\n  }\n  const event = JSON.parse(payload) as { type: string; data: unknown };\n  console.log('zyphr event', event.type);\n  res.sendStatus(204);\n});\n",
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV5,
+        nextSteps: [
+          ...NEXT_STEPS5,
+          "Mount the router BEFORE express.json(): app.use(zyphrWebhookRouter)"
+        ],
+        docsUrl: DOCS5
+      },
+      nextjs: {
+        channel: "webhook",
+        language: "node",
+        framework: "nextjs",
+        variant: "webhook-handler",
+        files: [
+          {
+            path: "src/lib/verifyZyphrWebhook.ts",
+            purpose: "Standard Webhooks signature verification helper",
+            contents: "import crypto from 'crypto';\n\nexport function verifyZyphrWebhook(payload: string, headers: Headers, secret: string): boolean {\n  const msgId = headers.get('webhook-id') || '';\n  const timestamp = parseInt(headers.get('webhook-timestamp') || '0', 10);\n  const signatures = headers.get('webhook-signature') || '';\n  const now = Math.floor(Date.now() / 1000);\n  if (Math.abs(now - timestamp) > 300) return false;\n  const signedContent = `${msgId}.${timestamp}.${payload}`;\n  const secretBytes = Buffer.from(secret.startsWith('whsec_') ? secret.slice(6) : secret, 'hex');\n  const expected = crypto.createHmac('sha256', secretBytes).update(signedContent).digest('base64');\n  return signatures.split(' ').some((sig) => {\n    const v = sig.slice(3);\n    return v.length === expected.length && crypto.timingSafeEqual(Buffer.from(v), Buffer.from(expected));\n  });\n}\n",
+            overwrite: false
+          },
+          {
+            path: "src/app/api/zyphr/webhook/route.ts",
+            purpose: "Next.js App Router webhook handler with signature verification",
+            contents: "import { NextResponse } from 'next/server';\nimport { verifyZyphrWebhook } from '@/lib/verifyZyphrWebhook';\n\nexport async function POST(req: Request) {\n  const payload = await req.text();\n  if (!verifyZyphrWebhook(payload, req.headers, process.env.ZYPHR_WEBHOOK_SECRET!)) {\n    return new NextResponse('invalid signature', { status: 401 });\n  }\n  const event = JSON.parse(payload) as { type: string; data: unknown };\n  console.log('zyphr event', event.type);\n  return new NextResponse(null, { status: 204 });\n}\n",
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV5,
+        nextSteps: NEXT_STEPS5,
+        docsUrl: DOCS5
+      }
+    }
+  },
+  python: {
+    sdk: {
+      channel: "webhook",
+      language: "python",
+      framework: null,
+      variant: "webhook-handler",
+      files: [
+        {
+          path: "app/zyphr_webhook.py",
+          purpose: "Standard Webhooks signature verification helper (verbatim from docs)",
+          contents: 'import hashlib\nimport hmac\nimport base64\nimport time\n\ndef verify_zyphr_webhook(payload: str, headers: dict, secret: str) -> bool:\n    msg_id = headers.get("webhook-id", "")\n    timestamp = headers.get("webhook-timestamp", "")\n    signature = headers.get("webhook-signature", "")\n\n    now = int(time.time())\n    if abs(now - int(timestamp)) > 300:\n        return False\n\n    signed_content = f"{msg_id}.{timestamp}.{payload}"\n    secret_hex = secret.removeprefix("whsec_")\n    secret_bytes = bytes.fromhex(secret_hex)\n    expected = base64.b64encode(\n        hmac.new(secret_bytes, signed_content.encode(), hashlib.sha256).digest()\n    ).decode()\n\n    for sig in signature.split(" "):\n        sig_value = sig.removeprefix("v1,")\n        if hmac.compare_digest(sig_value, expected):\n            return True\n    return False\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV5,
+      nextSteps: NEXT_STEPS5,
+      docsUrl: DOCS5
+    },
+    frameworks: {
+      flask: {
+        channel: "webhook",
+        language: "python",
+        framework: "flask",
+        variant: "webhook-handler",
+        files: [
+          {
+            path: "app/zyphr_webhook.py",
+            purpose: "Standard Webhooks signature verification helper",
+            contents: 'import hashlib, hmac, base64, time\n\ndef verify_zyphr_webhook(payload: str, headers, secret: str) -> bool:\n    msg_id = headers.get("webhook-id", "")\n    timestamp = headers.get("webhook-timestamp", "")\n    signature = headers.get("webhook-signature", "")\n    if abs(int(time.time()) - int(timestamp)) > 300:\n        return False\n    signed = f"{msg_id}.{timestamp}.{payload}"\n    secret_bytes = bytes.fromhex(secret.removeprefix("whsec_"))\n    expected = base64.b64encode(hmac.new(secret_bytes, signed.encode(), hashlib.sha256).digest()).decode()\n    return any(hmac.compare_digest(sig.removeprefix("v1,"), expected) for sig in signature.split(" "))\n',
+            overwrite: false
+          },
+          {
+            path: "app/routes/zyphr_webhook.py",
+            purpose: "Flask blueprint that verifies the webhook signature before processing",
+            contents: 'import os, json\nfrom flask import Blueprint, request, abort\nfrom ..zyphr_webhook import verify_zyphr_webhook\n\nzyphr_webhook_bp = Blueprint("zyphr_webhook", __name__)\n\n@zyphr_webhook_bp.route("/webhooks/zyphr", methods=["POST"])\ndef handle():\n    payload = request.get_data(as_text=True)\n    if not verify_zyphr_webhook(payload, request.headers, os.environ["ZYPHR_WEBHOOK_SECRET"]):\n        abort(401, "invalid signature")\n    event = json.loads(payload)\n    print("zyphr event", event.get("type"))\n    return "", 204\n',
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV5,
+        nextSteps: NEXT_STEPS5,
+        docsUrl: DOCS5
+      },
+      fastapi: {
+        channel: "webhook",
+        language: "python",
+        framework: "fastapi",
+        variant: "webhook-handler",
+        files: [
+          {
+            path: "app/routers/zyphr_webhook.py",
+            purpose: "FastAPI router that verifies the webhook signature before processing",
+            contents: 'import os, json, hashlib, hmac, base64, time\nfrom fastapi import APIRouter, Request, HTTPException\n\nrouter = APIRouter()\n\ndef verify_zyphr_webhook(payload: str, headers, secret: str) -> bool:\n    msg_id = headers.get("webhook-id", "")\n    timestamp = headers.get("webhook-timestamp", "")\n    signature = headers.get("webhook-signature", "")\n    if abs(int(time.time()) - int(timestamp)) > 300:\n        return False\n    signed = f"{msg_id}.{timestamp}.{payload}"\n    secret_bytes = bytes.fromhex(secret.removeprefix("whsec_"))\n    expected = base64.b64encode(hmac.new(secret_bytes, signed.encode(), hashlib.sha256).digest()).decode()\n    return any(hmac.compare_digest(sig.removeprefix("v1,"), expected) for sig in signature.split(" "))\n\n@router.post("/webhooks/zyphr")\nasync def handle(request: Request):\n    body = (await request.body()).decode()\n    if not verify_zyphr_webhook(body, request.headers, os.environ["ZYPHR_WEBHOOK_SECRET"]):\n        raise HTTPException(status_code=401, detail="invalid signature")\n    event = json.loads(body)\n    print("zyphr event", event.get("type"))\n    return {"ok": True}\n',
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV5,
+        nextSteps: NEXT_STEPS5,
+        docsUrl: DOCS5
+      }
+    }
+  },
+  ruby: {
+    sdk: {
+      channel: "webhook",
+      language: "ruby",
+      framework: null,
+      variant: "webhook-handler",
+      files: [
+        {
+          path: "app/services/zyphr_webhook.rb",
+          purpose: "Standard Webhooks signature verification helper",
+          contents: `require 'openssl'
+require 'base64'
+
+class ZyphrWebhook
+  def self.verify(payload:, headers:, secret:)
+    msg_id = headers['webhook-id'].to_s
+    timestamp = headers['webhook-timestamp'].to_i
+    signatures = headers['webhook-signature'].to_s
+
+    return false if (Time.now.to_i - timestamp).abs > 300
+
+    signed = "#{msg_id}.#{timestamp}.#{payload}"
+    hex = secret.start_with?('whsec_') ? secret[6..] : secret
+    secret_bytes = [hex].pack('H*')
+    expected = Base64.strict_encode64(OpenSSL::HMAC.digest('SHA256', secret_bytes, signed))
+
+    signatures.split(' ').any? do |sig|
+      v = sig[3..]
+      v && Rack::Utils.secure_compare(v, expected)
+    end
+  end
+end
+`,
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV5,
+      nextSteps: NEXT_STEPS5,
+      docsUrl: DOCS5
+    },
+    frameworks: {
+      rails: {
+        channel: "webhook",
+        language: "ruby",
+        framework: "rails",
+        variant: "webhook-handler",
+        files: [
+          {
+            path: "app/services/zyphr_webhook.rb",
+            purpose: "Standard Webhooks signature verification helper",
+            contents: `require 'openssl'
+require 'base64'
+
+class ZyphrWebhook
+  def self.verify(payload:, headers:, secret:)
+    msg_id = headers['webhook-id'].to_s
+    timestamp = headers['webhook-timestamp'].to_i
+    signatures = headers['webhook-signature'].to_s
+    return false if (Time.now.to_i - timestamp).abs > 300
+    signed = "#{msg_id}.#{timestamp}.#{payload}"
+    hex = secret.start_with?('whsec_') ? secret[6..] : secret
+    secret_bytes = [hex].pack('H*')
+    expected = Base64.strict_encode64(OpenSSL::HMAC.digest('SHA256', secret_bytes, signed))
+    signatures.split(' ').any? { |sig| sig[3..] && ActiveSupport::SecurityUtils.secure_compare(sig[3..], expected) }
+  end
+end
+`,
+            overwrite: false
+          },
+          {
+            path: "app/controllers/zyphr_webhooks_controller.rb",
+            purpose: "Rails controller that verifies the webhook signature before processing",
+            contents: `class ZyphrWebhooksController < ApplicationController
+  skip_before_action :verify_authenticity_token
+
+  def create
+    payload = request.raw_post
+    secret = ENV.fetch('ZYPHR_WEBHOOK_SECRET')
+    unless ZyphrWebhook.verify(payload: payload, headers: request.headers, secret: secret)
+      head :unauthorized and return
+    end
+    event = JSON.parse(payload)
+    Rails.logger.info("zyphr event #{event['type']}")
+    head :no_content
+  end
+end
+`,
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV5,
+        nextSteps: [
+          ...NEXT_STEPS5,
+          "Add route: post '/webhooks/zyphr', to: 'zyphr_webhooks#create'"
+        ],
+        docsUrl: DOCS5
+      }
+    }
+  },
+  go: {
+    sdk: {
+      channel: "webhook",
+      language: "go",
+      framework: null,
+      variant: "webhook-handler",
+      files: [
+        {
+          path: "internal/zyphr/verify.go",
+          purpose: "Standard Webhooks signature verification helper (verbatim from docs).",
+          contents: 'package zyphr\n\nimport (\n	"crypto/hmac"\n	"crypto/sha256"\n	"encoding/base64"\n	"encoding/hex"\n	"math"\n	"strconv"\n	"strings"\n	"time"\n)\n\nfunc VerifyWebhook(payload, msgID, timestamp, signature, secret string) bool {\n	ts, err := strconv.ParseInt(timestamp, 10, 64)\n	if err != nil { return false }\n	if math.Abs(float64(time.Now().Unix()-ts)) > 300 { return false }\n\n	signed := msgID + "." + timestamp + "." + payload\n	secretHex := strings.TrimPrefix(secret, "whsec_")\n	secretBytes, err := hex.DecodeString(secretHex)\n	if err != nil { return false }\n	mac := hmac.New(sha256.New, secretBytes)\n	mac.Write([]byte(signed))\n	expected := base64.StdEncoding.EncodeToString(mac.Sum(nil))\n\n	for _, sig := range strings.Split(signature, " ") {\n		v := strings.TrimPrefix(sig, "v1,")\n		if hmac.Equal([]byte(v), []byte(expected)) { return true }\n	}\n	return false\n}\n',
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV5,
+      nextSteps: NEXT_STEPS5,
+      docsUrl: DOCS5
+    }
+  },
+  php: {
+    sdk: {
+      channel: "webhook",
+      language: "php",
+      framework: null,
+      variant: "webhook-handler",
+      files: [
+        {
+          path: "app/Webhooks/ZyphrWebhook.php",
+          purpose: "Standard Webhooks signature verification helper (verbatim from docs)",
+          contents: `<?php
+
+namespace App\\Webhooks;
+
+class ZyphrWebhook
+{
+    public static function verify(string $payload, array $headers, string $secret): bool
+    {
+        $msgId = $headers['webhook-id'] ?? '';
+        $timestamp = $headers['webhook-timestamp'] ?? '';
+        $signature = $headers['webhook-signature'] ?? '';
+        if (abs(time() - intval($timestamp)) > 300) {
+            return false;
+        }
+        $signed = "{$msgId}.{$timestamp}.{$payload}";
+        $hex = str_starts_with($secret, 'whsec_') ? substr($secret, 6) : $secret;
+        $expected = base64_encode(hash_hmac('sha256', $signed, hex2bin($hex), true));
+        foreach (explode(' ', $signature) as $sig) {
+            if (hash_equals(substr($sig, 3), $expected)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+`,
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV5,
+      nextSteps: NEXT_STEPS5,
+      docsUrl: DOCS5
+    },
+    frameworks: {
+      laravel: {
+        channel: "webhook",
+        language: "php",
+        framework: "laravel",
+        variant: "webhook-handler",
+        files: [
+          {
+            path: "app/Webhooks/ZyphrWebhook.php",
+            purpose: "Standard Webhooks signature verification helper",
+            contents: `<?php
+
+namespace App\\Webhooks;
+
+class ZyphrWebhook
+{
+    public static function verify(string $payload, array $headers, string $secret): bool
+    {
+        $msgId = $headers['webhook-id'][0] ?? '';
+        $timestamp = $headers['webhook-timestamp'][0] ?? '';
+        $signature = $headers['webhook-signature'][0] ?? '';
+        if (abs(time() - intval($timestamp)) > 300) {
+            return false;
+        }
+        $signed = "{$msgId}.{$timestamp}.{$payload}";
+        $hex = str_starts_with($secret, 'whsec_') ? substr($secret, 6) : $secret;
+        $expected = base64_encode(hash_hmac('sha256', $signed, hex2bin($hex), true));
+        foreach (explode(' ', $signature) as $sig) {
+            if (hash_equals(substr($sig, 3), $expected)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+`,
+            overwrite: false
+          },
+          {
+            path: "app/Http/Controllers/ZyphrWebhookController.php",
+            purpose: "Laravel controller that verifies the webhook signature before processing",
+            contents: "<?php\n\nnamespace App\\Http\\Controllers;\n\nuse App\\Webhooks\\ZyphrWebhook;\nuse Illuminate\\Http\\Request;\n\nclass ZyphrWebhookController extends Controller\n{\n    public function handle(Request $request)\n    {\n        $payload = $request->getContent();\n        $secret = config('services.zyphr.webhook_secret');\n        if (! ZyphrWebhook::verify($payload, $request->headers->all(), $secret)) {\n            return response('invalid signature', 401);\n        }\n        $event = json_decode($payload, true);\n        \\Log::info('zyphr event ' . ($event['type'] ?? 'unknown'));\n        return response()->noContent();\n    }\n}\n",
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV5,
+        nextSteps: [
+          ...NEXT_STEPS5,
+          "Register route in routes/api.php: Route::post('/webhooks/zyphr', [ZyphrWebhookController::class, 'handle']);",
+          "Exclude this route from CSRF (VerifyCsrfToken::$except)."
+        ],
+        docsUrl: DOCS5
+      }
+    }
+  },
+  csharp: {
+    sdk: {
+      channel: "webhook",
+      language: "csharp",
+      framework: null,
+      variant: "webhook-handler",
+      files: [
+        {
+          path: "Webhooks/ZyphrWebhookVerifier.cs",
+          purpose: "Standard Webhooks signature verification helper",
+          contents: `using System.Security.Cryptography;
+using System.Text;
+
+namespace YourApp.Webhooks;
+
+public static class ZyphrWebhookVerifier
+{
+    public static bool Verify(string payload, IDictionary<string,string> headers, string secret)
+    {
+        var msgId = headers.TryGetValue("webhook-id", out var id) ? id : "";
+        var timestamp = headers.TryGetValue("webhook-timestamp", out var ts) ? long.Parse(ts) : 0;
+        var signatures = headers.TryGetValue("webhook-signature", out var sig) ? sig : "";
+
+        var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        if (Math.Abs(now - timestamp) > 300) return false;
+
+        var signed = $"{msgId}.{timestamp}.{payload}";
+        var hex = secret.StartsWith("whsec_") ? secret[6..] : secret;
+        var secretBytes = Convert.FromHexString(hex);
+        using var hmac = new HMACSHA256(secretBytes);
+        var expected = Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(signed)));
+
+        foreach (var s in signatures.Split(' '))
+        {
+            var v = s.Length > 3 ? s[3..] : "";
+            if (CryptographicOperations.FixedTimeEquals(Encoding.UTF8.GetBytes(v), Encoding.UTF8.GetBytes(expected)))
+                return true;
+        }
+        return false;
+    }
+}
+`,
+          overwrite: false
+        }
+      ],
+      envVarsNeeded: ENV5,
+      nextSteps: NEXT_STEPS5,
+      docsUrl: DOCS5
+    },
+    frameworks: {
+      aspnetcore: {
+        channel: "webhook",
+        language: "csharp",
+        framework: "aspnetcore",
+        variant: "webhook-handler",
+        files: [
+          {
+            path: "Webhooks/ZyphrWebhookVerifier.cs",
+            purpose: "Standard Webhooks signature verification helper",
+            contents: `using System.Security.Cryptography;
+using System.Text;
+
+namespace YourApp.Webhooks;
+
+public static class ZyphrWebhookVerifier
+{
+    public static bool Verify(string payload, IHeaderDictionary headers, string secret)
+    {
+        string msgId = headers["webhook-id"].ToString();
+        long timestamp = long.TryParse(headers["webhook-timestamp"], out var t) ? t : 0;
+        string signatures = headers["webhook-signature"].ToString();
+        if (Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - timestamp) > 300) return false;
+        var signed = $"{msgId}.{timestamp}.{payload}";
+        var hex = secret.StartsWith("whsec_") ? secret[6..] : secret;
+        using var hmac = new HMACSHA256(Convert.FromHexString(hex));
+        var expected = Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(signed)));
+        foreach (var s in signatures.Split(' '))
+        {
+            var v = s.Length > 3 ? s[3..] : "";
+            if (CryptographicOperations.FixedTimeEquals(Encoding.UTF8.GetBytes(v), Encoding.UTF8.GetBytes(expected)))
+                return true;
+        }
+        return false;
+    }
+}
+`,
+            overwrite: false
+          },
+          {
+            path: "Controllers/ZyphrWebhookController.cs",
+            purpose: "ASP.NET Core controller that verifies the webhook signature before processing",
+            contents: 'using Microsoft.AspNetCore.Mvc;\nusing YourApp.Webhooks;\n\n[ApiController]\n[Route("webhooks/zyphr")]\npublic class ZyphrWebhookController : ControllerBase\n{\n    [HttpPost]\n    public async Task<IActionResult> Handle()\n    {\n        using var reader = new StreamReader(Request.Body);\n        var payload = await reader.ReadToEndAsync();\n        var secret = Environment.GetEnvironmentVariable("ZYPHR_WEBHOOK_SECRET")!;\n        if (!ZyphrWebhookVerifier.Verify(payload, Request.Headers, secret))\n            return Unauthorized("invalid signature");\n        Console.WriteLine($"zyphr event {payload[..Math.Min(80, payload.Length)]}");\n        return NoContent();\n    }\n}\n',
+            overwrite: false
+          }
+        ],
+        envVarsNeeded: ENV5,
+        nextSteps: NEXT_STEPS5,
+        docsUrl: DOCS5
+      }
+    }
+  }
+};
+
+// src/integration/quickstart/index.ts
+var REGISTRY = {
+  email: emailChannel,
+  push: pushChannel,
+  sms: smsChannel,
+  inbox: inboxChannel,
+  webhook: webhookChannel
+};
+function resolveQuickstart(args) {
+  const langMap = REGISTRY[args.channel]?.[args.language];
+  if (!langMap) return null;
+  if (args.framework) {
+    const key = args.framework.trim().toLowerCase();
+    const fw = langMap.frameworks?.[key];
+    if (fw) return { result: fw, frameworkRecognized: true };
+    return { result: langMap.sdk, frameworkRecognized: false };
+  }
+  return { result: langMap.sdk, frameworkRecognized: true };
+}
+
+// src/integration/sdk-snippets.ts
+var DOCS6 = "https://docs.zyphr.dev/sdks";
+var SDK_INSTALL_TABLE = {
+  node: {
+    language: "node",
+    kind: "sdk",
+    packageName: "@zyphr-dev/node-sdk",
+    registry: "npm",
+    registryUrl: "https://www.npmjs.com/package/@zyphr-dev/node-sdk",
+    installCommands: [
+      { manager: "npm", command: "npm install @zyphr-dev/node-sdk" },
+      { manager: "yarn", command: "yarn add @zyphr-dev/node-sdk" },
+      { manager: "pnpm", command: "pnpm add @zyphr-dev/node-sdk" }
+    ],
+    initSnippet: {
+      imports: "import { Zyphr } from '@zyphr-dev/node-sdk';",
+      init: "export const zyphr = new Zyphr({ apiKey: process.env.ZYPHR_API_KEY! });",
+      fileExample: "src/lib/zyphr.ts"
+    },
+    envVarsNeeded: ["ZYPHR_API_KEY"],
+    docsUrl: `${DOCS6}/node`
+  },
+  csharp: {
+    language: "csharp",
+    kind: "sdk",
+    packageName: "ZyphrDev.SDK",
+    registry: "NuGet",
+    registryUrl: "https://www.nuget.org/packages/ZyphrDev.SDK",
+    installCommands: [
+      { manager: "dotnet", command: "dotnet add package ZyphrDev.SDK" },
+      { manager: "nuget", command: "Install-Package ZyphrDev.SDK" }
+    ],
+    initSnippet: {
+      imports: [
+        "using ZyphrDev.SDK.Api;",
+        "using ZyphrDev.SDK.Client;",
+        "using ZyphrDev.SDK.Model;"
+      ].join("\n"),
+      init: [
+        "var config = new Configuration",
+        "{",
+        "    ApiKey = new Dictionary<string, string>",
+        "    {",
+        '        { "X-API-Key", Environment.GetEnvironmentVariable("ZYPHR_API_KEY")! }',
+        "    }",
+        "};",
+        "var emails = new EmailsApi(config);"
+      ].join("\n"),
+      fileExample: "Services/ZyphrClient.cs"
+    },
+    envVarsNeeded: ["ZYPHR_API_KEY"],
+    docsUrl: `${DOCS6}/csharp`
+  },
+  ruby: {
+    language: "ruby",
+    kind: "sdk",
+    packageName: "zyphr",
+    registry: "RubyGems",
+    registryUrl: "https://rubygems.org/gems/zyphr",
+    installCommands: [
+      { manager: "gem", command: "gem install zyphr" },
+      { manager: "bundler", command: "bundle add zyphr" }
+    ],
+    initSnippet: {
+      imports: "require 'zyphr'",
+      init: [
+        "Zyphr.configure do |config|",
+        "  config.api_key['X-API-Key'] = ENV.fetch('ZYPHR_API_KEY')",
+        "end"
+      ].join("\n"),
+      fileExample: "config/initializers/zyphr.rb"
+    },
+    envVarsNeeded: ["ZYPHR_API_KEY"],
+    docsUrl: `${DOCS6}/ruby`
+  },
+  python: {
+    language: "python",
+    kind: "rest-client",
+    packageName: "requests",
+    registry: "PyPI",
+    registryUrl: "https://pypi.org/project/requests/",
+    installCommands: [
+      { manager: "pip", command: "pip install requests" },
+      { manager: "poetry", command: "poetry add requests" },
+      { manager: "uv", command: "uv add requests" }
+    ],
+    initSnippet: {
+      imports: "import os\nimport requests",
+      init: [
+        'ZYPHR_API_KEY = os.environ["ZYPHR_API_KEY"]',
+        'BASE_URL = "https://api.zyphr.dev/v1"',
+        "",
+        "headers = {",
+        '    "X-API-Key": ZYPHR_API_KEY,',
+        '    "Content-Type": "application/json",',
+        "}",
+        "",
+        "def zyphr_request(method, path, json=None, params=None):",
+        "    response = requests.request(",
+        '        method, f"{BASE_URL}{path}", headers=headers, json=json, params=params,',
+        "    )",
+        "    response.raise_for_status()",
+        "    return response.json()"
+      ].join("\n"),
+      fileExample: "app/zyphr_client.py"
+    },
+    envVarsNeeded: ["ZYPHR_API_KEY"],
+    docsUrl: `${DOCS6}/python`,
+    notes: "There is no official Zyphr Python SDK yet \u2014 the canonical integration is a thin REST wrapper around the requests library."
+  },
+  go: {
+    language: "go",
+    kind: "rest-client",
+    packageName: "net/http (stdlib)",
+    registry: "stdlib",
+    registryUrl: "https://pkg.go.dev/net/http",
+    installCommands: [
+      { manager: "go", command: "# No install needed \u2014 net/http ships with Go." }
+    ],
+    initSnippet: {
+      imports: [
+        "package zyphr",
+        "",
+        "import (",
+        '	"bytes"',
+        '	"encoding/json"',
+        '	"fmt"',
+        '	"io"',
+        '	"net/http"',
+        '	"os"',
+        ")"
+      ].join("\n"),
+      init: [
+        'const baseURL = "https://api.zyphr.dev/v1"',
+        "",
+        "type Client struct {",
+        "	APIKey     string",
+        "	HTTPClient *http.Client",
+        "}",
+        "",
+        "func NewClient() *Client {",
+        '	return &Client{APIKey: os.Getenv("ZYPHR_API_KEY"), HTTPClient: &http.Client{}}',
+        "}",
+        "",
+        "func (c *Client) Do(method, path string, body any) ([]byte, error) {",
+        "	var buf io.Reader",
+        "	if body != nil {",
+        "		b, err := json.Marshal(body)",
+        '		if err != nil { return nil, fmt.Errorf("marshal: %w", err) }',
+        "		buf = bytes.NewReader(b)",
+        "	}",
+        "	req, err := http.NewRequest(method, baseURL+path, buf)",
+        "	if err != nil { return nil, err }",
+        '	req.Header.Set("X-API-Key", c.APIKey)',
+        '	req.Header.Set("Content-Type", "application/json")',
+        "	resp, err := c.HTTPClient.Do(req)",
+        "	if err != nil { return nil, err }",
+        "	defer resp.Body.Close()",
+        "	data, _ := io.ReadAll(resp.Body)",
+        '	if resp.StatusCode >= 400 { return nil, fmt.Errorf("zyphr %d: %s", resp.StatusCode, data) }',
+        "	return data, nil",
+        "}"
+      ].join("\n"),
+      fileExample: "internal/zyphr/client.go"
+    },
+    envVarsNeeded: ["ZYPHR_API_KEY"],
+    docsUrl: `${DOCS6}/go`,
+    notes: "There is no official Zyphr Go SDK yet \u2014 the canonical integration is a thin REST wrapper around net/http."
+  },
+  php: {
+    language: "php",
+    kind: "rest-client",
+    packageName: "guzzlehttp/guzzle",
+    registry: "Packagist",
+    registryUrl: "https://packagist.org/packages/guzzlehttp/guzzle",
+    installCommands: [
+      { manager: "composer", command: "composer require guzzlehttp/guzzle" }
+    ],
+    initSnippet: {
+      imports: [
+        "<?php",
+        "",
+        "use GuzzleHttp\\Client;"
+      ].join("\n"),
+      init: [
+        "$client = new Client([",
+        "    'base_uri' => 'https://api.zyphr.dev/v1/',",
+        "    'headers' => [",
+        "        'X-API-Key' => getenv('ZYPHR_API_KEY'),",
+        "        'Content-Type' => 'application/json',",
+        "    ],",
+        "]);"
+      ].join("\n"),
+      fileExample: "app/Services/ZyphrClient.php"
+    },
+    envVarsNeeded: ["ZYPHR_API_KEY"],
+    docsUrl: `${DOCS6}/php`,
+    notes: "There is no official Zyphr PHP SDK yet \u2014 the canonical integration uses Guzzle (or raw cURL)."
+  }
+};
+function resolveInstallEntry(language, packageManager) {
+  const entry = SDK_INSTALL_TABLE[language];
+  if (!packageManager) return entry;
+  const normalized = packageManager.trim().toLowerCase();
+  const match = entry.installCommands.find((c) => c.manager.toLowerCase() === normalized);
+  if (!match) return entry;
+  return { ...entry, installCommands: [match] };
+}
+
+// src/tools/integration.ts
+function registerIntegrationTools(server, guards) {
+  if (isToolEnabled({ name: "get_sdk_install_for_language", mutates: false }, guards)) {
+    server.registerTool(
+      "get_sdk_install_for_language",
+      {
+        title: "Get SDK install instructions for a language",
+        description: "Returns install commands, init snippet, env vars, and docs URL for the chosen language. Use this when wiring Zyphr into a new project so the AI can drop the correct package + client init code.",
+        inputSchema: getSdkInstallShape
+      },
+      async (args) => {
+        const entry = resolveInstallEntry(args.language, args.packageManager);
+        return toolResult(entry);
+      }
+    );
+  }
+  if (isToolEnabled({ name: "get_quickstart_for_channel", mutates: false }, guards)) {
+    server.registerTool(
+      "get_quickstart_for_channel",
+      {
+        title: "Get quickstart code for a channel + language",
+        description: "Returns drop-in service file(s) for the chosen Zyphr channel (email/push/sms/inbox/webhook), language, and optional framework (express, nextjs, flask, fastapi, rails, laravel, aspnetcore). Webhook handlers ALWAYS verify HMAC signatures. Unknown frameworks fall back to plain SDK code.",
+        inputSchema: getQuickstartShape
+      },
+      async (args) => {
+        const resolved = resolveQuickstart({
+          channel: args.channel,
+          language: args.language,
+          framework: args.framework
+        });
+        if (!resolved) {
+          return toolResult({
+            error: `No quickstart available for channel=${args.channel} language=${args.language}`
+          });
+        }
+        const { result, frameworkRecognized } = resolved;
+        return toolResult({
+          ...result,
+          frameworkRecognized,
+          requestedFramework: args.framework ?? null
+        });
+      }
+    );
+  }
+}
+
+// src/tools/webhooks.ts
+function registerWebhookTools(server, guards) {
+  if (isToolEnabled({ name: "list_webhooks", mutates: false }, guards)) {
+    server.registerTool(
+      "list_webhooks",
+      {
+        title: "List webhooks",
+        description: "List webhook endpoints configured for the account.",
+        inputSchema: listWebhooksShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.webhooks.listWebhooks(args.limit, args.offset);
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "create_webhook", mutates: true }, guards)) {
+    server.registerTool(
+      "create_webhook",
+      {
+        title: "Create webhook",
+        description: 'Register a new webhook endpoint. Subscribe to event types like "email.*", "subscriber.created", or "*".',
+        inputSchema: createWebhookShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.webhooks.createWebhook({
+            url: args.url,
+            events: args.events,
+            description: args.description,
+            secret: args.secret,
+            metadata: args.metadata,
+            headers: args.headers,
+            version: args.version,
+            rateLimit: args.rateLimit
+          });
+        });
+      }
+    );
+  }
+  if (isToolEnabled({ name: "get_webhook_deliveries", mutates: false }, guards)) {
+    server.registerTool(
+      "get_webhook_deliveries",
+      {
+        title: "List webhook deliveries",
+        description: "Inspect delivery history for a webhook endpoint. Filter by status (pending/delivering/delivered/failed/exhausted), event type, or date range. Useful for debugging why a webhook is not firing.",
+        inputSchema: getWebhookDeliveriesShape
+      },
+      async (args) => {
+        return runTool(async () => {
+          const zyphr = getZyphrClient();
+          return await zyphr.webhooks.listWebhookDeliveries(
+            args.webhookId,
+            args.status,
+            args.eventType,
+            args.search,
+            args.startDate ? new Date(args.startDate) : void 0,
+            args.endDate ? new Date(args.endDate) : void 0,
+            args.limit,
+            args.offset
+          );
+        });
+      }
+    );
+  }
+}
+
+// src/server.ts
+var SERVER_NAME = "zyphr";
+var SERVER_VERSION = "0.1.0";
+function createServer() {
+  const server = new McpServer(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: { tools: {} } }
+  );
+  const guards = loadToolGuards();
+  registerSendTools(server, guards);
+  registerTemplateTools(server, guards);
+  registerSubscriberTools(server, guards);
+  registerWebhookTools(server, guards);
+  registerIntegrationTools(server, guards);
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  if (!process.env.ZYPHR_API_KEY) {
+    process.stderr.write(
+      "[zyphr-mcp] ZYPHR_API_KEY is not set. Provide a zy_live_* or zy_test_* key via the `env` block of your MCP client config.\n"
+    );
+    process.exit(1);
+  }
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write(`[zyphr-mcp] connected (base=${getBaseUrl()})
+`);
+}
+main().catch((err) => {
+  process.stderr.write(`[zyphr-mcp] fatal: ${err instanceof Error ? err.stack ?? err.message : String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map