@hogsend/cli 0.2.3 → 0.7.0

package/dist/bin.js

@@ -3,7 +3,7 @@
 // src/bin.ts
 import { createRequire as createRequire3 } from "module";
 
-// src/commands/contacts.ts
+// src/commands/campaigns.ts
 import { parseArgs } from "util";
 
 // src/lib/http.ts
@@ -33,53 +33,81 @@ function bodyMessage(status, body) {
   }
   return `request failed with status ${status}`;
 }
-function createAdminClient(cfg) {
-  async function request(method, path, opts) {
-    if (opts.auth && !cfg.adminKey) {
-      throw makeHttpError(
-        "no admin key configured \u2014 pass --admin-key, or set HOGSEND_ADMIN_KEY / ADMIN_API_KEY",
-        0,
-        void 0
-      );
-    }
-    const headers = { Accept: "application/json" };
-    if (opts.auth && cfg.adminKey) {
-      headers.Authorization = `Bearer ${cfg.adminKey}`;
-    }
-    if (opts.body !== void 0) {
-      headers["Content-Type"] = "application/json";
-    }
-    const url = buildUrl(cfg.baseUrl, path, opts.query);
-    let res;
+async function request(baseUrl, key, missingKeyMessage, method, path, opts) {
+  if (opts.auth && !key) {
+    throw makeHttpError(missingKeyMessage, 0, void 0);
+  }
+  const headers = { Accept: "application/json" };
+  if (opts.auth && key) {
+    headers.Authorization = `Bearer ${key}`;
+  }
+  if (opts.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  const url = buildUrl(baseUrl, path, opts.query);
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    });
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw makeHttpError(`cannot reach ${baseUrl} (${msg})`, 0, void 0);
+  }
+  const text = await res.text();
+  let parsed;
+  if (text.length > 0) {
     try {
-      res = await fetch(url, {
-        method,
-        headers,
-        body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
-      });
-    } catch (cause) {
-      const msg = cause instanceof Error ? cause.message : String(cause);
-      throw makeHttpError(`cannot reach ${cfg.baseUrl} (${msg})`, 0, void 0);
-    }
-    const text = await res.text();
-    let parsed;
-    if (text.length > 0) {
-      try {
-        parsed = JSON.parse(text);
-      } catch {
-        parsed = text;
-      }
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = text;
     }
-    if (!res.ok) {
-      throw makeHttpError(bodyMessage(res.status, parsed), res.status, parsed);
-    }
-    return parsed;
   }
+  if (!res.ok) {
+    throw makeHttpError(bodyMessage(res.status, parsed), res.status, parsed);
+  }
+  return parsed;
+}
+function createAdminClient(cfg) {
+  const missing = "no admin key configured \u2014 pass --admin-key, or set HOGSEND_ADMIN_KEY / ADMIN_API_KEY";
+  return {
+    cfg,
+    get: (path, query, extras) => request(cfg.baseUrl, cfg.adminKey, missing, "GET", path, {
+      query,
+      auth: extras?.auth ?? true
+    }),
+    patch: (path, body) => request(cfg.baseUrl, cfg.adminKey, missing, "PATCH", path, {
+      body,
+      auth: true
+    }),
+    post: (path, body) => request(cfg.baseUrl, cfg.adminKey, missing, "POST", path, {
+      body,
+      auth: true
+    })
+  };
+}
+function createDataPlaneClient(cfg) {
+  const missing = "no data key configured \u2014 pass --data-key, or set HOGSEND_DATA_KEY / HOGSEND_API_KEY";
   return {
     cfg,
-    get: (path, query, extras) => request("GET", path, { query, auth: extras?.auth ?? true }),
-    patch: (path, body) => request("PATCH", path, { body, auth: true }),
-    post: (path, body) => request("POST", path, { body, auth: true })
+    get: (path, query) => request(cfg.baseUrl, cfg.dataKey, missing, "GET", path, {
+      query,
+      auth: true
+    }),
+    post: (path, body) => request(cfg.baseUrl, cfg.dataKey, missing, "POST", path, {
+      body,
+      auth: true
+    }),
+    put: (path, body) => request(cfg.baseUrl, cfg.dataKey, missing, "PUT", path, {
+      body,
+      auth: true
+    }),
+    del: (path, body) => request(cfg.baseUrl, cfg.dataKey, missing, "DELETE", path, {
+      body,
+      auth: true
+    })
   };
 }
 
@@ -198,15 +226,249 @@ ${title}`);
   };
 }
 
+// src/commands/campaigns.ts
+var usage = `hogsend campaigns <subcommand> [options]
+
+Queue and inspect broadcasts: durably send one email template to every
+subscribed member of a list (or every active member of a bucket). Wraps the
+data-plane campaigns routes (POST /v1/campaigns, GET /v1/campaigns/{id}).
+
+Subcommands:
+  send                  Queue a campaign. Sends run async in the worker.
+  status <id>           Show a campaign's status + send counts.
+
+send options (exactly one of --list / --bucket, plus --template, required):
+  --list <id>           Target every subscribed member of this list.
+  --bucket <id>         Target every active member of this bucket.
+  --template <key>      Email template to send.
+  --prop <key=value>    Template prop; repeatable. Value parsed as JSON, falling
+                        back to a string.
+  --props <json>        Template props as one JSON object (merged with --prop).
+  --name <text>         Human label for the campaign.
+  --from <addr>         Override the default From address.
+  --subject <text>      Override the rendered subject.
+
+Global options (handled by the router): --url, --admin-key, --data-key, --json,
+-h/--help.
+
+Examples:
+  hogsend campaigns send --list newsletter --template june-update --name "June"
+  hogsend campaigns send --bucket power-users --template feature-launch --json
+  hogsend campaigns status cmp_123 --json`;
+var badge = `${color.bgMagenta(color.black(" hogsend "))} campaigns`;
+function parseProps(ctx, propsJson, propPairs) {
+  const out = {};
+  let any = false;
+  if (propsJson !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(propsJson);
+    } catch {
+      ctx.out.fail(`--props must be valid JSON, got: ${propsJson}`);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      ctx.out.fail("--props must be a JSON object");
+    }
+    Object.assign(out, parsed);
+    any = true;
+  }
+  for (const pair of propPairs ?? []) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) {
+      ctx.out.fail(`--prop must be key=value, got: ${pair}`);
+    }
+    const key = pair.slice(0, eq).trim();
+    if (key === "") {
+      ctx.out.fail(`--prop key cannot be empty, got: ${pair}`);
+    }
+    out[key] = coerceValue(pair.slice(eq + 1));
+    any = true;
+  }
+  return any ? out : void 0;
+}
+function coerceValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function statusColor(status) {
+  switch (status) {
+    case "sent":
+      return color.green(status);
+    case "queued":
+    case "sending":
+      return color.cyan(status);
+    default:
+      return color.red(status);
+  }
+}
+async function runSend(ctx, argv) {
+  const { values } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      list: { type: "string" },
+      bucket: { type: "string" },
+      template: { type: "string" },
+      prop: { type: "string", multiple: true },
+      props: { type: "string" },
+      name: { type: "string" },
+      from: { type: "string" },
+      subject: { type: "string" },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    ctx.out.log(usage);
+    return;
+  }
+  const list = values.list;
+  const bucket = values.bucket;
+  if (list && bucket || !list && !bucket) {
+    ctx.out.fail("campaigns send requires exactly one of --list or --bucket");
+  }
+  const template = values.template;
+  if (!template) {
+    ctx.out.fail(
+      "campaigns send requires --template, e.g. hogsend campaigns send --list newsletter --template welcome"
+    );
+  }
+  const props = parseProps(ctx, values.props, values.prop);
+  const body = { template };
+  if (list) body.list = list;
+  if (bucket) body.bucket = bucket;
+  if (props) body.props = props;
+  if (values.name) body.name = values.name;
+  if (values.from) body.from = values.from;
+  if (values.subject) body.subject = values.subject;
+  let res;
+  try {
+    res = await ctx.out.step(
+      `Queuing campaign ${template}`,
+      () => ctx.dataHttp.post("/v1/campaigns", body)
+    );
+  } catch (error) {
+    if (isHttpError(error)) {
+      ctx.out.fail(error.message);
+    }
+    throw error;
+  }
+  if (ctx.json) {
+    ctx.out.json(res);
+    return;
+  }
+  ctx.out.intro(`${badge} send`);
+  ctx.out.kv(
+    {
+      campaignId: res.campaignId,
+      template,
+      audience: list ? `list:${list}` : `bucket:${bucket}`,
+      status: statusColor(res.status)
+    },
+    "Campaign queued"
+  );
+  ctx.out.outro(
+    `${color.green("Queued")} \u2014 poll ${color.cyan(`hogsend campaigns status ${res.campaignId}`)} for progress.`
+  );
+}
+async function runStatus(ctx, argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    ctx.out.log(usage);
+    return;
+  }
+  const id = positionals[0];
+  if (!id) {
+    ctx.out.fail(
+      "campaigns status requires a campaign id, e.g. hogsend campaigns status cmp_123"
+    );
+  }
+  let res;
+  try {
+    res = await ctx.out.step(
+      `Fetching campaign ${id}`,
+      () => ctx.dataHttp.get(
+        `/v1/campaigns/${encodeURIComponent(id)}`
+      )
+    );
+  } catch (error) {
+    if (isHttpError(error)) {
+      ctx.out.fail(error.message);
+    }
+    throw error;
+  }
+  if (ctx.json) {
+    ctx.out.json(res);
+    return;
+  }
+  ctx.out.intro(`${badge} status`);
+  ctx.out.kv(
+    {
+      id: res.id,
+      name: res.name,
+      status: statusColor(res.status),
+      audience: `${res.audienceKind}:${res.audienceId}`,
+      template: res.templateKey,
+      recipients: res.totalRecipients,
+      sent: color.green(String(res.sentCount)),
+      skipped: color.yellow(String(res.skippedCount)),
+      failed: res.failedCount > 0 ? color.red(String(res.failedCount)) : String(res.failedCount),
+      startedAt: res.startedAt ?? "",
+      completedAt: res.completedAt ?? ""
+    },
+    "Campaign"
+  );
+  ctx.out.outro(
+    `${res.name} \u2192 ${statusColor(res.status)} ` + color.dim(
+      `(${res.sentCount}/${res.totalRecipients} sent, ${res.skippedCount} skipped, ${res.failedCount} failed)`
+    )
+  );
+}
+async function run(ctx) {
+  const sub = ctx.argv[0];
+  switch (sub) {
+    case "send":
+      return runSend(ctx, ctx.argv.slice(1));
+    case "status":
+      return runStatus(ctx, ctx.argv.slice(1));
+    case void 0:
+      ctx.out.fail(
+        "campaigns requires a subcommand: send | status (see hogsend campaigns --help)"
+      );
+      break;
+    default:
+      ctx.out.fail(
+        `unknown campaigns subcommand "${sub}" \u2014 expected send or status`
+      );
+  }
+}
+var campaignsCommand = {
+  name: "campaigns",
+  summary: "Queue a broadcast to a list/bucket, or check its status",
+  usage,
+  run
+};
+
 // src/commands/contacts.ts
-var usage = `hogsend contacts <subcommand> [options]
+import { parseArgs as parseArgs2 } from "util";
+var usage2 = `hogsend contacts <subcommand> [options]
 
-Inspect contacts via the running app's admin API (/v1/admin/contacts).
+Inspect contacts via the admin API (/v1/admin/contacts) and upsert them via the
+data plane (PUT /v1/contacts).
 
 Subcommands:
   list                  List contacts (newest activity first).
   get <id>              Get one contact (by id or externalId) + preferences.
   timeline <id>        Merged event/email/journey activity for a contact.
+  upsert                Create or update a contact (PUT /v1/contacts).
 
 list options:
   --search <q>          Filter by email/externalId substring.
@@ -218,13 +480,76 @@ timeline options:
   --limit <n>           Page size (1-100, default 50).
   --offset <n>          Page offset (default 0).
 
-Global options (handled by the router): --url, --admin-key, --json, -h/--help.
+upsert options (at least one of --email / --user-id required):
+  --email <addr>        Contact email (a resolvable identity key).
+  --user-id <id>        External (distinct) id.
+  --prop <key=value>    Contact property; repeatable. Value parsed as JSON,
+                        falling back to a string. Uses the data plane (ingest key).
+  --props <json>        Contact properties as one JSON object (merged with --prop).
+  --list <id>           Subscribe to a list; repeatable.
+  --unlist <id>         Unsubscribe from a list; repeatable.
+
+Global options (handled by the router): --url, --admin-key, --data-key, --json,
+-h/--help.
 
 Examples:
   hogsend contacts list --search acme@ --json
   hogsend contacts get user_123
-  hogsend contacts timeline user_123 --type email --json`;
-var badge = `${color.bgMagenta(color.black(" hogsend "))} contacts`;
+  hogsend contacts timeline user_123 --type email --json
+  hogsend contacts upsert --email a@b.com --user-id user_123 --prop plan=pro
+  hogsend contacts upsert --user-id user_123 --props '{"plan":"pro","seats":5}'`;
+var badge2 = `${color.bgMagenta(color.black(" hogsend "))} contacts`;
+function parseProps2(ctx, propsJson, propPairs) {
+  const out = {};
+  let any = false;
+  if (propsJson !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(propsJson);
+    } catch {
+      ctx.out.fail(`--props must be valid JSON, got: ${propsJson}`);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      ctx.out.fail("--props must be a JSON object");
+    }
+    Object.assign(out, parsed);
+    any = true;
+  }
+  for (const pair of propPairs ?? []) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) {
+      ctx.out.fail(`--prop must be key=value, got: ${pair}`);
+    }
+    const key = pair.slice(0, eq).trim();
+    if (key === "") {
+      ctx.out.fail(`--prop key cannot be empty, got: ${pair}`);
+    }
+    const raw = pair.slice(eq + 1);
+    out[key] = coerceValue2(raw);
+    any = true;
+  }
+  return any ? out : void 0;
+}
+function coerceValue2(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseLists(subscribe, unsubscribe) {
+  const out = {};
+  let any = false;
+  for (const id of subscribe ?? []) {
+    out[id] = true;
+    any = true;
+  }
+  for (const id of unsubscribe ?? []) {
+    out[id] = false;
+    any = true;
+  }
+  return any ? out : void 0;
+}
 async function fetchOrFail(ctx, label, fn) {
   try {
     return await ctx.out.step(label, fn);
@@ -239,7 +564,7 @@ async function fetchOrFail(ctx, label, fn) {
   }
 }
 async function runList(ctx, argv) {
-  const { values } = parseArgs({
+  const { values } = parseArgs2({
     args: argv,
     allowPositionals: true,
     options: {
@@ -250,7 +575,7 @@ async function runList(ctx, argv) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage);
+    ctx.out.log(usage2);
     return;
   }
   const query = {
@@ -258,7 +583,7 @@ async function runList(ctx, argv) {
     limit: values.limit,
     offset: values.offset
   };
-  if (!ctx.json) ctx.out.intro(`${badge} list`);
+  if (!ctx.json) ctx.out.intro(`${badge2} list`);
   const res = await fetchOrFail(
     ctx,
     "Fetching contacts",
@@ -282,7 +607,7 @@ async function runList(ctx, argv) {
   );
 }
 async function runGet(ctx, argv) {
-  const { values, positionals } = parseArgs({
+  const { values, positionals } = parseArgs2({
     args: argv,
     allowPositionals: true,
     options: {
@@ -290,7 +615,7 @@ async function runGet(ctx, argv) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage);
+    ctx.out.log(usage2);
     return;
   }
   const id = positionals[1];
@@ -299,7 +624,7 @@ async function runGet(ctx, argv) {
       "contacts get requires an id, e.g. hogsend contacts get user_123"
     );
   }
-  if (!ctx.json) ctx.out.intro(`${badge} get`);
+  if (!ctx.json) ctx.out.intro(`${badge2} get`);
   const res = await fetchOrFail(
     ctx,
     "Fetching contact",
@@ -337,7 +662,7 @@ async function runGet(ctx, argv) {
   ctx.out.outro(`Contact ${color.cyan(contact.externalId)}`);
 }
 async function runTimeline(ctx, argv) {
-  const { values, positionals } = parseArgs({
+  const { values, positionals } = parseArgs2({
     args: argv,
     allowPositionals: true,
     options: {
@@ -348,7 +673,7 @@ async function runTimeline(ctx, argv) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage);
+    ctx.out.log(usage2);
     return;
   }
   const id = positionals[1];
@@ -365,7 +690,7 @@ async function runTimeline(ctx, argv) {
     limit: values.limit,
     offset: values.offset
   };
-  if (!ctx.json) ctx.out.intro(`${badge} timeline`);
+  if (!ctx.json) ctx.out.intro(`${badge2} timeline`);
   const res = await fetchOrFail(
     ctx,
     "Fetching timeline",
@@ -401,7 +726,62 @@ function summarizeTimelineEntry(entry) {
   const subject = d.subject ? String(d.subject) : String(d.templateKey ?? "");
   return `${subject} [${String(d.status ?? "")}]`;
 }
-async function run(ctx) {
+async function runUpsert(ctx, argv) {
+  const { values } = parseArgs2({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      email: { type: "string" },
+      "user-id": { type: "string" },
+      prop: { type: "string", multiple: true },
+      props: { type: "string" },
+      list: { type: "string", multiple: true },
+      unlist: { type: "string", multiple: true },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    ctx.out.log(usage2);
+    return;
+  }
+  const email = values.email;
+  const userId = values["user-id"];
+  if (!email && !userId) {
+    ctx.out.fail(
+      "contacts upsert requires at least one of --email or --user-id"
+    );
+  }
+  const properties = parseProps2(ctx, values.props, values.prop);
+  const lists = parseLists(values.list, values.unlist);
+  const body = {};
+  if (email) body.email = email;
+  if (userId) body.userId = userId;
+  if (properties) body.properties = properties;
+  if (lists) body.lists = lists;
+  if (!ctx.json) ctx.out.intro(`${badge2} upsert`);
+  const res = await fetchOrFail(
+    ctx,
+    "Upserting contact",
+    () => ctx.dataHttp.put("/v1/contacts", body)
+  );
+  if (ctx.json) {
+    ctx.out.json(res);
+    return;
+  }
+  ctx.out.kv(
+    {
+      id: res.id,
+      created: res.created,
+      linked: res.linked,
+      email: email ?? color.dim("(none)"),
+      userId: userId ?? color.dim("(none)")
+    },
+    "Contact"
+  );
+  const verb = res.created ? "created" : "updated";
+  ctx.out.outro(`Contact ${color.cyan(res.id)} ${verb}.`);
+}
+async function run2(ctx) {
   const sub = ctx.argv[0];
   switch (sub) {
     case "list":
@@ -410,26 +790,28 @@ async function run(ctx) {
       return runGet(ctx, ctx.argv);
     case "timeline":
       return runTimeline(ctx, ctx.argv);
+    case "upsert":
+      return runUpsert(ctx, ctx.argv.slice(1));
     case void 0:
       ctx.out.fail(
-        "contacts requires a subcommand: list, get, or timeline (see hogsend contacts --help)"
+        "contacts requires a subcommand: list, get, timeline, or upsert (see hogsend contacts --help)"
       );
       break;
     default:
       ctx.out.fail(
-        `unknown contacts subcommand "${sub}" \u2014 expected list, get, or timeline`
+        `unknown contacts subcommand "${sub}" \u2014 expected list, get, timeline, or upsert`
       );
   }
 }
 var contactsCommand = {
   name: "contacts",
-  summary: "List, inspect, and trace contact activity",
-  usage,
-  run
+  summary: "List, inspect, trace, and upsert contacts",
+  usage: usage2,
+  run: run2
 };
 
 // src/commands/doctor.ts
-import { parseArgs as parseArgs2 } from "util";
+import { parseArgs as parseArgs3 } from "util";
 
 // src/lib/skills.ts
 import {
@@ -561,7 +943,7 @@ function skillsNudge(ctx) {
     "Skills out of date"
   );
 }
-var usage2 = `hogsend doctor [--url <baseUrl>] [--admin-key <key>] [--json]
+var usage3 = `hogsend doctor [--url <baseUrl>] [--admin-key <key>] [--json]
 
 Probe a running Hogsend instance via GET /v1/health and report its health:
 component status (database, redis), two-track schema state (engine + client),
@@ -603,8 +985,8 @@ function trackLine(name, track) {
   const required = track.required ?? color.dim("none");
   return `${color.bold(name.padEnd(7))} applied ${applied} -> required ${required}  ${sync}`;
 }
-async function run2(ctx) {
-  const { values } = parseArgs2({
+async function run3(ctx) {
+  const { values } = parseArgs3({
     args: ctx.argv,
     allowPositionals: true,
     options: {
@@ -614,7 +996,7 @@ async function run2(ctx) {
     strict: false
   });
   if (values.help) {
-    ctx.out.log(usage2);
+    ctx.out.log(usage3);
     return;
   }
   const { baseUrl } = ctx.http.cfg;
@@ -675,8 +1057,8 @@ async function run2(ctx) {
     if (!ok) process.exit(1);
     return;
   }
-  const badge3 = `${color.bgMagenta(color.black(" hogsend "))} doctor`;
-  ctx.out.intro(badge3);
+  const badge5 = `${color.bgMagenta(color.black(" hogsend "))} doctor`;
+  ctx.out.intro(badge5);
   const verdictColor = verdict === "ok" ? color.green : verdict === "degraded" ? color.red : color.yellow;
   const lines = [
     `${verdictColor("\u25CF")} ${color.bold(verdict)}`,
@@ -704,15 +1086,15 @@ async function run2(ctx) {
 var doctorCommand = {
   name: "doctor",
   summary: "Probe a running instance's health (GET /v1/health)",
-  usage: usage2,
-  run: run2
+  usage: usage3,
+  run: run3
 };
 
 // src/commands/eject.ts
 import { existsSync as existsSync3, realpathSync } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { dirname, join as join3, sep as sep2 } from "path";
-import { parseArgs as parseArgs3 } from "util";
+import { parseArgs as parseArgs4 } from "util";
 
 // src/eject.ts
 import { existsSync as existsSync2 } from "fs";
@@ -826,7 +1208,7 @@ async function countFiles(dir) {
 }
 
 // src/commands/eject.ts
-var usage3 = `hogsend eject <package> [--force] [--cwd <dir>]
+var usage4 = `hogsend eject <package> [--force] [--cwd <dir>]
 
 Copy a @hogsend/* package's source into vendor/<name> and rewrite the consumer
 dependency to file:./vendor/<name>. Every other dependency keeps upgrading.
@@ -854,8 +1236,8 @@ function resolveSourceDir(pkg, consumerRoot) {
   }
   return null;
 }
-async function run3(ctx) {
-  const { values, positionals } = parseArgs3({
+async function run4(ctx) {
+  const { values, positionals } = parseArgs4({
     args: ctx.argv,
     allowPositionals: true,
     options: {
@@ -865,7 +1247,7 @@ async function run3(ctx) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage3);
+    ctx.out.log(usage4);
     return;
   }
   const pkg = positionals[0];
@@ -909,36 +1291,242 @@ async function run3(ctx) {
 var ejectCommand = {
   name: "eject",
   summary: "Vendor a @hogsend/* package into vendor/<name>",
-  usage: usage3,
-  run: run3
+  usage: usage4,
+  run: run4
 };
 
-// src/commands/events.ts
-import { parseArgs as parseArgs4 } from "util";
-var usage4 = `hogsend events <userId> [options]
+// src/commands/emails.ts
+import { parseArgs as parseArgs5 } from "util";
+var usage5 = `hogsend emails <subcommand> [options]
 
-Stream the event history for a single user, newest first. Wraps
-GET /v1/admin/events?userId=<userId>.
+Send a transactional email through the data plane (POST /v1/emails). The send
+runs through the full preferences + tracking pipeline (link-click + open).
 
-Arguments:
-  <userId>            The user (distinct) id to fetch events for. Required.
+Subcommands:
+  send <template>       Send the named template to a recipient.
+
+send options (at least one of --to / --user-id required):
+  --to <addr>           Recipient email address.
+  --user-id <id>        External (distinct) id; the recipient email is resolved
+                        from the contact (404 if it has no resolvable email).
+  --prop <key=value>    Template prop; repeatable. Value parsed as JSON, falling
+                        back to a string.
+  --props <json>        Template props as one JSON object (merged with --prop).
+  --from <addr>         Override the default From address.
+  --subject <text>      Override the rendered subject.
+  --reply-to <addr>     Set the Reply-To address.
+  --category <key>      Preference category / list id to gate the send on.
+  --skip-preference-check  Bypass unsubscribe/suppression (requires full-admin).
+  --idempotency-key <k> Dedup key.
+
+Global options (handled by the router): --url, --admin-key, --data-key, --json,
+-h/--help.
 
-Options:
-  --event <name>      Filter to a single event name.
-  --from <iso>        Only events at/after this ISO-8601 timestamp.
-  --to <iso>          Only events at/before this ISO-8601 timestamp.
-  --limit <n>         Max events to return (1-100, default 50).
-  --offset <n>        Pagination offset (default 0).
-  --json              Emit machine-readable JSON only.
-  -h, --help          Show this help.
+Examples:
+  hogsend emails send welcome --to a@b.com --prop name=Ada
+  hogsend emails send welcome --user-id user_123 --props '{"name":"Ada"}' --json`;
+var badge3 = `${color.bgMagenta(color.black(" hogsend "))} emails`;
+function parseProps3(ctx, propsJson, propPairs) {
+  const out = {};
+  let any = false;
+  if (propsJson !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(propsJson);
+    } catch {
+      ctx.out.fail(`--props must be valid JSON, got: ${propsJson}`);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      ctx.out.fail("--props must be a JSON object");
+    }
+    Object.assign(out, parsed);
+    any = true;
+  }
+  for (const pair of propPairs ?? []) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) {
+      ctx.out.fail(`--prop must be key=value, got: ${pair}`);
+    }
+    const key = pair.slice(0, eq).trim();
+    if (key === "") {
+      ctx.out.fail(`--prop key cannot be empty, got: ${pair}`);
+    }
+    out[key] = coerceValue3(pair.slice(eq + 1));
+    any = true;
+  }
+  return any ? out : void 0;
+}
+function coerceValue3(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function statusColor2(status) {
+  switch (status) {
+    case "queued":
+    case "sent":
+      return color.green(status);
+    case "skipped":
+      return color.dim(status);
+    default:
+      return color.yellow(status);
+  }
+}
+async function runSend2(ctx, argv) {
+  const { values, positionals } = parseArgs5({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      to: { type: "string" },
+      "user-id": { type: "string" },
+      prop: { type: "string", multiple: true },
+      props: { type: "string" },
+      from: { type: "string" },
+      subject: { type: "string" },
+      "reply-to": { type: "string" },
+      category: { type: "string" },
+      "skip-preference-check": { type: "boolean", default: false },
+      "idempotency-key": { type: "string" },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    ctx.out.log(usage5);
+    return;
+  }
+  const template = positionals[0];
+  if (!template) {
+    ctx.out.fail(
+      "emails send requires a template, e.g. hogsend emails send welcome --to a@b.com"
+    );
+  }
+  const to = values.to;
+  const userId = values["user-id"];
+  if (!to && !userId) {
+    ctx.out.fail("emails send requires at least one of --to or --user-id");
+  }
+  const props = parseProps3(ctx, values.props, values.prop);
+  const body = { template };
+  if (to) body.to = to;
+  if (userId) body.userId = userId;
+  if (props) body.props = props;
+  if (values.from) body.from = values.from;
+  if (values.subject) body.subject = values.subject;
+  if (values["reply-to"]) body.replyTo = values["reply-to"];
+  if (values.category) body.category = values.category;
+  if (values["skip-preference-check"]) body.skipPreferenceCheck = true;
+  if (values["idempotency-key"]) {
+    body.idempotencyKey = values["idempotency-key"];
+  }
+  let res;
+  try {
+    res = await ctx.out.step(
+      `Sending ${template}`,
+      () => ctx.dataHttp.post("/v1/emails", body)
+    );
+  } catch (error) {
+    if (isHttpError(error)) {
+      ctx.out.fail(error.message);
+    }
+    throw error;
+  }
+  if (ctx.json) {
+    ctx.out.json(res);
+    return;
+  }
+  ctx.out.intro(`${badge3} send`);
+  ctx.out.kv(
+    {
+      emailSendId: res.emailSendId,
+      template,
+      recipient: to ?? userId ?? "",
+      status: statusColor2(res.status),
+      reason: res.reason ?? ""
+    },
+    "Email send"
+  );
+  ctx.out.outro(`${template} \u2192 ${statusColor2(res.status)}.`);
+}
+async function run5(ctx) {
+  const sub = ctx.argv[0];
+  switch (sub) {
+    case "send":
+      return runSend2(ctx, ctx.argv.slice(1));
+    case void 0:
+      ctx.out.fail(
+        "emails requires a subcommand: send (see hogsend emails --help)"
+      );
+      break;
+    default:
+      ctx.out.fail(`unknown emails subcommand "${sub}" \u2014 expected send`);
+  }
+}
+var emailsCommand = {
+  name: "emails",
+  summary: "Send a transactional email through the data plane",
+  usage: usage5,
+  run: run5
+};
+
+// src/commands/events.ts
+import { parseArgs as parseArgs6 } from "util";
+var usage6 = `hogsend events <userId> [options]
+hogsend events send <name> [options]
+
+Read a single user's event history (admin API), or send an event into the data
+plane to drive journeys/buckets.
+
+Read mode \u2014 hogsend events <userId>:
+  Stream the event history for a single user, newest first. Wraps
+  GET /v1/admin/events?userId=<userId>.
+
+  Arguments:
+    <userId>          The user (distinct) id to fetch events for. Required.
+
+  Options:
+    --event <name>    Filter to a single event name.
+    --from <iso>      Only events at/after this ISO-8601 timestamp.
+    --to <iso>        Only events at/before this ISO-8601 timestamp.
+    --limit <n>       Max events to return (1-100, default 50).
+    --offset <n>      Pagination offset (default 0).
+
+Send mode \u2014 hogsend events send <name>:
+  Push an event into POST /v1/events (data plane, ingest key). At least one of
+  --email / --user-id is required.
+
+  Options:
+    --email <addr>          Recipient/identity email.
+    --user-id <id>          External (distinct) id.
+    --prop <key=value>      Event property; repeatable. Value parsed as JSON,
+                            falling back to a string.
+    --props <json>          Event properties as one JSON object.
+    --contact-prop <k=v>    Contact property to merge onto the contact; repeatable.
+    --contact-props <json>  Contact properties as one JSON object.
+    --list <id>             Subscribe to a list; repeatable.
+    --unlist <id>           Unsubscribe from a list; repeatable.
+    --idempotency-key <k>   Dedup key (sent as the Idempotency-Key header).
+    --timestamp <iso>       Override the event timestamp.
+
+Global options (handled by the router): --url, --admin-key, --data-key, --json,
+-h/--help.
 
 Examples:
   hogsend events user_123
   hogsend events user_123 --event signup --limit 10
-  hogsend events user_123 --from 2026-01-01T00:00:00Z --json`;
-async function run4(ctx) {
-  const { values, positionals } = parseArgs4({
-    args: ctx.argv,
+  hogsend events user_123 --from 2026-01-01T00:00:00Z --json
+  hogsend events send signup --user-id user_123 --prop plan=pro
+  hogsend events send purchase --email a@b.com --props '{"amount":49}' --json`;
+async function run6(ctx) {
+  if (ctx.argv[0] === "send") {
+    return runSend3(ctx, ctx.argv.slice(1));
+  }
+  return runRead(ctx, ctx.argv);
+}
+async function runRead(ctx, argv) {
+  const { values, positionals } = parseArgs6({
+    args: argv,
     allowPositionals: true,
     options: {
       event: { type: "string" },
@@ -950,7 +1538,7 @@ async function run4(ctx) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage4);
+    ctx.out.log(usage6);
     return;
   }
   const userId = positionals[0];
@@ -1005,6 +1593,145 @@ async function run4(ctx) {
     `${color.green(String(shown))} event${shown === 1 ? "" : "s"} ` + color.dim(`(${data.offset + 1}-${through} of ${data.total})`)
   );
 }
+async function runSend3(ctx, argv) {
+  const { values, positionals } = parseArgs6({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      email: { type: "string" },
+      "user-id": { type: "string" },
+      prop: { type: "string", multiple: true },
+      props: { type: "string" },
+      "contact-prop": { type: "string", multiple: true },
+      "contact-props": { type: "string" },
+      list: { type: "string", multiple: true },
+      unlist: { type: "string", multiple: true },
+      "idempotency-key": { type: "string" },
+      timestamp: { type: "string" },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    ctx.out.log(usage6);
+    return;
+  }
+  const name = positionals[0];
+  if (!name) {
+    ctx.out.fail(
+      "events send requires an event name, e.g. hogsend events send signup --user-id user_123"
+    );
+  }
+  const email = values.email;
+  const userId = values["user-id"];
+  if (!email && !userId) {
+    ctx.out.fail("events send requires at least one of --email or --user-id");
+  }
+  const eventProperties = parseProps4(ctx, values.props, values.prop, "prop");
+  const contactProperties = parseProps4(
+    ctx,
+    values["contact-props"],
+    values["contact-prop"],
+    "contact-prop"
+  );
+  const lists = parseLists2(values.list, values.unlist);
+  const body = { name };
+  if (email) body.email = email;
+  if (userId) body.userId = userId;
+  if (eventProperties) body.eventProperties = eventProperties;
+  if (contactProperties) body.contactProperties = contactProperties;
+  if (lists) body.lists = lists;
+  if (values["idempotency-key"]) {
+    body.idempotencyKey = values["idempotency-key"];
+  }
+  if (values.timestamp) body.timestamp = values.timestamp;
+  let res;
+  try {
+    res = await ctx.out.step(
+      `Sending event ${name}`,
+      () => ctx.dataHttp.post("/v1/events", body)
+    );
+  } catch (error) {
+    if (isHttpError(error)) {
+      ctx.out.fail(error.message);
+    }
+    throw error;
+  }
+  if (ctx.json) {
+    ctx.out.json(res);
+    return;
+  }
+  ctx.out.intro(`${color.bgMagenta(color.black(" hogsend "))} events send`);
+  const exited = res.exits.filter((e) => e.exited);
+  ctx.out.kv(
+    {
+      event: name,
+      stored: res.stored,
+      identity: email ?? userId ?? "",
+      exits: res.exits.length,
+      "journeys exited": exited.length
+    },
+    "Event sent"
+  );
+  if (exited.length > 0) {
+    ctx.out.table(
+      exited.map((e) => ({ journeyId: e.journeyId, stateId: e.stateId })),
+      ["journeyId", "stateId"]
+    );
+  }
+  ctx.out.outro(
+    res.stored ? `${color.green("Stored")} ${name}.` : color.dim(`${name} was deduped (not stored).`)
+  );
+}
+function parseProps4(ctx, json, pairs, flagName) {
+  const out = {};
+  let any = false;
+  if (json !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      ctx.out.fail(`--${flagName}s must be valid JSON, got: ${json}`);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      ctx.out.fail(`--${flagName}s must be a JSON object`);
+    }
+    Object.assign(out, parsed);
+    any = true;
+  }
+  for (const pair of pairs ?? []) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) {
+      ctx.out.fail(`--${flagName} must be key=value, got: ${pair}`);
+    }
+    const key = pair.slice(0, eq).trim();
+    if (key === "") {
+      ctx.out.fail(`--${flagName} key cannot be empty, got: ${pair}`);
+    }
+    out[key] = coerceValue4(pair.slice(eq + 1));
+    any = true;
+  }
+  return any ? out : void 0;
+}
+function coerceValue4(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseLists2(subscribe, unsubscribe) {
+  const out = {};
+  let any = false;
+  for (const id of subscribe ?? []) {
+    out[id] = true;
+    any = true;
+  }
+  for (const id of unsubscribe ?? []) {
+    out[id] = false;
+    any = true;
+  }
+  return any ? out : void 0;
+}
 function parseNumber(raw, name, ctx) {
   if (raw === void 0) return void 0;
   const n = Number(raw);
@@ -1022,14 +1749,14 @@ function summarizeProps(props) {
 }
 var eventsCommand = {
   name: "events",
-  summary: "Stream a single user's event history",
-  usage: usage4,
-  run: run4
+  summary: "Stream a user's event history, or send an event",
+  usage: usage6,
+  run: run6
 };
 
 // src/commands/journeys.ts
-import { parseArgs as parseArgs5 } from "util";
-var usage5 = `hogsend journeys <subcommand> [options]
+import { parseArgs as parseArgs7 } from "util";
+var usage7 = `hogsend journeys <subcommand> [options]
 
 Inspect and toggle journeys via the admin API (/v1/admin/journeys).
 
@@ -1051,14 +1778,14 @@ Examples:
   hogsend journeys list --enabled true
   hogsend journeys get activation-welcome --json
   hogsend journeys disable churn-prevention`;
-function badge2() {
+function badge4() {
   return `${color.bgMagenta(color.black(" hogsend "))} journeys`;
 }
-function statusColor(enabled) {
+function statusColor3(enabled) {
   return enabled ? color.green("enabled") : color.yellow("disabled");
 }
 async function runList2(ctx) {
-  const { values } = parseArgs5({
+  const { values } = parseArgs7({
     args: ctx.argv,
     allowPositionals: true,
     options: {
@@ -1069,7 +1796,7 @@ async function runList2(ctx) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage5);
+    ctx.out.log(usage7);
     return;
   }
   if (values.enabled !== void 0 && !["true", "false"].includes(values.enabled)) {
@@ -1080,7 +1807,7 @@ async function runList2(ctx) {
     limit: values.limit,
     offset: values.offset
   };
-  if (!ctx.json) ctx.out.intro(badge2());
+  if (!ctx.json) ctx.out.intro(badge4());
   const data = await ctx.out.step(
     "Fetching journeys",
     () => ctx.http.get("/v1/admin/journeys", query)
@@ -1096,7 +1823,7 @@ async function runList2(ctx) {
       data.journeys.map((j) => ({
         id: j.id,
         name: j.name,
-        status: statusColor(j.enabled),
+        status: statusColor3(j.enabled),
         trigger: j.trigger.event,
         active: j.counts.active,
         waiting: j.counts.waiting,
@@ -1125,7 +1852,7 @@ async function runGet2(ctx, id) {
       "journeys get requires a journey id, e.g. hogsend journeys get activation-welcome"
     );
   }
-  if (!ctx.json) ctx.out.intro(badge2());
+  if (!ctx.json) ctx.out.intro(badge4());
   const data = await ctx.out.step(
     `Fetching journey ${id}`,
     () => ctx.http.get(
@@ -1142,7 +1869,7 @@ async function runGet2(ctx, id) {
       id: j.id,
       name: j.name,
       description: j.description ?? "",
-      status: statusColor(j.enabled),
+      status: statusColor3(j.enabled),
       trigger: j.trigger.event,
       entryLimit: j.entryLimit,
       exitOn: j.exitOn?.map((e) => e.event).join(", ") ?? "(none)"
@@ -1182,7 +1909,7 @@ async function runToggle(ctx, id, enabled) {
       `journeys ${verb} requires a journey id, e.g. hogsend journeys ${verb} activation-welcome`
     );
   }
-  if (!ctx.json) ctx.out.intro(badge2());
+  if (!ctx.json) ctx.out.intro(badge4());
   const data = await ctx.out.step(
     `${enabled ? "Enabling" : "Disabling"} ${id}`,
     () => ctx.http.patch(
@@ -1198,14 +1925,14 @@ async function runToggle(ctx, id, enabled) {
   ctx.out.note(
     [
       `${color.bold(j.name)} (${j.id})`,
-      `status: ${statusColor(j.enabled)}`,
+      `status: ${statusColor3(j.enabled)}`,
       `updated: ${j.updatedAt}`
     ].join("\n"),
     `Journey ${enabled ? "enabled" : "disabled"}`
   );
-  ctx.out.outro(`${j.id} is now ${statusColor(j.enabled)}.`);
+  ctx.out.outro(`${j.id} is now ${statusColor3(j.enabled)}.`);
 }
-async function run5(ctx) {
+async function run7(ctx) {
   const sub = ctx.argv[0];
   const rest = ctx.argv.slice(1);
   const subCtx = { ...ctx, argv: rest };
@@ -1217,7 +1944,7 @@ async function run5(ctx) {
       case "get": {
         const id = rest.find((a) => !a.startsWith("-"));
         if (rest.includes("--help") || rest.includes("-h")) {
-          ctx.out.log(usage5);
+          ctx.out.log(usage7);
           return;
         }
         await runGet2(subCtx, id);
@@ -1225,7 +1952,7 @@ async function run5(ctx) {
       }
       case "enable": {
         if (rest.includes("--help") || rest.includes("-h")) {
-          ctx.out.log(usage5);
+          ctx.out.log(usage7);
           return;
         }
         await runToggle(
@@ -1237,7 +1964,7 @@ async function run5(ctx) {
       }
       case "disable": {
         if (rest.includes("--help") || rest.includes("-h")) {
-          ctx.out.log(usage5);
+          ctx.out.log(usage7);
           return;
         }
         await runToggle(
@@ -1271,14 +1998,14 @@ async function run5(ctx) {
 var journeysCommand = {
   name: "journeys",
   summary: "List, inspect, enable, and disable journeys",
-  usage: usage5,
-  run: run5
+  usage: usage7,
+  run: run7
 };
 
 // src/commands/patch.ts
 import { spawnSync } from "child_process";
-import { parseArgs as parseArgs6 } from "util";
-var usage6 = `hogsend patch <package> [--cwd <dir>]
+import { parseArgs as parseArgs8 } from "util";
+var usage8 = `hogsend patch <package> [--cwd <dir>]
 
 Thin wrapper over pnpm's native patch flow. Runs \`pnpm patch <package>\`, which
 extracts the package into a temp dir and prints the path to edit. After editing,
@@ -1289,8 +2016,8 @@ This does NOT replace scripts/patch-check.sh (the patch re-apply contract).
 Options:
   --cwd <dir>    Project root to run pnpm in (defaults to current directory).
   -h, --help     Show this help.`;
-async function run6(ctx) {
-  const { values, positionals } = parseArgs6({
+async function run8(ctx) {
+  const { values, positionals } = parseArgs8({
     args: ctx.argv,
     allowPositionals: true,
     options: {
@@ -1299,7 +2026,7 @@ async function run6(ctx) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage6);
+    ctx.out.log(usage8);
     return;
   }
   const pkg = positionals[0];
@@ -1339,8 +2066,8 @@ async function run6(ctx) {
 var patchCommand = {
   name: "patch",
   summary: "Patch a package via pnpm's native patch flow",
-  usage: usage6,
-  run: run6
+  usage: usage8,
+  run: run8
 };
 
 // src/commands/setup.ts
@@ -1348,7 +2075,7 @@ import { spawnSync as spawnSync2 } from "child_process";
 import { randomBytes } from "crypto";
 import { copyFileSync, existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join4 } from "path";
-import { parseArgs as parseArgs7 } from "util";
+import { parseArgs as parseArgs9 } from "util";
 import { confirm } from "@clack/prompts";
 
 // src/lib/prompt.ts
@@ -1362,7 +2089,7 @@ function bail(value) {
 }
 
 // src/commands/setup.ts
-var usage7 = `hogsend setup [--cwd <dir>] [--yes] [--json]
+var usage9 = `hogsend setup [--cwd <dir>] [--yes] [--json]
 
 Interactive local onboarding for a scaffolded Hogsend app. Mirrors the
 create-hogsend "next steps":
@@ -1473,8 +2200,8 @@ function runCmd(cmd, args, cwd, json) {
   });
   return { status: result.status, ok: result.status === 0 };
 }
-async function run7(ctx) {
-  const { values } = parseArgs7({
+async function run9(ctx) {
+  const { values } = parseArgs9({
     args: ctx.argv,
     allowPositionals: true,
     options: {
@@ -1484,7 +2211,7 @@ async function run7(ctx) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage7);
+    ctx.out.log(usage9);
     return;
   }
   const cwd = values.cwd ?? process.cwd();
@@ -1595,16 +2322,16 @@ async function run7(ctx) {
 var setupCommand = {
   name: "setup",
   summary: "Local onboarding: docker compose up, gen secret, db:migrate",
-  usage: usage7,
-  run: run7
+  usage: usage9,
+  run: run9
 };
 
 // src/commands/skills.ts
 import { existsSync as existsSync5 } from "fs";
 import { join as join5 } from "path";
-import { parseArgs as parseArgs8 } from "util";
+import { parseArgs as parseArgs10 } from "util";
 import { multiselect } from "@clack/prompts";
-var usage8 = `hogsend skills <subcommand> [options]
+var usage10 = `hogsend skills <subcommand> [options]
 
 Manage the Claude Code skills bundled with @hogsend/cli. Bundled skills teach
 agents how to drive the hogsend CLI; \`add\` copies them into your project's
@@ -1665,7 +2392,7 @@ function runList3(ctx) {
   );
 }
 async function runAdd(ctx, argv) {
-  const { values, positionals } = parseArgs8({
+  const { values, positionals } = parseArgs10({
     args: argv,
     allowPositionals: true,
     options: {
@@ -1675,7 +2402,7 @@ async function runAdd(ctx, argv) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage8);
+    ctx.out.log(usage10);
     return;
   }
   const cwd = process.cwd();
@@ -1743,7 +2470,7 @@ async function runAdd(ctx, argv) {
     `Installed ${installedCount} skill${installedCount === 1 ? "" : "s"}` + (skippedCount > 0 ? `, skipped ${skippedCount}.` : ".")
   );
 }
-async function run8(ctx) {
+async function run10(ctx) {
   const sub = ctx.argv[0];
   switch (sub) {
     case "list":
@@ -1755,7 +2482,7 @@ async function run8(ctx) {
     case void 0:
     case "-h":
     case "--help":
-      ctx.out.log(usage8);
+      ctx.out.log(usage10);
       return;
     default:
       ctx.out.fail(
@@ -1766,13 +2493,13 @@ async function run8(ctx) {
 var skillsCommand = {
   name: "skills",
   summary: "List + install bundled Claude Code skills into .claude/skills",
-  usage: usage8,
-  run: run8
+  usage: usage10,
+  run: run10
 };
 
 // src/commands/stats.ts
-import { parseArgs as parseArgs9 } from "util";
-var usage9 = `hogsend stats [--json]
+import { parseArgs as parseArgs11 } from "util";
+var usage11 = `hogsend stats [--json]
 
 Show system-wide overview metrics from a running Hogsend instance.
 Wraps GET /v1/admin/metrics/overview.
@@ -1794,8 +2521,8 @@ Options:
 function pct(rate) {
   return `${(rate * 100).toFixed(2)}%`;
 }
-async function run9(ctx) {
-  const { values } = parseArgs9({
+async function run11(ctx) {
+  const { values } = parseArgs11({
     args: ctx.argv,
     allowPositionals: true,
     options: {
@@ -1803,7 +2530,7 @@ async function run9(ctx) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage9);
+    ctx.out.log(usage11);
     return;
   }
   const metrics = await ctx.out.step(
@@ -1832,8 +2559,8 @@ async function run9(ctx) {
 var statsCommand = {
   name: "stats",
   summary: "Show system-wide overview metrics",
-  usage: usage9,
-  run: run9
+  usage: usage11,
+  run: run11
 };
 
 // src/commands/studio.ts
@@ -1842,8 +2569,8 @@ import { createReadStream, existsSync as existsSync6, readFileSync as readFileSy
 import { createServer } from "http";
 import { extname, join as join6, normalize, resolve, sep as sep3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { parseArgs as parseArgs10 } from "util";
-var usage10 = `hogsend studio [options]
+import { parseArgs as parseArgs12 } from "util";
+var usage12 = `hogsend studio [options]
 
 Serve the bundled Hogsend Studio (the admin SPA) locally and open it in a
 browser. The Studio is a static single-page app; this command starts a tiny
@@ -1929,8 +2656,8 @@ function openBrowser(url) {
   } catch {
   }
 }
-async function run10(ctx) {
-  const { values, positionals } = parseArgs10({
+async function run12(ctx) {
+  const { values, positionals } = parseArgs12({
     args: ctx.argv,
     allowPositionals: true,
     strict: false,
@@ -1943,7 +2670,7 @@ async function run10(ctx) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage10);
+    ctx.out.log(usage12);
     return;
   }
   const port = Number(values.port ?? "3333");
@@ -2027,17 +2754,17 @@ async function run10(ctx) {
 var studioCommand = {
   name: "studio",
   summary: "Serve the bundled Hogsend Studio admin SPA locally",
-  usage: usage10,
-  run: run10
+  usage: usage12,
+  run: run12
 };
 
 // src/commands/upgrade.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
 import { join as join7 } from "path";
-import { parseArgs as parseArgs11 } from "util";
+import { parseArgs as parseArgs13 } from "util";
 import { confirm as confirm2 } from "@clack/prompts";
-var usage11 = `hogsend upgrade [--cwd <dir>] [--pm <pnpm|npm|yarn|bun>] [options]
+var usage13 = `hogsend upgrade [--cwd <dir>] [--pm <pnpm|npm|yarn|bun>] [options]
 
 Upgrade a scaffolded Hogsend app in one step:
   1. bump every @hogsend/* dependency to latest (or --to <version>), then
@@ -2073,8 +2800,8 @@ function hogsendDeps(cwd) {
 function addArgs(pm, specs) {
   return [pm === "npm" ? "install" : "add", ...specs];
 }
-async function run11(ctx) {
-  const { values } = parseArgs11({
+async function run13(ctx) {
+  const { values } = parseArgs13({
     args: ctx.argv,
     allowPositionals: true,
     options: {
@@ -2088,7 +2815,7 @@ async function run11(ctx) {
     }
   });
   if (values.help) {
-    ctx.out.log(usage11);
+    ctx.out.log(usage13);
     return;
   }
   if (values["deps-only"] && values["skills-only"]) {
@@ -2213,8 +2940,8 @@ async function run11(ctx) {
 var upgradeCommand = {
   name: "upgrade",
   summary: "Bump @hogsend/* deps to latest + refresh vendored skills",
-  usage: usage11,
-  run: run11
+  usage: usage13,
+  run: run13
 };
 
 // src/commands/index.ts
@@ -2224,6 +2951,8 @@ var commands = [
   contactsCommand,
   statsCommand,
   eventsCommand,
+  emailsCommand,
+  campaignsCommand,
   studioCommand,
   setupCommand,
   skillsCommand,
@@ -2235,10 +2964,10 @@ var commands = [
 // src/lib/config.ts
 import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
 import { join as join8 } from "path";
-import { parseArgs as parseArgs12 } from "util";
+import { parseArgs as parseArgs14 } from "util";
 var DEFAULT_BASE_URL = "http://localhost:3002";
 function parseGlobalFlags(argv) {
-  const { values, tokens } = parseArgs12({
+  const { values, tokens } = parseArgs14({
     args: argv,
     allowPositionals: true,
     strict: false,
@@ -2246,11 +2975,12 @@ function parseGlobalFlags(argv) {
     options: {
       url: { type: "string" },
       "admin-key": { type: "string" },
+      "data-key": { type: "string" },
       json: { type: "boolean", default: false },
       help: { type: "boolean", short: "h", default: false }
     }
   });
-  const owned = /* @__PURE__ */ new Set(["url", "admin-key", "json", "help", "h"]);
+  const owned = /* @__PURE__ */ new Set(["url", "admin-key", "data-key", "json", "help", "h"]);
   const rest = [];
   for (const token of tokens) {
     if (token.kind === "positional") {
@@ -2268,6 +2998,7 @@ function parseGlobalFlags(argv) {
   return {
     url: typeof values.url === "string" ? values.url : void 0,
     adminKey: typeof values["admin-key"] === "string" ? values["admin-key"] : void 0,
+    dataKey: typeof values["data-key"] === "string" ? values["data-key"] : void 0,
     json: values.json === true,
     help: values.help === true,
     rest
@@ -2303,9 +3034,11 @@ function resolveConfig(flags, cwd = process.cwd()) {
   const dotenv = loadDotEnv(cwd);
   const baseUrlRaw = flags.url ?? process.env.HOGSEND_API_URL ?? dotenv.HOGSEND_API_URL ?? DEFAULT_BASE_URL;
   const adminKey = flags.adminKey ?? process.env.HOGSEND_ADMIN_KEY ?? process.env.ADMIN_API_KEY ?? dotenv.HOGSEND_ADMIN_KEY ?? dotenv.ADMIN_API_KEY;
+  const dataKey = flags.dataKey ?? process.env.HOGSEND_DATA_KEY ?? process.env.HOGSEND_API_KEY ?? dotenv.HOGSEND_DATA_KEY ?? dotenv.HOGSEND_API_KEY;
   return {
     baseUrl: baseUrlRaw.replace(/\/+$/, ""),
-    adminKey: adminKey && adminKey.length > 0 ? adminKey : void 0
+    adminKey: adminKey && adminKey.length > 0 ? adminKey : void 0,
+    dataKey: dataKey && dataKey.length > 0 ? dataKey : void 0
   };
 }
 
@@ -2332,6 +3065,7 @@ ${list}
 ${color.dim("Global options:")}
   --url <baseUrl>     Target instance (default HOGSEND_API_URL or http://localhost:3002)
   --admin-key <key>   Admin bearer token (default HOGSEND_ADMIN_KEY / ADMIN_API_KEY)
+  --data-key <key>    Ingest bearer token for writes (default HOGSEND_DATA_KEY / HOGSEND_API_KEY)
   --json              Emit machine-readable JSON only (for agents)
   -h, --help          Show help (use after a command for command help)
   -v, --version       Show version
@@ -2372,10 +3106,12 @@ ${rootUsage()}
   }
   const cfg = resolveConfig(flags);
   const http = createAdminClient(cfg);
+  const dataHttp = createDataPlaneClient(cfg);
   await command.run({
     argv: flags.rest,
     cfg,
     http,
+    dataHttp,
     out,
     json: flags.json
   });