cloudflare-email 0.1.0 → 0.3.0

data/templates/worker/test/relay.test.ts

@@ -0,0 +1,226 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { archiveEmail, relayEmail, signedEmailHeaders } from "../src/index.js";
+
+const raw = new Uint8Array([0, 255, 13, 10, 128]);
+function message(bytes = raw, rawSize = bytes.length) {
+  return { from: "sender@example.com", to: "inbox@tenant.example.com", rawSize,
+    raw: new ReadableStream({ start(c) { c.enqueue(bytes); c.close(); } }) };
+}
+function options(overrides = {}) {
+  return { resolveBackend: async () => ({ url: "https://rails.example.com/ingest", secret: "test-secret" }),
+    headers: async ({ raw, from, to, backend }) => signedEmailHeaders({ raw, from, to, secret: backend.secret }),
+    ...overrides };
+}
+afterEach(() => { vi.unstubAllGlobals(); vi.useRealTimers(); });
+
+describe("host-controlled relay", () => {
+  it("archives once before acceptance and backend lookup, signs and sends exact binary bytes", async () => {
+    const order: string[] = [];
+    const put = vi.fn(async (key, body, metadata) => {
+      order.push("archive");
+      expect(key).toBe("mail/one.eml");
+      expect(body).toEqual(raw);
+      expect(metadata).toEqual({ httpMetadata: { contentType: "message/rfc822" },
+        customMetadata: { from: "sender@example.com", to: "inbox@tenant.example.com", size: "5" } });
+    });
+    const fetch = vi.fn(async (_url, init) => {
+      order.push("fetch");
+      expect(init.body).toEqual(raw);
+      expect(init.headers.get("X-CF-Email-Signature-Version")).toBe("2");
+      expect(init.redirect).toBe("manual");
+      expect(init.signal).toBeInstanceOf(AbortSignal);
+      return new Response(null, { status: 202 });
+    });
+    vi.stubGlobal("fetch", fetch);
+    const result = await relayEmail(message(), options({
+      archive: (args) => archiveEmail({ ...args, bucket: { put }, key: "mail/one.eml" }),
+      accepts: async () => { order.push("accepts"); return true; },
+      resolveBackend: async () => { order.push("backend"); return { url: "https://rails.example.com/ingest", secret: "test-secret" }; },
+      headers: async (args) => {
+        expect(args.archive).toEqual({ key: "mail/one.eml" });
+        order.push("headers");
+        return signedEmailHeaders({ ...args, secret: args.backend.secret });
+      },
+    }));
+    expect(order).toEqual(["archive", "accepts", "backend", "headers", "fetch"]);
+    expect(result).toEqual({ status: "delivered", reason: "delivered", httpStatus: 202, archiveFailed: false });
+    expect(fetch).toHaveBeenCalledOnce();
+    expect(put).toHaveBeenCalledOnce();
+  });
+
+  it("continues after archive failure without exposing exception content", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => new Response(null, { status: 204 })));
+    const result = await relayEmail(message(), options({ archive: async () => { throw new Error("PRIVATE EMAIL SECRET"); } }));
+    expect(result).toEqual({ status: "delivered", reason: "delivered", httpStatus: 204, archiveFailed: true });
+  });
+
+  it("archives rejected recipients without resolving a backend", async () => {
+    const archive = vi.fn(async () => ({ key: "retained.eml" }));
+    const resolveBackend = vi.fn();
+    expect(await relayEmail(message(), options({ archive, accepts: async () => false, resolveBackend })))
+      .toEqual({ status: "rejected", reason: "not_accepted", archiveFailed: false });
+    expect(archive).toHaveBeenCalledOnce();
+    expect(resolveBackend).not.toHaveBeenCalled();
+  });
+
+  it("continues when the archive deadline expires, allowing a late archive completion", async () => {
+    vi.useFakeTimers();
+    let finish;
+    const archive = vi.fn(() => new Promise(resolve => { finish = resolve; }));
+    const fetch = vi.fn(async () => new Response(null, { status: 200 }));
+    vi.stubGlobal("fetch", fetch);
+    const pending = relayEmail(message(), options({ archive, archiveTimeoutMs: 20,
+      headers: async ({ archive }) => { expect(archive).toBeUndefined(); return {}; },
+    }));
+    await vi.advanceTimersByTimeAsync(19);
+    expect(fetch).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1);
+    expect(await pending).toEqual({ status: "delivered", reason: "delivered", httpStatus: 200, archiveFailed: true });
+    finish({ key: "late.eml" });
+    await Promise.resolve();
+    expect(fetch).toHaveBeenCalledOnce();
+    expect(archive).toHaveBeenCalledOnce();
+  });
+
+  it("uses the validated URL even when the headers callback changes the backend", async () => {
+    const fetch = vi.fn(async () => new Response(null, { status: 200 }));
+    vi.stubGlobal("fetch", fetch);
+    await relayEmail(message(), options({ headers: async ({ backend }) => {
+      backend.url = "http://untrusted.example.com/secret";
+      return { Authorization: "Basic private" };
+    } }));
+    expect(fetch.mock.calls[0][0]).toBe("https://rails.example.com/ingest");
+  });
+
+  it("bounds actual streaming bytes even when rawSize is false", async () => {
+    const cancel = vi.fn();
+    const stream = new ReadableStream({ start(c) { c.enqueue(raw); }, cancel });
+    const archive = vi.fn();
+    expect(await relayEmail({ ...message(), raw: stream, rawSize: 1 }, options({ maxEmailBytes: 4, archive })))
+      .toEqual({ status: "rejected", reason: "too_large", archiveFailed: false });
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(archive).not.toHaveBeenCalled();
+  });
+
+  it("rejects declared oversize or invalid envelopes without reading", async () => {
+    const getReader = vi.fn();
+    expect((await relayEmail({ ...message(), raw: { getReader }, rawSize: 100 }, options({ maxEmailBytes: 50 }))).reason).toBe("too_large");
+    expect((await relayEmail({ ...message(), raw: { getReader }, to: "bad\r\naddress" }, options())).reason).toBe("invalid_envelope");
+    expect(getReader).not.toHaveBeenCalled();
+  });
+
+  it("reports read failures and invalid chunks without forwarding", async () => {
+    const fetch = vi.fn(); vi.stubGlobal("fetch", fetch);
+    for (const stream of [new ReadableStream({ start(c) { c.error(new Error("secret")); } }),
+      new ReadableStream({ start(c) { c.enqueue("bad chunk"); c.close(); } })]) {
+      expect(await relayEmail({ ...message(), raw: stream }, options()))
+        .toEqual({ status: "failed", reason: "unreadable", archiveFailed: false });
+    }
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it.each(["http://rails.example.com", "https://user:secret@example.com", "https://example.com/#secret", "ftp://example.com", "invalid"])
+    ("rejects unsafe backend %s", async (url) => {
+      const fetch = vi.fn(); vi.stubGlobal("fetch", fetch);
+      expect((await relayEmail(message(), options({ resolveBackend: async () => ({ url }) }))).reason).toBe("invalid_backend");
+      expect(fetch).not.toHaveBeenCalled();
+    });
+
+  it("supports a host-selected loopback backend and Basic headers", async () => {
+    const fetch = vi.fn(async (url, init) => {
+      expect(url).toBe("http://127.0.0.1:3000/ingest");
+      expect(init.headers.get("Authorization")).toBe("Basic dGVzdDp0ZXN0");
+      expect(init.body).toEqual(raw);
+      return new Response(null, { status: 200 });
+    });
+    vi.stubGlobal("fetch", fetch);
+    const result = await relayEmail(message(), options({
+      resolveBackend: async ({ to }) => ({ url: to.includes("tenant") ? "http://127.0.0.1:3000/ingest" : "https://other.example.com" }),
+      headers: async () => ({ Authorization: "Basic dGVzdDp0ZXN0", "Content-Type": "message/rfc822" }),
+    }));
+    expect(result.status).toBe("delivered");
+  });
+
+  it("leaves Unicode and legacy address shapes to host acceptance with custom headers", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => new Response(null, { status: 200 })));
+    const from = "séndér@example.com";
+    const to = '"quoted local"@TENANT.example.com';
+    const accepts = vi.fn(async (envelope) => {
+      expect(envelope).toEqual({ from, to });
+      return true;
+    });
+    expect((await relayEmail({ ...message(), from, to }, options({ accepts,
+      headers: async () => ({ Authorization: "Basic dGVzdDp0ZXN0" }),
+    }))).status).toBe("delivered");
+    expect(accepts).toHaveBeenCalledOnce();
+  });
+
+  it.each([301, 400, 401, 413, 422, 429, 500, 503])("returns HTTP %i without reading response content or retrying", async (status) => {
+    const cancel = vi.fn();
+    const response = new Response(new ReadableStream({ cancel }), { status });
+    const text = vi.spyOn(response, "text");
+    const fetch = vi.fn(async () => response); vi.stubGlobal("fetch", fetch);
+    expect(await relayEmail(message(), options())).toEqual({ status: "failed", reason: "http_status", httpStatus: status, archiveFailed: false });
+    expect(text).not.toHaveBeenCalled();
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(fetch).toHaveBeenCalledOnce();
+  });
+
+  it("does not wait for an unresponsive response cancellation", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => new Response(new ReadableStream({ cancel: () => new Promise(() => {}) }), { status: 200 })));
+    expect((await relayEmail(message(), options())).status).toBe("delivered");
+  });
+
+  it("aborts fetch on the configured timeout and returns no exception text", async () => {
+    vi.useFakeTimers();
+    vi.stubGlobal("fetch", vi.fn(async (_url, { signal }) => new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => reject(new Error("private backend")));
+    })));
+    const pending = relayEmail(message(), options({ timeoutMs: 25, headers: async () => ({}) }));
+    await vi.advanceTimersByTimeAsync(25);
+    expect(await pending).toEqual({ status: "failed", reason: "timeout", archiveFailed: false });
+  });
+
+  it.each([
+    [{ accepts: async () => { throw new Error("secret"); } }, "acceptance_failed"],
+    [{ resolveBackend: async () => { throw new Error("secret"); } }, "backend_failed"],
+    [{ resolveBackend: async () => null }, "invalid_backend"],
+    [{ headers: async () => { throw new Error("secret"); } }, "headers_failed"],
+    [{ headers: async () => ({ "Bad\nHeader": "secret" }) }, "headers_failed"],
+    [{ maxEmailBytes: 0 }, "invalid_options"],
+    [{ timeoutMs: Infinity }, "invalid_options"],
+    [{ timeoutMs: 2 ** 31 }, "invalid_options"],
+    [{ archive: true }, "invalid_options"],
+    [{ archiveTimeoutMs: 0 }, "invalid_options"],
+    [{ archiveTimeoutMs: 2 ** 31 }, "invalid_options"],
+  ])("returns safe callback/configuration failure %#", async (overrides, reason) => {
+    expect(await relayEmail(message(), options(overrides))).toEqual({ status: "failed", reason, archiveFailed: false });
+  });
+
+  it("returns fetch failures without backend secrets", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => { throw new Error("secret-url"); }));
+    expect(await relayEmail(message(), options())).toEqual({ status: "failed", reason: "fetch_failed", archiveFailed: false });
+  });
+});
+
+describe("R2 archive helper", () => {
+  it("validates archive arguments before invoking the bucket", async () => {
+    const put = vi.fn();
+    const args = { bucket: { put }, key: "mail/id.eml", raw, from: "", to: "inbox@example.com" };
+    for (const overrides of [{ key: "" }, { key: "x".repeat(1025) }, { key: "\u0000" }, { raw: "bad" },
+      { from: "sender\r\n@example.com" }, { to: "" }]) {
+      await expect(archiveEmail({ ...args, ...overrides })).rejects.toThrow("invalid email archive arguments");
+    }
+    expect(put).not.toHaveBeenCalled();
+    await expect(archiveEmail(args)).resolves.toEqual({ key: "mail/id.eml" });
+    expect(put.mock.calls[0][2].customMetadata.from).toBe("");
+  });
+
+  it("stores ASCII-safe envelope metadata while preserving raw Unicode mail bytes", async () => {
+    const put = vi.fn();
+    await archiveEmail({ bucket: { put }, key: "mail/unicode.eml", raw,
+      from: "séndér@example.com", to: "inbox@tenant.example.com" });
+    expect(put.mock.calls[0][1]).toEqual(raw);
+    expect(put.mock.calls[0][2].customMetadata.from).toBe("s?nd?r@example.com");
+  });
+});

data/templates/worker/wrangler.toml

@@ -1,10 +1,69 @@
-name = "cloudflare-email-ingress"
+name = "cloudflare-email-ingress-unconfigured"
 main = "src/index.js"
-compatibility_date = "2026-04-01"
+compatibility_date = "2026-09-10"
 
-# Required secrets (set via `wrangler secret put`):
+[env.development]
+name = "cloudflare-email-ingress-development"
+
+[env.staging]
+name = "cloudflare-email-ingress-staging"
+
+[env.production]
+name = "cloudflare-email-ingress-production"
+
+# Required secrets (set via `npx wrangler secret put NAME --env production`):
 #   RAILS_INGRESS_URL  - https://your-rails-app.example.com/rails/action_mailbox/cloudflare/inbound_emails
 #   INGRESS_SECRET     - shared secret matching cloudflare.ingress_secret in Rails credentials
 
 # After deploying, in the Cloudflare dashboard:
-#   Email Routing -> Routes -> "Send to a Worker" -> select cloudflare-email-ingress
+#   Email Routing -> Routes -> "Send to a Worker" -> select the matching environment Worker
+
+# Durable delivery is the default. Create these private resources before deploy.
+# See docs/durable-inbound.md. Buckets must not expire pending objects.
+# Explicit emergency fallback: set INBOUND_DELIVERY_MODE = "direct" in the
+# chosen environment's [env.<name>.vars]. Keep recovery bindings and cron.
+
+[[env.development.r2_buckets]]
+binding = "INBOUND_EMAIL_STORE"
+bucket_name = "cloudflare-email-inbound-development"
+[[env.development.queues.producers]]
+binding = "INBOUND_EMAIL_QUEUE"
+queue = "cloudflare-email-inbound-development"
+[[env.development.queues.consumers]]
+queue = "cloudflare-email-inbound-development"
+max_batch_size = 5
+max_batch_timeout = 5
+max_retries = 10
+retry_delay = 300
+[env.development.triggers]
+crons = ["* * * * *"]
+
+[[env.staging.r2_buckets]]
+binding = "INBOUND_EMAIL_STORE"
+bucket_name = "cloudflare-email-inbound-staging"
+[[env.staging.queues.producers]]
+binding = "INBOUND_EMAIL_QUEUE"
+queue = "cloudflare-email-inbound-staging"
+[[env.staging.queues.consumers]]
+queue = "cloudflare-email-inbound-staging"
+max_batch_size = 5
+max_batch_timeout = 5
+max_retries = 10
+retry_delay = 300
+[env.staging.triggers]
+crons = ["* * * * *"]
+
+[[env.production.r2_buckets]]
+binding = "INBOUND_EMAIL_STORE"
+bucket_name = "cloudflare-email-inbound-production"
+[[env.production.queues.producers]]
+binding = "INBOUND_EMAIL_QUEUE"
+queue = "cloudflare-email-inbound-production"
+[[env.production.queues.consumers]]
+queue = "cloudflare-email-inbound-production"
+max_batch_size = 5
+max_batch_timeout = 5
+max_retries = 10
+retry_delay = 300
+[env.production.triggers]
+crons = ["* * * * *"]

metadata

@@ -1,14 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: cloudflare-email
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Cole
 bindir: bin
 cert_chain: []
-date: 2026-04-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -57,7 +77,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: 7.2.3.2
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -67,7 +87,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: 7.2.3.2
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -85,6 +105,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: A Ruby client and Rails integration for Cloudflare's Email Service. Send
   mail via an ActionMailer delivery method, receive mail via an ActionMailbox ingress
   backed by a shipped Cloudflare Email Worker template.
@@ -97,35 +137,142 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- SECURITY.md
 - app/controllers/cloudflare/email/ingress_controller.rb
+- app/controllers/cloudflare/email/management/mailboxes_controller.rb
+- app/controllers/cloudflare/email/management/styles_controller.rb
+- app/views/cloudflare/email/management/mailboxes/index.html.erb
+- app/views/cloudflare/email/management/mailboxes/message.html.erb
+- app/views/cloudflare/email/management/mailboxes/show.html.erb
+- app/views/layouts/cloudflare/email/management.html.erb
+- docs/activerecord-tenanted.md
+- docs/architecture.md
+- docs/custom-ingress.md
+- docs/delivery-events.md
+- docs/features.md
+- docs/getting-started.md
+- docs/mailboxes.md
+- docs/management-engine.md
+- docs/outbox.md
+- docs/routing-deliveries.md
+- docs/routing-diagnostics.md
+- docs/tenant-mailboxes-plan.md
+- docs/thread-correlation.md
+- docs/troubleshooting.md
+- docs/upgrading-0.2.md
+- docs/upgrading-0.3.md
+- docs/verification/2026-09-10-followup.md
+- docs/verification/2026-09-10-install-upgrade.md
+- docs/verification/2026-09-10-live.md
+- docs/verification/2026-09-10.md
+- docs/verification/2026-09-11-custom-ingress.md
+- docs/verification/2026-09-11-extraction.md
+- docs/verification/2026-09-11-outbound-ledger.md
+- docs/verification/2026-09-11-security.md
+- docs/verification/2026-09-11-tenant-mailboxes.md
+- docs/verification/2026-09-12-destination-context.md
+- docs/verification/2026-09-13-durable-inbound-and-routing.md
+- examples/plain_ruby.rb
 - lib/cloudflare-email.rb
+- lib/cloudflare/email/active_record.rb
+- lib/cloudflare/email/active_record/base.rb
+- lib/cloudflare/email/active_record/delivery_events.rb
+- lib/cloudflare/email/active_record/event_inbox.rb
+- lib/cloudflare/email/active_record/event_receipt.rb
+- lib/cloudflare/email/active_record/mail_snapshot.rb
+- lib/cloudflare/email/active_record/outbound_delivery.rb
+- lib/cloudflare/email/active_record/outbound_recipient.rb
+- lib/cloudflare/email/active_record/outbound_reconciliation.rb
+- lib/cloudflare/email/active_record/outbox.rb
+- lib/cloudflare/email/active_record/outbox_notifications.rb
+- lib/cloudflare/email/active_record/routing_deliveries.rb
+- lib/cloudflare/email/check_route_task.rb
 - lib/cloudflare/email/client.rb
+- lib/cloudflare/email/consume_events_task.rb
 - lib/cloudflare/email/credentials.rb
+- lib/cloudflare/email/delivery_event.rb
 - lib/cloudflare/email/delivery_method.rb
 - lib/cloudflare/email/deploy_worker_task.rb
+- lib/cloudflare/email/dev_ingress_guard.rb
 - lib/cloudflare/email/dev_tunnel.rb
 - lib/cloudflare/email/doctor.rb
+- lib/cloudflare/email/endpoint.rb
 - lib/cloudflare/email/engine.rb
+- lib/cloudflare/email/envelope.rb
 - lib/cloudflare/email/error.rb
+- lib/cloudflare/email/event_consumer.rb
+- lib/cloudflare/email/ingress.rb
+- lib/cloudflare/email/mailboxes.rb
+- lib/cloudflare/email/mailboxes/configuration.rb
+- lib/cloudflare/email/mailboxes/events.rb
+- lib/cloudflare/email/mailboxes/inbound_retention.rb
+- lib/cloudflare/email/mailboxes/jobs.rb
+- lib/cloudflare/email/mailboxes/models.rb
+- lib/cloudflare/email/mailboxes/provider_correlation.rb
+- lib/cloudflare/email/mailboxes/service.rb
+- lib/cloudflare/email/mailboxes/shared_event_receipt.rb
+- lib/cloudflare/email/management.rb
+- lib/cloudflare/email/management/adapter.rb
+- lib/cloudflare/email/management/configuration.rb
+- lib/cloudflare/email/management/engine.rb
+- lib/cloudflare/email/management/management.css
+- lib/cloudflare/email/management/routes.rb
+- lib/cloudflare/email/message_id.rb
+- lib/cloudflare/email/provider_metadata.rb
 - lib/cloudflare/email/provision_catchall_task.rb
 - lib/cloudflare/email/provision_route_task.rb
+- lib/cloudflare/email/replay_events_job.rb
 - lib/cloudflare/email/response.rb
+- lib/cloudflare/email/routing_analytics.rb
+- lib/cloudflare/email/routing_diagnostics.rb
 - lib/cloudflare/email/routing_provisioner.rb
-- lib/cloudflare/email/secure_message_id.rb
+- lib/cloudflare/email/send_job.rb
 - lib/cloudflare/email/send_test.rb
 - lib/cloudflare/email/signing.rb
 - lib/cloudflare/email/task_base.rb
+- lib/cloudflare/email/tenancy.rb
+- lib/cloudflare/email/tenant_job_context.rb
 - lib/cloudflare/email/verification.rb
 - lib/cloudflare/email/version.rb
 - lib/cloudflare/email/worker_deployer.rb
 - lib/generators/cloudflare/email/install_generator.rb
+- lib/generators/cloudflare/email/mailboxes/catch_all/catch_all_generator.rb
+- lib/generators/cloudflare/email/mailboxes/catch_all/templates/add_cloudflare_email_catch_all.rb
+- lib/generators/cloudflare/email/mailboxes/mailboxes_generator.rb
+- lib/generators/cloudflare/email/mailboxes/templates/create_cloudflare_email_mailboxes.rb
+- lib/generators/cloudflare/email/mailboxes/templates/create_cloudflare_email_receiving_domains.rb
+- lib/generators/cloudflare/email/mailboxes/templates/create_cloudflare_email_shared_events.rb
+- lib/generators/cloudflare/email/outbox/outbox_generator.rb
+- lib/generators/cloudflare/email/outbox/templates/create_cloudflare_email_outbox.rb
+- lib/generators/cloudflare/email/routing_tracking/routing_tracking_generator.rb
+- lib/generators/cloudflare/email/routing_tracking/templates/create_cloudflare_email_routing_delivery_receipts.rb
 - lib/generators/cloudflare/email/templates/initializer.rb
 - lib/generators/cloudflare/email/templates/main_mailbox.rb
+- lib/generators/cloudflare/email/tracking/templates/create_cloudflare_email_event_receipts.rb
+- lib/generators/cloudflare/email/tracking/tracking_generator.rb
 - lib/tasks/cloudflare_email.rake
+- lib/tasks/cloudflare_email_diagnostics.rake
+- templates/deploy-to-cloudflare/.dev.vars.example
+- templates/deploy-to-cloudflare/.gitignore
+- templates/deploy-to-cloudflare/LICENSE.txt
+- templates/deploy-to-cloudflare/README.md
+- templates/deploy-to-cloudflare/package-lock.json
+- templates/deploy-to-cloudflare/package.json
+- templates/deploy-to-cloudflare/src/index.js
+- templates/deploy-to-cloudflare/test/durable.test.ts
+- templates/deploy-to-cloudflare/test/index.test.ts
+- templates/deploy-to-cloudflare/test/relay.test.ts
+- templates/deploy-to-cloudflare/vitest.config.ts
+- templates/deploy-to-cloudflare/wrangler.toml
 - templates/worker/README.md
+- templates/worker/docs/durable-inbound.md
+- templates/worker/package-lock.json
 - templates/worker/package.json
+- templates/worker/scripts/wrangler.mjs
 - templates/worker/src/index.js
+- templates/worker/test/durable.test.ts
 - templates/worker/test/index.test.ts
+- templates/worker/test/relay.test.ts
 - templates/worker/vitest.config.ts
 - templates/worker/wrangler.toml
 homepage: https://github.com/cole-robertson/cloudflare-email
@@ -142,14 +289,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Cloudflare Email Service client for Ruby and Rails (ActionMailer + ActionMailbox).
 test_files: []

data/lib/cloudflare/email/secure_message_id.rb

@@ -1,89 +0,0 @@
-require "json"
-require "cloudflare/email/signing"
-
-module Cloudflare
-  module Email
-    # Signed outbound Message-IDs for reply authentication.
-    #
-    # Sign the outbound Message-ID with HMAC-SHA256. The recipient's reply
-    # naturally carries the signed id in `In-Reply-To:`, which your mailbox
-    # verifies and decodes to recover the original thread state.
-    #
-    # See README's "Signed replies" section for a full usage example.
-    module SecureMessageId
-      InvalidToken = Class.new(Cloudflare::Email::Error)
-
-      DEFAULT_PREFIX  = "msg".freeze
-      DEFAULT_MAX_AGE = 30 * 24 * 60 * 60   # 30 days
-      EPOCH_OFFSET    = Time.utc(2026, 1, 1).to_i.freeze
-
-      class << self
-        # Build a signed Message-ID carrying `payload`. Returns the bare
-        # Message-ID without angle brackets — SMTP/Mail adds them.
-        def encode(payload:, domain:, secret:, prefix: DEFAULT_PREFIX, now: Time.now.to_i)
-          raise ArgumentError, "secret must not be empty" if secret.to_s.empty?
-          raise ArgumentError, "domain must not be empty" if domain.to_s.empty?
-
-          iat_offset = now.to_i - EPOCH_OFFSET
-          raise ArgumentError, "timestamp out of 32-bit range" if iat_offset.negative? || iat_offset >= (1 << 32)
-
-          packed = [iat_offset].pack("N") + JSON.generate(payload)
-          b64    = Signing.base64url_encode(packed)
-          mac    = Signing.hmac_hex(secret, b64)
-
-          "#{prefix}.#{b64}.#{mac}@#{domain}"
-        end
-
-        # Decode a Message-ID produced by encode. Accepts `<bracketed>` form
-        # too. Returns parsed payload or raises InvalidToken.
-        def decode(message_id, secret:, max_age: DEFAULT_MAX_AGE, now: Time.now.to_i)
-          raise InvalidToken, "message-id is empty" if message_id.to_s.empty?
-
-          id = strip_brackets(message_id.to_s).strip
-          local, domain = id.split("@", 2)
-          raise InvalidToken, "missing @ in message-id" unless local && domain
-
-          _prefix, b64, mac = local.split(".", 3)
-          raise InvalidToken, "malformed message-id" unless b64 && mac && !b64.empty? && !mac.empty?
-
-          expected = Signing.hmac_hex(secret, b64)
-          raise InvalidToken, "signature mismatch" unless Signing.secure_compare(expected, mac)
-
-          packed = begin
-            Signing.base64url_decode(b64)
-          rescue StandardError
-            raise InvalidToken, "base64 decode failed"
-          end
-          raise InvalidToken, "truncated packed bytes" if packed.bytesize < 4
-
-          iat_offset   = packed.byteslice(0, 4).unpack1("N")
-          iat          = iat_offset + EPOCH_OFFSET
-          payload_json = packed.byteslice(4..)
-
-          raise InvalidToken, "token expired"                 if now - iat > max_age
-          raise InvalidToken, "token timestamp in the future" if iat - now > 5 * 60
-
-          JSON.parse(payload_json.to_s)
-        rescue JSON::ParserError
-          raise InvalidToken, "payload not valid JSON"
-        end
-
-        # Cheap heuristic — does this look like one of our signed Message-IDs?
-        def match?(message_id, prefix: DEFAULT_PREFIX)
-          id = strip_brackets(message_id.to_s).strip
-          local, domain = id.split("@", 2)
-          return false unless local && domain
-          p, b64, mac = local.split(".", 3)
-          return false unless p && b64 && mac
-          p == prefix && !b64.empty? && mac.match?(/\A[0-9a-f]{64}\z/)
-        end
-
-        private
-
-        def strip_brackets(s)
-          s.start_with?("<") && s.end_with?(">") ? s[1..-2] : s
-        end
-      end
-    end
-  end
-end