git-paid 2.1.2 → 2.1.4

package/lib/inbox.js

@@ -1,31 +1,120 @@
+import crypto from "node:crypto";
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 
-const INBOX_STORE_PATH = path.join(os.tmpdir(), "postbuild-verification-inbox.json");
+const RETENTION_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+const memoryInboxMessages = new Map(); // id -> msg
 
-function loadStore() {
+function getLocalStorePath() {
   try {
-    if (fs.existsSync(INBOX_STORE_PATH)) {
-      return JSON.parse(fs.readFileSync(INBOX_STORE_PATH, "utf8"));
+    const dir = path.join(process.cwd(), ".postbuild");
+    if (fs.existsSync(dir)) {
+      return path.join(dir, "inbox-messages.json");
     }
   } catch {}
-  return { messages: [] };
+  return null;
 }
 
-function saveStore(store) {
+function pruneAndLoadMessages() {
+  const now = Date.now();
+  const storePath = getLocalStorePath();
+  if (storePath && fs.existsSync(storePath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(storePath, "utf8"));
+      if (Array.isArray(parsed?.messages)) {
+        for (const m of parsed.messages) {
+          if (m && m.id && (!m.deleteAfterMs || m.deleteAfterMs > now)) {
+            memoryInboxMessages.set(m.id, m);
+          }
+        }
+      }
+    } catch {}
+  }
+
+  for (const [id, m] of memoryInboxMessages.entries()) {
+    if (m.deleteAfterMs && m.deleteAfterMs <= now) {
+      memoryInboxMessages.delete(id);
+    }
+  }
+
+  return Array.from(memoryInboxMessages.values()).sort((a, b) =>
+    String(b.receivedAt || "").localeCompare(String(a.receivedAt || ""))
+  );
+}
+
+function persistMessages() {
+  const storePath = getLocalStorePath();
+  if (!storePath) return;
   try {
-    fs.writeFileSync(INBOX_STORE_PATH, JSON.stringify(store, null, 2), "utf8");
+    const messages = pruneAndLoadMessages().slice(0, 200);
+    fs.writeFileSync(storePath, JSON.stringify({ messages }, null, 2), "utf8");
   } catch {}
 }
 
+/**
+ * Generates the dedicated @postbuild.dev bot inbox address for a target domain
+ * from the full hostname, with dots replaced by hyphens, so different TLDs never
+ * collide (acme.com -> acme-com-bot@postbuild.dev, acme.io -> acme-io-bot@postbuild.dev).
+ * postbuild.dev itself keeps the operator alias postbuild-bot@postbuild.dev.
+ * Hostnames longer than the slug limit are truncated and suffixed with a short hash.
+ */
+const MAX_INBOX_SLUG = 40;
+
+export function getBotInboxForDomain(rawDomain = "", ownerKey = "") {
+  const cleanDomain = String(rawDomain || "")
+    .trim()
+    .toLowerCase()
+    .replace(/^https?:\/\//, "")
+    .replace(/^www\./, "")
+    .split("/")[0]
+    .split(":")[0]
+    .replace(/\.$/, "");
+
+  if (!cleanDomain || !cleanDomain.includes(".")) {
+    if (ownerKey) {
+      const ownerHash = crypto
+        .createHash("sha256")
+        .update(String(ownerKey).toLowerCase().trim())
+        .digest("hex")
+        .slice(0, 8);
+      return `project-${ownerHash}-bot@postbuild.dev`;
+    }
+    return "unassigned-bot@postbuild.dev";
+  }
+
+  if (cleanDomain === "postbuild.dev") {
+    return "postbuild-bot@postbuild.dev";
+  }
+
+  const hasHyphenOrMultiDot = cleanDomain.includes("-") || cleanDomain.split(".").length > 2;
+
+  let slug =
+    cleanDomain
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/-+/g, "-")
+      .replace(/^-|-$/g, "") || "project";
+
+  if (slug.length > MAX_INBOX_SLUG || hasHyphenOrMultiDot) {
+    const hash = crypto.createHash("sha256").update(`pb-inbox:v2:${cleanDomain}`).digest("hex").slice(0, 6);
+    const maxBase = MAX_INBOX_SLUG - 7;
+    const base = slug.length > maxBase ? slug.slice(0, maxBase).replace(/-$/, "") : slug;
+    slug = `${base}-${hash}`;
+  }
+
+  return `${slug}-bot@postbuild.dev`;
+}
+
+export function isValidPostbuildInboxAddress(addr = "") {
+  const clean = String(addr || "").trim().toLowerCase();
+  return /^[a-z0-9][a-z0-9._-]{1,48}@postbuild\.dev$/.test(clean);
+}
+
 /**
  * Extracts confirmation/verification links and 4-to-8 digit OTP codes from email text/HTML.
  */
 export function extractVerificationSignals(subject = "", text = "", html = "") {
   const combined = `${subject}\n${text}\n${html.replace(/<[^>]+>/g, " ")}`;
 
-  // Extract all https:// URLs
   const urlMatches = `${text}\n${html}`.match(/https?:\/\/[^\s"'<>)+]+/gi) || [];
   const cleanedUrls = [...new Set(urlMatches.map((u) => u.replace(/[.,;!?]+$/, "")))];
 
@@ -33,7 +122,6 @@ export function extractVerificationSignals(subject = "", text = "", html = "") {
   const verificationLinks = cleanedUrls.filter((u) => verificationKeywords.test(u));
   const primaryLink = verificationLinks[0] || cleanedUrls[0] || null;
 
-  // Extract 6-digit OTP code (or 4-8 digit code near "code", "OTP", "PIN", "verification")
   let otpCode = null;
   const contextualOtp = combined.match(/(?:code|otp|pin|token|verification|confirm)[:\s#-]*([0-9]{4,8})\b/i);
   if (contextualOtp) {
@@ -52,12 +140,36 @@ export function extractVerificationSignals(subject = "", text = "", html = "") {
   };
 }
 
+export function sanitizeSubjectForDisplay(subject = "", otpCode = "") {
+  let clean = String(subject || "")
+    .replace(/\s*\((?:Code|OTP|Pin|Verification\s*Code)[:\s#-]*[0-9]{4,8}\)/gi, "")
+    .replace(/\s*[-–—:]\s*(?:Code|OTP|Pin)[:\s#-]*[0-9]{4,8}\b/gi, "");
+  if (otpCode) {
+    const escaped = String(otpCode).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    clean = clean.replace(new RegExp(`\\b${escaped}\\b`, "g"), "••••••");
+  }
+  return clean.trim() || "Confirm your directory submission";
+}
+
 /**
- * Ingests an inbound email webhook payload (Resend `email.received`, Postmark, ForwardEmail, or raw JSON).
+ * Ingests a verified inbound email webhook payload.
+ * Rejects mail addressed to unknown or non-@postbuild.dev recipients.
  */
 export async function ingestInboundEmail(rawPayload = {}) {
   const payload = rawPayload?.data && typeof rawPayload.data === "object" ? rawPayload.data : rawPayload;
 
+  const toRaw = payload.to || payload.recipient || payload.envelope?.to || "";
+  const toAddress = (Array.isArray(toRaw) ? toRaw[0] : String(toRaw))
+    .replace(/^.*<([^>]+)>.*$/, "$1")
+    .trim()
+    .toLowerCase();
+
+  if (!isValidPostbuildInboxAddress(toAddress)) {
+    const err = new Error(`Rejected inbound email for unknown or invalid recipient: ${toAddress || "empty"}`);
+    err.statusCode = 422;
+    throw err;
+  }
+
   let textBody = String(payload.text || payload.body || payload.rawText || "").trim();
   let htmlBody = String(payload.html || "").trim();
   let subject = String(payload.subject || "Confirm your directory submission").trim();
@@ -67,7 +179,8 @@ export async function ingestInboundEmail(rawPayload = {}) {
   if (resendEmailId && resendApiKey && !textBody && !htmlBody) {
     try {
       const resp = await fetch(`https://api.resend.com/emails/receiving/${encodeURIComponent(resendEmailId)}`, {
-        headers: { Authorization: `Bearer ${resendApiKey}` }
+        headers: { Authorization: `Bearer ${resendApiKey}` },
+        signal: AbortSignal.timeout(3500)
       });
       if (resp.ok) {
         const fullEmail = await resp.json();
@@ -78,139 +191,313 @@ export async function ingestInboundEmail(rawPayload = {}) {
     } catch {}
   }
 
-  const toRaw = payload.to || payload.recipient || payload.envelope?.to || "postbuild-bot@postbuild.dev";
-  const toAddress = (Array.isArray(toRaw) ? toRaw[0] : String(toRaw))
-    .replace(/^.*<([^>]+)>.*$/, "$1")
-    .trim()
-    .toLowerCase();
-
   const fromRaw = payload.from || payload.sender || payload.envelope?.from || "no-reply@directory-verifier.com";
   const fromAddress = String(fromRaw).trim();
 
   const signals = extractVerificationSignals(subject, textBody, htmlBody);
+  const displaySubject = sanitizeSubjectForDisplay(subject, signals.otpCode);
+  const receivedDate = payload.created_at ? new Date(payload.created_at) : new Date();
+  const receivedMs = Number.isNaN(receivedDate.getTime()) ? Date.now() : receivedDate.getTime();
+  const deleteAfterMs = receivedMs + RETENTION_MS;
 
   const msg = {
-    id: resendEmailId || `msg_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+    id: resendEmailId || `msg_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`,
     to: toAddress,
     from: fromAddress,
-    subject,
+    subject: displaySubject,
     snippet: (textBody || htmlBody.replace(/<[^>]+>/g, " ")).slice(0, 220).trim(),
     primaryLink: signals.primaryLink,
     verificationLinks: signals.verificationLinks,
     otpCode: signals.otpCode,
     status: signals.primaryLink || signals.otpCode ? "action_ready" : "received",
-    receivedAt: payload.created_at || new Date().toISOString()
+    receivedAt: new Date(receivedMs).toISOString(),
+    deleteAfter: new Date(deleteAfterMs).toISOString(),
+    deleteAfterMs
   };
 
-  const store = loadStore();
-  const existsIdx = store.messages.findIndex((m) => m.id === msg.id);
-  if (existsIdx >= 0) {
-    store.messages[existsIdx] = msg;
-  } else {
-    store.messages.unshift(msg);
-  }
-  store.messages = store.messages.slice(0, 100);
-  saveStore(store);
+  memoryInboxMessages.set(msg.id, msg);
+  persistMessages();
 
   return msg;
 }
 
 /**
- * Syncs recent inbound emails directly from Resend Receiving API (`GET /emails/receiving`)
- * so serverless cold starts never lose verification emails.
+ * Syncs recent inbound emails from Resend Receiving API (`GET /emails/receiving`)
+ * filtered strictly by exact recipient match.
  */
 async function syncFromResendReceivingApi(targetInbox = "") {
   const resendApiKey = (process.env.RESEND_API_KEY || "").trim();
-  if (!resendApiKey) return;
+  if (!resendApiKey || !isValidPostbuildInboxAddress(targetInbox)) return;
+
+  const normalizedTarget = targetInbox.trim().toLowerCase();
 
   try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 3500);
-    const resp = await fetch("https://api.resend.com/emails/receiving?limit=20", {
+    const resp = await fetch("https://api.resend.com/emails/receiving?limit=25", {
       headers: { Authorization: `Bearer ${resendApiKey}` },
-      signal: controller.signal
+      signal: AbortSignal.timeout(3500)
     });
-    clearTimeout(timer);
     if (!resp.ok) return;
 
     const data = await resp.json();
     const items = Array.isArray(data?.data) ? data.data : Array.isArray(data) ? data : [];
-    const store = loadStore();
-    const knownIds = new Set(store.messages.map((m) => m.id));
-    const prefix = targetInbox ? targetInbox.split("@")[0].toLowerCase() : "";
 
-    for (const item of items.slice(0, 12)) {
+    for (const item of items.slice(0, 15)) {
       const id = item.id || item.email_id;
-      if (!id || knownIds.has(id)) continue;
+      if (!id || memoryInboxMessages.has(id)) continue;
+
+      const recipients = (Array.isArray(item.to) ? item.to : [item.to])
+        .filter(Boolean)
+        .map((r) => String(r).replace(/^.*<([^>]+)>.*$/, "$1").trim().toLowerCase());
+
+      if (!recipients.includes(normalizedTarget)) continue;
 
-      const toList = Array.isArray(item.to) ? item.to.join(" ").toLowerCase() : String(item.to || "").toLowerCase();
-      if (prefix && !toList.includes(prefix) && !toList.includes("postbuild.dev")) continue;
+      let fullItem = item;
+      if (!item.text && !item.html) {
+        try {
+          const detResp = await fetch(`https://api.resend.com/emails/receiving/${encodeURIComponent(id)}`, {
+            headers: { Authorization: `Bearer ${resendApiKey}` },
+            signal: AbortSignal.timeout(2500)
+          });
+          if (detResp.ok) {
+            fullItem = await detResp.json();
+          }
+        } catch {}
+      }
 
-      await ingestInboundEmail(item);
+      await ingestInboundEmail(fullItem);
     }
   } catch {}
 }
 
+export function normalizeInboxInput(raw = "") {
+  const s = String(raw || "").trim().toLowerCase();
+  if (!s) return "";
+  if (s.includes("@") && !s.startsWith("http")) {
+    return s;
+  }
+  return getBotInboxForDomain(s);
+}
+
 /**
- * Lists verification emails for a given bot inbox address (e.g., postbuild-bot@postbuild.dev).
- * Queries Resend Receiving API directly when RESEND_API_KEY is present, or syncs from postbuild.dev when run via local CLI.
+ * Lists verification emails for a specific bot inbox address using exact recipient matching.
  */
 export async function listInboxMessages(inboxAddress = "", options = {}) {
-  const normalized = String(inboxAddress || "postbuild-bot@postbuild.dev").trim().toLowerCase();
+  const normalized = normalizeInboxInput(inboxAddress);
 
   if (process.env.RESEND_API_KEY) {
     await syncFromResendReceivingApi(normalized);
-  } else if (options.allowRemoteFallback !== false && !process.env.VERCEL) {
+  } else if (options.allowRemoteFallback !== false && !process.env.VERCEL && options.bearerToken) {
     try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), 3000);
       const remoteResp = await fetch(
         `https://www.postbuild.dev/api/dispatch?action=inbox_list&inbox=${encodeURIComponent(normalized)}`,
-        { signal: controller.signal }
+        {
+          headers: {
+            Authorization: `Bearer ${options.bearerToken}`
+          },
+          signal: AbortSignal.timeout(3000)
+        }
       );
-      clearTimeout(timer);
       if (remoteResp.ok) {
         const remoteData = await remoteResp.json();
-        if (Array.isArray(remoteData.messages) && remoteData.messages.length > 0) {
-          const store = loadStore();
-          const existingIds = new Set(store.messages.map((m) => m.id));
+        if (Array.isArray(remoteData.messages)) {
           for (const rm of remoteData.messages) {
-            if (!existingIds.has(rm.id)) store.messages.push(rm);
+            if (rm && rm.id && rm.to === normalized) {
+              memoryInboxMessages.set(rm.id, rm);
+            }
           }
-          saveStore(store);
+          persistMessages();
         }
       }
     } catch {}
   }
 
-  const store = loadStore();
-  const filtered = normalized
-    ? store.messages.filter((m) => m.to === normalized || m.to.includes(normalized.split("@")[0]))
-    : store.messages;
+  const allMessages = pruneAndLoadMessages();
+  // Exact address match only — never substring match
+  const filtered = allMessages
+    .filter((m) => m.to === normalized)
+    .map((m) => ({
+      ...m,
+      subject: sanitizeSubjectForDisplay(m.subject, m.otpCode),
+      verificationUrl: m.primaryLink && /^https:\/\//i.test(m.primaryLink) ? m.primaryLink : null
+    }));
 
   return {
     inboxAddress: normalized,
+    retentionDays: 30,
     count: filtered.length,
     messages: filtered
   };
 }
 
+export function markMessageVerified(id, verified = true, httpStatus = 200) {
+  if (!id || !memoryInboxMessages.has(id)) return false;
+  const existing = memoryInboxMessages.get(id);
+  memoryInboxMessages.set(id, {
+    ...existing,
+    autoVerified: Boolean(verified),
+    httpStatus,
+    status: verified ? "verified" : existing.status
+  });
+  persistMessages();
+  return true;
+}
+
 /**
- * Generates a realistic test verification email so users can verify the inbox pipeline immediately.
+ * Generates and sends a verification test email via Resend API (admin/authorized testing only).
  */
-export async function sendTestVerificationEmail(inboxAddress = "postbuild-bot@postbuild.dev", domain = "postbuild.dev") {
-  const cleanInbox = String(inboxAddress || "postbuild-bot@postbuild.dev").trim().toLowerCase();
-  const otp = String(Math.floor(100000 + Math.random() * 900000));
-  const token = Buffer.from(`${domain}:${Date.now()}`).toString("base64url");
-  const verifyUrl = `https://postbuild.dev/?verified_directory=betalist&domain=${encodeURIComponent(domain)}&token=${token}`;
+export async function sendTestVerificationEmail(inboxAddress = "", domain = "postbuild.dev") {
+  const cleanInbox = normalizeInboxInput(inboxAddress || domain);
+  if (!isValidPostbuildInboxAddress(cleanInbox)) {
+    throw new Error("Recipient must be a valid @postbuild.dev inbox address");
+  }
+
+  const otp = String(crypto.randomInt(100000, 1000000));
+  const token = crypto.randomBytes(12).toString("base64url");
+  const verifyUrl = `https://www.postbuild.dev/?verified_directory=test&domain=${encodeURIComponent(domain)}&token=${token}`;
+
+  const subject = `[Verification Test] Confirm ${domain} launch listing`;
+  const textBody = `Hello ${domain} team,\n\nThis is a verification test message for your dedicated postbuild inbox (${cleanInbox}). Your one-time verification code is ${otp}.\n\nConfirmation link:\n${verifyUrl}\n`;
+
+  let resendMessageId = null;
+  const resendApiKey = (process.env.RESEND_API_KEY || "").trim();
+  if (resendApiKey) {
+    try {
+      const resp = await fetch("https://api.resend.com/emails", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${resendApiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          from: "Postbuild Verification Service <verify@postbuild.dev>",
+          to: [cleanInbox],
+          subject,
+          text: textBody
+        }),
+        signal: AbortSignal.timeout(4500)
+      });
+      if (resp.ok) {
+        const sentData = await resp.json();
+        resendMessageId = sentData.id || null;
+      }
+    } catch {}
+  }
 
   return ingestInboundEmail({
     type: "email.received",
     data: {
+      id: resendMessageId || undefined,
       to: [cleanInbox],
-      from: "BetaList Launch Bot <verify@betalist.com>",
-      subject: `[Action Required] Verify ${domain} submission on BetaList (Code: ${otp})`,
-      text: `Hi ${domain} team,\n\nWe received your directory launch submission via postbuild. Your one-time verification code is ${otp}.\n\nOr click the instant confirmation link below to publish your listing immediately:\n${verifyUrl}\n`
+      from: "Postbuild Verification Service <verify@postbuild.dev>",
+      subject,
+      text: textBody
     }
   });
 }
+
+export function clearInboxStoreForTests() {
+  memoryInboxMessages.clear();
+}
+
+/**
+ * Queries Resend Domains & Receiving API for local operator diagnostics (`scripts/email-diag.mjs`).
+ */
+export async function getResendDomainDiagnostics(triggerVerify = false) {
+  const resendApiKey = (process.env.RESEND_API_KEY || "").trim();
+  if (!resendApiKey) {
+    return { configured: false, error: "RESEND_API_KEY not set" };
+  }
+
+  let domains = [];
+  let domainDetail = null;
+  let verifyTriggered = false;
+  let webhooks = [];
+  let webhookAutoCreated = null;
+  let receivingCount = 0;
+  let receivingSample = [];
+
+  try {
+    const dResp = await fetch("https://api.resend.com/domains", {
+      headers: { Authorization: `Bearer ${resendApiKey}` },
+      signal: AbortSignal.timeout(4000)
+    });
+    if (dResp.ok) {
+      const dJson = await dResp.json();
+      domains = dJson.data || [];
+      const pbDomain = domains.find((d) => d.name === "postbuild.dev") || domains[0];
+      if (pbDomain?.id) {
+        if (triggerVerify) {
+          const vResp = await fetch(`https://api.resend.com/domains/${pbDomain.id}/verify`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${resendApiKey}` },
+            signal: AbortSignal.timeout(4000)
+          });
+          verifyTriggered = vResp.ok;
+        }
+        const detResp = await fetch(`https://api.resend.com/domains/${pbDomain.id}`, {
+          headers: { Authorization: `Bearer ${resendApiKey}` },
+          signal: AbortSignal.timeout(4000)
+        });
+        if (detResp.ok) {
+          domainDetail = await detResp.json();
+        }
+      }
+    }
+  } catch {}
+
+  try {
+    const wResp = await fetch("https://api.resend.com/webhooks", {
+      headers: { Authorization: `Bearer ${resendApiKey}` },
+      signal: AbortSignal.timeout(4000)
+    });
+    if (wResp.ok) {
+      const wJson = await wResp.json();
+      webhooks = wJson.data || [];
+      const targetEndpoint = "https://www.postbuild.dev/api/inbound-email";
+      const hasInboundHook = webhooks.some((w) => String(w.endpoint || "").includes("/api/inbound-email"));
+      if (!hasInboundHook) {
+        const createResp = await fetch("https://api.resend.com/webhooks", {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${resendApiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            endpoint: targetEndpoint,
+            events: ["email.received"]
+          }),
+          signal: AbortSignal.timeout(4000)
+        });
+        if (createResp.ok) {
+          webhookAutoCreated = await createResp.json();
+        } else {
+          webhookAutoCreated = { status: createResp.status, error: await createResp.text() };
+        }
+      }
+    }
+  } catch {}
+
+  try {
+    const rResp = await fetch("https://api.resend.com/emails/receiving?limit=10", {
+      headers: { Authorization: `Bearer ${resendApiKey}` },
+      signal: AbortSignal.timeout(4000)
+    });
+    if (rResp.ok) {
+      const rJson = await rResp.json();
+      const list = rJson.data || [];
+      receivingCount = list.length;
+      receivingSample = list.slice(0, 3);
+    }
+  } catch {}
+
+  return {
+    configured: true,
+    verifyTriggered,
+    domains,
+    domainDetail,
+    webhooks,
+    webhookAutoCreated,
+    receivingCount,
+    receivingSample
+  };
+}