mailtea-cli 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mailtea
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# `mailtea-cli`
+
+Send, schedule, and manage email with [Mailtea](https://mailtea.app) from your
+shell or an AI agent. Wraps the [`mailtea-sdk`](https://www.npmjs.com/package/mailtea-sdk)
+SDK for everyday commands, and bridges the full
+[`mailtea-mcp`](https://www.npmjs.com/package/mailtea-mcp) tool catalog so an agent
+can reach **every** Mailtea capability — the same surface as the MCP server.
+MIT-licensed.
+
+## Quick start
+
+```bash
+# one-off, no install
+npx -y mailtea-cli emails send \
+  --from "you@yourdomain.com" \
+  --to "user@example.com" \
+  --subject "Hello" \
+  --html "<p>Sent from the Mailtea CLI</p>"
+# -> {"id":"txemail_..."}
+```
+
+Authenticate with a personal access token (prefix `mt_pat_`) from **Settings →
+API keys**, supplied any of three ways (in order):
+
+1. `--api-key mt_pat_xxx`
+2. `MAILTEA_API_KEY` (or `MAILTEA_API_TOKEN`) environment variable
+3. `mailtea login --api-key mt_pat_xxx` (saved to `~/.mailtea/config.json`)
+
+Self-hosting or local dev? add `--base-url http://localhost:8787` (or
+`MAILTEA_API_BASE_URL`).
+
+## Full capability bridge (every MCP tool)
+
+Beyond the named commands below, the CLI exposes the **entire MCP tool catalog** —
+issue drafting/scheduling/sending, analytics, sections, referrals, monetization,
+AI drafting, and more — through three generic commands:
+
+```bash
+mailtea tools [--names]                 # list every capability (no auth)
+mailtea schema <tool>                   # print a tool's JSON input schema (no auth)
+mailtea call <tool> [--json '{...}'] [--arg key=value ...]   # invoke any tool
+```
+
+```bash
+# discover, inspect, then call — exactly how an agent operates
+mailtea tools --names | jq -r '.[]' | grep '^issue\.'
+mailtea schema issue.send_now
+mailtea call issue.send_now --json '{"issueId":"iss_123"}'
+
+# --arg overlays string values onto the --json base
+mailtea call email.send --json '{"from":"you@d.com","to":"u@e.com","subject":"Hi"}' --arg html='<p>hi</p>'
+```
+
+`mailtea call` prints the tool's structured result on stdout; a tool/API error is
+JSON on stderr with a non-zero exit code. New MCP tools appear automatically.
+
+## Named commands
+
+```bash
+mailtea emails send --from <a> --to <a> --subject <s> (--html <h> | --text <t> | --template-id <id>)
+mailtea emails batch --json '[{...}, ...]'
+mailtea emails list [--status <s>] [--limit <n>] [--offset <n>] [--tag-name <n>] [--tag-value <v>]
+mailtea emails get|cancel <id>
+mailtea emails reschedule <id> --scheduled-at <iso>
+mailtea emails analytics [--from-date <iso>] [--to-date <iso>]
+mailtea posts send-test <post-id> --to <addr> --from <addr> [--reply-to <addr>]
+
+mailtea contacts create|list|get|update|delete --publication-id <pub> ...
+mailtea segments create|list|get|update|delete --publication-id <pub> ...
+mailtea tags create|list|get|update|delete --publication-id <pub> ...
+mailtea domains create|list|get|verify|update|delete --publication-id <pub> ...
+mailtea domains tracking create|list|verify|delete --publication-id <pub> --domain-id <id> ...
+mailtea webhooks create|list|get|update|delete --publication-id <pub> [--event <e> ...]
+mailtea contact-properties create|list|update|delete ...        # team-scoped, no --publication-id
+mailtea api-keys create|list|revoke ...
+mailtea templates create|list|get|update|publish|duplicate|delete --publication-id <pub> ...
+mailtea inbound list --publication-id <pub> [--limit <n>] [--cursor <c>]
+mailtea inbound get|attachments <id>
+mailtea inbound attachment <id> <attachment-id>
+mailtea inbound reply <id> (--html <h> | --text <t>) [--from <addr>] [--from-name <n>] [--subject <s>] [--cc <a>] [--bcc <a>] [--idempotency-key <k>]
+
+mailtea login --api-key mt_pat_xxx [--base-url <url>]
+mailtea version | help
+```
+
+`emails send` extras: `--cc` / `--bcc` / `--reply-to` (repeatable or comma-separated),
+`--scheduled-at <iso>`, `--tag name=value`, `--header name=value`,
+`--template-var name=value` (all repeatable), and `--dry-run` to print the
+resolved payload without sending.
+
+## Agent-friendly
+
+Output is **JSON on stdout**; errors are **JSON on stderr** with a non-zero exit
+code — so an agent in a non-TTY shell can parse results and detect failures.
+
+```bash
+ID=$(mailtea emails send --from you@d.com --to u@e.com --subject Hi --text hi | jq -r .id)
+mailtea emails get "$ID" | jq -r .last_event
+```

package/bin/mailtea.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// Executable entry for the `mailtea` CLI. Delegates to the built run() and maps
+// its return value to a process exit code.
+import { run } from "../dist/cli.js";
+
+run(process.argv.slice(2))
+  .then((code) => process.exit(code))
+  .catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });

package/dist/cli.d.ts

@@ -0,0 +1,17 @@
+declare const VERSION = "0.1.0";
+interface RunDeps {
+    env?: Record<string, string | undefined>;
+    stdout?: (line: string) => void;
+    stderr?: (line: string) => void;
+    /** Injected for tests; defaults to the global fetch via the SDK. */
+    fetchImpl?: typeof fetch;
+    /** Home directory for the `login` config file; defaults to os.homedir(). */
+    homeDir?: string;
+}
+/**
+ * Run the Mailtea CLI. Returns a process exit code (0 ok, non-zero error).
+ * All side effects go through injectable deps so the command surface is testable.
+ */
+declare function run(argv: string[], deps?: RunDeps): Promise<number>;
+
+export { type RunDeps, VERSION, run };

package/dist/cli.js

@@ -0,0 +1,975 @@
+// src/cli.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { Mailtea, MailteaError } from "mailtea-sdk";
+import { handleMcpRequest, MCP_TOOLS } from "mailtea-mcp";
+
+// src/args.ts
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["dry-run", "help", "version", "pretty", "names"]);
+function parseArgs(argv) {
+  const positionals = [];
+  const values = {};
+  const push = (key, value) => {
+    (values[key] ??= []).push(value);
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--") {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (token.startsWith("--")) {
+      const body = token.slice(2);
+      const eq = body.indexOf("=");
+      if (eq !== -1) {
+        push(body.slice(0, eq), body.slice(eq + 1));
+      } else if (BOOLEAN_FLAGS.has(body)) {
+        push(body, "true");
+      } else {
+        const next = argv[i + 1];
+        if (next !== void 0 && next !== "--" && !next.startsWith("--")) {
+          push(body, next);
+          i++;
+        } else {
+          push(body, "true");
+        }
+      }
+    } else {
+      positionals.push(token);
+    }
+  }
+  return { positionals, values };
+}
+function flagValue(parsed, key) {
+  const arr = parsed.values[key];
+  return arr && arr.length > 0 ? arr[arr.length - 1] : void 0;
+}
+function flagList(parsed, key) {
+  return parsed.values[key] ?? [];
+}
+function flagBool(parsed, key) {
+  return (parsed.values[key] ?? []).includes("true");
+}
+function flagPairs(parsed, key) {
+  return flagList(parsed, key).map((raw) => {
+    const eq = raw.indexOf("=");
+    return eq === -1 ? { name: raw, value: "" } : { name: raw.slice(0, eq), value: raw.slice(eq + 1) };
+  });
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+async function run(argv, deps = {}) {
+  const ctx = {
+    env: deps.env ?? process.env,
+    out: deps.stdout ?? ((line) => process.stdout.write(`${line}
+`)),
+    err: deps.stderr ?? ((line) => process.stderr.write(`${line}
+`)),
+    home: deps.homeDir ?? homedir(),
+    fetchImpl: deps.fetchImpl
+  };
+  const parsed = parseArgs(argv);
+  const [group, sub, ...rest] = parsed.positionals;
+  if (group === "version" || flagBool(parsed, "version")) {
+    ctx.out(VERSION);
+    return 0;
+  }
+  if (!group || group === "help" || flagBool(parsed, "help")) {
+    ctx.out(USAGE);
+    return 0;
+  }
+  if (group === "login") {
+    return doLogin(parsed, ctx);
+  }
+  if (group === "tools") {
+    return toolsCommand(parsed, ctx);
+  }
+  if (group === "schema") {
+    return schemaCommand(sub, ctx);
+  }
+  if (group === "call") {
+    return callCommand(sub, parsed, ctx);
+  }
+  if (group === "emails") {
+    return emailsCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "posts") {
+    return postsCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "contacts") {
+    return contactsCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "segments") {
+    return segmentsCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "tags") {
+    return tagsCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "domains") {
+    return domainsCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "webhooks") {
+    return webhooksCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "contact-properties") {
+    return contactPropertiesCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "api-keys") {
+    return apiKeysCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "templates") {
+    return templatesCommand(sub, rest, parsed, ctx);
+  }
+  if (group === "inbound") {
+    return inboundCommand(sub, rest, parsed, ctx);
+  }
+  ctx.err(`Unknown command: ${group}. Run \`mailtea help\`.`);
+  return 1;
+}
+function toolsCommand(parsed, ctx) {
+  const namesOnly = flagBool(parsed, "names");
+  const list = MCP_TOOLS.map(
+    (tool) => namesOnly ? tool.name : { name: tool.name, description: tool.description }
+  );
+  ctx.out(JSON.stringify(list));
+  return 0;
+}
+function schemaCommand(name, ctx) {
+  if (!name) return fail(ctx, "schema requires a <tool> name. Run `mailtea tools`.");
+  const tool = MCP_TOOLS.find((t) => t.name === name);
+  if (!tool) {
+    ctx.err(JSON.stringify({ error: `Unknown tool: ${name}. Run \`mailtea tools\`.` }));
+    return 1;
+  }
+  ctx.out(JSON.stringify(tool.inputSchema));
+  return 0;
+}
+async function callCommand(name, parsed, ctx) {
+  if (!name) return fail(ctx, "call requires a <tool> name. Run `mailtea tools`.");
+  let args = {};
+  const json = flagValue(parsed, "json");
+  if (json !== void 0) {
+    let parsedJson;
+    try {
+      parsedJson = JSON.parse(json);
+    } catch {
+      return fail(ctx, "--json must be valid JSON");
+    }
+    if (!parsedJson || typeof parsedJson !== "object" || Array.isArray(parsedJson)) {
+      return fail(ctx, "--json must be a JSON object");
+    }
+    args = parsedJson;
+  }
+  for (const { name: key, value } of flagPairs(parsed, "arg")) {
+    args[key] = value;
+  }
+  return runBridgeTool(parsed, ctx, name, args);
+}
+async function runBridgeTool(parsed, ctx, toolName, args) {
+  const auth = resolveAuth(parsed, ctx);
+  if (!auth) return 1;
+  const res = await handleMcpRequest(
+    { jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: toolName, arguments: args } },
+    { apiBaseUrl: auth.baseUrl, token: auth.apiKey, fetchImpl: ctx.fetchImpl }
+  );
+  if (res.error) {
+    ctx.err(JSON.stringify({ error: res.error.message, code: res.error.code, details: res.error.data }));
+    return 1;
+  }
+  const result = res.result;
+  const text = (result?.content ?? []).map((c) => c.text ?? "").join("\n");
+  if (result?.isError) {
+    ctx.err(JSON.stringify({ error: text || "Tool returned an error" }));
+    return 1;
+  }
+  ctx.out(JSON.stringify(result?.structuredContent ?? { text }));
+  return 0;
+}
+async function emailsCommand(sub, rest, parsed, ctx) {
+  switch (sub) {
+    case "send": {
+      const payload = buildSendPayload(parsed);
+      const problem = validateSend(payload);
+      if (problem) {
+        ctx.err(problem);
+        return 1;
+      }
+      if (flagBool(parsed, "dry-run")) {
+        ctx.out(JSON.stringify(payload));
+        return 0;
+      }
+      return callApi(
+        parsed,
+        ctx,
+        (client) => client.emails.send(payload)
+      );
+    }
+    case "batch": {
+      const json = flagValue(parsed, "json");
+      if (!json) return fail(ctx, "emails batch requires --json '[{...}, ...]' (a JSON array of emails)");
+      let emails;
+      try {
+        emails = JSON.parse(json);
+      } catch {
+        return fail(ctx, "emails batch --json must be valid JSON");
+      }
+      if (!Array.isArray(emails)) return fail(ctx, "emails batch --json must be a JSON array");
+      return callApi(parsed, ctx, (client) => client.emails.batch(emails));
+    }
+    case "list": {
+      let params;
+      try {
+        params = buildListParams(parsed);
+      } catch (error) {
+        return fail(ctx, error instanceof Error ? error.message : String(error));
+      }
+      return callApi(parsed, ctx, (client) => client.emails.list(params));
+    }
+    case "get": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "emails get requires an <id>");
+      return callApi(parsed, ctx, (client) => client.emails.get(id));
+    }
+    case "cancel": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "emails cancel requires an <id>");
+      return callApi(parsed, ctx, (client) => client.emails.cancel(id));
+    }
+    case "reschedule": {
+      const id = rest[0];
+      const at = flagValue(parsed, "scheduled-at");
+      if (!id || !at) return fail(ctx, "emails reschedule requires <id> and --scheduled-at <iso>");
+      return callApi(parsed, ctx, (client) => client.emails.reschedule(id, at));
+    }
+    case "analytics":
+      return callApi(
+        parsed,
+        ctx,
+        (client) => client.emails.analytics({
+          from_date: flagValue(parsed, "from-date"),
+          to_date: flagValue(parsed, "to-date")
+        })
+      );
+    default:
+      return fail(
+        ctx,
+        `Unknown emails subcommand: ${sub ?? "(none)"}. Try: send, batch, list, get, cancel, reschedule, analytics.`
+      );
+  }
+}
+async function postsCommand(sub, rest, parsed, ctx) {
+  switch (sub) {
+    case "create": {
+      const pub = flagValue(parsed, "publication-id");
+      const subject = flagValue(parsed, "subject");
+      const templateId = flagValue(parsed, "template-id");
+      const html = flagValue(parsed, "html");
+      const kind = flagValue(parsed, "kind");
+      if (!pub) return fail(ctx, "posts create requires --publication-id");
+      if (!subject) return fail(ctx, "posts create requires --subject");
+      if (!templateId && !html) return fail(ctx, "posts create requires --template-id or --html");
+      if (templateId && html) return fail(ctx, "posts create: use --template-id OR --html, not both");
+      if (kind && kind !== "newsletter" && kind !== "broadcast") {
+        return fail(ctx, "posts create --kind must be 'newsletter' or 'broadcast'");
+      }
+      const vars = flagPairs(parsed, "template-var");
+      return callApi(
+        parsed,
+        ctx,
+        (client) => client.posts.create({
+          publication_id: pub,
+          subject,
+          ...templateId ? { template_id: templateId } : {},
+          ...vars.length ? { variables: Object.fromEntries(vars.map((v) => [v.name, v.value])) } : {},
+          ...html ? { html } : {},
+          ...kind ? { kind } : {}
+        })
+      );
+    }
+    case "send-test": {
+      const id = rest[0];
+      const from = flagValue(parsed, "from");
+      const recipients = splitList(flagList(parsed, "to"));
+      if (!id) return fail(ctx, "posts send-test requires a <post-id>");
+      if (!from) return fail(ctx, "posts send-test requires --from");
+      if (recipients.length === 0) return fail(ctx, "posts send-test requires --to");
+      const replyTo = flagValue(parsed, "reply-to");
+      return callApi(
+        parsed,
+        ctx,
+        (client) => client.posts.sendTest(id, {
+          recipients,
+          from,
+          ...replyTo ? { reply_to: replyTo } : {}
+        })
+      );
+    }
+    default:
+      return fail(ctx, `Unknown posts subcommand: ${sub ?? "(none)"}. Try: create, send-test.`);
+  }
+}
+async function contactsCommand(sub, rest, parsed, ctx) {
+  const pub = flagValue(parsed, "publication-id");
+  switch (sub) {
+    case "create": {
+      if (!pub) return fail(ctx, "contacts create requires --publication-id");
+      const email = flagValue(parsed, "email");
+      if (!email) return fail(ctx, "contacts create requires --email");
+      const status = flagValue(parsed, "status");
+      return callApi(
+        parsed,
+        ctx,
+        (client) => client.contacts.create({ publication_id: pub, email, ...status ? { status } : {} })
+      );
+    }
+    case "list": {
+      if (!pub) return fail(ctx, "contacts list requires --publication-id");
+      let params;
+      try {
+        params = listParams(parsed, pub);
+      } catch (error) {
+        return fail(ctx, error instanceof Error ? error.message : String(error));
+      }
+      const status = flagValue(parsed, "status");
+      const search = flagValue(parsed, "search");
+      if (status) params.status = status;
+      if (search) params.search = search;
+      return callApi(parsed, ctx, (client) => client.contacts.list(params));
+    }
+    case "get": {
+      const idOrEmail = rest[0];
+      if (!idOrEmail) return fail(ctx, "contacts get requires an <id-or-email>");
+      if (!pub) return fail(ctx, "contacts get requires --publication-id");
+      return callApi(parsed, ctx, (client) => client.contacts.get(idOrEmail, { publication_id: pub }));
+    }
+    case "update": {
+      const idOrEmail = rest[0];
+      if (!idOrEmail) return fail(ctx, "contacts update requires an <id-or-email>");
+      if (!pub) return fail(ctx, "contacts update requires --publication-id");
+      const status = flagValue(parsed, "status");
+      return callApi(
+        parsed,
+        ctx,
+        (client) => client.contacts.update(idOrEmail, { publication_id: pub, ...status ? { status } : {} })
+      );
+    }
+    case "delete": {
+      const idOrEmail = rest[0];
+      if (!idOrEmail) return fail(ctx, "contacts delete requires an <id-or-email>");
+      if (!pub) return fail(ctx, "contacts delete requires --publication-id");
+      return callApi(parsed, ctx, (client) => client.contacts.delete(idOrEmail, { publication_id: pub }));
+    }
+    default:
+      return fail(ctx, `Unknown contacts subcommand: ${sub ?? "(none)"}. Try: create, list, get, update, delete.`);
+  }
+}
+async function segmentsCommand(sub, rest, parsed, ctx) {
+  const pub = flagValue(parsed, "publication-id");
+  switch (sub) {
+    case "create": {
+      if (!pub) return fail(ctx, "segments create requires --publication-id");
+      const name = flagValue(parsed, "name");
+      if (!name) return fail(ctx, "segments create requires --name");
+      const body = { publication_id: pub, name, ...collect(parsed, ["description", "status-filter", "query-filter"]) };
+      return callApi(parsed, ctx, (client) => client.segments.create(body));
+    }
+    case "list": {
+      if (!pub) return fail(ctx, "segments list requires --publication-id");
+      return listCall(parsed, ctx, pub, (client, params) => client.segments.list(params));
+    }
+    case "get": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "segments get requires <id> and --publication-id");
+      return callApi(parsed, ctx, (client) => client.segments.get(id, { publication_id: pub }));
+    }
+    case "update": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "segments update requires <id> and --publication-id");
+      const body = { publication_id: pub, ...collect(parsed, ["name", "description", "status-filter", "query-filter"]) };
+      return callApi(parsed, ctx, (client) => client.segments.update(id, body));
+    }
+    case "delete": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "segments delete requires <id> and --publication-id");
+      return callApi(parsed, ctx, (client) => client.segments.delete(id, { publication_id: pub }));
+    }
+    default:
+      return fail(ctx, `Unknown segments subcommand: ${sub ?? "(none)"}. Try: create, list, get, update, delete.`);
+  }
+}
+async function tagsCommand(sub, rest, parsed, ctx) {
+  const pub = flagValue(parsed, "publication-id");
+  switch (sub) {
+    case "create": {
+      if (!pub) return fail(ctx, "tags create requires --publication-id");
+      const name = flagValue(parsed, "name");
+      const defaultSubscription = flagValue(parsed, "default-subscription");
+      if (!name) return fail(ctx, "tags create requires --name");
+      if (!defaultSubscription) return fail(ctx, "tags create requires --default-subscription (opt_in|opt_out)");
+      const body = {
+        publication_id: pub,
+        name,
+        default_subscription: defaultSubscription,
+        ...collect(parsed, ["description", "visibility"])
+      };
+      return callApi(parsed, ctx, (client) => client.tags.create(body));
+    }
+    case "list": {
+      if (!pub) return fail(ctx, "tags list requires --publication-id");
+      return listCall(parsed, ctx, pub, (client, params) => client.tags.list(params));
+    }
+    case "get": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "tags get requires <id> and --publication-id");
+      return callApi(parsed, ctx, (client) => client.tags.get(id, { publication_id: pub }));
+    }
+    case "update": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "tags update requires <id> and --publication-id");
+      const body = {
+        publication_id: pub,
+        ...collect(parsed, ["name", "description", "default-subscription", "visibility"])
+      };
+      return callApi(parsed, ctx, (client) => client.tags.update(id, body));
+    }
+    case "delete": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "tags delete requires <id> and --publication-id");
+      return callApi(parsed, ctx, (client) => client.tags.delete(id, { publication_id: pub }));
+    }
+    default:
+      return fail(ctx, `Unknown tags subcommand: ${sub ?? "(none)"}. Try: create, list, get, update, delete.`);
+  }
+}
+async function domainsCommand(sub, rest, parsed, ctx) {
+  if (sub === "tracking") {
+    return domainsTrackingCommand(rest[0], rest.slice(1), parsed, ctx);
+  }
+  const pub = flagValue(parsed, "publication-id");
+  switch (sub) {
+    case "create": {
+      if (!pub) return fail(ctx, "domains create requires --publication-id");
+      const name = flagValue(parsed, "name");
+      if (!name) return fail(ctx, "domains create requires --name");
+      const body = { publication_id: pub, name, ...collect(parsed, ["purpose", "proxy-target"]) };
+      const isPrimary = boolFlag(parsed, "is-primary");
+      if (isPrimary !== void 0) body.is_primary = isPrimary;
+      return callApi(parsed, ctx, (client) => client.domains.create(body));
+    }
+    case "list": {
+      if (!pub) return fail(ctx, "domains list requires --publication-id");
+      return listCall(parsed, ctx, pub, (client, params) => client.domains.list(params));
+    }
+    case "get": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "domains get requires <id> and --publication-id");
+      return callApi(parsed, ctx, (client) => client.domains.get(id, { publication_id: pub }));
+    }
+    case "verify": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "domains verify requires <id> and --publication-id");
+      return callApi(parsed, ctx, (client) => client.domains.verify(id, { publication_id: pub }));
+    }
+    case "update": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "domains update requires <id> and --publication-id");
+      const body = { publication_id: pub, ...collect(parsed, ["purpose", "proxy-target"]) };
+      const isPrimary = boolFlag(parsed, "is-primary");
+      if (isPrimary !== void 0) body.is_primary = isPrimary;
+      return callApi(parsed, ctx, (client) => client.domains.update(id, body));
+    }
+    case "delete": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "domains delete requires <id> and --publication-id");
+      return callApi(parsed, ctx, (client) => client.domains.delete(id, { publication_id: pub }));
+    }
+    default:
+      return fail(
+        ctx,
+        `Unknown domains subcommand: ${sub ?? "(none)"}. Try: create, list, get, verify, update, delete, tracking.`
+      );
+  }
+}
+async function domainsTrackingCommand(verb, rest, parsed, ctx) {
+  const pub = flagValue(parsed, "publication-id");
+  const domainId = flagValue(parsed, "domain-id");
+  if (!pub) return fail(ctx, "domains tracking requires --publication-id");
+  if (!domainId) return fail(ctx, "domains tracking requires --domain-id");
+  switch (verb) {
+    case "create": {
+      const subdomain = flagValue(parsed, "subdomain");
+      if (!subdomain) return fail(ctx, "domains tracking create requires --subdomain");
+      return callApi(
+        parsed,
+        ctx,
+        (client) => client.domains.tracking.create(domainId, { publication_id: pub, subdomain })
+      );
+    }
+    case "list":
+      return callApi(parsed, ctx, (client) => client.domains.tracking.list(domainId, { publication_id: pub }));
+    case "verify": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "domains tracking verify requires a <tracking-domain-id>");
+      return callApi(parsed, ctx, (client) => client.domains.tracking.verify(domainId, id, { publication_id: pub }));
+    }
+    case "delete": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "domains tracking delete requires a <tracking-domain-id>");
+      return callApi(parsed, ctx, (client) => client.domains.tracking.delete(domainId, id, { publication_id: pub }));
+    }
+    default:
+      return fail(ctx, `Unknown domains tracking subcommand: ${verb ?? "(none)"}. Try: create, list, verify, delete.`);
+  }
+}
+async function webhooksCommand(sub, rest, parsed, ctx) {
+  const pub = flagValue(parsed, "publication-id");
+  switch (sub) {
+    case "create": {
+      if (!pub) return fail(ctx, "webhooks create requires --publication-id");
+      const endpoint = flagValue(parsed, "endpoint");
+      const events = splitList(flagList(parsed, "event"));
+      if (!endpoint) return fail(ctx, "webhooks create requires --endpoint");
+      if (events.length === 0) return fail(ctx, "webhooks create requires at least one --event");
+      return callApi(
+        parsed,
+        ctx,
+        (client) => client.webhooks.create({ publication_id: pub, endpoint, events })
+      );
+    }
+    case "list": {
+      if (!pub) return fail(ctx, "webhooks list requires --publication-id");
+      return listCall(parsed, ctx, pub, (client, params) => client.webhooks.list(params));
+    }
+    case "get": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "webhooks get requires <id> and --publication-id");
+      return callApi(parsed, ctx, (client) => client.webhooks.get(id, { publication_id: pub }));
+    }
+    case "update": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "webhooks update requires <id> and --publication-id");
+      const body = { publication_id: pub, ...collect(parsed, ["endpoint", "status"]) };
+      const events = splitList(flagList(parsed, "event"));
+      if (events.length > 0) body.events = events;
+      return callApi(parsed, ctx, (client) => client.webhooks.update(id, body));
+    }
+    case "delete": {
+      const id = rest[0];
+      if (!id || !pub) return fail(ctx, "webhooks delete requires <id> and --publication-id");
+      return callApi(parsed, ctx, (client) => client.webhooks.delete(id, { publication_id: pub }));
+    }
+    default:
+      return fail(ctx, `Unknown webhooks subcommand: ${sub ?? "(none)"}. Try: create, list, get, update, delete.`);
+  }
+}
+async function contactPropertiesCommand(sub, rest, parsed, ctx) {
+  switch (sub) {
+    case "create": {
+      const key = flagValue(parsed, "key");
+      const type = flagValue(parsed, "type");
+      if (!key) return fail(ctx, "contact-properties create requires --key");
+      if (!type) return fail(ctx, "contact-properties create requires --type (string|number)");
+      const body = { key, type, ...collect(parsed, ["fallback-value", "description"]) };
+      return callApi(parsed, ctx, (client) => client.contactProperties.create(body));
+    }
+    case "list":
+      return callApi(parsed, ctx, (client) => {
+        const params = {};
+        const limit = intFlag(parsed, "limit");
+        if (limit !== void 0) params.limit = limit;
+        const after = flagValue(parsed, "after");
+        if (after) params.after = after;
+        return client.contactProperties.list(params);
+      });
+    case "update": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "contact-properties update requires an <id>");
+      const body = collect(parsed, ["fallback-value", "description"]);
+      return callApi(parsed, ctx, (client) => client.contactProperties.update(id, body));
+    }
+    case "delete": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "contact-properties delete requires an <id>");
+      return callApi(parsed, ctx, (client) => client.contactProperties.delete(id));
+    }
+    default:
+      return fail(ctx, `Unknown contact-properties subcommand: ${sub ?? "(none)"}. Try: create, list, update, delete.`);
+  }
+}
+async function apiKeysCommand(sub, rest, parsed, ctx) {
+  switch (sub) {
+    case "create": {
+      const name = flagValue(parsed, "name");
+      if (!name) return fail(ctx, "api-keys create requires --name");
+      const body = { name, ...collect(parsed, ["permission", "domain-id"]) };
+      return callApi(parsed, ctx, (client) => client.apiKeys.create(body));
+    }
+    case "list":
+      return callApi(parsed, ctx, (client) => client.apiKeys.list());
+    case "revoke": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "api-keys revoke requires an <id>");
+      return callApi(parsed, ctx, (client) => client.apiKeys.revoke(id));
+    }
+    default:
+      return fail(ctx, `Unknown api-keys subcommand: ${sub ?? "(none)"}. Try: create, list, revoke.`);
+  }
+}
+async function templatesCommand(sub, rest, parsed, ctx) {
+  const pub = flagValue(parsed, "publication-id");
+  if (!pub) return fail(ctx, "templates commands require --publication-id");
+  switch (sub) {
+    case "create": {
+      const name = flagValue(parsed, "name");
+      if (!name) return fail(ctx, "templates create requires --name");
+      const html = flagValue(parsed, "html");
+      const spec = parseJsonFlag(parsed, "spec");
+      if (spec === INVALID_JSON) return fail(ctx, "templates create --spec must be valid JSON");
+      if (!html && spec === void 0) return fail(ctx, "templates create requires --html or --spec");
+      const args = { publicationId: pub, name };
+      if (html) args.html = html;
+      if (spec !== void 0) args.spec = spec;
+      const description = flagValue(parsed, "description");
+      const subject = flagValue(parsed, "subject");
+      if (description) args.description = description;
+      if (subject) args.subject = subject;
+      return runBridgeTool(parsed, ctx, "template.create", args);
+    }
+    case "list": {
+      const args = { publicationId: pub };
+      const limit = intFlag(parsed, "limit");
+      if (limit !== void 0) args.limit = limit;
+      return runBridgeTool(parsed, ctx, "template.list", args);
+    }
+    case "get": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "templates get requires a <template-id>");
+      return runBridgeTool(parsed, ctx, "template.get", { publicationId: pub, templateId: id });
+    }
+    case "update": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "templates update requires a <template-id>");
+      const args = { publicationId: pub, templateId: id };
+      for (const key of ["name", "html", "description", "text", "subject", "from", "reply-to"]) {
+        const v = flagValue(parsed, key);
+        if (v !== void 0) args[key === "reply-to" ? "reply_to" : key] = v;
+      }
+      const spec = parseJsonFlag(parsed, "spec");
+      if (spec === INVALID_JSON) return fail(ctx, "templates update --spec must be valid JSON");
+      if (spec !== void 0) args.spec = spec;
+      return runBridgeTool(parsed, ctx, "template.update", args);
+    }
+    case "publish": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "templates publish requires a <template-id>");
+      return runBridgeTool(parsed, ctx, "template.publish", { publicationId: pub, templateId: id });
+    }
+    case "duplicate": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "templates duplicate requires a <template-id>");
+      return runBridgeTool(parsed, ctx, "template.duplicate", { publicationId: pub, templateId: id });
+    }
+    case "delete": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "templates delete requires a <template-id>");
+      return runBridgeTool(parsed, ctx, "template.delete", { publicationId: pub, templateId: id });
+    }
+    default:
+      return fail(
+        ctx,
+        `Unknown templates subcommand: ${sub ?? "(none)"}. Try: create, list, get, update, publish, duplicate, delete.`
+      );
+  }
+}
+async function inboundCommand(sub, rest, parsed, ctx) {
+  switch (sub) {
+    case "list": {
+      const pub = flagValue(parsed, "publication-id");
+      if (!pub) return fail(ctx, "inbound list requires --publication-id");
+      const params = { publication_id: pub };
+      let limit;
+      try {
+        limit = intFlag(parsed, "limit");
+      } catch (error) {
+        return fail(ctx, error instanceof Error ? error.message : String(error));
+      }
+      if (limit !== void 0) params.limit = limit;
+      const cursor = flagValue(parsed, "cursor");
+      if (cursor) params.cursor = cursor;
+      return callApi(parsed, ctx, (client) => client.emails.inbound.list(params));
+    }
+    case "get": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "inbound get requires an <id>");
+      return callApi(parsed, ctx, (client) => client.emails.inbound.get(id));
+    }
+    case "attachments": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "inbound attachments requires an <id>");
+      return callApi(parsed, ctx, (client) => client.emails.inbound.attachments.list(id));
+    }
+    case "attachment": {
+      const id = rest[0];
+      const attachmentId = rest[1];
+      if (!id || !attachmentId) return fail(ctx, "inbound attachment requires <id> and <attachment-id>");
+      return callApi(parsed, ctx, (client) => client.emails.inbound.attachments.get(id, attachmentId));
+    }
+    case "reply": {
+      const id = rest[0];
+      if (!id) return fail(ctx, "inbound reply requires an <id>");
+      const html = flagValue(parsed, "html");
+      const text = flagValue(parsed, "text");
+      if (!html && !text) return fail(ctx, "inbound reply requires --html or --text");
+      const body = {};
+      const fromEmail = flagValue(parsed, "from");
+      if (fromEmail) {
+        const fromName = flagValue(parsed, "from-name");
+        body.from = { email: fromEmail, ...fromName ? { name: fromName } : {} };
+      }
+      const subject = flagValue(parsed, "subject");
+      if (subject) body.subject = subject;
+      if (html) body.html = html;
+      if (text) body.text = text;
+      const cc = splitList(flagList(parsed, "cc"));
+      if (cc.length) body.cc = cc;
+      const bcc = splitList(flagList(parsed, "bcc"));
+      if (bcc.length) body.bcc = bcc;
+      const idempotencyKey = flagValue(parsed, "idempotency-key");
+      if (idempotencyKey) body.idempotency_key = idempotencyKey;
+      return callApi(parsed, ctx, (client) => client.emails.inbound.reply(id, body));
+    }
+    default:
+      return fail(
+        ctx,
+        `Unknown inbound subcommand: ${sub ?? "(none)"}. Try: list, get, attachments, attachment, reply.`
+      );
+  }
+}
+function doLogin(parsed, ctx) {
+  const apiKey = flagValue(parsed, "api-key");
+  if (!apiKey) {
+    ctx.err("login requires --api-key mt_pat_xxx");
+    return 1;
+  }
+  const baseUrl = flagValue(parsed, "base-url");
+  const dir = join(ctx.home, ".mailtea");
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, "config.json");
+  writeFileSync(
+    path,
+    `${JSON.stringify({ apiKey, ...baseUrl ? { baseUrl } : {} }, null, 2)}
+`,
+    { mode: 384 }
+  );
+  ctx.out(JSON.stringify({ ok: true, path }));
+  return 0;
+}
+function resolveAuth(parsed, ctx) {
+  const config = loadConfig(ctx.home);
+  const apiKey = flagValue(parsed, "api-key") ?? ctx.env.MAILTEA_API_KEY ?? ctx.env.MAILTEA_API_TOKEN ?? config.apiKey;
+  if (!apiKey) {
+    ctx.err(
+      JSON.stringify({
+        error: "Missing API key. Use --api-key, set MAILTEA_API_KEY, or run `mailtea login`."
+      })
+    );
+    return null;
+  }
+  const baseUrl = flagValue(parsed, "base-url") ?? ctx.env.MAILTEA_API_BASE_URL ?? config.baseUrl;
+  return { apiKey, baseUrl };
+}
+async function callApi(parsed, ctx, op) {
+  const auth = resolveAuth(parsed, ctx);
+  if (!auth) return 1;
+  const client = new Mailtea(auth.apiKey, { baseUrl: auth.baseUrl, fetch: ctx.fetchImpl });
+  try {
+    const result = await op(client);
+    ctx.out(JSON.stringify(result ?? { ok: true }));
+    return 0;
+  } catch (error) {
+    if (error instanceof MailteaError) {
+      ctx.err(
+        JSON.stringify({
+          error: error.message,
+          status: error.status,
+          details: error.details,
+          requestId: error.requestId
+        })
+      );
+    } else {
+      ctx.err(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+    }
+    return 1;
+  }
+}
+function listCall(parsed, ctx, pub, op) {
+  let params;
+  try {
+    params = listParams(parsed, pub);
+  } catch (error) {
+    return Promise.resolve(fail(ctx, error instanceof Error ? error.message : String(error)));
+  }
+  return callApi(parsed, ctx, (client) => op(client, params));
+}
+function listParams(parsed, pub) {
+  const params = { publication_id: pub };
+  const limit = intFlag(parsed, "limit");
+  if (limit !== void 0) params.limit = limit;
+  const after = flagValue(parsed, "after");
+  if (after) params.after = after;
+  return params;
+}
+function collect(parsed, keys) {
+  const body = {};
+  for (const key of keys) {
+    const value = flagValue(parsed, key);
+    if (value !== void 0) body[key.replace(/-/g, "_")] = value;
+  }
+  return body;
+}
+function buildSendPayload(parsed) {
+  const recipients = (key) => {
+    const all = splitList(flagList(parsed, key));
+    if (all.length === 0) return void 0;
+    return all.length === 1 ? all[0] : all;
+  };
+  const payload = {
+    from: flagValue(parsed, "from"),
+    to: recipients("to"),
+    subject: flagValue(parsed, "subject")
+  };
+  const html = flagValue(parsed, "html");
+  const text = flagValue(parsed, "text");
+  const templateId = flagValue(parsed, "template-id");
+  if (html) payload.html = html;
+  if (text) payload.text = text;
+  if (templateId) {
+    const vars = flagPairs(parsed, "template-var");
+    payload.template = {
+      id: templateId,
+      ...vars.length ? { variables: Object.fromEntries(vars.map((v) => [v.name, v.value])) } : {}
+    };
+  }
+  const cc = recipients("cc");
+  if (cc) payload.cc = cc;
+  const bcc = recipients("bcc");
+  if (bcc) payload.bcc = bcc;
+  const replyTo = recipients("reply-to");
+  if (replyTo) payload.reply_to = replyTo;
+  const scheduledAt = flagValue(parsed, "scheduled-at");
+  if (scheduledAt) payload.scheduled_at = scheduledAt;
+  const tags = flagPairs(parsed, "tag");
+  if (tags.length) payload.tags = tags;
+  const headers = flagPairs(parsed, "header");
+  if (headers.length) payload.headers = Object.fromEntries(headers.map((h) => [h.name, h.value]));
+  return payload;
+}
+function validateSend(payload) {
+  if (!payload.from) return "emails send requires --from";
+  if (!payload.to) return "emails send requires --to";
+  if (!payload.subject) return "emails send requires --subject";
+  if (!payload.html && !payload.text && !payload.template) {
+    return "emails send requires --html, --text, or --template-id";
+  }
+  return null;
+}
+function buildListParams(parsed) {
+  const params = {};
+  const status = flagValue(parsed, "status");
+  if (status) params.status = status;
+  const limit = intFlag(parsed, "limit");
+  if (limit !== void 0) params.limit = limit;
+  const offset = intFlag(parsed, "offset");
+  if (offset !== void 0) params.offset = offset;
+  const tagName = flagValue(parsed, "tag-name");
+  if (tagName) params.tag_name = tagName;
+  const tagValue = flagValue(parsed, "tag-value");
+  if (tagValue) params.tag_value = tagValue;
+  const fromDate = flagValue(parsed, "from-date");
+  if (fromDate) params.from_date = fromDate;
+  const toDate = flagValue(parsed, "to-date");
+  if (toDate) params.to_date = toDate;
+  return params;
+}
+function loadConfig(home) {
+  try {
+    return JSON.parse(readFileSync(join(home, ".mailtea", "config.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function splitList(values) {
+  return values.flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+}
+function intFlag(parsed, key) {
+  const raw = flagValue(parsed, key);
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`--${key} must be a non-negative integer (got "${raw}")`);
+  }
+  return value;
+}
+function boolFlag(parsed, key) {
+  const raw = flagValue(parsed, key);
+  if (raw === void 0) return void 0;
+  return raw !== "false";
+}
+var INVALID_JSON = /* @__PURE__ */ Symbol("invalid-json");
+function parseJsonFlag(parsed, key) {
+  const raw = flagValue(parsed, key);
+  if (raw === void 0) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return INVALID_JSON;
+  }
+}
+function fail(ctx, message) {
+  ctx.err(message);
+  return 1;
+}
+var USAGE = `mailtea \u2014 send and manage email from your shell or AI agent
+
+Capabilities (full MCP parity):
+  mailtea tools [--names]                 List every available capability (no auth)
+  mailtea schema <tool>                   Print a tool's JSON input schema (no auth)
+  mailtea call <tool> [--json '{...}'] [--arg k=v ...]
+                                          Invoke any of the ~121 MCP tools
+
+Common email & audience commands:
+  mailtea emails send --from <a> --to <a> --subject <s> (--html <h> | --text <t> | --template-id <id>)
+  mailtea emails batch --json '[{...}, ...]'
+  mailtea emails list|get|cancel|reschedule|analytics ...
+  mailtea posts create --publication-id <id> --subject <s> (--template-id <id> [--template-var k=v ...] | --html <h>) [--kind newsletter|broadcast]
+  mailtea posts send-test <post-id> --to <addr> --from <addr> [--reply-to <addr>]
+  mailtea contacts create|list|get|update|delete --publication-id <pub> ...
+  mailtea segments create|list|get|update|delete --publication-id <pub> ...
+  mailtea tags create|list|get|update|delete --publication-id <pub> ...
+  mailtea domains create|list|get|verify|update|delete --publication-id <pub> ...
+  mailtea domains tracking create|list|verify|delete --publication-id <pub> --domain-id <id> ...
+  mailtea webhooks create|list|get|update|delete --publication-id <pub> [--event <e> ...]
+  mailtea contact-properties create|list|update|delete ...
+  mailtea api-keys create|list|revoke ...
+  mailtea templates create|list|get|update|publish|duplicate|delete --publication-id <pub> ...
+  mailtea inbound list --publication-id <pub> [--limit <n>] [--cursor <c>]
+  mailtea inbound get|attachments <id>
+  mailtea inbound attachment <id> <attachment-id>
+  mailtea inbound reply <id> (--html <h> | --text <t>) [--from <addr> --from-name <n>] [--subject <s>] [--cc <a> ...] [--bcc <a> ...] [--idempotency-key <k>]
+  mailtea login --api-key mt_pat_xxx [--base-url <url>]
+  mailtea version | help
+
+Auth (in order): --api-key flag, MAILTEA_API_KEY / MAILTEA_API_TOKEN env, or ~/.mailtea/config.json (mailtea login).
+Self-host/local: --base-url or MAILTEA_API_BASE_URL.
+
+emails send flags: --cc --bcc --reply-to (repeatable / comma-separated), --scheduled-at <iso>,
+            --tag name=value (repeatable), --header name=value (repeatable),
+            --template-var name=value (repeatable), --dry-run (print payload, don't send).
+
+Output is JSON on stdout; errors are JSON on stderr with a non-zero exit code.`;
+export {
+  VERSION,
+  run
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "mailtea-cli",
+  "version": "0.1.1",
+  "description": "Mailtea CLI — send, schedule, and manage email from your shell or AI agent.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "mailtea": "bin/mailtea.mjs"
+  },
+  "main": "dist/cli.js",
+  "types": "dist/cli.d.ts",
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "keywords": [
+    "mailtea",
+    "email",
+    "cli",
+    "transactional-email",
+    "ai-agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mailtea-app/mailtea-cli.git"
+  },
+  "homepage": "https://mailtea.app",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    }
+  },
+  "dependencies": {
+    "mailtea-mcp": "0.1.1",
+    "mailtea-sdk": "0.1.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "dev": "tsup src/cli.ts --watch --format esm --dts",
+    "build": "tsup src/cli.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo \"No lint for mailtea-cli yet\"",
+    "test": "tsx --test src/*.test.ts"
+  }
+}