posthorn 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,646 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk7 from "chalk";
+
+// src/commands/auth.ts
+import chalk from "chalk";
+import ora from "ora";
+
+// src/config.ts
+import Conf from "conf";
+var defaults = {
+  apiKey: null,
+  apiUrl: "https://api-production-08f2.up.railway.app",
+  userId: null,
+  setupStep: 0,
+  cloudflareConnected: false,
+  workspaceConnected: false,
+  workspaceAccountId: null
+};
+var conf = new Conf({
+  projectName: "outbound-engine",
+  defaults
+});
+function getConfig() {
+  return {
+    apiKey: conf.get("apiKey"),
+    apiUrl: conf.get("apiUrl"),
+    userId: conf.get("userId"),
+    setupStep: conf.get("setupStep"),
+    cloudflareConnected: conf.get("cloudflareConnected"),
+    workspaceConnected: conf.get("workspaceConnected"),
+    workspaceAccountId: conf.get("workspaceAccountId")
+  };
+}
+function setConfig(updates) {
+  for (const [key, value] of Object.entries(updates)) {
+    conf.set(key, value);
+  }
+}
+function resetConfig() {
+  conf.clear();
+}
+function getConfigPath() {
+  return conf.path;
+}
+
+// src/commands/auth.ts
+async function register(options) {
+  const apiUrl = options.url ?? "https://api-production-08f2.up.railway.app";
+  const spinner = ora("Creating account...").start();
+  try {
+    const res = await fetch(`${apiUrl}/api/auth/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      spinner.fail(data.error ?? "Registration failed");
+      return;
+    }
+    setConfig({
+      apiKey: data.api_key,
+      apiUrl,
+      userId: data.user.id,
+      setupStep: 1
+    });
+    spinner.succeed("Account created!");
+    console.log();
+    console.log(`  API Key: ${chalk.cyan(data.api_key)}`);
+    console.log(`  Tier:    ${chalk.yellow(data.user.tier)}`);
+    console.log();
+    console.log(chalk.dim("  Save this API key \u2014 it won't be shown again."));
+    console.log(chalk.dim(`  Config stored at: ${getConfigPath()}`));
+  } catch (err) {
+    spinner.fail(`Could not reach ${apiUrl}`);
+    console.log(chalk.dim(`  Is the server running? Try: posthorn auth register --url <your-api-url>`));
+  }
+}
+async function status() {
+  const config = getConfig();
+  if (!config.apiKey) {
+    console.log(chalk.yellow("Not logged in."));
+    console.log(`  Run: ${chalk.cyan("posthorn auth register")}`);
+    return;
+  }
+  console.log(chalk.bold("Account"));
+  console.log(`  API URL:    ${config.apiUrl}`);
+  console.log(`  API Key:    ${config.apiKey.slice(0, 15)}...`);
+  console.log(`  User ID:    ${config.userId ?? "unknown"}`);
+  console.log(`  Cloudflare: ${config.cloudflareConnected ? chalk.green("connected") : chalk.dim("not connected")}`);
+  console.log(`  Workspace:  ${config.workspaceConnected ? chalk.green("connected") : chalk.dim("not connected")}`);
+  console.log(`  Setup Step: ${config.setupStep}`);
+  console.log();
+  console.log(chalk.dim(`  Config: ${getConfigPath()}`));
+}
+async function logout() {
+  resetConfig();
+  console.log(chalk.green("Logged out. Config cleared."));
+}
+
+// src/commands/accounts.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+
+// src/api.ts
+var ApiError = class extends Error {
+  constructor(statusCode, message, body) {
+    super(message);
+    this.statusCode = statusCode;
+    this.body = body;
+  }
+  statusCode;
+  body;
+};
+async function api(path, options = {}) {
+  const config = getConfig();
+  if (!config.apiKey) {
+    throw new Error("Not logged in. Run: posthorn setup");
+  }
+  const url = `${config.apiUrl}${path}`;
+  const res = await fetch(url, {
+    method: options.method ?? "GET",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    ...options.body && { body: JSON.stringify(options.body) }
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new ApiError(
+      res.status,
+      data.error ?? `Request failed with ${res.status}`,
+      data
+    );
+  }
+  return data;
+}
+
+// src/commands/accounts.ts
+async function connectCloudflare(token, options) {
+  const spinner = ora2("Connecting Cloudflare...").start();
+  const data = await api("/api/accounts", {
+    method: "POST",
+    body: {
+      provider: "cloudflare",
+      label: options.label ?? "main",
+      credentials: { apiToken: token }
+    }
+  });
+  const verify = await api(
+    `/api/accounts/${data.account.id}/verify`,
+    { method: "POST" }
+  );
+  if (verify.valid) {
+    setConfig({ cloudflareConnected: true });
+    spinner.succeed("Cloudflare connected!");
+    console.log(`  Account ID: ${chalk2.dim(data.account.id)}`);
+    if (verify.accountId) console.log(`  CF Account: ${chalk2.dim(verify.accountId)}`);
+  } else {
+    spinner.fail("Cloudflare token is invalid. Check permissions.");
+  }
+}
+async function connectWorkspace(adminEmail) {
+  const spinner = ora2("Connecting Google Workspace...").start();
+  const data = await api("/api/accounts/workspace", {
+    method: "POST",
+    body: { adminEmail }
+  });
+  setConfig({
+    workspaceConnected: true,
+    workspaceAccountId: data.account.id
+  });
+  spinner.succeed(data.message);
+  console.log(`  Customer ID: ${chalk2.dim(data.customerId)}`);
+  console.log(`  Admin:       ${chalk2.dim(data.adminEmail)}`);
+}
+async function listAccounts() {
+  const data = await api("/api/accounts");
+  if (data.accounts.length === 0) {
+    console.log(chalk2.dim("  No connected accounts."));
+    return;
+  }
+  console.log(chalk2.bold("Connected Accounts\n"));
+  for (const a of data.accounts) {
+    const statusColor = a.status === "active" ? chalk2.green : chalk2.red;
+    console.log(`  ${chalk2.cyan(a.provider)}  ${a.label}  ${statusColor(a.status)}  ${chalk2.dim(a.id)}`);
+  }
+}
+
+// src/commands/domains.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+async function listDomains() {
+  const spinner = ora3("Fetching domains...").start();
+  const data = await api("/api/domains");
+  spinner.stop();
+  if (data.domains.length === 0) {
+    console.log(chalk3.dim("  No domains yet. Run: posthorn domains buy <domain>"));
+    return;
+  }
+  console.log(chalk3.bold("Domains\n"));
+  for (const d of data.domains) {
+    const statusColor = d.status === "ready" ? chalk3.green : d.status === "failed" ? chalk3.red : chalk3.yellow;
+    console.log(`  ${chalk3.cyan(d.name)}  ${statusColor(d.status)}  ${chalk3.dim(d.id)}`);
+  }
+}
+async function buyDomain(domain, options) {
+  if (!options.contact) {
+    console.log(chalk3.red("Contact info required for domain purchase."));
+    console.log(chalk3.dim(`  Use: posthorn domains buy example.com --cloudflare <account-id> --contact '{"email":"...","phone":"...","name":"...","street":"...","city":"...","state":"...","postalCode":"...","countryCode":"US"}'`));
+    return;
+  }
+  let contact;
+  try {
+    contact = JSON.parse(options.contact);
+  } catch {
+    console.log(chalk3.red("Invalid contact JSON"));
+    return;
+  }
+  const spinner = ora3(`Purchasing ${domain}...`).start();
+  const data = await api("/api/domains", {
+    method: "POST",
+    body: {
+      name: domain,
+      cloudflareAccountId: options.cloudflare,
+      contact
+    }
+  });
+  spinner.succeed(`Domain purchase started: ${chalk3.cyan(domain)}`);
+  console.log(`  Job ID: ${chalk3.dim(data.jobId)}`);
+  console.log(`  Status: ${chalk3.yellow(data.domain.status)}`);
+  console.log();
+  console.log(chalk3.dim("  DNS records will be configured automatically."));
+  console.log(chalk3.dim(`  Check progress: posthorn domains get ${data.domain.id}`));
+}
+async function connectDomain(domain, options) {
+  const spinner = ora3(`Connecting ${domain}...`).start();
+  const body = {
+    name: domain,
+    cloudflareAccountId: options.cloudflare
+  };
+  if (options.workspace) body.workspaceAccountId = options.workspace;
+  const data = await api("/api/domains/connect", {
+    method: "POST",
+    body
+  });
+  spinner.succeed(data.message);
+  console.log(`  Domain ID: ${chalk3.dim(data.domain.id)}`);
+}
+async function getDomain(domainId) {
+  const data = await api(`/api/domains/${domainId}`);
+  const d = data.domain;
+  console.log(chalk3.bold("Domain\n"));
+  console.log(`  Name:   ${chalk3.cyan(d.name)}`);
+  console.log(`  Status: ${d.status === "ready" ? chalk3.green(d.status) : chalk3.yellow(d.status)}`);
+  console.log(`  ID:     ${chalk3.dim(d.id)}`);
+  if (d.cloudflare_zone_id) console.log(`  Zone:   ${chalk3.dim(d.cloudflare_zone_id)}`);
+}
+async function checkDomains(domains2, options) {
+  const spinner = ora3("Checking availability...").start();
+  const data = await api("/api/domains/check", {
+    method: "POST",
+    body: { domains: domains2, cloudflareAccountId: options.cloudflare }
+  });
+  spinner.stop();
+  console.log(chalk3.bold("Domain Availability\n"));
+  for (const r of data.results) {
+    const icon = r.available ? chalk3.green("  \u2713") : chalk3.red("  \u2717");
+    const price = r.price ? chalk3.dim(`$${r.price}/yr`) : "";
+    console.log(`${icon} ${r.domain}  ${price}`);
+  }
+}
+
+// src/commands/mailboxes.ts
+import chalk4 from "chalk";
+import ora4 from "ora";
+async function listMailboxes(domainId) {
+  const data = await api(
+    `/api/domains/${domainId}/mailboxes`
+  );
+  if (data.mailboxes.length === 0) {
+    console.log(chalk4.dim("  No mailboxes yet."));
+    return;
+  }
+  console.log(chalk4.bold("Mailboxes\n"));
+  for (const m of data.mailboxes) {
+    const statusColor = m.status === "active" ? chalk4.green : chalk4.yellow;
+    console.log(`  ${chalk4.cyan(m.email_address)}  ${statusColor(m.status)}  ${chalk4.dim(m.id)}`);
+  }
+}
+async function createMailbox(domainId, options) {
+  const localPart = options.email.split("@")[0];
+  const spinner = ora4(`Creating ${options.email}...`).start();
+  const data = await api(`/api/domains/${domainId}/mailboxes`, {
+    method: "POST",
+    body: {
+      localPart,
+      firstName: options.first,
+      lastName: options.last
+    }
+  });
+  spinner.succeed(`Mailbox created: ${chalk4.cyan(data.credentials.email)}`);
+  console.log();
+  console.log(`  ${chalk4.bold("Email:")}    ${data.credentials.email}`);
+  console.log(`  ${chalk4.bold("Password:")} ${chalk4.yellow(data.credentials.password)}`);
+  console.log();
+  console.log(chalk4.red("  Save this password now \u2014 it will not be shown again."));
+  console.log(chalk4.dim("  Login at: https://mail.google.com"));
+}
+async function sendEmail(mailboxId, options) {
+  const spinner = ora4("Sending...").start();
+  const data = await api(
+    `/api/mailboxes/${mailboxId}/send`,
+    {
+      method: "POST",
+      body: {
+        to: options.to,
+        subject: options.subject,
+        html: `<p>${options.body}</p>`
+      }
+    }
+  );
+  spinner.succeed("Email sent!");
+  console.log(`  From:       ${chalk4.cyan(data.from)}`);
+  console.log(`  To:         ${data.to}`);
+  console.log(`  Message-ID: ${chalk4.dim(data.messageId)}`);
+}
+async function provisionCredentials(mailboxId, options) {
+  const spinner = ora4("Provisioning credentials...").start();
+  const data = await api(`/api/mailboxes/${mailboxId}/credentials`, {
+    method: "POST",
+    body: { authType: options.type ?? "xoauth2" }
+  });
+  if (data.connectivity.smtp && data.connectivity.imap) {
+    spinner.succeed("Credentials provisioned \u2014 SMTP and IMAP connected!");
+  } else {
+    spinner.warn("Credentials provisioned but connectivity issues:");
+    for (const err of data.connectivity.errors) {
+      console.log(`  ${chalk4.red("!")} ${err}`);
+    }
+  }
+}
+
+// src/commands/warmup.ts
+import chalk5 from "chalk";
+import ora5 from "ora";
+async function startWarmup(mailboxId) {
+  const spinner = ora5("Starting warmup...").start();
+  const data = await api("/api/warmup/campaigns", {
+    method: "POST",
+    body: { mailboxId, autoStart: true }
+  });
+  spinner.succeed("Warmup started!");
+  console.log(`  Campaign ID: ${chalk5.dim(data.campaign.id)}`);
+  console.log(`  Status:      ${chalk5.green("active")}`);
+  console.log(chalk5.dim("  Emails will ramp up gradually over 30 days."));
+}
+async function pauseWarmup(campaignId) {
+  await api(`/api/warmup/campaigns/${campaignId}`, {
+    method: "PATCH",
+    body: { action: "pause" }
+  });
+  console.log(chalk5.yellow("Warmup paused."));
+}
+async function warmupStats(campaignId) {
+  const data = await api(`/api/warmup/campaigns/${campaignId}`);
+  const s = data.stats;
+  const c = data.campaign;
+  console.log(chalk5.bold("Warmup Stats\n"));
+  console.log(`  Mailbox:    ${chalk5.cyan(c.email_address)}`);
+  console.log(`  Status:     ${c.status === "active" ? chalk5.green("active") : chalk5.yellow(c.status)}`);
+  console.log(`  Day:        ${s.currentDay} / 30`);
+  console.log(`  Sent:       ${s.emailsSent}`);
+  console.log(`  Received:   ${s.emailsReceived}`);
+  console.log(`  Spam Saves: ${s.spamRescues}`);
+  console.log(`  Placement:  ${s.inboxPlacementRate !== null ? `${s.inboxPlacementRate}%` : chalk5.dim("n/a")}`);
+  console.log(`  Reputation: ${s.reputationScore}/100`);
+  if (s.dailyBreakdown.length > 0) {
+    console.log(chalk5.bold("\n  Daily Breakdown\n"));
+    console.log(chalk5.dim("  Date          Sent  Inbox  Spam  Replied  Placement"));
+    for (const d of s.dailyBreakdown.slice(-14)) {
+      const date = d.date.slice(0, 10).padEnd(14);
+      const placement = d.placementRate !== null ? `${d.placementRate}%` : "-";
+      console.log(`  ${date}${String(d.sent).padEnd(6)}${String(d.delivered).padEnd(7)}${String(d.spamDetected + d.spamRescued).padEnd(6)}${String(d.replied).padEnd(9)}${placement}`);
+    }
+  }
+}
+async function listCampaigns() {
+  const data = await api("/api/warmup/campaigns");
+  if (data.campaigns.length === 0) {
+    console.log(chalk5.dim("  No warmup campaigns. Run: posthorn warmup start <mailbox-id>"));
+    return;
+  }
+  console.log(chalk5.bold("Warmup Campaigns\n"));
+  for (const c of data.campaigns) {
+    const statusColor = c.status === "active" ? chalk5.green : c.status === "paused" ? chalk5.yellow : chalk5.dim;
+    console.log(
+      `  ${chalk5.cyan(c.email_address)}  ${statusColor(c.status)}  day ${c.current_day}  rep ${c.reputation_score ?? "-"}  ${chalk5.dim(c.id)}`
+    );
+  }
+}
+
+// src/commands/setup.ts
+import chalk6 from "chalk";
+import ora6 from "ora";
+import inquirer from "inquirer";
+var STEPS = [
+  "Account",
+  "Cloudflare",
+  "Google Workspace",
+  "Domain",
+  "DKIM",
+  "Mailboxes",
+  "Warmup"
+];
+function printProgress(currentStep) {
+  console.log();
+  for (let i = 0; i < STEPS.length; i++) {
+    const icon = i < currentStep ? chalk6.green("  \u2713") : i === currentStep ? chalk6.cyan("  \u2192") : chalk6.dim("  \u25CB");
+    const label = i === currentStep ? chalk6.bold(STEPS[i]) : i < currentStep ? STEPS[i] : chalk6.dim(STEPS[i]);
+    console.log(`${icon} Step ${i + 1}: ${label}`);
+  }
+  console.log();
+}
+async function setup(options) {
+  console.log(chalk6.bold("\n  Posthorn Setup\n"));
+  const config = getConfig();
+  let step = config.setupStep;
+  if (step < 1) {
+    printProgress(0);
+    if (!config.apiKey) {
+      await register({ url: options.url });
+    } else {
+      console.log(chalk6.green("  Account already exists."));
+    }
+    setConfig({ setupStep: 1 });
+    step = 1;
+  }
+  if (step < 2) {
+    printProgress(1);
+    if (!config.cloudflareConnected) {
+      const { hasCf } = await inquirer.prompt([
+        { type: "confirm", name: "hasCf", message: "Do you have a Cloudflare account?", default: true }
+      ]);
+      if (!hasCf) {
+        console.log();
+        console.log("  1. Go to " + chalk6.cyan("https://dash.cloudflare.com/sign-up"));
+        console.log("  2. Create a free account");
+        console.log("  3. Add a payment method if you want to purchase domains");
+        console.log();
+        await inquirer.prompt([{ type: "confirm", name: "ready", message: "Ready to continue?" }]);
+      }
+      console.log();
+      console.log("  Create an API token:");
+      console.log("  1. Go to " + chalk6.cyan("https://dash.cloudflare.com/profile/api-tokens"));
+      console.log('  2. Click "Create Token" \u2192 "Create Custom Token"');
+      console.log("  3. Add these permissions:");
+      console.log("     - Account \u2192 Registrar: Domains \u2192 Admin");
+      console.log("     - Account \u2192 Billing \u2192 Edit");
+      console.log("     - Zone \u2192 Zone \u2192 Edit");
+      console.log("     - Zone \u2192 DNS \u2192 Edit");
+      console.log("  4. Account/Zone Resources: Include All");
+      console.log('  5. Click "Continue to summary" \u2192 "Create Token"');
+      console.log();
+      const { token } = await inquirer.prompt([
+        { type: "password", name: "token", message: "Paste your Cloudflare API token:", mask: "*" }
+      ]);
+      await connectCloudflare(token);
+    } else {
+      console.log(chalk6.green("  Cloudflare already connected."));
+    }
+    setConfig({ setupStep: 2 });
+    step = 2;
+  }
+  if (step < 3) {
+    printProgress(2);
+    if (!config.workspaceConnected) {
+      const { hasWs } = await inquirer.prompt([
+        { type: "confirm", name: "hasWs", message: "Do you have a Google Workspace account?", default: true }
+      ]);
+      if (!hasWs) {
+        console.log();
+        console.log("  Set up a new Google Workspace:");
+        console.log("  1. Go to " + chalk6.cyan("https://workspace.google.com") + " \u2192 Get Started");
+        console.log('  2. Enter your business name, select "Just you"');
+        console.log('  3. Click "Set up using your existing domain" and enter your domain');
+        console.log("  4. Create your first email (this will be your outbound email)");
+        console.log("  5. Complete billing setup (14-day free trial available)");
+        console.log();
+        await inquirer.prompt([{ type: "confirm", name: "ready", message: "Done setting up Workspace?" }]);
+      }
+      console.log();
+      console.log("  Set up domain-wide delegation:");
+      console.log("  1. Go to " + chalk6.cyan("admin.google.com") + " \u2192 Security \u2192 API controls");
+      console.log("  2. Click Domain-wide delegation \u2192 Add new");
+      console.log("  3. Client ID: " + chalk6.yellow("110137377718772968374"));
+      console.log("  4. Scopes: " + chalk6.dim("https://mail.google.com/,https://www.googleapis.com/auth/admin.directory.user,https://www.googleapis.com/auth/admin.directory.domain,https://www.googleapis.com/auth/siteverification"));
+      console.log("  5. Click Authorize");
+      console.log();
+      await inquirer.prompt([{ type: "confirm", name: "ready", message: "Done with delegation?" }]);
+      const { adminEmail } = await inquirer.prompt([
+        { type: "input", name: "adminEmail", message: "Your Workspace admin email:" }
+      ]);
+      await connectWorkspace(adminEmail);
+    } else {
+      console.log(chalk6.green("  Google Workspace already connected."));
+    }
+    setConfig({ setupStep: 3 });
+    step = 3;
+  }
+  if (step < 4) {
+    printProgress(3);
+    const { domainChoice } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "domainChoice",
+        message: "Domain setup:",
+        choices: [
+          { name: "Buy a new domain", value: "buy" },
+          { name: "Connect an existing domain (must be on Cloudflare)", value: "connect" },
+          { name: "Skip for now", value: "skip" }
+        ]
+      }
+    ]);
+    if (domainChoice === "connect") {
+      const { domain } = await inquirer.prompt([
+        { type: "input", name: "domain", message: "Domain name:" }
+      ]);
+      const accounts2 = await api("/api/accounts");
+      const cfAccount = accounts2.accounts.find((a) => a.provider === "cloudflare");
+      if (cfAccount) {
+        const spinner = ora6(`Connecting ${domain}...`).start();
+        try {
+          const data = await api("/api/domains/connect", {
+            method: "POST",
+            body: {
+              name: domain,
+              cloudflareAccountId: cfAccount.id,
+              workspaceAccountId: config.workspaceAccountId
+            }
+          });
+          spinner.succeed(data.message);
+        } catch (err) {
+          spinner.fail(err.message);
+          console.log(chalk6.dim("\n  If the domain isn't on Cloudflare yet:"));
+          console.log(chalk6.dim("  1. Go to dash.cloudflare.com \u2192 Add a site \u2192 enter your domain"));
+          console.log(chalk6.dim("  2. Change nameservers at your registrar to Cloudflare's"));
+          console.log(chalk6.dim("  3. Run this setup again\n"));
+        }
+      }
+    } else if (domainChoice === "buy") {
+      console.log(chalk6.dim("\n  Use the domains command to search and buy:"));
+      console.log(chalk6.cyan("  posthorn domains check example.com example.io --cloudflare <id>"));
+      console.log(chalk6.cyan("  posthorn domains buy example.com --cloudflare <id> --contact '{...}'"));
+      console.log();
+    }
+    setConfig({ setupStep: 4 });
+    step = 4;
+  }
+  if (step < 5) {
+    printProgress(4);
+    console.log("  DKIM needs to be set up per domain.");
+    console.log("  If you're using Claude Code, run the setup skill \u2014 it automates DKIM via browser.");
+    console.log("  Otherwise, go to admin.google.com \u2192 Apps \u2192 Gmail \u2192 Authenticate email");
+    console.log();
+    await inquirer.prompt([{ type: "confirm", name: "ready", message: "DKIM set up (or skipping for now)?" }]);
+    setConfig({ setupStep: 5 });
+    step = 5;
+  }
+  if (step < 6) {
+    printProgress(5);
+    console.log("  Create mailboxes with:");
+    console.log(chalk6.cyan("  posthorn mailboxes create <domain-id> --email john@yourdomain.com --first John --last Smith"));
+    console.log();
+    await inquirer.prompt([{ type: "confirm", name: "ready", message: "Mailboxes created (or skipping)?" }]);
+    setConfig({ setupStep: 6 });
+    step = 6;
+  }
+  if (step < 7) {
+    printProgress(6);
+    console.log("  Start warming your mailboxes:");
+    console.log(chalk6.cyan("  posthorn warmup start <mailbox-id>"));
+    console.log(chalk6.cyan("  posthorn warmup stats <campaign-id>"));
+    console.log();
+    await inquirer.prompt([{ type: "confirm", name: "ready", message: "Ready to finish setup?" }]);
+    setConfig({ setupStep: 7 });
+    step = 7;
+  }
+  printProgress(7);
+  console.log(chalk6.bold.green("  Setup complete!\n"));
+  console.log("  Useful commands:");
+  console.log(chalk6.cyan("  posthorn domains list"));
+  console.log(chalk6.cyan("  posthorn mailboxes list <domain-id>"));
+  console.log(chalk6.cyan("  posthorn warmup stats <campaign-id>"));
+  console.log(chalk6.cyan("  posthorn send <mailbox-id> --to user@example.com --subject 'Hi' --body 'Hello!'"));
+  console.log(chalk6.cyan("  posthorn auth status"));
+  console.log();
+}
+
+// src/index.ts
+var program = new Command();
+program.name("posthorn").description("Posthorn \u2014 domain setup, mailbox creation, and email warmup").version("0.1.0");
+program.command("setup").description("Guided setup \u2014 walk through the full onboarding flow").option("--url <url>", "API server URL", "https://api-production-08f2.up.railway.app").action(setup);
+var auth = program.command("auth").description("Account management");
+auth.command("register").description("Create a new account and get an API key").option("--url <url>", "API server URL", "https://api-production-08f2.up.railway.app").action(register);
+auth.command("status").description("Show current account info").action(status);
+auth.command("logout").description("Clear stored credentials").action(logout);
+var accounts = program.command("accounts").description("Connected accounts (Cloudflare, Workspace)");
+accounts.command("list").description("List connected accounts").action(listAccounts);
+accounts.command("cloudflare <token>").description("Connect a Cloudflare account").option("--label <label>", "Account label", "main").action(connectCloudflare);
+accounts.command("workspace <admin-email>").description("Connect Google Workspace via domain-wide delegation").action(connectWorkspace);
+var domains = program.command("domains").description("Domain management");
+domains.command("list").description("List all domains").action(listDomains);
+domains.command("get <domain-id>").description("Get domain details").action(getDomain);
+domains.command("check <domains...>").description("Check domain availability").requiredOption("--cloudflare <account-id>", "Cloudflare account ID").action(checkDomains);
+domains.command("buy <domain>").description("Purchase a domain").requiredOption("--cloudflare <account-id>", "Cloudflare account ID").option("--contact <json>", "Registrant contact info as JSON").action(buyDomain);
+domains.command("connect <domain>").description("Connect an existing domain (must be on Cloudflare)").requiredOption("--cloudflare <account-id>", "Cloudflare account ID").option("--workspace <account-id>", "Workspace account ID").action(connectDomain);
+var mailboxes = program.command("mailboxes").description("Mailbox management");
+mailboxes.command("list <domain-id>").description("List mailboxes for a domain").action(listMailboxes);
+mailboxes.command("create <domain-id>").description("Create a new mailbox").requiredOption("--email <email>", "Email address (e.g. john@example.com)").requiredOption("--first <name>", "First name").requiredOption("--last <name>", "Last name").action(createMailbox);
+mailboxes.command("credentials <mailbox-id>").description("Provision IMAP/SMTP credentials for a mailbox").option("--type <type>", "Auth type: xoauth2 or password", "xoauth2").action(provisionCredentials);
+program.command("send <mailbox-id>").description("Send an email").requiredOption("--to <email>", "Recipient email").requiredOption("--subject <subject>", "Email subject").requiredOption("--body <body>", "Email body (plain text)").action(sendEmail);
+var warmup = program.command("warmup").description("Email warmup management");
+warmup.command("list").description("List warmup campaigns").action(listCampaigns);
+warmup.command("start <mailbox-id>").description("Start warming a mailbox").action(startWarmup);
+warmup.command("pause <campaign-id>").description("Pause a warmup campaign").action(pauseWarmup);
+warmup.command("stats <campaign-id>").description("Show warmup stats and daily breakdown").action(warmupStats);
+program.hook("preAction", () => {
+});
+program.parseAsync(process.argv).catch((err) => {
+  if (err.statusCode === 401) {
+    console.log(chalk7.red("\n  Authentication failed. Run: posthorn auth register\n"));
+  } else if (err.statusCode === 403) {
+    console.log(chalk7.red("\n  Account not verified. Complete onboarding: posthorn setup\n"));
+  } else if (err.statusCode === 429) {
+    console.log(chalk7.yellow("\n  Rate limit exceeded. Try again in a minute.\n"));
+  } else {
+    console.error(chalk7.red(`
+  Error: ${err.message}
+`));
+  }
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "posthorn",
+  "version": "0.1.0",
+  "description": "Posthorn — domain setup, mailbox creation, and email warmup from the command line",
+  "type": "module",
+  "bin": {
+    "posthorn": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "email",
+    "warmup",
+    "cold-email",
+    "deliverability",
+    "smtp",
+    "outbound",
+    "cli"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^13.0.0",
+    "chalk": "^5.4.0",
+    "ora": "^8.2.0",
+    "inquirer": "^12.0.0",
+    "conf": "^13.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "@types/node": "^22.0.0"
+  }
+}