@develemail/cli 0.1.5 → 0.1.7

package/README.md

@@ -0,0 +1,43 @@
+# @develemail/cli
+
+The `devel` command-line tool for DevelEmail: manage projects, domains and API
+keys, publish DNS, and send test emails.
+
+```bash
+npm install -g @develemail/cli
+devel --version
+```
+
+## Onboarding
+
+```bash
+devel login                      # opens a browser; saves an owner session
+devel domains add example.com    # prints the domain ID
+devel domains records <id>       # DNS records to publish (--format bind)
+devel domains publish-dns <id>   # or publish them to Cloudflare for you
+devel domains verify <id> --wait # poll until DNS verifies
+devel init --project my-app --from noreply@example.com
+```
+
+`devel login` defaults to `--url https://develemail.com/api`. The session is
+saved to `~/.config/develemail/auth.json`.
+
+`publish-dns` needs a Cloudflare token connected first:
+`devel cloudflare connect --token-env CLOUDFLARE_API_TOKEN`.
+
+## Receiving mail
+
+```bash
+devel inbound add example.com privacy --if-missing   # inbox-only mailbox
+devel inbound list example.com
+devel inbound check example.com                      # does the MX reach us?
+```
+
+`devel init` creates the project and an API key and writes
+`DEVELEMAIL_BASE_URL` and `DEVELEMAIL_API_KEY` to your env files. After that,
+`devel send`, `devel logs` and `devel tail` use that API key.
+
+## Reference
+
+Every command and option is documented in the
+[CLI reference](https://docs.develemail.com/cli-reference) on the DevelEmail docs site.

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import { Command as Command8 } from "commander";
+// src/program.ts
+import { Command as Command13 } from "commander";
 
 // src/commands/send.ts
 import { Command } from "commander";
@@ -91,7 +91,10 @@ var COL_STATUS = 10;
 function col(s, w) {
   return s.slice(0, w).padEnd(w);
 }
-var logsCommand = new Command2("logs").description("List recent emails").option("--limit <n>", "Number of emails to show", "20").option("--status <status>", "Filter by status (sent, queued, failed, \u2026)").action(async (opts) => {
+var logsCommand = new Command2("logs").description("List recent emails").option("--limit <n>", "Number of emails to show", "20").option(
+  "--status <status>",
+  "Filter by status (sent, delivered, queued, deferred, bounced, failed, \u2026)"
+).action(async (opts) => {
   const cfg = loadConfig();
   const params = new URLSearchParams({ limit: opts.limit });
   if (opts.status) params.set("status", opts.status);
@@ -139,6 +142,12 @@ var tailCommand = new Command3("tail").description("Poll and print new email eve
   const cfg = loadConfig();
   const seen = /* @__PURE__ */ new Set();
   const startedAt = opts.since ? new Date(opts.since) : /* @__PURE__ */ new Date();
+  if (opts.since && isNaN(startedAt.getTime())) {
+    console.error(
+      `Error: invalid --since value "${opts.since}" \u2014 use ISO 8601 (e.g. 2026-07-20) or other valid date format`
+    );
+    process.exit(1);
+  }
   console.log("Tailing email events\u2026 (Ctrl-C to stop)");
   const poll = async () => {
     try {
@@ -173,20 +182,74 @@ import { Command as Command4 } from "commander";
 import {
   createServer
 } from "http";
-import { exec } from "child_process";
+
+// src/open-browser.ts
+import { execFile } from "child_process";
 import { platform } from "os";
-function openBrowser(url) {
-  const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
-  exec(`${cmd} "${url}"`);
-}
-var loginCommand = new Command4("login").description("Authenticate with your DevelEmail instance via browser").option(
-  "--url <url>",
-  "Base URL of your DevelEmail API",
-  "https://develemail.com/api"
+function isHttpUrl(url) {
+  try {
+    const { protocol } = new URL(url);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function commandFor(os, url) {
+  if (os === "darwin") return ["open", [url]];
+  if (os === "win32") return ["rundll32", ["url.dll,FileProtocolHandler", url]];
+  return ["xdg-open", [url]];
+}
+function openBrowser(url, deps = {}) {
+  if (!isHttpUrl(url)) return false;
+  const spawn = deps.spawn ?? ((file2, args2) => {
+    execFile(file2, args2, () => {
+    });
+  });
+  const [file, args] = commandFor(deps.platform ?? platform(), url);
+  spawn(file, args);
+  return true;
+}
+
+// src/resolve-web-app-url.ts
+var DISCOVERY_TIMEOUT_MS = 3e3;
+function trimSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function legacyWebAppUrl(apiUrl) {
+  return trimSlash(apiUrl).replace(/\/api$/, "");
+}
+async function resolveWebAppUrl(apiUrl, fetchImpl = fetch, options = {}) {
+  if (options.appUrl?.trim()) return trimSlash(options.appUrl.trim());
+  const base = trimSlash(apiUrl);
+  try {
+    const res = await fetchImpl(`${base}/meta/public-urls`, {
+      signal: AbortSignal.timeout(options.timeoutMs ?? DISCOVERY_TIMEOUT_MS)
+    });
+    if (!res.ok) return legacyWebAppUrl(base);
+    const body = await res.json();
+    return typeof body.webAppUrl === "string" && body.webAppUrl.trim() ? trimSlash(body.webAppUrl.trim()) : legacyWebAppUrl(base);
+  } catch {
+    return legacyWebAppUrl(base);
+  }
+}
+
+// src/commands/login.ts
+var DEFAULT_API_URL = "https://develemail.com/api";
+var loginCommand = new Command4("login").description("Authenticate with your DevelEmail instance via browser").option("--url <url>", "Base URL of your DevelEmail API", DEFAULT_API_URL).option(
+  "--app-url <url>",
+  "Dashboard URL to open for sign-in (discovered from the API by default)"
 ).action(async (opts) => {
+  if (!isHttpUrl(opts.url) || opts.appUrl && !isHttpUrl(opts.appUrl)) {
+    console.error("--url must be an http(s) URL");
+    process.exit(1);
+    return;
+  }
   const apiUrl = opts.url.replace(/\/$/, "");
-  const baseUrl = apiUrl.replace(/\/api$/, "");
+  const webAppUrl = await resolveWebAppUrl(apiUrl, fetch, {
+    appUrl: opts.appUrl
+  });
   await new Promise((resolve2, reject) => {
+    let timeout;
     const server = createServer(
       (req, res) => {
         const url = new URL(req.url ?? "/", `http://localhost`);
@@ -208,6 +271,7 @@ var loginCommand = new Command4("login").description("Authenticate with your Dev
         );
         console.log("Authenticated successfully.");
         console.log("Session saved to ~/.config/develemail/auth.json");
+        clearTimeout(timeout);
         server.close();
         resolve2();
       }
@@ -219,13 +283,16 @@ var loginCommand = new Command4("login").description("Authenticate with your Dev
         return;
       }
       const port = addr.port;
-      const authUrl = `${baseUrl}/cli-auth?port=${port}`;
+      const authUrl = `${webAppUrl}/cli-auth?port=${port}`;
       console.log("Opening browser for authentication...");
       console.log(`If the browser doesn't open, visit: ${authUrl}`);
       openBrowser(authUrl);
     });
-    server.on("error", reject);
-    setTimeout(
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+    timeout = setTimeout(
       () => {
         server.close();
         reject(new Error("Authentication timed out after 5 minutes"));
@@ -262,6 +329,21 @@ var COL_ENV = 12;
 function col2(s, w) {
   return (s ?? "").slice(0, w).padEnd(w);
 }
+function formatCooldown(minutes) {
+  if (minutes == null) return "platform default";
+  return minutes === 0 ? "disabled" : `${minutes} min`;
+}
+function parseCooldownMinutes(raw) {
+  if (raw === "default") return null;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0 || n > 1440) {
+    console.error(
+      'Error: --recipient-cooldown must be 0-1440 minutes, or "default"'
+    );
+    process.exit(1);
+  }
+  return n;
+}
 var listCommand = new Command5("list").description("List all projects").action(async () => {
   const { url, token } = loadOwnerSession();
   const projects = await apiRequest(`${url}/projects`, token);
@@ -278,7 +360,25 @@ var listCommand = new Command5("list").description("List all projects").action(a
     );
   }
 });
-var createCommand = new Command5("create").description("Create a new project").requiredOption("--name <name>", "Project name (slug, e.g. my-app)").option(
+var getCommand = new Command5("get").description("Get project details").argument("<id>", "Project ID").action(async (id) => {
+  const { url, token } = loadOwnerSession();
+  const project = await apiRequest(`${url}/projects/${id}`, token);
+  console.log(`ID: ${project.id}`);
+  console.log(`Name: ${project.name}`);
+  console.log(`Environment: ${project.environment}`);
+  console.log(`From Address: ${project.defaultFromAddress ?? "\u2014"}`);
+  console.log(
+    `Rate Limit: ${project.rateLimitPerDay ?? "Unlimited"} per day`
+  );
+  console.log(
+    `Recipient Cooldown: ${formatCooldown(project.recipientCooldownMinutes)}`
+  );
+  if (project.domainId) {
+    console.log(`Domain ID: ${project.domainId}`);
+  }
+  console.log(`Created At: ${new Date(project.createdAt).toISOString()}`);
+});
+var createCommand = new Command5("create").description("Create a new project").requiredOption("--name <name>", "Project name (slug, e.g. my-app)").option("--domain <domainId>", "Domain ID for this project").option(
   "--env <env>",
   "Environment: development | staging | production",
   "production"
@@ -289,6 +389,7 @@ var createCommand = new Command5("create").description("Create a new project").r
       method: "POST",
       body: JSON.stringify({
         name: opts.name,
+        domainId: opts.domain,
         environment: opts.env,
         defaultFromAddress: opts.from,
         rateLimitPerDay: opts.rateLimit ? Number(opts.rateLimit) : void 0,
@@ -298,10 +399,563 @@ var createCommand = new Command5("create").description("Create a new project").r
     console.log(`Created project: ${project.name} (${project.id})`);
   }
 );
-var projectCommand = new Command5("project").description("Manage projects").addCommand(listCommand).addCommand(createCommand);
+var updateCommand = new Command5("update").description("Update project settings").argument("<id>", "Project ID").option(
+  "--recipient-cooldown <minutes>",
+  'Minutes before the same subject can be re-sent to a recipient (0 disables, "default" restores the platform default)'
+).action(async (id, opts) => {
+  const body = {};
+  if (opts.recipientCooldown !== void 0) {
+    body.recipientCooldownMinutes = parseCooldownMinutes(
+      opts.recipientCooldown
+    );
+  }
+  if (Object.keys(body).length === 0) {
+    console.error("Error: nothing to update; pass --recipient-cooldown");
+    process.exit(1);
+  }
+  const { url, token } = loadOwnerSession();
+  const project = await apiRequest(`${url}/projects/${id}`, token, {
+    method: "PATCH",
+    body: JSON.stringify(body)
+  });
+  console.log(
+    `Updated project: ${project.name} (recipient cooldown: ${formatCooldown(project.recipientCooldownMinutes)})`
+  );
+});
+var projectCommand = new Command5("project").description("Manage projects").addCommand(listCommand).addCommand(getCommand).addCommand(createCommand).addCommand(updateCommand);
 
-// src/commands/key.ts
+// src/commands/domains.ts
+import { Command as Command8 } from "commander";
+
+// src/owner-api.ts
+var OwnerApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+async function ownerRequest(path, init) {
+  const { url, token } = loadOwnerSession();
+  const res = await fetch(`${url}${path}`, {
+    ...init,
+    headers: {
+      Cookie: `session=${token}`,
+      ...init?.body != null ? { "Content-Type": "application/json" } : {},
+      ...init?.headers ?? {}
+    }
+  });
+  if (res.status === 401) {
+    throw new OwnerApiError(
+      "Session expired or missing. Run `devel login` first.",
+      401
+    );
+  }
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new OwnerApiError(body.message ?? res.statusText, res.status);
+  }
+  if (res.status === 204) return void 0;
+  return res.json();
+}
+function exitOnError(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  };
+}
+
+// src/commands/dns-records.ts
+var BIND_TTL = 3600;
+function formatBind(records) {
+  return records.map((r) => {
+    const value = r.type === "TXT" ? `"${r.value.replace(/"/g, '\\"')}"` : r.value;
+    return `${r.host}. ${BIND_TTL} IN ${r.type} ${value}`;
+  }).join("\n");
+}
+function formatTable(records) {
+  return records.map(
+    (r) => `${r.priority.padEnd(11)} ${r.type.padEnd(5)} ${r.host}
+  ${r.value}
+  (${r.purpose})`
+  ).join("\n");
+}
+function printRecords(records, format, json) {
+  if (json) console.log(JSON.stringify(records, null, 2));
+  else if (format === "bind") console.log(formatBind(records));
+  else console.log(formatTable(records));
+}
+
+// src/commands/publish-dns.ts
 import { Command as Command6 } from "commander";
+import { createInterface } from "readline/promises";
+function pickZone(domainName, zones) {
+  const matches = zones.filter(
+    (z) => domainName === z.name || domainName.endsWith(`.${z.name}`)
+  );
+  if (matches.length === 0) {
+    throw new Error(`No Cloudflare zone matches ${domainName}.`);
+  }
+  const longest = Math.max(...matches.map((z) => z.name.length));
+  const best = matches.filter((z) => z.name.length === longest);
+  if (best.length > 1) {
+    throw new Error(
+      `Several zones match ${domainName}: ${best.map((z) => z.id).join(", ")}. Pass --zone.`
+    );
+  }
+  return best[0];
+}
+function printPlan(plan) {
+  for (const w of plan.warnings) console.log(`warning: ${w}`);
+  for (const c of plan.changes) {
+    const from = c.existingContent ? ` (was: ${c.existingContent})` : "";
+    console.log(
+      `${c.action.padEnd(6)} ${c.type} ${c.name} -> ${c.content}${from}`
+    );
+    for (const w of c.warnings) console.log(`       warning: ${w}`);
+  }
+}
+async function confirm() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question("Apply these changes? [y/N] ");
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+var publishDnsCommand = new Command6("publish-dns").description("Publish a domain\u2019s DNS records to Cloudflare").argument("<id>", "Domain ID").option("--zone <zoneId>", "Cloudflare zone ID (default: auto-pick)").option("--yes", "Apply without prompting").option("--json", "Output JSON").action(
+  exitOnError(async (id, opts) => {
+    let zoneId = opts.zone;
+    if (!zoneId) {
+      const domain = await ownerRequest(`/domains/${id}`);
+      const zones = await ownerRequest("/cloudflare/zones");
+      zoneId = pickZone(domain.name, zones).id;
+    }
+    const plan = await ownerRequest(`/cloudflare/domains/${id}/plan`, {
+      method: "POST",
+      body: JSON.stringify({ zoneId })
+    });
+    if (!opts.json) printPlan(plan);
+    const apply = opts.yes || process.stdin.isTTY === true && await confirm();
+    if (!apply) {
+      if (opts.json) console.log(JSON.stringify({ plan, applied: false }));
+      else
+        console.log("Dry run: nothing applied. Re-run with --yes to apply.");
+      return;
+    }
+    const result = await ownerRequest("/cloudflare/apply", {
+      method: "POST",
+      body: JSON.stringify(plan)
+    });
+    if (opts.json)
+      console.log(JSON.stringify({ plan, applied: true, result }));
+    else console.log("Applied.");
+  })
+);
+
+// src/commands/domains-warmup.ts
+import { Command as Command7 } from "commander";
+var FULLY_WARMED_STAGE = 7;
+var STAGE_LIMITS = {
+  1: "50",
+  2: "100",
+  3: "200",
+  4: "400",
+  5: "800",
+  6: "1,600",
+  7: "Unlimited"
+};
+function printWarmupStatus(d) {
+  console.log(`Domain: ${d.name}`);
+  if (d.warmupStage === null) {
+    console.log("Warmup: not started");
+    return;
+  }
+  console.log(
+    d.warmupStage >= FULLY_WARMED_STAGE ? "Stage: Fully warmed" : `Stage: ${d.warmupStage} of ${FULLY_WARMED_STAGE}`
+  );
+  console.log(`Daily limit: ${STAGE_LIMITS[d.warmupStage] ?? "Unknown"}`);
+  if (d.warmupPausedAt) {
+    console.log(`Paused since ${new Date(d.warmupPausedAt).toLocaleString()}`);
+  }
+}
+async function runWarmup(id, opts) {
+  if (opts.pause && opts.resume) {
+    throw new Error("Use either --pause or --resume, not both.");
+  }
+  const patch = (warmupPausedAt) => ownerRequest(`/domains/${id}`, {
+    method: "PATCH",
+    body: JSON.stringify({ warmupPausedAt })
+  });
+  let domain;
+  if (opts.pause) {
+    domain = await patch((/* @__PURE__ */ new Date()).toISOString());
+  } else if (opts.resume) {
+    domain = await patch(null);
+  } else {
+    domain = await ownerRequest(`/domains/${id}`);
+    if (domain.warmupStage === null) {
+      domain = await ownerRequest(
+        `/domains/${id}/warmup/enable`,
+        {
+          method: "POST"
+        }
+      );
+    } else {
+      console.log("Warmup already in progress");
+    }
+  }
+  if (opts.json) console.log(JSON.stringify(domain, null, 2));
+  else printWarmupStatus(domain);
+}
+var warmupCommand = new Command7("warmup").description("Start, pause or resume domain warmup").argument("<id>", "Domain ID").option("--pause", "Pause the warmup ramp").option("--resume", "Resume a paused warmup ramp").option("--json", "Output the domain as JSON").action(exitOnError(runWarmup));
+
+// src/commands/domains.ts
+var COL_ID3 = 40;
+var COL_NAME2 = 30;
+var COL_STATUS2 = 15;
+function col3(s, w) {
+  return (s ?? "").slice(0, w).padEnd(w);
+}
+function printStatuses(d) {
+  console.log(`SPF Status: ${d.spfStatus ?? "\u2014"}`);
+  console.log(`DKIM Status: ${d.dkimStatus ?? "\u2014"}`);
+  console.log(`DMARC Status: ${d.dmarcStatus ?? "\u2014"}`);
+}
+var listCommand2 = new Command8("list").description("List all domains").action(
+  exitOnError(async () => {
+    const domains = await ownerRequest("/domains");
+    if (domains.length === 0) {
+      console.log("No domains found.");
+      return;
+    }
+    const header = `${col3("ID", COL_ID3)} ${col3("NAME", COL_NAME2)} ${col3("STATUS", COL_STATUS2)} CREATED`;
+    console.log(header);
+    console.log("-".repeat(header.length + 20));
+    for (const d of domains) {
+      const createdAt = new Date(d.createdAt).toLocaleDateString();
+      console.log(
+        `${col3(d.id, COL_ID3)} ${col3(d.name, COL_NAME2)} ${col3(d.verificationStatus, COL_STATUS2)} ${createdAt}`
+      );
+    }
+  })
+);
+var getCommand2 = new Command8("get").description("Get domain details").argument("<id>", "Domain ID").action(
+  exitOnError(async (id) => {
+    const domain = await ownerRequest(`/domains/${id}`);
+    console.log(`ID: ${domain.id}`);
+    console.log(`Name: ${domain.name}`);
+    console.log(`Verification Status: ${domain.verificationStatus}`);
+    printStatuses(domain);
+    console.log(`MX Status: ${domain.mxStatus ?? "\u2014"}`);
+    console.log(`Return Path Status: ${domain.returnPathStatus ?? "\u2014"}`);
+    console.log(`PTR Status: ${domain.ptrStatus ?? "\u2014"}`);
+    console.log(`DKIM Selector: ${domain.dkimSelector}`);
+    console.log(`DKIM Public Key:
+${domain.dkimPublicKey}`);
+    console.log(`Created At: ${new Date(domain.createdAt).toISOString()}`);
+  })
+);
+var addCommand = new Command8("add").description("Create a domain and print its required DNS records").argument("<name>", "Domain name, e.g. example.com").option("--dkim-selector <selector>", "DKIM selector").option("--json", "Output JSON").action(
+  exitOnError(
+    async (name, opts) => {
+      const domain = await ownerRequest("/domains", {
+        method: "POST",
+        body: JSON.stringify({ name, dkimSelector: opts.dkimSelector })
+      });
+      const records = await ownerRequest(
+        `/domains/${domain.id}/dns-records`
+      );
+      if (opts.json) {
+        console.log(JSON.stringify({ domain, records }, null, 2));
+        return;
+      }
+      console.log(`Created domain: ${domain.name} (${domain.id})`);
+      console.log("\nRequired DNS records:");
+      printRecords(records, "table", false);
+    }
+  )
+);
+var recordsCommand = new Command8("records").description("Print the DNS records a domain requires").argument("<id>", "Domain ID").option("--json", "Output JSON").option("--format <format>", "table | bind", "table").action(
+  exitOnError(
+    async (id, opts) => {
+      const records = await ownerRequest(
+        `/domains/${id}/dns-records`
+      );
+      printRecords(records, opts.format, opts.json === true);
+    }
+  )
+);
+var POLL_INTERVAL_MS2 = 1e4;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var verifyCommand = new Command8("verify").description("Trigger domain verification").argument("<id>", "Domain ID").option("--wait", "Poll until verified or timed out").option("--timeout <seconds>", "Max seconds to wait with --wait", "600").action(
+  exitOnError(
+    async (id, opts) => {
+      const deadline = Date.now() + Number(opts.timeout) * 1e3;
+      for (; ; ) {
+        const domain = await ownerRequest(
+          `/domains/${id}/verify`,
+          { method: "POST" }
+        );
+        console.log(`Domain verification: ${domain.name}`);
+        console.log(`Current status: ${domain.verificationStatus}`);
+        printStatuses(domain);
+        if (!opts.wait || domain.verificationStatus === "verified") return;
+        if (Date.now() + POLL_INTERVAL_MS2 > deadline) {
+          throw new Error(
+            `Timed out after ${opts.timeout}s; not yet verified.`
+          );
+        }
+        await sleep(POLL_INTERVAL_MS2);
+      }
+    }
+  )
+);
+var domainsCommand = new Command8("domains").description("Manage domains").addCommand(listCommand2).addCommand(getCommand2).addCommand(addCommand).addCommand(recordsCommand).addCommand(publishDnsCommand).addCommand(verifyCommand).addCommand(warmupCommand);
+
+// src/commands/inbound.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { Command as Command9 } from "commander";
+
+// src/commands/inbound-check.ts
+import { resolve4, resolveMx } from "dns/promises";
+var INBOUND_HOST = "mail.develemail.com";
+async function checkMx(domain) {
+  const [mx, inbound] = await Promise.all([
+    resolveMx(domain),
+    resolve4(INBOUND_HOST)
+  ]);
+  const checks = await Promise.all(
+    mx.map(async (r) => {
+      const addresses = await resolve4(r.exchange).catch(() => []);
+      return {
+        exchange: r.exchange,
+        priority: r.priority,
+        addresses,
+        pointsAtInbound: addresses.some((a) => inbound.includes(a))
+      };
+    })
+  );
+  return checks.sort((a, b) => a.priority - b.priority);
+}
+
+// src/commands/inbound.ts
+var COL_ADDRESS = 32;
+var COL_ACTIVE = 8;
+var COL_WEBHOOK = 36;
+var COL_NOTIFY = 30;
+function col4(s, w) {
+  return s.slice(0, w).padEnd(w);
+}
+function toAddress(localPart) {
+  return localPart === "*" ? null : localPart;
+}
+function label(address) {
+  return address ?? "*";
+}
+async function resolveDomain(nameOrId) {
+  const domains = await ownerRequest("/domains");
+  const match = domains.find(
+    (d) => d.id === nameOrId || d.name === nameOrId.toLowerCase()
+  );
+  if (!match) throw new Error(`Domain not found: ${nameOrId}`);
+  return match;
+}
+async function findRoute(domain, localPart) {
+  const address = toAddress(localPart.toLowerCase());
+  const routes = await ownerRequest(
+    `/domains/${domain.id}/inbound-routes`
+  );
+  const route = routes.find((r) => r.address === address);
+  if (!route) {
+    throw new Error(`No inbound route for ${label(address)}@${domain.name}`);
+  }
+  return route;
+}
+function noneToNull(value) {
+  return value === "none" ? null : value;
+}
+async function confirm2(question) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    return /^y(es)?$/i.test((await rl.question(question)).trim());
+  } finally {
+    rl.close();
+  }
+}
+var listCommand3 = new Command9("list").description("List inbound routes for a domain").argument("<domain>", "Domain name or ID").option("--json", "Output JSON").action(
+  exitOnError(async (domainArg, opts) => {
+    const domain = await resolveDomain(domainArg);
+    const routes = await ownerRequest(
+      `/domains/${domain.id}/inbound-routes`
+    );
+    if (opts.json) {
+      console.log(JSON.stringify(routes, null, 2));
+      return;
+    }
+    if (routes.length === 0) {
+      console.log(`No inbound routes for ${domain.name}.`);
+      return;
+    }
+    const header = `${col4("ADDRESS", COL_ADDRESS)} ${col4("ACTIVE", COL_ACTIVE)} ${col4("WEBHOOK", COL_WEBHOOK)} ${col4("NOTIFY", COL_NOTIFY)} CREATED`;
+    console.log(header);
+    console.log("-".repeat(header.length + 10));
+    for (const r of routes) {
+      console.log(
+        `${col4(`${label(r.address)}@${domain.name}`, COL_ADDRESS)} ${col4(r.active ? "yes" : "no", COL_ACTIVE)} ${col4(r.webhookUrl ?? "-", COL_WEBHOOK)} ${col4(r.notifyEmail ?? "-", COL_NOTIFY)} ${new Date(r.createdAt).toLocaleDateString()}`
+      );
+    }
+  })
+);
+var addCommand2 = new Command9("add").description("Create an inbound route (use * for a catch-all)").argument("<domain>", "Domain name or ID").argument("<local-part>", "Local part, or * for catch-all").option("--webhook <url>", "Deliver received mail to this webhook").option("--notify <email>", "Send an arrival notification to this address").option("--if-missing", "Exit 0 if the route already exists").action(
+  exitOnError(
+    async (domainArg, localPart, opts) => {
+      const domain = await resolveDomain(domainArg);
+      const address = toAddress(localPart);
+      try {
+        const route = await ownerRequest(
+          `/domains/${domain.id}/inbound-routes`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              address,
+              webhookUrl: opts.webhook ?? null,
+              notifyEmail: opts.notify ?? null
+            })
+          }
+        );
+        console.log(
+          `Created inbound route ${label(address)}@${domain.name} (${route.id})`
+        );
+      } catch (err) {
+        if (opts.ifMissing && err instanceof OwnerApiError && err.status === 409) {
+          console.log(
+            `Inbound route ${label(address)}@${domain.name} already exists`
+          );
+          return;
+        }
+        throw err;
+      }
+    }
+  )
+);
+var updateCommand2 = new Command9("update").description("Update an inbound route").argument("<domain>", "Domain name or ID").argument("<local-part>", "Local part, or * for catch-all").option("--webhook <url|none>", "Set or clear the webhook").option("--notify <email|none>", "Set or clear the notify email").option("--active", "Enable the route").option("--inactive", "Disable the route").action(
+  exitOnError(
+    async (domainArg, localPart, opts) => {
+      if (opts.active && opts.inactive) {
+        throw new Error("Pass only one of --active and --inactive");
+      }
+      const domain = await resolveDomain(domainArg);
+      const route = await findRoute(domain, localPart);
+      const body = {
+        webhookUrl: noneToNull(opts.webhook),
+        notifyEmail: noneToNull(opts.notify),
+        active: opts.active ? true : opts.inactive ? false : void 0
+      };
+      await ownerRequest(
+        `/domains/${domain.id}/inbound-routes/${route.id}`,
+        { method: "PATCH", body: JSON.stringify(body) }
+      );
+      console.log(`Updated ${label(route.address)}@${domain.name}`);
+    }
+  )
+);
+var removeCommand = new Command9("remove").description("Delete an inbound route").argument("<domain>", "Domain name or ID").argument("<local-part>", "Local part, or * for catch-all").option("--yes", "Delete without prompting").action(
+  exitOnError(
+    async (domainArg, localPart, opts) => {
+      const domain = await resolveDomain(domainArg);
+      const route = await findRoute(domain, localPart);
+      const target = `${label(route.address)}@${domain.name}`;
+      const ok = opts.yes || process.stdin.isTTY === true && await confirm2(`Delete inbound route ${target}? [y/N] `);
+      if (!ok) {
+        console.log("Nothing deleted. Re-run with --yes to delete.");
+        return;
+      }
+      await ownerRequest(
+        `/domains/${domain.id}/inbound-routes/${route.id}`,
+        { method: "DELETE" }
+      );
+      console.log(`Deleted ${target}`);
+    }
+  )
+);
+var checkCommand = new Command9("check").description("Show whether a domain MX points at the inbound server").argument("<domain>", "Domain name or ID").option("--json", "Output JSON").action(
+  exitOnError(async (domainArg, opts) => {
+    const ref = await resolveDomain(domainArg);
+    const [domain, mx] = await Promise.all([
+      ownerRequest(`/domains/${ref.id}`),
+      checkMx(ref.name)
+    ]);
+    const ok = mx.some((r) => r.pointsAtInbound);
+    if (opts.json) {
+      console.log(
+        JSON.stringify(
+          { mxStatus: domain.mxStatus ?? null, ok, mx },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(`MX Status: ${domain.mxStatus ?? "\u2014"}`);
+    if (mx.length === 0) console.log("No MX records found.");
+    for (const r of mx) {
+      console.log(
+        `MX ${r.priority} ${r.exchange} -> ${r.addresses.join(", ") || "unresolved"} ${r.pointsAtInbound ? "(inbound server)" : "(not the inbound server)"}`
+      );
+    }
+    console.log(
+      ok ? `OK: mail for ${ref.name} reaches ${INBOUND_HOST}.` : `Mail for ${ref.name} does not reach ${INBOUND_HOST}; point its MX at ${INBOUND_HOST}.`
+    );
+  })
+);
+var inboundCommand = new Command9("inbound").description("Manage inbound mailboxes").addCommand(listCommand3).addCommand(addCommand2).addCommand(updateCommand2).addCommand(removeCommand).addCommand(checkCommand);
+
+// src/commands/cloudflare.ts
+import { Command as Command10 } from "commander";
+var connectCommand = new Command10("connect").description("Connect a Cloudflare API token to your organization").requiredOption(
+  "--token-env <VAR>",
+  "Environment variable holding the Cloudflare API token"
+).action(
+  exitOnError(async (opts) => {
+    const apiToken = process.env[opts.tokenEnv];
+    if (!apiToken) {
+      throw new Error(`Environment variable ${opts.tokenEnv} is not set.`);
+    }
+    await ownerRequest("/cloudflare/connect", {
+      method: "POST",
+      body: JSON.stringify({ apiToken })
+    });
+    console.log("Cloudflare connected.");
+  })
+);
+var statusCommand = new Command10("status").description("Show whether Cloudflare is connected").action(
+  exitOnError(async () => {
+    const { connected } = await ownerRequest(
+      "/cloudflare/status"
+    );
+    console.log(connected ? "Connected" : "Not connected");
+  })
+);
+var zonesCommand = new Command10("zones").description("List Cloudflare zones").option("--json", "Output JSON").action(
+  exitOnError(async (opts) => {
+    const zones = await ownerRequest("/cloudflare/zones");
+    if (opts.json) {
+      console.log(JSON.stringify(zones, null, 2));
+      return;
+    }
+    for (const z of zones) console.log(`${z.id}  ${z.name}  ${z.status}`);
+  })
+);
+var cloudflareCommand = new Command10("cloudflare").description("Manage the Cloudflare integration").addCommand(connectCommand).addCommand(statusCommand).addCommand(zonesCommand);
+
+// src/commands/key.ts
+import { Command as Command11 } from "commander";
 function ownerHeaders2(token) {
   return { Cookie: `session=${token}`, "Content-Type": "application/json" };
 }
@@ -317,7 +971,7 @@ async function apiRequest2(url, token, init) {
   }
   return res.json();
 }
-var listCommand2 = new Command6("list").description("List API keys for a project").requiredOption("--project <id>", "Project ID").action(async (opts) => {
+var listCommand4 = new Command11("list").description("List API keys for a project").requiredOption("--project <id>", "Project ID").action(async (opts) => {
   const { url, token } = loadOwnerSession();
   const keys = await apiRequest2(
     `${url}/projects/${opts.project}/api-keys`,
@@ -332,7 +986,7 @@ var listCommand2 = new Command6("list").description("List API keys for a project
     console.log(`${status} ${k.keyPrefix}\u2026  ${k.name}  (${k.id})`);
   }
 });
-var createCommand2 = new Command6("create").description("Create a new API key for a project").requiredOption("--project <id>", "Project ID").requiredOption("--name <name>", "Key name (e.g. production, ci)").option("--expires <date>", "Expiry date (ISO-8601, e.g. 2027-01-01)").option("--rate-limit <n>", "Max requests per minute").action(
+var createCommand2 = new Command11("create").description("Create a new API key for a project").requiredOption("--project <id>", "Project ID").requiredOption("--name <name>", "Key name (e.g. production, ci)").option("--expires <date>", "Expiry date (ISO-8601, e.g. 2027-01-01)").option("--rate-limit <n>", "Max requests per minute").action(
   async (opts) => {
     const { url, token } = loadOwnerSession();
     const result = await apiRequest2(
@@ -354,10 +1008,10 @@ var createCommand2 = new Command6("create").description("Create a new API key fo
     console.log("Store the secret now \u2014 it will not be shown again.");
   }
 );
-var keyCommand = new Command6("key").description("Manage API keys").addCommand(listCommand2).addCommand(createCommand2);
+var keyCommand = new Command11("key").description("Manage API keys").addCommand(listCommand4).addCommand(createCommand2);
 
 // src/commands/init.ts
-import { Command as Command7 } from "commander";
+import { Command as Command12 } from "commander";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
 function ownerHeaders3(token) {
@@ -387,7 +1041,7 @@ function upsertEnvFile(filePath, vars) {
   const content = lines.join("\n").trimEnd() + (lines.some((l) => l.trim()) ? "\n" : "") + appended + "\n";
   writeFileSync2(filePath, content, "utf-8");
 }
-var initCommand = new Command7("init").description(
+var initCommand = new Command12("init").description(
   "Provision a project + API key and write credentials to an env file"
 ).requiredOption(
   "--project <name>",
@@ -440,14 +1094,29 @@ var initCommand = new Command7("init").description(
   }
 );
 
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function readCliVersion() {
+  return require2("../package.json").version;
+}
+
+// src/program.ts
+function buildProgram() {
+  const program = new Command13().name("devel").description("DevelEmail CLI \u2014 interact with your DevelEmail instance").version(readCliVersion());
+  program.addCommand(loginCommand);
+  program.addCommand(logoutCommand);
+  program.addCommand(projectCommand);
+  program.addCommand(domainsCommand);
+  program.addCommand(inboundCommand);
+  program.addCommand(cloudflareCommand);
+  program.addCommand(keyCommand);
+  program.addCommand(initCommand);
+  program.addCommand(sendCommand);
+  program.addCommand(logsCommand);
+  program.addCommand(tailCommand);
+  return program;
+}
+
 // src/index.ts
-var program = new Command8().name("devel").description("DevelEmail CLI \u2014 interact with your DevelEmail instance").version("0.1.0");
-program.addCommand(loginCommand);
-program.addCommand(logoutCommand);
-program.addCommand(projectCommand);
-program.addCommand(keyCommand);
-program.addCommand(initCommand);
-program.addCommand(sendCommand);
-program.addCommand(logsCommand);
-program.addCommand(tailCommand);
-program.parse(process.argv);
+buildProgram().parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@develemail/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "bin": {
     "devel": "dist/index.js"
@@ -16,7 +16,7 @@
   "dependencies": {
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",
-    "@develemail/sdk": "0.1.1"
+    "@develemail/sdk": "0.4.1"
   },
   "devDependencies": {
     "tsup": "^8.3.5",