carlyemail 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SWH Labs LLC
+
+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,113 @@
+# carlyemail
+
+Real email inboxes your agent can send, receive and reply from.
+
+```bash
+npx carlyemail signup --human-email you@example.com --username my-agent
+```
+
+That returns a working address and an API key. Confirm the emailed code and it
+can send:
+
+```bash
+npx carlyemail verify 123456
+npx carlyemail send \
+  --from my-agent@agents.carlyemail.com \
+  --to someone@example.com \
+  --subject "Hello" \
+  --text "Sent by an agent with its own address."
+```
+
+Install it properly if you use it often:
+
+```bash
+npm install -g carlyemail
+```
+
+## Commands
+
+| | |
+|---|---|
+| `signup --human-email <e> --username <u>` | Create an account and an inbox |
+| `verify <code>` | Confirm the owner email |
+| `whoami` | Identity and scope of the current key |
+| `inboxes` | List inboxes |
+| `create --username <u>` | Create an inbox |
+| `delete <inbox> --yes` | Delete an inbox and its mail |
+| `send --from <i> --to <a> --subject <s> --text <t>` | Send an email |
+| `messages <inbox>` | List messages |
+| `plan` | Current plan, with usage against every limit |
+| `upgrade <plan>` | A Stripe checkout link |
+| `billing` | Invoices, card changes, cancellation |
+| `mcp` | The MCP endpoint, for Claude and other clients |
+
+## Scripting
+
+`--json` prints the API response untouched — the same shape the
+[API reference](https://docs.carlyemail.com/api-reference) documents, not a
+reshaped subset:
+
+```bash
+carlyemail inboxes --json | jq -r '.inboxes[].email'
+carlyemail plan --json | jq '.organization.storage_bytes'
+```
+
+Failures still exit `1` under `--json`, and the error is still printed, so
+`set -e` behaves.
+
+## Configuration
+
+The key is saved to `~/.carlyemail/config.json`, written `0600` — it can read
+and send your mail, so it is not left group-readable.
+
+Two environment variables override it, and the environment always wins:
+
+| | |
+|---|---|
+| `CARLYEMAIL_API_KEY` | Use this key instead of the saved one |
+| `CARLYEMAIL_API_URL` | Point at a different deployment |
+
+That ordering is what makes CI and containers work without touching the saved
+state, and it means running one command as a different account is a prefix
+rather than a login.
+
+## Notes
+
+**Sign-up is idempotent by owner email, and rotates the key.** Running it again
+for an address that already has an account issues a new key and **revokes the
+previous one**. It is how you recover a lost key; it is not a way to add a
+second inbox. Use `create` for that.
+
+**`delete` requires `--yes`.** It removes the inbox and every message in it,
+and there is no undo.
+
+**Exit codes are meaningful.** `0` on success, `1` on any failure, so
+`carlyemail send … || handle-it` behaves in a script.
+
+**Errors carry their fix.** The API answers with a message, the thing that
+clears it, and a documentation link; all three are printed.
+
+```
+✗ Inbox limit reached (3 on the free plan).
+  Upgrade the plan, or delete an inbox you no longer need.
+  https://docs.carlyemail.com/inboxes
+```
+
+## Requirements
+
+Node 18 or newer. No dependencies — this is one file that uses Node's built-in
+`fetch`, so `npx` never resolves a tree and never fails for a reason unrelated
+to the thing you asked for.
+
+## Licence
+
+MIT — see `LICENSE`. That covers **this CLI only**. The CarlyEmail service it
+talks to is a separate, proprietary product; a permissive licence on an HTTP
+client grants nothing over the API behind it.
+
+## Links
+
+- [Documentation](https://docs.carlyemail.com)
+- [API reference](https://docs.carlyemail.com/api-reference)
+- [Pricing](https://carlyemail.com/pricing)
+- [Support](https://docs.carlyemail.com/support)

package/carlyemail.js

@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+// CarlyEmail command line.
+//
+// One file, no dependencies, no build step. That is a deliberate constraint
+// rather than minimalism for its own sake: this is the first thing a new user
+// runs, usually through `npx`, and every dependency is a chance for that first
+// command to fail on somebody's machine for a reason that has nothing to do
+// with us. Node 18+ has `fetch` built in, which is the only thing a REST client
+// actually needs.
+//
+// The CLI is a thin shell over the same public API the docs describe. It holds
+// no logic the API does not — if a command here disagrees with the server, the
+// server is right.
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const VERSION = "0.1.0";
+
+const DEFAULT_API = "https://api.carlyemail.com";
+const CONFIG_DIR = join(homedir(), ".carlyemail");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+// ---------------------------------------------------------------- output
+
+const isTTY = process.stdout.isTTY;
+const paint = (code, s) => (isTTY ? `[${code}m${s}` : s);
+const dim = (s) => paint(2, s);
+const bold = (s) => paint(1, s);
+
+export const ok = (s) => `${paint(32, "✓")} ${s}`;
+export const arrow = (s) => `${dim("→")} ${s}`;
+
+/** A credential is shown once, at creation, and never echoed again. */
+export function maskKey(key) {
+  if (!key || key.length < 12) return "(hidden)";
+  return `${key.slice(0, 9)}${"·".repeat(8)}${key.slice(-4)}`;
+}
+
+// ---------------------------------------------------------------- config
+
+/**
+ * Where the API key lives between commands.
+ *
+ * The environment wins over the file, always. That is what lets CI, a
+ * container, or a second account run without touching the machine's saved
+ * state — and it means `CARLYEMAIL_API_KEY=... carlyemail whoami` does the
+ * obvious thing rather than silently using somebody else's key.
+ */
+export function loadConfig(env = process.env, file = CONFIG_FILE) {
+  const config = { api_url: DEFAULT_API };
+  if (existsSync(file)) {
+    try {
+      Object.assign(config, JSON.parse(readFileSync(file, "utf8")));
+    } catch {
+      // A corrupt config must not brick every command. `signup` rewrites it.
+      process.stderr.write(dim(`warning: ${file} is not valid JSON; ignoring it\n`));
+    }
+  }
+  if (env.CARLYEMAIL_API_KEY) config.api_key = env.CARLYEMAIL_API_KEY;
+  if (env.CARLYEMAIL_API_URL) config.api_url = env.CARLYEMAIL_API_URL;
+  return config;
+}
+
+/**
+ * Written 0600, and the directory 0700.
+ *
+ * This file holds a credential that can read and send someone's mail. The
+ * default umask would leave it group- and world-readable on a shared machine,
+ * which is not a state anybody would choose if asked.
+ */
+export function saveConfig(config, file = CONFIG_FILE, dir = CONFIG_DIR) {
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+  chmodSync(file, 0o600); // existing files keep their old mode without this
+  return file;
+}
+
+// ---------------------------------------------------------------- errors
+
+export class ApiError extends Error {
+  constructor(status, body) {
+    const message = (body && body.message) || `request failed with ${status}`;
+    super(message);
+    this.status = status;
+    this.code = body && body.code;
+    this.fix = body && body.fix;
+    this.docs = body && body.docs;
+  }
+
+  /**
+   * The API answers with `{name, code, message, fix, docs}`. The `fix` field
+   * is the actionable half and printing only `message` throws it away — which
+   * matters most for the plan limits, where the message says what ran out and
+   * the fix says what clears it.
+   */
+  render() {
+    const lines = [`${paint(31, "✗")} ${this.message}`];
+    if (this.fix) lines.push(`  ${this.fix}`);
+    if (this.docs) lines.push(dim(`  ${this.docs}`));
+    return lines.join("\n");
+  }
+}
+
+class UsageError extends Error {}
+
+// ---------------------------------------------------------------- transport
+
+export async function request(config, method, path, { body, auth = true, fetchImpl = fetch } = {}) {
+  const headers = { accept: "application/json" };
+  if (body !== undefined) headers["content-type"] = "application/json";
+  if (auth) {
+    if (!config.api_key) {
+      throw new UsageError(
+        "No API key. Run `carlyemail signup` first, or set CARLYEMAIL_API_KEY."
+      );
+    }
+    headers.authorization = `Bearer ${config.api_key}`;
+  }
+
+  let response;
+  try {
+    response = await fetchImpl(`${config.api_url}${path}`, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body),
+    });
+  } catch (cause) {
+    throw new Error(`could not reach ${config.api_url}: ${cause.message}`);
+  }
+
+  if (response.status === 204) return null;
+
+  const text = await response.text();
+  let parsed = null;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      // A gateway or proxy failing in front of us answers HTML, not our
+      // envelope. Say so rather than printing a page of markup.
+      if (!response.ok) throw new ApiError(response.status, { message: text.slice(0, 200) });
+    }
+  }
+  if (!response.ok) throw new ApiError(response.status, parsed);
+  return parsed;
+}
+
+// ---------------------------------------------------------------- arguments
+
+/**
+ * `--flag value`, `--flag=value`, and bare positionals. No parser library,
+ * because the grammar is this small and a dependency here costs more than it
+ * saves.
+ */
+export function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const equals = arg.indexOf("=");
+    if (equals !== -1) {
+      flags[arg.slice(2, equals)] = arg.slice(equals + 1);
+    } else if (i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
+      flags[arg.slice(2)] = argv[++i];
+    } else {
+      flags[arg.slice(2)] = true;
+    }
+  }
+  return { flags, positional };
+}
+
+function required(flags, name) {
+  const value = flags[name];
+  if (typeof value !== "string" || !value) {
+    throw new UsageError(`--${name} is required`);
+  }
+  return value;
+}
+
+// ---------------------------------------------------------------- commands
+
+const commands = {};
+const define = (name, summary, usage, run) => {
+  commands[name] = { name, summary, usage, run };
+};
+
+/**
+ * Print either the raw API payload or a human rendering of it.
+ *
+ * `--json` exists because this is a CLI for people building agents, and the
+ * second thing they do after running a command by hand is put it in a script.
+ * Making them re-parse a table we formatted would be a strange thing to ask
+ * when we already had the JSON.
+ *
+ * The payload is passed through untouched — not a reshaped subset — so what a
+ * script sees matches the API reference rather than our idea of the useful
+ * fields.
+ */
+function emit(ctx, payload, render) {
+  if (ctx.flags.json) {
+    ctx.print(JSON.stringify(payload, null, 2));
+    return;
+  }
+  render();
+}
+
+define(
+  "signup",
+  "Create an account and an inbox",
+  "carlyemail signup --human-email you@example.com --username my-agent",
+  async (ctx) => {
+    const human_email = required(ctx.flags, "human-email");
+    const username = required(ctx.flags, "username");
+
+    const out = await request(ctx.config, "POST", "/v0/agent/sign-up", {
+      auth: false,
+      body: { human_email, username, source: "cli" },
+    });
+
+    // Saved before anything else is printed: the key is returned exactly once
+    // and is unrecoverable afterwards, so losing it to a later crash would
+    // cost the account.
+    const saved = saveConfig(
+      { ...ctx.config, api_key: out.api_key, organization_id: out.organization_id },
+      ctx.configFile,
+      ctx.configDir
+    );
+
+    ctx.print(ok(bold(out.inbox_id)));
+    ctx.print(ok(`key saved to ${saved}`));
+    ctx.print("");
+    ctx.print(arrow(`check ${human_email} for a 6-digit code, then:`));
+    ctx.print(`    carlyemail verify <code>`);
+    ctx.print("");
+    ctx.print(dim("Until it is confirmed the account can read its own mail but not send."));
+  }
+);
+
+define("verify", "Confirm the owner email with the code", "carlyemail verify 123456", async (ctx) => {
+  const code = ctx.positional[0] || ctx.flags.code;
+  if (!code) throw new UsageError("the 6-digit code is required: carlyemail verify 123456");
+
+  await request(ctx.config, "POST", "/v0/agent/verify", { body: { otp_code: String(code) } });
+  ctx.print(ok("verified — this account can send now"));
+});
+
+define("whoami", "Show the key's identity and scope", "carlyemail whoami", async (ctx) => {
+  const me = await request(ctx.config, "GET", "/v0/auth/me");
+  emit(ctx, me, () => {
+  ctx.print(`${dim("organization")}  ${me.organization_id ?? "—"}`);
+  ctx.print(`${dim("scope")}         ${me.scope_type ?? "—"}${me.scope_id ? dim(`  ${me.scope_id}`) : ""}`);
+  // Worth its own line rather than folded into scope: a key pinned to one
+  // inbox cannot reach a sibling, and "why does this 404" is the question it
+  // answers.
+  if (me.inbox_id) ctx.print(`${dim("inbox")}         ${me.inbox_id} ${dim("(this key sees only this inbox)")}`);
+  ctx.print(`${dim("key")}           ${maskKey(ctx.config.api_key)} ${dim(me.api_key_id ?? "")}`);
+  ctx.print(`${dim("api")}           ${ctx.config.api_url}`);
+  });
+});
+
+define("inboxes", "List inboxes", "carlyemail inboxes", async (ctx) => {
+  const out = await request(ctx.config, "GET", "/v0/inboxes");
+  emit(ctx, out, () => {
+    if (!out.inboxes.length) {
+      ctx.print(dim("no inboxes"));
+      return;
+    }
+    for (const inbox of out.inboxes) {
+      ctx.print(`${bold(inbox.email)}${inbox.display_name ? dim(`  ${inbox.display_name}`) : ""}`);
+    }
+  });
+});
+
+define("create", "Create an inbox", "carlyemail create --username support", async (ctx) => {
+  const username = ctx.positional[0] || required(ctx.flags, "username");
+  const body = { username };
+  if (typeof ctx.flags.domain === "string") body.domain = ctx.flags.domain;
+  const inbox = await request(ctx.config, "POST", "/v0/inboxes", { body });
+  emit(ctx, inbox, () => ctx.print(ok(bold(inbox.email))));
+});
+
+define("delete", "Delete an inbox and its mail", "carlyemail delete support@carlyemail.com", async (ctx) => {
+  const inbox = ctx.positional[0];
+  if (!inbox) throw new UsageError("which inbox? carlyemail delete <inbox>");
+  if (!ctx.flags.yes) {
+    throw new UsageError(
+      `this deletes ${inbox} and every message in it. Re-run with --yes to confirm.`
+    );
+  }
+  await request(ctx.config, "DELETE", `/v0/inboxes/${encodeURIComponent(inbox)}`);
+  ctx.print(ok(`deleted ${inbox}`));
+});
+
+define(
+  "send",
+  "Send an email",
+  'carlyemail send --from me@carlyemail.com --to you@example.com --subject Hi --text "Hello"',
+  async (ctx) => {
+    const from = required(ctx.flags, "from");
+    const body = {
+      to: required(ctx.flags, "to").split(",").map((s) => s.trim()),
+      subject: typeof ctx.flags.subject === "string" ? ctx.flags.subject : undefined,
+      text: typeof ctx.flags.text === "string" ? ctx.flags.text : undefined,
+      html: typeof ctx.flags.html === "string" ? ctx.flags.html : undefined,
+    };
+    const sent = await request(
+      ctx.config,
+      "POST",
+      `/v0/inboxes/${encodeURIComponent(from)}/messages/send`,
+      { body }
+    );
+    emit(ctx, sent, () => ctx.print(ok(`sent  ${dim(sent.message_id ?? "")}`)));
+  }
+);
+
+define("messages", "List messages in an inbox", "carlyemail messages me@carlyemail.com", async (ctx) => {
+  const inbox = ctx.positional[0];
+  if (!inbox) throw new UsageError("which inbox? carlyemail messages <inbox>");
+  const out = await request(
+    ctx.config,
+    "GET",
+    `/v0/inboxes/${encodeURIComponent(inbox)}/messages`
+  );
+  emit(ctx, out, () => {
+    if (!out.messages.length) {
+      ctx.print(dim("no messages"));
+      return;
+    }
+    for (const m of out.messages) {
+      const when = (m.timestamp || "").slice(0, 16).replace("T", " ");
+      ctx.print(`${dim(when)}  ${bold(m.subject || "(no subject)")}`);
+      ctx.print(`${" ".repeat(18)}${dim(`from ${m.from ?? m.from_address ?? "?"}`)}`);
+    }
+  });
+});
+
+define("plan", "Show the current plan and its limits", "carlyemail plan", async (ctx) => {
+  const [billing, org] = await Promise.all([
+    request(ctx.config, "GET", "/v0/billing"),
+    request(ctx.config, "GET", "/v0/organizations"),
+  ]);
+  if (ctx.flags.json) {
+    ctx.print(JSON.stringify({ billing, organization: org }, null, 2));
+    return;
+  }
+  const cap = (n) => (n === null || n === undefined ? "unlimited" : String(n));
+  const gb = (b) => (b === null || b === undefined ? "unlimited" : `${(b / 1024 ** 3).toFixed(1)} GB`);
+
+  ctx.print(`${bold(billing.plan)}  ${dim(`$${billing.price_usd_month}/mo`)}`);
+  ctx.print("");
+  ctx.print(`  ${dim("inboxes")}   ${org.inbox_count} / ${cap(org.inbox_limit)}`);
+  ctx.print(`  ${dim("domains")}   ${org.domain_count} / ${cap(org.domain_limit)}`);
+  ctx.print(`  ${dim("pods")}      ${org.pod_count} / ${cap(org.pod_limit)}`);
+  ctx.print(`  ${dim("webhooks")}  ${org.webhook_count} / ${cap(org.webhook_limit)}`);
+  ctx.print(`  ${dim("storage")}   ${gb(org.storage_bytes)} / ${gb(org.storage_limit_bytes)}`);
+  ctx.print(`  ${dim("email")}     ${cap(billing.monthly_emails)} a month`);
+});
+
+define("upgrade", "Get a checkout link for a paid plan", "carlyemail upgrade developer", async (ctx) => {
+  const plan = ctx.positional[0] || ctx.flags.plan;
+  if (!plan) throw new UsageError("which plan? carlyemail upgrade developer|startup");
+  const out = await request(ctx.config, "POST", "/v0/billing/checkout", { body: { plan } });
+  emit(ctx, out, () => {
+    ctx.print(arrow("open this to upgrade:"));
+    ctx.print(out.checkout_url);
+  });
+});
+
+define("billing", "Open the billing portal (invoices, card, cancel)", "carlyemail billing", async (ctx) => {
+  const out = await request(ctx.config, "POST", "/v0/billing/portal");
+  emit(ctx, out, () => {
+    ctx.print(arrow("invoices, card changes and cancellation:"));
+    ctx.print(out.portal_url);
+  });
+});
+
+define("mcp", "Print the MCP endpoint for Claude and other clients", "carlyemail mcp", (ctx) => {
+  const endpoint = `${ctx.config.api_url}/mcp`;
+  ctx.print(bold(endpoint));
+  ctx.print("");
+  ctx.print("Add it as a custom connector. It speaks OAuth with dynamic client");
+  ctx.print("registration, so there is no client_id to configure.");
+  ctx.print("");
+  ctx.print(dim("An API key works too: Authorization: Bearer <key>"));
+});
+
+// ---------------------------------------------------------------- help
+
+export function helpText() {
+  const width = Math.max(...Object.keys(commands).map((n) => n.length));
+  const lines = [
+    bold("carlyemail") + dim(` ${VERSION}`),
+    "",
+    "Real email inboxes your agent can send, receive and reply from.",
+    "",
+    bold("Commands"),
+  ];
+  for (const c of Object.values(commands)) {
+    lines.push(`  ${c.name.padEnd(width + 2)}${c.summary}`);
+  }
+  lines.push(
+    "",
+    bold("Getting started"),
+    "  carlyemail signup --human-email you@example.com --username my-agent",
+    "  carlyemail verify 123456",
+    "  carlyemail send --from my-agent@agents.carlyemail.com \\",
+    '      --to someone@example.com --subject Hi --text "Hello from an agent"',
+    "",
+    bold("Options"),
+    "  --json" + dim("               print the raw API response instead of a table"),
+    "",
+    bold("Configuration"),
+    `  ${CONFIG_FILE}` + dim("  (written 0600)"),
+    "  CARLYEMAIL_API_KEY" + dim("   overrides the saved key"),
+    "  CARLYEMAIL_API_URL" + dim("   overrides the API base URL"),
+    "",
+    dim("  https://docs.carlyemail.com")
+  );
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------- entry
+
+export async function main(argv, { env = process.env, print = console.log, configFile, configDir } = {}) {
+  const { flags, positional } = parseArgs(argv);
+  const name = positional.shift();
+
+  if (!name || name === "help" || flags.help) {
+    print(helpText());
+    return 0;
+  }
+  if (name === "version" || flags.version) {
+    print(VERSION);
+    return 0;
+  }
+
+  const command = commands[name];
+  if (!command) {
+    // Suggest rather than just refuse: a wrong guess at a command name is the
+    // most common thing a first-time user does.
+    const near = Object.keys(commands).filter((c) => c.startsWith(name[0]));
+    print(`${paint(31, "✗")} unknown command "${name}"`);
+    if (near.length) print(dim(`  did you mean: ${near.join(", ")}?`));
+    print(dim("  carlyemail help"));
+    return 1;
+  }
+
+  const config = loadConfig(env, configFile);
+  try {
+    await command.run({ config, flags, positional, print, configFile, configDir });
+    return 0;
+  } catch (error) {
+    if (error instanceof ApiError) {
+      print(error.render());
+    } else if (error instanceof UsageError) {
+      print(`${paint(31, "✗")} ${error.message}`);
+      print(dim(`  ${command.usage}`));
+    } else {
+      print(`${paint(31, "✗")} ${error.message}`);
+    }
+    return 1;
+  }
+}
+
+/**
+ * Whether this file was run as a program rather than imported.
+ *
+ * The obvious version — comparing `import.meta.url` to
+ * `file://${process.argv[1]}` — is wrong in exactly the case that matters.
+ * `npm install` puts a **symlink** in `node_modules/.bin`, so `argv[1]` is the
+ * link and `import.meta.url` is its target; the strings never match and the
+ * CLI exits 0 having done nothing. It works perfectly from a checkout and is
+ * silently inert once published, which is the worst shape a bug can take.
+ *
+ * `realpathSync` resolves the link. `fileURLToPath` is used rather than
+ * trimming `file://` by hand because that is also wrong on Windows, where the
+ * URL carries a drive letter.
+ */
+function invokedDirectly() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    return false; // argv[1] is not a path we can resolve — treat as imported
+  }
+}
+
+if (invokedDirectly()) {
+  main(process.argv.slice(2)).then((code) => process.exit(code));
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "carlyemail",
+  "version": "0.1.0",
+  "description": "Real email inboxes your agent can send, receive and reply from.",
+  "keywords": ["email", "agent", "ai", "inbox", "smtp", "mcp", "cli"],
+  "homepage": "https://carlyemail.com",
+  "bugs": "https://docs.carlyemail.com/support",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shirschfield/carlyemail.git",
+    "directory": "cli"
+  },
+  "license": "MIT",
+  "author": "SWH Labs LLC",
+  "type": "module",
+  "bin": {
+    "carlyemail": "./carlyemail.js"
+  },
+  "exports": "./carlyemail.js",
+  "files": ["carlyemail.js", "README.md", "LICENSE"],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test"
+  }
+}