groundmail-cli 0.0.0-stage → 0.16.0

package/dist/cli.js

@@ -0,0 +1,3495 @@
+#!/usr/bin/env node
+import "./chunk-4SSJDDBV.js";
+
+// src/commands/emails/send.ts
+function readFlag(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function readFlags(args, flag) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === flag && args[index + 1]) values.push(args[index + 1]);
+  }
+  return values;
+}
+function parseTags(values) {
+  const tags = values.map((value) => {
+    const separator = value.indexOf("=");
+    if (separator <= 0) {
+      return null;
+    }
+    const name = value.slice(0, separator).trim();
+    const tagValue = value.slice(separator + 1).trim();
+    if (!name || !tagValue) return null;
+    return { name, value: tagValue };
+  });
+  if (tags.some((tag) => tag == null)) {
+    return { error: "--tag must be in name=value format" };
+  }
+  return tags;
+}
+function parseSendCommandArgs(args) {
+  const parsedTags = parseTags(readFlags(args, "--tag"));
+  const category = readFlag(args, "--category");
+  return {
+    from: readFlag(args, "--from"),
+    to: readFlag(args, "--to"),
+    subject: readFlag(args, "--subject"),
+    html: readFlag(args, "--html"),
+    text: readFlag(args, "--text"),
+    tags: Array.isArray(parsedTags) ? parsedTags : void 0,
+    scheduledAt: readFlag(args, "--schedule"),
+    category,
+    unsubscribe: args.includes("--unsubscribe") ? true : void 0,
+    apiKey: readFlag(args, "--api-key"),
+    baseUrl: readFlag(args, "--base-url")
+  };
+}
+async function runSendCommand(args, deps) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? ((line) => console.log(line));
+  const stderr = deps.stderr ?? ((line) => console.error(line));
+  const options = parseSendCommandOptions(args, env);
+  if ("error" in options) {
+    stderr(options.error);
+    return 1;
+  }
+  try {
+    const result = await deps.sendEmail({
+      from: options.from,
+      to: options.to,
+      subject: options.subject,
+      html: options.html,
+      text: options.text,
+      tags: options.tags,
+      scheduledAt: options.scheduledAt,
+      category: options.category,
+      unsubscribe: options.unsubscribe
+    });
+    stdout(JSON.stringify(result));
+    return 0;
+  } catch (error) {
+    stderr(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+function parseSendCommandOptions(args, env) {
+  const parsed = parseSendCommandArgs(args);
+  const apiKey = parsed.apiKey || env.GROUNDMAIL_API_KEY;
+  const parsedTags = parseTags(readFlags(args, "--tag"));
+  if (!apiKey) {
+    return { error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  if ("error" in parsedTags) {
+    return { error: parsedTags.error };
+  }
+  if (!parsed.from || !parsed.to || !parsed.subject) {
+    return { error: "Required flags: --from --to --subject (and --html or --text)" };
+  }
+  if (!parsed.html && !parsed.text) {
+    return { error: "Provide --html or --text" };
+  }
+  return {
+    from: parsed.from,
+    to: parsed.to,
+    subject: parsed.subject,
+    html: parsed.html,
+    text: parsed.text,
+    tags: parsedTags.length ? parsedTags : void 0,
+    scheduledAt: parsed.scheduledAt,
+    category: parsed.category,
+    unsubscribe: parsed.unsubscribe,
+    apiKey,
+    baseUrl: parsed.baseUrl
+  };
+}
+function createDefaultSendDeps(apiKey, baseUrl) {
+  return {
+    sendEmail: async (params) => {
+      const { Groundmail } = await import("groundmail");
+      const client = new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+      return client.emails.send(params);
+    }
+  };
+}
+async function runSendCommandWithClient(args, env = process.env) {
+  const parsed = parseSendCommandOptions(args, env);
+  if ("error" in parsed) {
+    return { exitCode: 1, error: parsed.error };
+  }
+  const deps = createDefaultSendDeps(parsed.apiKey, parsed.baseUrl);
+  const exitCode = await runSendCommand(args, { ...deps, env });
+  return { exitCode };
+}
+
+// src/commands/emails/batch.ts
+import { readFile } from "fs/promises";
+function readFlag2(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function readFirstPositional(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg.startsWith("--")) {
+      if (arg === "--api-key" || arg === "--base-url" || arg === "--file") index += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+async function runBatchCommand(args, deps) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? ((line) => console.log(line));
+  const stderr = deps.stderr ?? ((line) => console.error(line));
+  const apiKey = readFlag2(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  if (!apiKey) {
+    stderr("Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key.");
+    return { exitCode: 1, error: "missing key" };
+  }
+  const filePath = readFlag2(args, "--file") || readFirstPositional(args);
+  if (!filePath) {
+    stderr("Required: --file <emails.json>");
+    return { exitCode: 1, error: "missing file" };
+  }
+  try {
+    const readTextFile = deps.readTextFile ?? ((path) => readFile(path, "utf8"));
+    const source = await readTextFile(filePath);
+    const payload = parseBatchPayload(source);
+    if ("error" in payload) {
+      stderr(payload.error);
+      return { exitCode: 1, error: payload.error };
+    }
+    const result = await deps.sendBatch(payload.emails);
+    stdout(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    stderr(error instanceof Error ? error.message : String(error));
+    return { exitCode: 1, error: String(error) };
+  }
+}
+async function runBatchCommandWithClient(args, env = process.env) {
+  const apiKey = readFlag2(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const baseUrl = readFlag2(args, "--base-url");
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const { Groundmail } = await import("groundmail");
+  const client = new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+  return runBatchCommand(args, {
+    env,
+    sendBatch: (emails) => client.emails.batch(emails)
+  });
+}
+function parseBatchPayload(source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    return { error: "Batch file must be valid JSON." };
+  }
+  const emails = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && "emails" in parsed && Array.isArray(parsed.emails) ? parsed.emails : null;
+  if (!emails || emails.length === 0) {
+    return { error: "Batch file must contain a non-empty array of emails." };
+  }
+  return { emails };
+}
+
+// src/commands/emails/cancel.ts
+function readFlag3(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+async function runCancelCommand(args, deps) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? ((line) => console.log(line));
+  const stderr = deps.stderr ?? ((line) => console.error(line));
+  const apiKey = readFlag3(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const id = readFlag3(args, "--id") || args.find((arg) => !arg.startsWith("--"));
+  if (!apiKey) {
+    stderr("Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key.");
+    return { exitCode: 1, error: "missing key" };
+  }
+  if (!id) {
+    stderr("Required: --id <msg_\u2026>");
+    return { exitCode: 1, error: "missing id" };
+  }
+  try {
+    const result = await deps.cancelEmail(id);
+    stdout(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    stderr(error instanceof Error ? error.message : String(error));
+    return { exitCode: 1, error: String(error) };
+  }
+}
+async function runCancelCommandWithClient(args, env = process.env) {
+  const apiKey = readFlag3(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const baseUrl = readFlag3(args, "--base-url");
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const { Groundmail } = await import("groundmail");
+  const client = new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+  return runCancelCommand(args, {
+    env,
+    cancelEmail: (id) => client.emails.cancel(id)
+  });
+}
+
+// src/commands/emails/resend.ts
+function readFlag4(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+async function runResendCommand(args, deps) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? ((line) => console.log(line));
+  const stderr = deps.stderr ?? ((line) => console.error(line));
+  const apiKey = readFlag4(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const id = readFlag4(args, "--id") || args.find((arg) => !arg.startsWith("--"));
+  if (!apiKey) {
+    stderr("Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key.");
+    return { exitCode: 1, error: "missing key" };
+  }
+  if (!id) {
+    stderr("Required: --id <msg_\u2026>");
+    return { exitCode: 1, error: "missing id" };
+  }
+  try {
+    const result = await deps.resendEmail(id);
+    stdout(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    stderr(error instanceof Error ? error.message : String(error));
+    return { exitCode: 1, error: String(error) };
+  }
+}
+async function runResendCommandWithClient(args, env = process.env) {
+  const apiKey = readFlag4(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const baseUrl = readFlag4(args, "--base-url");
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const { Groundmail } = await import("groundmail");
+  const client = new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+  return runResendCommand(args, {
+    env,
+    resendEmail: (id) => client.emails.resend(id)
+  });
+}
+
+// src/commands/emails/get.ts
+function readFlag5(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+async function runGetCommand(args, deps) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? ((line) => console.log(line));
+  const stderr = deps.stderr ?? ((line) => console.error(line));
+  const id = readFlag5(args, "--id") || args.find((a) => !a.startsWith("--"));
+  const apiKey = readFlag5(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  if (!apiKey) {
+    stderr("Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key.");
+    return { exitCode: 1, error: "missing key" };
+  }
+  if (!id) {
+    stderr("Required: --id <msg_\u2026>");
+    return { exitCode: 1, error: "missing id" };
+  }
+  try {
+    const result = await deps.getEmail(id);
+    stdout(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    stderr(error instanceof Error ? error.message : String(error));
+    return { exitCode: 1, error: String(error) };
+  }
+}
+async function runGetCommandWithClient(args, env = process.env) {
+  const apiKey = readFlag5(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const baseUrl = readFlag5(args, "--base-url");
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const { Groundmail } = await import("groundmail");
+  const client = new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+  return runGetCommand(args, {
+    env,
+    getEmail: (id) => client.emails.get(id)
+  });
+}
+
+// src/commands/emails/insights.ts
+function readFlag6(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+async function runInsightsCommand(args, deps) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? ((line) => console.log(line));
+  const stderr = deps.stderr ?? ((line) => console.error(line));
+  const apiKey = readFlag6(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  if (!apiKey) {
+    stderr("Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key.");
+    return { exitCode: 1, error: "missing key" };
+  }
+  const windowFlag = readFlag6(args, "--window");
+  if (windowFlag && windowFlag !== "7d" && windowFlag !== "30d") {
+    stderr("Invalid --window. Use 7d or 30d.");
+    return { exitCode: 1, error: "invalid window" };
+  }
+  try {
+    const result = await deps.getInsights(windowFlag);
+    stdout(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    stderr(error instanceof Error ? error.message : String(error));
+    return { exitCode: 1, error: String(error) };
+  }
+}
+async function runInsightsCommandWithClient(args, env = process.env) {
+  const apiKey = readFlag6(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const baseUrl = readFlag6(args, "--base-url");
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const { Groundmail } = await import("groundmail");
+  const client = new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+  return runInsightsCommand(args, {
+    env,
+    getInsights: (window) => client.emails.insights(window)
+  });
+}
+
+// src/commands/emails/list.ts
+function readFlag7(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+async function runListCommand(args, deps) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? ((line) => console.log(line));
+  const stderr = deps.stderr ?? ((line) => console.error(line));
+  const apiKey = readFlag7(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  if (!apiKey) {
+    stderr("Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key.");
+    return { exitCode: 1, error: "missing key" };
+  }
+  const limitRaw = readFlag7(args, "--limit");
+  const cursor = readFlag7(args, "--cursor");
+  const limit = limitRaw ? Number(limitRaw) : void 0;
+  try {
+    const result = await deps.listEmails({
+      ...limit != null && Number.isFinite(limit) ? { limit } : {},
+      ...cursor ? { cursor } : {}
+    });
+    stdout(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    stderr(error instanceof Error ? error.message : String(error));
+    return { exitCode: 1, error: String(error) };
+  }
+}
+async function runListCommandWithClient(args, env = process.env) {
+  const apiKey = readFlag7(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const baseUrl = readFlag7(args, "--base-url");
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const { Groundmail } = await import("groundmail");
+  const client = new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+  return runListCommand(args, {
+    env,
+    listEmails: (params) => client.emails.list(params)
+  });
+}
+
+// src/commands/events/send.ts
+function readFlag8(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function resolveApiKey(args, env) {
+  return readFlag8(args, "--api-key") || env.GROUNDMAIL_API_KEY || null;
+}
+async function createClient(apiKey, baseUrl) {
+  const { Groundmail } = await import("groundmail");
+  return new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+}
+async function runSendEventCommand(args, env = process.env) {
+  const apiKey = resolveApiKey(args, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const name = readFlag8(args, "--name") || readFlag8(args, "--type");
+  if (!name) {
+    return { exitCode: 1, error: "Required flag: --name or --type" };
+  }
+  const email = readFlag8(args, "--email");
+  const userId = readFlag8(args, "--user-id");
+  const dataRaw = readFlag8(args, "--data");
+  const idempotencyKey = readFlag8(args, "--idempotency-key");
+  const baseUrl = readFlag8(args, "--base-url");
+  let data;
+  if (dataRaw) {
+    try {
+      const parsed = JSON.parse(dataRaw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { exitCode: 1, error: "--data must be a JSON object" };
+      }
+      data = parsed;
+    } catch (error) {
+      return {
+        exitCode: 1,
+        error: error instanceof Error ? error.message : "--data must be valid JSON"
+      };
+    }
+  }
+  try {
+    const client = await createClient(apiKey, baseUrl);
+    const result = await client.events.trigger({
+      name,
+      email,
+      user_id: userId,
+      data,
+      idempotencyKey
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/automations/shared.ts
+import { readFile as readFile2 } from "fs/promises";
+function readFlag9(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function parseAutomationsCommonArgs(args) {
+  return {
+    apiKey: readFlag9(args, "--api-key"),
+    baseUrl: readFlag9(args, "--base-url")
+  };
+}
+function resolveApiKey2(options, env) {
+  return options.apiKey || env.GROUNDMAIL_API_KEY || null;
+}
+async function createAutomationsClient(apiKey, baseUrl) {
+  const { Groundmail } = await import("groundmail");
+  return new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+}
+async function readAutomationDefinition(args) {
+  const file = readFlag9(args, "--file");
+  if (file) {
+    try {
+      const raw = await readFile2(file, "utf8");
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { ok: false, error: "--file must contain a JSON object" };
+      }
+      return { ok: true, value: parsed };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : "Failed to read --file"
+      };
+    }
+  }
+  const name = readFlag9(args, "--name");
+  const triggerEvent = readFlag9(args, "--trigger") || readFlag9(args, "--event");
+  const stepsRaw = readFlag9(args, "--steps");
+  let steps;
+  if (stepsRaw) {
+    try {
+      steps = JSON.parse(stepsRaw);
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : "--steps must be valid JSON"
+      };
+    }
+  }
+  return {
+    ok: true,
+    value: {
+      ...name ? { name } : {},
+      ...triggerEvent ? { trigger: { type: "event", event: triggerEvent } } : {},
+      ...steps !== void 0 ? { steps } : {}
+    }
+  };
+}
+
+// src/commands/automations/list.ts
+async function runListCommand2(args, env = process.env) {
+  const options = parseAutomationsCommonArgs(args);
+  const apiKey = resolveApiKey2(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  try {
+    const client = await createAutomationsClient(apiKey, options.baseUrl);
+    const result = await client.automations.list();
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/automations/get.ts
+async function runGetCommand2(args, env = process.env) {
+  const options = parseAutomationsCommonArgs(args);
+  const apiKey = resolveApiKey2(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const id = readFlag9(args, "--id");
+  if (!id) return { exitCode: 1, error: "Required flag: --id" };
+  try {
+    const client = await createAutomationsClient(apiKey, options.baseUrl);
+    const result = await client.automations.get(id);
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/automations/create.ts
+async function runCreateCommand(args, env = process.env) {
+  const options = parseAutomationsCommonArgs(args);
+  const apiKey = resolveApiKey2(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const definition = await readAutomationDefinition(args);
+  if (!definition.ok) return { exitCode: 1, error: definition.error };
+  const { name, trigger, steps } = definition.value;
+  if (!name || typeof name !== "string") {
+    return { exitCode: 1, error: "Required: --name or name in --file" };
+  }
+  if (!trigger) {
+    return { exitCode: 1, error: "Required: --trigger/--event or trigger in --file" };
+  }
+  if (!steps) {
+    return { exitCode: 1, error: "Required: --steps or steps in --file" };
+  }
+  try {
+    const client = await createAutomationsClient(apiKey, options.baseUrl);
+    const result = await client.automations.create({
+      name,
+      trigger,
+      steps
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/automations/update.ts
+async function runUpdateCommand(args, env = process.env) {
+  const options = parseAutomationsCommonArgs(args);
+  const apiKey = resolveApiKey2(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const id = readFlag9(args, "--id");
+  if (!id) return { exitCode: 1, error: "Required flag: --id" };
+  const definition = await readAutomationDefinition(args);
+  if (!definition.ok) return { exitCode: 1, error: definition.error };
+  const { name, trigger, steps } = definition.value;
+  if (!name && !trigger && !steps) {
+    return {
+      exitCode: 1,
+      error: "Nothing to update. Pass --file and/or --name/--trigger/--steps."
+    };
+  }
+  try {
+    const client = await createAutomationsClient(apiKey, options.baseUrl);
+    const result = await client.automations.update(id, {
+      ...name ? { name } : {},
+      ...trigger ? { trigger } : {},
+      ...steps ? { steps } : {}
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/automations/actions.ts
+async function runActivateCommand(args, env = process.env) {
+  const options = parseAutomationsCommonArgs(args);
+  const apiKey = resolveApiKey2(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const id = readFlag9(args, "--id");
+  if (!id) return { exitCode: 1, error: "Required flag: --id" };
+  try {
+    const client = await createAutomationsClient(apiKey, options.baseUrl);
+    const result = await client.automations.activate(id);
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function runPauseCommand(args, env = process.env) {
+  const options = parseAutomationsCommonArgs(args);
+  const apiKey = resolveApiKey2(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const id = readFlag9(args, "--id");
+  if (!id) return { exitCode: 1, error: "Required flag: --id" };
+  try {
+    const client = await createAutomationsClient(apiKey, options.baseUrl);
+    const result = await client.automations.pause(id);
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function runDeleteCommand(args, env = process.env) {
+  const options = parseAutomationsCommonArgs(args);
+  const apiKey = resolveApiKey2(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const id = readFlag9(args, "--id");
+  if (!id) return { exitCode: 1, error: "Required flag: --id" };
+  try {
+    const client = await createAutomationsClient(apiKey, options.baseUrl);
+    const result = await client.automations.remove(id);
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/domains/shared.ts
+function readFlag10(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function parseDomainsCommonArgs(args) {
+  return {
+    apiKey: readFlag10(args, "--api-key"),
+    baseUrl: readFlag10(args, "--base-url"),
+    name: readFlag10(args, "--name") || readFlag10(args, "--domain"),
+    id: readFlag10(args, "--id")
+  };
+}
+function resolveApiKey3(options, env) {
+  return options.apiKey || env.GROUNDMAIL_API_KEY || null;
+}
+async function createDomainsClient(apiKey, baseUrl) {
+  const { Groundmail } = await import("groundmail");
+  return new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+}
+function formatDnsRecords(records) {
+  const lines = ["DNS records to add:", ""];
+  for (const record of records) {
+    lines.push(`  ${record.type.padEnd(6)} ${record.host}`);
+    if (record.type === "MX" && record.priority != null) {
+      lines.push(`         priority: ${record.priority}`);
+      lines.push(`         mail server: ${record.value}`);
+    } else {
+      lines.push(`         ${record.value}`);
+    }
+    lines.push(`         (${record.purpose})`);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+
+// src/commands/domains/add.ts
+async function runAddCommand(args, env = process.env) {
+  const options = parseDomainsCommonArgs(args);
+  const apiKey = resolveApiKey3(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const name = options.name || args.find((arg) => !arg.startsWith("--") && arg.includes("."));
+  if (!name) {
+    return {
+      exitCode: 1,
+      error: "Missing domain. Usage: groundmail domains add example.com"
+    };
+  }
+  try {
+    const client = await createDomainsClient(apiKey, options.baseUrl);
+    const inbound = readFlag10(args, "--inbound");
+    const result = await client.domains.create({
+      name,
+      ...inbound === "true" || inbound === "1" ? { inbound_enabled: true } : {}
+    });
+    console.log(JSON.stringify(result));
+    console.error("");
+    console.error(`Domain ${result.domain.name} added (${result.domain.status}).`);
+    console.error(formatDnsRecords(result.records));
+    console.error("");
+    console.error(`Then: groundmail domains verify ${result.domain.name}`);
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/domains/apply.ts
+async function runApplyCommand(args, env = process.env) {
+  const options = parseDomainsCommonArgs(args);
+  const apiKey = resolveApiKey3(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const providerFlag = args.includes("--provider") ? args[args.indexOf("--provider") + 1] : void 0;
+  const provider = (providerFlag || "").toLowerCase();
+  if (provider !== "cloudflare" && provider !== "godaddy" && provider !== "vercel") {
+    return {
+      exitCode: 1,
+      error: "Missing or invalid --provider. Use --provider cloudflare, --provider vercel, or --provider godaddy."
+    };
+  }
+  const idOrName = options.id || options.name || args.find((arg, i) => {
+    if (arg.startsWith("--")) return false;
+    const prev = args[i - 1];
+    if (prev === "--provider" || prev === "--api-key" || prev === "--base-url" || prev === "--name" || prev === "--domain" || prev === "--id") {
+      return false;
+    }
+    return arg.includes(".") || arg.length > 8;
+  });
+  if (!idOrName) {
+    return {
+      exitCode: 1,
+      error: "Missing domain. Usage: groundmail domains apply example.com --provider cloudflare"
+    };
+  }
+  try {
+    const client = await createDomainsClient(apiKey, options.baseUrl);
+    const localCloudflare = env.CLOUDFLARE_API_TOKEN || env.CLOUDFLARE_API_KEY;
+    const localVercel = env.VERCEL_API_TOKEN;
+    const useStoredCloudflare = provider === "cloudflare" && !localCloudflare;
+    const useStoredVercel = provider === "vercel" && !localVercel;
+    const result = useStoredCloudflare || useStoredVercel ? await client.domains.apply(idOrName, { provider }) : await client.domains.applyDns({
+      idOrName,
+      provider,
+      cloudflareApiToken: localCloudflare,
+      cloudflareZoneId: env.CLOUDFLARE_ZONE_ID,
+      godaddyApiKey: env.GODADDY_API_KEY,
+      godaddyApiSecret: env.GODADDY_API_SECRET,
+      vercelApiToken: localVercel,
+      vercelTeamId: env.VERCEL_TEAM_ID
+    });
+    console.log(JSON.stringify(result));
+    console.error(
+      useStoredCloudflare ? `Applied ${result.results.length} DNS change(s) via stored Cloudflare credentials for ${result.domain}.` : useStoredVercel ? `Applied ${result.results.length} DNS change(s) via stored Vercel credentials for ${result.domain}.` : `Applied ${result.results.length} DNS change(s) via ${result.provider} for ${result.domain}.`
+    );
+    for (const row of result.results) {
+      console.error(`  ${row.action.padEnd(10)} ${row.purpose} \u2192 ${row.host}`);
+    }
+    console.error("");
+    console.error(`Next: groundmail domains verify ${result.domain}`);
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/domains/delete.ts
+var POSITIONAL_FLAGS = ["--api-key", "--base-url", "--name", "--domain", "--id"];
+async function runDeleteCommand2(args, env = process.env) {
+  const options = parseDomainsCommonArgs(args);
+  const apiKey = resolveApiKey3(options, env);
+  if (!apiKey) return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  const idOrName = options.id || options.name || readFirstPositional2(args);
+  if (!idOrName) return { exitCode: 1, error: "Missing domain. Usage: groundmail domains delete example.com" };
+  try {
+    const client = await createDomainsClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.domains.delete(idOrName)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readFirstPositional2(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+
+// src/commands/domains/get.ts
+var POSITIONAL_FLAGS2 = ["--api-key", "--base-url", "--name", "--domain", "--id"];
+async function runGetCommand3(args, env = process.env) {
+  const options = parseDomainsCommonArgs(args);
+  const apiKey = resolveApiKey3(options, env);
+  if (!apiKey) return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  const idOrName = options.id || options.name || readFirstPositional3(args);
+  if (!idOrName) return { exitCode: 1, error: "Missing domain. Usage: groundmail domains get example.com" };
+  try {
+    const client = await createDomainsClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.domains.get(idOrName)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readFirstPositional3(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS2.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+
+// src/commands/domains/list.ts
+async function runListCommand3(args, env = process.env) {
+  const options = parseDomainsCommonArgs(args);
+  const apiKey = resolveApiKey3(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  try {
+    const client = await createDomainsClient(apiKey, options.baseUrl);
+    const result = await client.domains.list();
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/domains/update.ts
+function parseBooleanFlag(value, flag) {
+  if (value == null) return void 0;
+  if (value === "true" || value === "1") return true;
+  if (value === "false" || value === "0") return false;
+  throw new Error(`${flag} must be true or false`);
+}
+var POSITIONAL_FLAGS3 = [
+  "--api-key",
+  "--base-url",
+  "--name",
+  "--domain",
+  "--id",
+  "--tls-mode",
+  "--open-tracking",
+  "--click-tracking",
+  "--inbound"
+];
+function readFirstPositional4(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS3.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+async function runUpdateCommand2(args, env = process.env) {
+  const options = parseDomainsCommonArgs(args);
+  const apiKey = resolveApiKey3(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const idOrName = options.id || options.name || readFirstPositional4(args);
+  if (!idOrName) {
+    return {
+      exitCode: 1,
+      error: "Missing domain. Usage: groundmail domains update example.com --inbound true"
+    };
+  }
+  try {
+    const payload = {};
+    const tlsMode = readFlag10(args, "--tls-mode");
+    if (tlsMode) {
+      if (tlsMode !== "opportunistic" && tlsMode !== "enforced") {
+        return { exitCode: 1, error: "--tls-mode must be opportunistic or enforced" };
+      }
+      payload.tls_mode = tlsMode;
+    }
+    const openTracking = parseBooleanFlag(readFlag10(args, "--open-tracking"), "--open-tracking");
+    if (openTracking !== void 0) payload.open_tracking = openTracking;
+    const clickTracking = parseBooleanFlag(readFlag10(args, "--click-tracking"), "--click-tracking");
+    if (clickTracking !== void 0) payload.click_tracking = clickTracking;
+    const inbound = parseBooleanFlag(readFlag10(args, "--inbound"), "--inbound");
+    if (inbound !== void 0) payload.inbound_enabled = inbound;
+    if (!Object.keys(payload).length) {
+      return {
+        exitCode: 1,
+        error: "No updates provided. Pass --inbound true|false, --tls-mode opportunistic|enforced, --open-tracking true|false, or --click-tracking true|false."
+      };
+    }
+    const client = await createDomainsClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.domains.update(idOrName, payload)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/domains/verify.ts
+async function runVerifyCommand(args, env = process.env) {
+  const options = parseDomainsCommonArgs(args);
+  const apiKey = resolveApiKey3(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const idOrName = options.id || options.name || args.find((arg) => !arg.startsWith("--") && (arg.includes(".") || arg.length > 8));
+  if (!idOrName) {
+    return {
+      exitCode: 1,
+      error: "Missing domain. Usage: groundmail domains verify example.com"
+    };
+  }
+  try {
+    const client = await createDomainsClient(apiKey, options.baseUrl);
+    const result = await client.domains.verify(idOrName);
+    console.log(JSON.stringify(result));
+    if (result.verified) {
+      console.error(`Domain ${result.domain.name} verified.`);
+    }
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/received-emails/shared.ts
+function readFlag11(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function parseReceivedEmailsCommonArgs(args) {
+  return {
+    apiKey: readFlag11(args, "--api-key"),
+    baseUrl: readFlag11(args, "--base-url"),
+    id: readFlag11(args, "--id")
+  };
+}
+function resolveApiKey4(options, env) {
+  return options.apiKey || env.GROUNDMAIL_API_KEY || null;
+}
+async function createReceivedEmailsClient(apiKey, baseUrl) {
+  const { Groundmail } = await import("groundmail");
+  return new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+}
+
+// src/commands/received-emails/get.ts
+var POSITIONAL_FLAGS4 = ["--api-key", "--base-url", "--id"];
+function readFirstPositional5(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS4.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+async function runGetCommand4(args, env = process.env) {
+  const options = parseReceivedEmailsCommonArgs(args);
+  const apiKey = resolveApiKey4(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const id = options.id || readFirstPositional5(args);
+  if (!id) {
+    return { exitCode: 1, error: "Missing id. Usage: groundmail received-emails get inb_..." };
+  }
+  try {
+    const client = await createReceivedEmailsClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.receivedEmails.get(id)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/received-emails/list.ts
+async function runListCommand4(args, env = process.env) {
+  const options = parseReceivedEmailsCommonArgs(args);
+  const apiKey = resolveApiKey4(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  try {
+    const client = await createReceivedEmailsClient(apiKey, options.baseUrl);
+    console.log(
+      JSON.stringify(
+        await client.receivedEmails.list({
+          limit: readFlag11(args, "--limit") ? Number(readFlag11(args, "--limit")) : void 0,
+          cursor: readFlag11(args, "--cursor"),
+          domain: readFlag11(args, "--domain")
+        })
+      )
+    );
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/webhooks/shared.ts
+function readFlag12(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function parseWebhooksCommonArgs(args) {
+  return {
+    apiKey: readFlag12(args, "--api-key"),
+    baseUrl: readFlag12(args, "--base-url")
+  };
+}
+function resolveApiKey5(options, env) {
+  return options.apiKey || env.GROUNDMAIL_API_KEY || null;
+}
+async function createWebhooksClient(apiKey, baseUrl) {
+  const { Groundmail } = await import("groundmail");
+  return new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+}
+
+// src/commands/webhooks/create.ts
+async function runCreateCommand2(args, env = process.env) {
+  const options = parseWebhooksCommonArgs(args);
+  const apiKey = resolveApiKey5(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const url = readFlag12(args, "--url");
+  if (!url) {
+    return { exitCode: 1, error: "Required flag: --url" };
+  }
+  try {
+    const client = await createWebhooksClient(apiKey, options.baseUrl);
+    const result = await client.webhooks.create({ url });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/webhooks/get.ts
+var POSITIONAL_FLAGS5 = ["--api-key", "--base-url", "--id"];
+async function runGetCommand5(args, env = process.env) {
+  const options = parseWebhooksCommonArgs(args);
+  const apiKey = resolveApiKey5(options, env);
+  if (!apiKey) return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  const id = readFlag13(args, "--id") || readFirstPositional6(args);
+  if (!id) return { exitCode: 1, error: "Missing webhook id. Pass --id wh_\u2026" };
+  try {
+    const client = await createWebhooksClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.webhooks.get(id)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readFlag13(args, flag) {
+  const index = args.indexOf(flag);
+  return index === -1 ? void 0 : args[index + 1];
+}
+function readFirstPositional6(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS5.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+
+// src/commands/webhooks/delete.ts
+async function runDeleteCommand3(args, env = process.env) {
+  const options = parseWebhooksCommonArgs(args);
+  const apiKey = resolveApiKey5(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const id = readFlag12(args, "--id");
+  if (!id) {
+    return { exitCode: 1, error: "Required flag: --id" };
+  }
+  try {
+    const client = await createWebhooksClient(apiKey, options.baseUrl);
+    const result = await client.webhooks.delete(id);
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/webhooks/list.ts
+async function runListCommand5(args, env = process.env) {
+  const options = parseWebhooksCommonArgs(args);
+  const apiKey = resolveApiKey5(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  try {
+    const client = await createWebhooksClient(apiKey, options.baseUrl);
+    const result = await client.webhooks.list();
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/webhooks/update.ts
+var POSITIONAL_FLAGS6 = ["--api-key", "--base-url", "--id", "--url", "--event", "--enabled"];
+async function runUpdateCommand3(args, env = process.env) {
+  const options = parseWebhooksCommonArgs(args);
+  const apiKey = resolveApiKey5(options, env);
+  if (!apiKey) return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  const id = readFlag14(args, "--id") || readFirstPositional7(args);
+  if (!id) return { exitCode: 1, error: "Missing webhook id. Pass --id wh_\u2026" };
+  const url = readFlag14(args, "--url");
+  const events = readFlags2(args, "--event");
+  const enabled = parseEnabledFlag(readFlag14(args, "--enabled"));
+  if ("error" in enabled) return { exitCode: 1, error: enabled.error };
+  if (!url && events.length === 0 && enabled.value === void 0) {
+    return { exitCode: 1, error: "Nothing to update. Pass --url, --event, or --enabled true|false." };
+  }
+  const payload = {
+    ...url ? { url } : {},
+    ...events.length > 0 ? { events } : {},
+    ...enabled.value !== void 0 ? { enabled: enabled.value } : {}
+  };
+  try {
+    const client = await createWebhooksClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.webhooks.update(id, payload)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readFlag14(args, flag) {
+  const index = args.indexOf(flag);
+  return index === -1 ? void 0 : args[index + 1];
+}
+function readFlags2(args, flag) {
+  const values = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === flag && args[i + 1]) values.push(args[i + 1]);
+  }
+  return values;
+}
+function readFirstPositional7(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS6.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+function parseEnabledFlag(value) {
+  if (value === void 0) return { value: void 0 };
+  if (value === "true") return { value: true };
+  if (value === "false") return { value: false };
+  return { error: "--enabled must be true or false" };
+}
+
+// src/commands/keys/list.ts
+function readFlag15(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+async function runListKeysCommandWithClient(args, env = process.env) {
+  const apiKey = readFlag15(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const baseUrl = readFlag15(args, "--base-url");
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const { Groundmail } = await import("groundmail");
+  const client = new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+  try {
+    const limitRaw = readFlag15(args, "--limit");
+    const cursor = readFlag15(args, "--cursor");
+    const result = await client.apiKeys.list({
+      ...limitRaw ? { limit: Number(limitRaw) } : {},
+      ...cursor ? { cursor } : {}
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    return { exitCode: 1, error: message };
+  }
+}
+
+// src/session/brand.ts
+var GROUNDMAIL = {
+  bin: "groundmail",
+  product: "Groundmail",
+  configDirName: "groundmail",
+  keyEnvVar: "GROUNDMAIL_API_KEY",
+  npx: "npx -y groundmail-cli@latest"
+};
+function cliBrand(_env = process.env) {
+  return GROUNDMAIL;
+}
+var SDK_DEFAULT_API_URL = "https://api.groundmail.dev";
+var DEFAULT_API_URL_ENV = "GROUNDMAIL_DEFAULT_API_URL";
+function defaultApiUrl(env = process.env) {
+  return trimUrl(env[DEFAULT_API_URL_ENV]) || SDK_DEFAULT_API_URL;
+}
+function explicitApiUrl(env = process.env) {
+  return trimUrl(env.GROUNDMAIL_API_URL) || null;
+}
+function trimUrl(value) {
+  return (value ?? "").trim().replace(/\/+$/, "");
+}
+
+// package.json
+var version = "0.16.0";
+
+// src/user-agent.ts
+function buildUserAgent(own) {
+  return `${own.name}/${own.version} node/${process.versions.node}`;
+}
+function withUserAgent(init, userAgent) {
+  const headers = init?.headers;
+  if (headers instanceof Headers) {
+    const next = new Headers(headers);
+    if (!next.has("user-agent")) next.set("User-Agent", userAgent);
+    return { ...init, headers: next };
+  }
+  if (Array.isArray(headers)) {
+    const has2 = headers.some(([key]) => key.toLowerCase() === "user-agent");
+    return { ...init, headers: has2 ? headers : [...headers, ["User-Agent", userAgent]] };
+  }
+  const record = headers ?? {};
+  const has = Object.keys(record).some((key) => key.toLowerCase() === "user-agent");
+  return { ...init, headers: has ? record : { ...record, "User-Agent": userAgent } };
+}
+function fetchWithUserAgent(userAgent) {
+  return ((input, init) => globalThis.fetch(input, withUserAgent(init, userAgent)));
+}
+
+// src/client-info.ts
+var CLI_PACKAGE = { name: "groundmail-cli", version };
+
+// src/session/http.ts
+var CliRequestError = class extends Error {
+};
+async function apiRequest(baseUrl, path, options = {}) {
+  const doFetch = fetchWithUserAgent(buildUserAgent(CLI_PACKAGE));
+  const url = `${baseUrl.replace(/\/+$/, "")}${path}`;
+  let response;
+  try {
+    response = await doFetch(url, {
+      method: options.method ?? (options.body === void 0 ? "GET" : "POST"),
+      headers: {
+        Accept: "application/json",
+        ...options.body === void 0 ? {} : { "Content-Type": "application/json" },
+        ...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {}
+      },
+      ...options.body === void 0 ? {} : { body: JSON.stringify(options.body) }
+    });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new CliRequestError(`Could not reach ${baseUrl}: ${reason}`);
+  }
+  const text = await response.text();
+  let body = {};
+  try {
+    const parsed = text ? JSON.parse(text) : {};
+    body = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { value: parsed };
+  } catch {
+    body = { error: text.slice(0, 300) || `HTTP ${response.status}` };
+  }
+  return { ok: response.ok, status: response.status, body };
+}
+function sentence(text) {
+  return /[.!?…)]$/.test(text.trim()) ? text.trim() : `${text.trim()}.`;
+}
+function errorMessage(response, fallback) {
+  const error = response.body.error;
+  if (typeof error === "string" && error.trim()) return error.trim();
+  if (error && typeof error === "object") {
+    const message = error.message;
+    if (typeof message === "string" && message.trim()) return message.trim();
+  }
+  return `${fallback} (HTTP ${response.status}).`;
+}
+
+// src/commands/login.ts
+import { spawn } from "child_process";
+import { hostname } from "os";
+
+// src/session/args.ts
+var COMMON_VALUE_FLAGS = ["--api-key", "--base-url", "--workspace"];
+var COMMON_BOOLEAN_FLAGS = ["--json"];
+function parseArgs(argv, spec) {
+  const valueFlags = new Set(spec.values ?? []);
+  const booleanFlags = new Set(spec.booleans ?? []);
+  const values = {};
+  const booleans = {};
+  const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (!arg.startsWith("--") || arg === "-") {
+      positionals.push(arg);
+      continue;
+    }
+    const eq = arg.indexOf("=");
+    const name = eq === -1 ? arg : arg.slice(0, eq);
+    if (valueFlags.has(name)) {
+      const value = eq === -1 ? argv[i + 1] : arg.slice(eq + 1);
+      if (value === void 0 || eq === -1 && value.startsWith("--")) {
+        return { ok: false, error: `${name} needs a value.` };
+      }
+      values[name] = value;
+      if (eq === -1) i++;
+      continue;
+    }
+    if (booleanFlags.has(name) && eq === -1) {
+      booleans[name] = true;
+      continue;
+    }
+    const negated = name.startsWith("--no-") ? `--${name.slice("--no-".length)}` : null;
+    if (negated && booleanFlags.has(negated) && eq === -1) {
+      booleans[negated] = false;
+      continue;
+    }
+    const known = [...valueFlags, ...booleanFlags].sort().join(", ");
+    return { ok: false, error: `Unknown flag ${name}.${known ? ` This command takes: ${known}.` : ""}` };
+  }
+  return { ok: true, args: { values, booleans, positionals } };
+}
+function wantsJson(args, stdout = process.stdout) {
+  if (args.booleans["--json"] !== void 0) return args.booleans["--json"];
+  return !stdout.isTTY;
+}
+var EXIT_OK = 0;
+var EXIT_FAILED = 1;
+var EXIT_USAGE = 2;
+
+// src/session/config.ts
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function configDir(env = process.env) {
+  const override2 = env.GROUNDMAIL_CONFIG_DIR?.trim();
+  if (override2) return override2;
+  const base = env.XDG_CONFIG_HOME?.trim() || (process.platform === "win32" ? env.APPDATA?.trim() || join(homedir(), "AppData", "Roaming") : "") || join(homedir(), ".config");
+  return join(base, cliBrand(env).configDirName);
+}
+function configPath(env = process.env) {
+  return join(configDir(env), "config.json");
+}
+function loadConfig(env = process.env) {
+  try {
+    const parsed = JSON.parse(readFileSync(configPath(env), "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const record = parsed;
+    const workspaces = {};
+    for (const [id, entry] of Object.entries(record.workspaces ?? {})) {
+      const hasKey = typeof entry?.apiKey === "string" && entry.apiKey.length > 0;
+      const hasOAuth = Boolean(entry?.oauth && typeof entry.oauth === "object" && typeof entry.oauth.clientId === "string");
+      if (entry && typeof entry.id === "string" && (hasKey || hasOAuth)) {
+        workspaces[id] = entry;
+      }
+    }
+    return {
+      ...typeof record.current === "string" && workspaces[record.current] ? { current: record.current } : {},
+      workspaces,
+      ...record.pendingLogin && typeof record.pendingLogin.deviceCode === "string" ? { pendingLogin: record.pendingLogin } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config, env = process.env) {
+  const file = configPath(env);
+  mkdirSync(dirname(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  renameSync(tmp, file);
+  try {
+    chmodSync(file, 384);
+  } catch {
+  }
+}
+function updateConfig(change, env = process.env) {
+  const next = change(loadConfig(env));
+  saveConfig(next, env);
+  return next;
+}
+function savedWorkspaces(config) {
+  return Object.values(config.workspaces ?? {}).sort((a, b) => a.name.localeCompare(b.name));
+}
+function findSavedWorkspace(config, wanted) {
+  const all = savedWorkspaces(config);
+  const key = wanted.trim();
+  const byId = all.find((workspace) => workspace.id === key);
+  if (byId) return { ok: true, workspace: byId };
+  const byName = all.filter((workspace) => workspace.name.trim().toLowerCase() === key.toLowerCase());
+  if (byName.length === 1) return { ok: true, workspace: byName[0] };
+  return { ok: false, reason: byName.length ? "ambiguous" : "none", matches: byName };
+}
+
+// src/session/keychain.ts
+import { createRequire } from "module";
+var SERVICE = "groundmail-cli";
+var override;
+var cached;
+function platformLabel() {
+  if (process.platform === "darwin") return "the macOS Keychain";
+  if (process.platform === "win32") return "Windows Credential Manager";
+  return "the system keyring";
+}
+function loadKeyring() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    return require2("@napi-rs/keyring");
+  } catch {
+    return null;
+  }
+}
+function secretStore(env = process.env) {
+  if (override !== void 0) return override;
+  if (/^(1|true|yes)$/i.test(env.GROUNDMAIL_NO_KEYCHAIN?.trim() ?? "")) return null;
+  if (cached !== void 0) return cached;
+  const keyring = loadKeyring();
+  if (!keyring) {
+    cached = null;
+    return cached;
+  }
+  cached = {
+    label: platformLabel(),
+    get(account) {
+      try {
+        return new keyring.Entry(SERVICE, account).getPassword() ?? null;
+      } catch {
+        return null;
+      }
+    },
+    set(account, secret) {
+      try {
+        const entry = new keyring.Entry(SERVICE, account);
+        entry.setPassword(secret);
+        return entry.getPassword() === secret;
+      } catch {
+        return false;
+      }
+    },
+    delete(account) {
+      try {
+        new keyring.Entry(SERVICE, account).deletePassword();
+      } catch {
+      }
+    }
+  };
+  return cached;
+}
+
+// src/session/oauth.ts
+var CLI_OAUTH_CLIENT_ID = "groundmail-cli";
+var DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+var EXPIRY_SKEW_MS = 60 * 1e3;
+function oauthErrorCode(response) {
+  const error = response.body.error;
+  return typeof error === "string" ? error : null;
+}
+function oauthErrorMessage(response, fallback) {
+  const description = response.body.error_description;
+  if (typeof description === "string" && description.trim()) return description.trim();
+  return errorMessage(response, fallback);
+}
+function isTokenSet(body) {
+  return typeof body.access_token === "string" && typeof body.refresh_token === "string";
+}
+function keychainAccount(apiUrl, workspaceId) {
+  return `${apiUrl.replace(/\/+$/, "")}#${workspaceId}`;
+}
+function storeRefreshToken(input, env = process.env) {
+  const keychain = secretStore(env);
+  if (keychain?.set(keychainAccount(input.apiUrl, input.workspaceId), input.refreshToken)) {
+    return { clientId: CLI_OAUTH_CLIENT_ID, scope: input.scope, store: "keychain" };
+  }
+  return { clientId: CLI_OAUTH_CLIENT_ID, scope: input.scope, store: "file", refreshToken: input.refreshToken };
+}
+function readRefreshToken(workspace, apiUrl, env = process.env) {
+  const oauth = workspace.oauth;
+  if (!oauth) return null;
+  if (oauth.store === "file") return oauth.refreshToken ?? null;
+  return secretStore(env)?.get(keychainAccount(apiUrl, workspace.id)) ?? null;
+}
+function forgetRefreshToken(workspace, apiUrl, env = process.env) {
+  if (workspace.oauth?.store === "keychain") secretStore(env)?.delete(keychainAccount(apiUrl, workspace.id));
+}
+function storeLabel(oauth, configFile, env = process.env) {
+  return oauth.store === "keychain" ? secretStore(env)?.label ?? "the system keychain" : `${configFile} (readable by you only)`;
+}
+async function refresh(apiUrl, refreshToken, scope, env) {
+  return apiRequest(apiUrl, "/oauth/token", {
+    body: {
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: CLI_OAUTH_CLIENT_ID,
+      ...scope ? { scope } : {}
+    },
+    env
+  });
+}
+async function accessTokenFor(workspace, apiUrl, options = {}) {
+  const env = options.env ?? process.env;
+  const now = options.now ?? Date.now;
+  const brand = cliBrand(env);
+  const oauth = workspace.oauth;
+  if (!oauth) return { ok: false, error: "Not an OAuth sign-in." };
+  const narrowed = Boolean(options.scope && options.scope.trim() !== oauth.scope);
+  if (!narrowed && oauth.accessToken && (oauth.accessTokenExpiresAt ?? 0) - EXPIRY_SKEW_MS > now()) {
+    return { ok: true, token: oauth.accessToken, scope: oauth.scope };
+  }
+  const signInAgain = `Run ${brand.bin} login${workspace.name ? ` --workspace "${workspace.name}"` : ""} to sign in again.`;
+  let refreshToken = readRefreshToken(workspace, apiUrl, env);
+  if (!refreshToken) return { ok: false, error: `The saved sign-in for ${workspace.name} has no refresh token. ${signInAgain}` };
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const response = await refresh(apiUrl, refreshToken, narrowed ? options.scope.trim() : null, env);
+    if (response.ok && isTokenSet(response.body)) {
+      const tokens = response.body;
+      const stored = storeRefreshToken({ apiUrl, workspaceId: workspace.id, refreshToken: tokens.refresh_token, scope: oauth.scope }, env);
+      updateConfig((config) => {
+        const current = config.workspaces?.[workspace.id];
+        if (!current) return config;
+        const next = {
+          ...stored,
+          scope: oauth.scope,
+          ...narrowed ? { accessToken: current.oauth?.accessToken, accessTokenExpiresAt: current.oauth?.accessTokenExpiresAt } : { accessToken: tokens.access_token, accessTokenExpiresAt: now() + tokens.expires_in * 1e3 }
+        };
+        return { ...config, workspaces: { ...config.workspaces, [workspace.id]: { ...current, oauth: next } } };
+      }, env);
+      return { ok: true, token: tokens.access_token, scope: tokens.scope };
+    }
+    const code = oauthErrorCode(response);
+    if (code === "invalid_grant" && attempt === 0) {
+      const latest = loadConfig(env).workspaces?.[workspace.id];
+      const latestToken = latest ? readRefreshToken(latest, apiUrl, env) : null;
+      if (latest?.oauth && latestToken && latestToken !== refreshToken) {
+        if (!narrowed && latest.oauth.accessToken && (latest.oauth.accessTokenExpiresAt ?? 0) - EXPIRY_SKEW_MS > now()) {
+          return { ok: true, token: latest.oauth.accessToken, scope: latest.oauth.scope };
+        }
+        refreshToken = latestToken;
+        continue;
+      }
+    }
+    if (code === "invalid_grant") {
+      return { ok: false, error: `${oauthErrorMessage(response, "The sign-in is no longer valid")} ${signInAgain}`.trim() };
+    }
+    if (code === "invalid_scope") {
+      return { ok: false, error: `${oauthErrorMessage(response, "That scope was not approved for this sign-in")} To get it: ${brand.bin} login --scope "${options.scope ?? ""}".` };
+    }
+    return { ok: false, error: oauthErrorMessage(response, "Could not refresh the access token") };
+  }
+  return { ok: false, error: `The sign-in is no longer valid. ${signInAgain}` };
+}
+async function revokeRefreshToken(apiUrl, refreshToken, env = process.env) {
+  return apiRequest(apiUrl, "/oauth/revoke", {
+    body: { token: refreshToken, token_type_hint: "refresh_token", client_id: CLI_OAUTH_CLIENT_ID },
+    env
+  });
+}
+
+// src/session/credentials.ts
+function envApiKey(env = process.env) {
+  return env.GROUNDMAIL_API_KEY?.trim() || null;
+}
+function currentSavedWorkspace(config, env = process.env) {
+  const brand = cliBrand(env);
+  const all = savedWorkspaces(config);
+  if (config.current && config.workspaces?.[config.current]) {
+    return { ok: true, workspace: config.workspaces[config.current] };
+  }
+  if (all.length === 1) return { ok: true, workspace: all[0] };
+  if (all.length === 0) {
+    return {
+      ok: false,
+      reason: "none",
+      error: `Not signed in. Run: ${brand.bin} login (it prints a link to approve in the browser). Or set ${brand.keyEnvVar}.`
+    };
+  }
+  return {
+    ok: false,
+    reason: "ambiguous",
+    error: `Signed in to ${all.length} workspaces on this computer and none is picked: ${all.map((workspace) => `"${workspace.name}"`).join(", ")}. Pick one: ${brand.bin} workspaces use <name>, or pass --workspace <name>.`
+  };
+}
+function savedApiUrl(workspace, env = process.env, flagUrl) {
+  return trimUrl(flagUrl) || explicitApiUrl(env) || trimUrl(workspace?.apiUrl) || defaultApiUrl(env);
+}
+async function savedCredential(workspace, env = process.env) {
+  if (workspace.oauth) {
+    const issuer = trimUrl(workspace.apiUrl) || defaultApiUrl(env);
+    const token = await accessTokenFor(workspace, issuer, { env });
+    return token.ok ? { ok: true, token: token.token, kind: "oauth" } : token;
+  }
+  if (workspace.apiKey) return { ok: true, token: workspace.apiKey, kind: "api_key" };
+  return { ok: false, error: `The saved sign-in for ${workspace.name} has no credential. Run ${cliBrand(env).bin} login.` };
+}
+async function resolveAuth(flags, env = process.env, config = loadConfig(env)) {
+  const brand = cliBrand(env);
+  const flagUrl = trimUrl(flags.baseUrl) || null;
+  const urlFor = (workspace) => savedApiUrl(workspace, env, flagUrl);
+  const flagKey = flags.apiKey?.trim();
+  if (flagKey) {
+    return { ok: true, auth: { apiKey: flagKey, baseUrl: urlFor(null), source: "flag", kind: "api_key", workspace: null } };
+  }
+  const fromSaved = async (workspace) => {
+    const baseUrl = urlFor(workspace);
+    const credential = await savedCredential(workspace, env);
+    if (!credential.ok) return credential;
+    return { ok: true, auth: { apiKey: credential.token, baseUrl, source: "saved", kind: credential.kind, workspace } };
+  };
+  if (flags.workspace?.trim()) {
+    const match = findSavedWorkspace(config, flags.workspace);
+    if (!match.ok) {
+      const saved = savedWorkspaces(config);
+      return {
+        ok: false,
+        error: match.reason === "ambiguous" ? `More than one saved workspace is called "${flags.workspace}". Use its id: ${match.matches.map((w) => w.id).join(", ")}.` : `Not signed in to "${flags.workspace}" on this computer.${saved.length ? ` Signed in: ${saved.map((w) => `"${w.name}"`).join(", ")}.` : ""} To add it: ${brand.bin} login --workspace "${flags.workspace}".`
+      };
+    }
+    return fromSaved(match.workspace);
+  }
+  const fromEnv = envApiKey(env);
+  if (fromEnv) {
+    return { ok: true, auth: { apiKey: fromEnv, baseUrl: urlFor(null), source: "env", kind: "api_key", workspace: null } };
+  }
+  const current = currentSavedWorkspace(config, env);
+  if (!current.ok) return { ok: false, error: current.error };
+  return fromSaved(current.workspace);
+}
+async function applySavedSession(argv, env = process.env, config) {
+  const hasFlag = (flag) => argv.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+  let workspace = null;
+  let notice;
+  if (!hasFlag("--api-key") && !envApiKey(env)) {
+    const current = currentSavedWorkspace(config ?? loadConfig(env), env);
+    if (current.ok) {
+      workspace = current.workspace;
+      const credential = await savedCredential(current.workspace, env);
+      if (credential.ok) env.GROUNDMAIL_API_KEY = credential.token;
+      else notice = credential.error;
+    } else if (current.reason === "ambiguous") {
+      notice = current.error;
+    }
+  }
+  if (hasFlag("--base-url")) return { argv, notice };
+  const url = explicitApiUrl(env) || trimUrl(workspace?.apiUrl) || trimUrl(env.GROUNDMAIL_DEFAULT_API_URL);
+  return { argv: url ? [...argv, "--base-url", url] : argv, notice };
+}
+
+// src/session/io.ts
+var processIo = {
+  out: (text) => process.stdout.write(text.endsWith("\n") ? text : `${text}
+`),
+  err: (text) => process.stderr.write(text.endsWith("\n") ? text : `${text}
+`),
+  get isTTY() {
+    return Boolean(process.stdout.isTTY);
+  }
+};
+function printJson(io, value) {
+  io.out(JSON.stringify(value, null, 2));
+}
+
+// src/commands/login.ts
+var realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var CLI_SCOPES = [
+  "full",
+  "emails:send",
+  "emails:read",
+  "domains:read",
+  "domains:write",
+  "webhooks:write",
+  "templates:write",
+  "suppressions:write",
+  "account:read"
+];
+function parseScopeFlag(value) {
+  const tokens = String(value ?? "").split(/[\s,]+/).map((token) => token.trim()).filter(Boolean);
+  if (!tokens.length) return { ok: true, scope: "full" };
+  const unknown = tokens.filter((token) => !CLI_SCOPES.includes(token));
+  if (unknown.length) {
+    return { ok: false, error: `Unknown scope: ${unknown.join(", ")}. Scopes: ${CLI_SCOPES.join(", ")}.` };
+  }
+  if (tokens.includes("full")) return { ok: true, scope: "full" };
+  return { ok: true, scope: CLI_SCOPES.filter((scope) => tokens.includes(scope)).join(" ") };
+}
+function openInBrowser(url) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function sourceLabel(source, env) {
+  if (source === "flag") return "--api-key";
+  if (source === "env") return cliBrand(env).keyEnvVar;
+  return "saved login";
+}
+function defaultDeviceName() {
+  try {
+    return hostname().slice(0, 80) || "this computer";
+  } catch {
+    return "this computer";
+  }
+}
+var dropPending = (env) => updateConfig(({ pendingLogin: _drop, ...rest }) => rest, env);
+async function runLoginCommand(argv, deps = {}) {
+  const io = deps.io ?? processIo;
+  const env = deps.env ?? process.env;
+  const sleep = deps.sleep ?? realSleep;
+  const now = deps.now ?? Date.now;
+  const brand = cliBrand(env);
+  const usage = `Usage: ${brand.bin} login [--scope <scopes>] [--workspace <name>] [--new] [--no-browser] [--wait|--no-wait] [--json]`;
+  const parsed = parseArgs(argv, {
+    values: ["--base-url", "--workspace", "--scope", "--device-name"],
+    booleans: ["--json", "--browser", "--wait", "--new"]
+  });
+  if (!parsed.ok) return { exitCode: EXIT_USAGE, error: `${parsed.error}
+${usage}` };
+  const { args } = parsed;
+  if (args.positionals.length) {
+    return { exitCode: EXIT_USAGE, error: `${brand.bin} login takes no arguments. To sign in to a workspace by name: ${brand.bin} login --workspace "<name>".` };
+  }
+  const scopeFlag = parseScopeFlag(args.values["--scope"]);
+  if (!scopeFlag.ok) return { exitCode: EXIT_USAGE, error: `${scopeFlag.error}
+${usage}` };
+  const scope = scopeFlag.scope;
+  const json = wantsJson(args, io);
+  const wait = args.booleans["--wait"] ?? io.isTTY;
+  const browser = args.booleans["--browser"] ?? true;
+  const apiUrl = trimUrl(args.values["--base-url"]) || explicitApiUrl(env) || defaultApiUrl(env);
+  const workspaceHint = args.values["--workspace"]?.trim() || null;
+  const deviceName = args.values["--device-name"]?.trim() || (deps.deviceName ?? defaultDeviceName)();
+  try {
+    const config = loadConfig(env);
+    let login = config.pendingLogin;
+    const resumed = Boolean(
+      !args.booleans["--new"] && login && login.kind === "oauth" && login.apiUrl === apiUrl && login.expiresAt > now() + 5e3 && (login.workspace ?? null) === workspaceHint && (login.scope ?? "full") === scope
+    );
+    if (!resumed && !workspaceHint && !args.booleans["--new"] && !args.values["--scope"]) {
+      const current = currentSavedWorkspace(config, env);
+      if (current.ok && current.workspace.oauth && (trimUrl(current.workspace.apiUrl) || defaultApiUrl(env)) === apiUrl) {
+        const next = `To sign in to another workspace: ${brand.bin} login --workspace "<name>". For other scopes: ${brand.bin} login --scope <scopes>. To sign in as someone else: ${brand.bin} logout, then ${brand.bin} login.`;
+        if (json) {
+          printJson(io, {
+            status: "signed_in",
+            already: true,
+            workspace: { id: current.workspace.id, name: current.workspace.name },
+            email: current.workspace.email ?? null,
+            scope: current.workspace.oauth.scope,
+            config_path: configPath(env),
+            next
+          });
+        } else {
+          io.out(`Already signed in${current.workspace.email ? ` as ${current.workspace.email}` : ""} to ${current.workspace.name}.
+${next}`);
+        }
+        return { exitCode: EXIT_OK };
+      }
+    }
+    if (!resumed) {
+      const start = await apiRequest(apiUrl, "/oauth/device_authorization", {
+        body: {
+          client_id: CLI_OAUTH_CLIENT_ID,
+          scope,
+          device_name: deviceName,
+          ...workspaceHint ? { workspace: workspaceHint } : {}
+        },
+        env
+      });
+      if (!start.ok) return { exitCode: EXIT_FAILED, error: oauthErrorMessage(start, "Could not start the sign-in") };
+      const body = start.body;
+      const url = typeof body.verification_uri_complete === "string" ? body.verification_uri_complete : body.verification_uri;
+      if (typeof body.device_code !== "string" || typeof body.user_code !== "string" || typeof url !== "string") {
+        return { exitCode: EXIT_FAILED, error: `Unexpected answer from ${apiUrl}/oauth/device_authorization. Is --base-url right?` };
+      }
+      login = {
+        kind: "oauth",
+        scope,
+        deviceCode: body.device_code,
+        userCode: body.user_code,
+        url,
+        interval: Math.max(1, Number(body.interval) || 5),
+        expiresAt: now() + (Number(body.expires_in) || 600) * 1e3,
+        apiUrl,
+        workspace: workspaceHint
+      };
+      const pending = login;
+      updateConfig((current) => ({ ...current, pendingLogin: pending }), env);
+    }
+    const active = login;
+    const link = `${resumed ? "Still waiting for approval" : `Sign in to ${brand.product}`}: open this link and approve code ${active.userCode}
+  ${active.url}`;
+    if (!json) {
+      io.out(`${link}${wait ? "\nWaiting\u2026 (Ctrl-C to stop; run the same command again to pick up where you left off)" : ""}`);
+    } else if (wait) {
+      io.err(link);
+    }
+    if (browser && !resumed && !env.CI) (deps.openBrowser ?? openInBrowser)(active.url);
+    let interval = active.interval;
+    for (; ; ) {
+      const poll = await apiRequest(apiUrl, "/oauth/token", {
+        body: { grant_type: DEVICE_CODE_GRANT_TYPE, device_code: active.deviceCode, client_id: CLI_OAUTH_CLIENT_ID },
+        env
+      });
+      if (poll.ok && isTokenSet(poll.body)) {
+        return finishLogin(poll.body, active, { io, env, json, now });
+      }
+      const code = oauthErrorCode(poll);
+      if (code === "slow_down") interval += 5;
+      else if (code === "access_denied") {
+        dropPending(env);
+        return {
+          exitCode: EXIT_FAILED,
+          error: `${sentence(oauthErrorMessage(poll, "The sign-in was canceled in the browser"))} Run ${brand.bin} login to start again.`
+        };
+      } else if (code !== "authorization_pending") {
+        if (poll.status < 500 && poll.status !== 429) dropPending(env);
+        if (code === "expired_token" || code === "invalid_grant") {
+          return { exitCode: EXIT_FAILED, error: `The sign-in code expired or was already used. Run ${brand.bin} login again.` };
+        }
+        return { exitCode: EXIT_FAILED, error: oauthErrorMessage(poll, "The sign-in check failed") };
+      }
+      if (!wait || now() + interval * 1e3 > active.expiresAt) {
+        const next = `Not signed in yet. Approve code ${active.userCode} in the browser, then run ${brand.bin} login again to finish.`;
+        if (json) {
+          printJson(io, {
+            status: "pending",
+            user_code: active.userCode,
+            verification_url: active.url,
+            expires_at: new Date(active.expiresAt).toISOString(),
+            next
+          });
+        } else {
+          io.out(next);
+        }
+        return { exitCode: EXIT_OK };
+      }
+      await sleep(interval * 1e3);
+    }
+  } catch (error) {
+    if (error instanceof CliRequestError) return { exitCode: EXIT_FAILED, error: error.message };
+    throw error;
+  }
+}
+async function finishLogin(tokens, login, { io, env, json, now }) {
+  const brand = cliBrand(env);
+  const workspace = tokens.workspace ?? {};
+  const user = tokens.user ?? {};
+  const id = typeof workspace.id === "string" && workspace.id ? workspace.id : "default";
+  const scope = typeof tokens.scope === "string" && tokens.scope ? tokens.scope : login.scope ?? "full";
+  const previous = loadConfig(env).workspaces?.[id];
+  let replacedKey = false;
+  if (previous?.apiKey) {
+    const response = await apiRequest(login.apiUrl, "/cli/session", { method: "DELETE", apiKey: previous.apiKey, env }).catch(() => null);
+    replacedKey = Boolean(response?.ok && response.body.revoked === true);
+  }
+  if (previous?.oauth) {
+    const oldRefresh = readRefreshToken(previous, login.apiUrl, env);
+    if (oldRefresh) await revokeRefreshToken(login.apiUrl, oldRefresh, env).catch(() => null);
+  }
+  const stored = storeRefreshToken({ apiUrl: login.apiUrl, workspaceId: id, refreshToken: tokens.refresh_token, scope }, env);
+  const saved = {
+    id,
+    name: typeof workspace.name === "string" && workspace.name ? workspace.name : "Workspace",
+    oauth: { ...stored, accessToken: tokens.access_token, accessTokenExpiresAt: now() + tokens.expires_in * 1e3 },
+    ...login.apiUrl !== defaultApiUrl(env) ? { apiUrl: login.apiUrl } : {},
+    email: typeof user.email === "string" ? user.email : null,
+    savedAt: new Date(now()).toISOString()
+  };
+  const config = updateConfig(({ pendingLogin: _drop, ...rest }) => ({
+    ...rest,
+    workspaces: { ...rest.workspaces ?? {}, [id]: saved },
+    current: id
+  }), env);
+  const others = savedWorkspaces(config).filter((entry) => entry.id !== id);
+  const envKey = envApiKey(env);
+  const envNote = envKey ? `${sourceLabel("env", env)} is set in this environment and is used instead of this sign-in until you unset it.` : null;
+  const where = storeLabel(saved.oauth, configPath(env), env);
+  if (json) {
+    printJson(io, {
+      status: "signed_in",
+      user: tokens.user ?? null,
+      workspace: { id: saved.id, name: saved.name },
+      scope,
+      refresh_token_store: stored.store,
+      config_path: configPath(env),
+      other_workspaces: others.map((entry) => ({ id: entry.id, name: entry.name })),
+      ...replacedKey ? { replaced_api_key: true } : {},
+      ...envNote ? { note: envNote } : {}
+    });
+    return { exitCode: EXIT_OK };
+  }
+  const lines = [
+    `Signed in${saved.email ? ` as ${saved.email}` : ""} to ${saved.name}.`,
+    `Access: ${scope === "full" ? "full" : scope.split(" ").join(", ")}. Tokens refresh on their own; the refresh token is in ${where}.`
+  ];
+  if (replacedKey) lines.push("The API key an earlier login saved was revoked; this sign-in replaces it.");
+  if (others.length) {
+    lines.push(
+      `Also signed in here: ${others.map((entry) => entry.name).join(", ")}. Switch with ${brand.bin} workspaces use <name>.`
+    );
+  }
+  if (envNote) lines.push(envNote);
+  lines.push(`Next: ${brand.bin} domains list`);
+  io.out(lines.join("\n"));
+  return { exitCode: EXIT_OK };
+}
+async function runLogoutCommand(argv, deps = {}) {
+  const io = deps.io ?? processIo;
+  const env = deps.env ?? process.env;
+  const brand = cliBrand(env);
+  const parsed = parseArgs(argv, { values: ["--workspace", "--base-url"], booleans: ["--json", "--all"] });
+  if (!parsed.ok) return { exitCode: EXIT_USAGE, error: `${parsed.error}
+Usage: ${brand.bin} logout [--workspace <name>] [--all]` };
+  const { args } = parsed;
+  const json = wantsJson(args, io);
+  const config = loadConfig(env);
+  const all = savedWorkspaces(config);
+  let targets;
+  if (args.booleans["--all"]) {
+    targets = all;
+  } else if (args.values["--workspace"]) {
+    const match = findSavedWorkspace(config, args.values["--workspace"]);
+    if (!match.ok) {
+      return { exitCode: EXIT_FAILED, error: `Not signed in to "${args.values["--workspace"]}" on this computer.` };
+    }
+    targets = [match.workspace];
+  } else {
+    const current = config.current ? config.workspaces?.[config.current] : all.length === 1 ? all[0] : void 0;
+    if (!current && all.length > 1) {
+      return {
+        exitCode: EXIT_USAGE,
+        error: `Signed in to ${all.length} workspaces and none is picked. Say which: ${brand.bin} logout --workspace <name>, or ${brand.bin} logout --all.`
+      };
+    }
+    targets = current ? [current] : [];
+  }
+  const results = [];
+  for (const workspace of targets) {
+    const apiUrl = trimUrl(args.values["--base-url"]) || explicitApiUrl(env) || trimUrl(workspace.apiUrl) || defaultApiUrl(env);
+    let revoked = false;
+    let warning;
+    try {
+      if (workspace.oauth) {
+        const refreshToken = readRefreshToken(workspace, apiUrl, env);
+        if (refreshToken) {
+          const response = await revokeRefreshToken(apiUrl, refreshToken, env);
+          revoked = response.ok;
+          if (!response.ok) warning = oauthErrorMessage(response, "Could not revoke the sign-in");
+        }
+        forgetRefreshToken(workspace, apiUrl, env);
+      } else if (workspace.apiKey) {
+        const response = await apiRequest(apiUrl, "/cli/session", { method: "DELETE", apiKey: workspace.apiKey, env });
+        revoked = response.ok && response.body.revoked === true;
+        if (!response.ok && response.status !== 401) warning = errorMessage(response, "Could not revoke the key");
+      }
+    } catch (error) {
+      warning = error instanceof Error ? error.message : String(error);
+    }
+    results.push({ id: workspace.id, name: workspace.name, revoked, ...warning ? { warning } : {} });
+  }
+  const removing = new Set(targets.map((workspace) => workspace.id));
+  const hadPending = Boolean(config.pendingLogin);
+  if (removing.size || hadPending) {
+    updateConfig((current) => {
+      const workspaces = Object.fromEntries(
+        Object.entries(current.workspaces ?? {}).filter(([id]) => !removing.has(id))
+      );
+      const { pendingLogin: _drop, current: picked, ...rest } = current;
+      return { ...rest, workspaces, ...picked && !removing.has(picked) ? { current: picked } : {} };
+    }, env);
+  }
+  const envNote = envApiKey(env) ? `${sourceLabel("env", env)} is still set in this environment, so commands keep using it.` : null;
+  if (json) {
+    printJson(io, { signed_out: results, config_path: configPath(env), ...envNote ? { note: envNote } : {} });
+    return { exitCode: EXIT_OK };
+  }
+  if (!results.length) {
+    io.out(`Not signed in on this computer.${envNote ? ` ${envNote}` : ""}`);
+    return { exitCode: EXIT_OK };
+  }
+  const lines = results.map((result) => {
+    const target = targets.find((workspace) => workspace.id === result.id);
+    const what = target?.oauth ? "the sign-in" : "the key";
+    const revokeHint = target?.oauth ? "Revoke it in Settings \u2192 CLIs & agents." : "Revoke it on the API keys page.";
+    return `Signed out of ${result.name}: ${result.revoked ? `${what} was revoked and` : `${what} was`} removed from this computer.${result.warning ? ` (Could not revoke it: ${result.warning} ${revokeHint})` : ""}`;
+  });
+  if (envNote) lines.push(envNote);
+  io.out(lines.join("\n"));
+  return { exitCode: EXIT_OK };
+}
+async function runWhoamiCommand(argv, deps = {}) {
+  const io = deps.io ?? processIo;
+  const env = deps.env ?? process.env;
+  const brand = cliBrand(env);
+  const parsed = parseArgs(argv, { values: [...COMMON_VALUE_FLAGS], booleans: [...COMMON_BOOLEAN_FLAGS] });
+  if (!parsed.ok) return { exitCode: EXIT_USAGE, error: `${parsed.error}
+Usage: ${brand.bin} whoami [--workspace <name>] [--json]` };
+  const { args } = parsed;
+  try {
+    const resolved = await resolveAuth(
+      { apiKey: args.values["--api-key"], baseUrl: args.values["--base-url"], workspace: args.values["--workspace"] },
+      env
+    );
+    if (!resolved.ok) return { exitCode: EXIT_FAILED, error: resolved.error };
+    const { auth } = resolved;
+    const response = await apiRequest(auth.baseUrl, "/cli/session", { apiKey: auth.apiKey, env });
+    if (!response.ok) {
+      const hint = response.status === 401 ? ` The credential was rejected; run ${brand.bin} login to sign in again.` : "";
+      return { exitCode: EXIT_FAILED, error: `${sentence(errorMessage(response, "Could not check the sign-in"))}${hint}` };
+    }
+    const session = response.body;
+    const source = sourceLabel(auth.source, env);
+    if (wantsJson(args, io)) {
+      printJson(io, { ...response.body, source, api_url: auth.baseUrl, config_path: configPath(env) });
+      return { exitCode: EXIT_OK };
+    }
+    const scope = session.scope ?? (session.key?.scope === "sending" ? "emails:send emails:read" : "full");
+    const credential = session.oauth ? `Signed in with OAuth: ${session.oauth.client_name ?? brand.product}${session.oauth.device_name ? ` on ${session.oauth.device_name}` : ""}, from ${source}` : `Key: ${session.key?.name ?? "?"} (${session.key?.prefix ?? "?"}\u2026), from ${source}`;
+    io.out(
+      [
+        session.user?.email ?? "(an API key; no person is recorded for it)",
+        `Workspace: ${session.workspace?.name ?? "?"} (${session.workspace?.id ?? "?"})`,
+        credential,
+        `Scopes: ${scope === "full" ? "full" : scope.split(" ").join(", ")}`,
+        ...session.allowed_domains?.length ? [`Sends only from: ${session.allowed_domains.join(", ")}`] : [],
+        ...auth.baseUrl !== defaultApiUrl(env) ? [`API: ${auth.baseUrl}`] : []
+      ].join("\n")
+    );
+    return { exitCode: EXIT_OK };
+  } catch (error) {
+    if (error instanceof CliRequestError) return { exitCode: EXIT_FAILED, error: error.message };
+    throw error;
+  }
+}
+
+// src/commands/keys/create.ts
+function readFlag16(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+async function runCreateKeyCommandWithClient(args, env = process.env) {
+  const apiKey = readFlag16(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const baseUrl = readFlag16(args, "--base-url") || defaultApiUrl(env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const name = readFlag16(args, "--name");
+  const scope = readFlag16(args, "--scope");
+  if (scope && scope !== "full" && scope !== "sending") {
+    return { exitCode: 1, error: "--scope must be full or sending (or use --scopes for fine-grained scopes)" };
+  }
+  const scopesFlag = readFlag16(args, "--scopes");
+  const scopes = scopesFlag !== void 0 ? parseScopeFlag(scopesFlag) : null;
+  if (scopes && !scopes.ok) return { exitCode: 1, error: scopes.error };
+  const domainsFlag = readFlag16(args, "--allowed-domains");
+  const allowedDomains = domainsFlag?.split(/[\s,]+/).map((domain) => domain.trim()).filter(Boolean);
+  try {
+    const response = await apiRequest(baseUrl, "/api-keys", {
+      apiKey,
+      env,
+      body: {
+        ...name ? { name } : {},
+        ...scope && !scopes ? { scope } : {},
+        ...scopes?.ok ? { scopes: scopes.scope.split(" ") } : {},
+        ...allowedDomains?.length ? { allowed_domains: allowedDomains } : {}
+      }
+    });
+    if (!response.ok) {
+      return { exitCode: 1, error: errorMessage(response, "Could not create the key") };
+    }
+    console.log(JSON.stringify(response.body));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/keys/delete.ts
+function readFlag17(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+async function runDeleteKeyCommandWithClient(args, env = process.env) {
+  const apiKey = readFlag17(args, "--api-key") || env.GROUNDMAIL_API_KEY;
+  const baseUrl = readFlag17(args, "--base-url");
+  const id = readFlag17(args, "--id");
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  if (!id) {
+    return { exitCode: 1, error: "Required: --id <api-key-id>" };
+  }
+  const { Groundmail } = await import("groundmail");
+  const client = new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+  try {
+    const result = await client.apiKeys.remove(id);
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    return { exitCode: 1, error: message };
+  }
+}
+
+// src/commands/suppressions/shared.ts
+function readFlag18(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function parseSuppressionsCommonArgs(args) {
+  return {
+    apiKey: readFlag18(args, "--api-key"),
+    baseUrl: readFlag18(args, "--base-url")
+  };
+}
+function resolveApiKey6(options, env) {
+  return options.apiKey || env.GROUNDMAIL_API_KEY || null;
+}
+async function createSuppressionsClient(apiKey, baseUrl) {
+  const { Groundmail } = await import("groundmail");
+  return new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+}
+
+// src/commands/suppressions/list.ts
+async function runListCommand6(args, env = process.env) {
+  const options = parseSuppressionsCommonArgs(args);
+  const apiKey = resolveApiKey6(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  try {
+    const client = await createSuppressionsClient(apiKey, options.baseUrl);
+    const limitRaw = readFlag18(args, "--limit");
+    const cursor = readFlag18(args, "--cursor");
+    const email = readFlag18(args, "--email");
+    const result = await client.suppressions.list({
+      ...limitRaw ? { limit: Number(limitRaw) } : {},
+      ...cursor ? { cursor } : {},
+      ...email ? { email } : {}
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/suppressions/add.ts
+async function runAddCommand2(args, env = process.env) {
+  const options = parseSuppressionsCommonArgs(args);
+  const apiKey = resolveApiKey6(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const email = readFlag18(args, "--email") || args.find((a) => a.includes("@") && !a.startsWith("-"));
+  if (!email) {
+    return { exitCode: 1, error: "Missing email. Pass --email user@example.com" };
+  }
+  try {
+    const client = await createSuppressionsClient(apiKey, options.baseUrl);
+    const reason = readFlag18(args, "--reason");
+    const result = await client.suppressions.create({
+      email,
+      ...reason ? { reason } : {}
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/suppressions/remove.ts
+async function runRemoveCommand(args, env = process.env) {
+  const options = parseSuppressionsCommonArgs(args);
+  const apiKey = resolveApiKey6(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const idOrEmail = readFlag18(args, "--id") || readFlag18(args, "--email") || args.find((a) => !a.startsWith("-") && a !== "remove" && a !== "delete");
+  if (!idOrEmail) {
+    return { exitCode: 1, error: "Missing id or email. Pass --id <uuid> or --email user@example.com" };
+  }
+  try {
+    const client = await createSuppressionsClient(apiKey, options.baseUrl);
+    const result = await client.suppressions.remove(idOrEmail);
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/templates/shared.ts
+function readFlag19(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function parseTemplatesCommonArgs(args) {
+  return {
+    apiKey: readFlag19(args, "--api-key"),
+    baseUrl: readFlag19(args, "--base-url")
+  };
+}
+function resolveApiKey7(options, env) {
+  return options.apiKey || env.GROUNDMAIL_API_KEY || null;
+}
+async function createTemplatesClient(apiKey, baseUrl) {
+  const { Groundmail } = await import("groundmail");
+  return new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+}
+
+// src/commands/templates/delete.ts
+var POSITIONAL_FLAGS7 = ["--api-key", "--base-url", "--id", "--alias"];
+async function runDeleteCommand4(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  const idOrAlias = readFlag19(args, "--id") || readFlag19(args, "--alias") || readFirstPositional8(args);
+  if (!idOrAlias) return { exitCode: 1, error: "Missing template id or alias. Pass --id tpl_\u2026 or --alias welcome" };
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.templates.remove(idOrAlias)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readFirstPositional8(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS7.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+
+// src/commands/templates/duplicate.ts
+var POSITIONAL_FLAGS8 = ["--api-key", "--base-url", "--id", "--alias", "--name"];
+async function runDuplicateCommand(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  const idOrAlias = readFlag19(args, "--id") || readFlag19(args, "--alias") || readFirstPositional9(args);
+  if (!idOrAlias) return { exitCode: 1, error: "Missing template id or alias. Pass --id tpl_\u2026 or --alias welcome" };
+  const name = readFlag19(args, "--name");
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.templates.duplicate(idOrAlias, name ? { name } : {})));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readFirstPositional9(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS8.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+
+// src/commands/templates/get.ts
+var POSITIONAL_FLAGS9 = ["--api-key", "--base-url", "--id", "--alias"];
+async function runGetCommand6(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  const idOrAlias = readFlag19(args, "--id") || readFlag19(args, "--alias") || readFirstPositional10(args);
+  if (!idOrAlias) return { exitCode: 1, error: "Missing template id or alias. Pass --id tpl_\u2026 or --alias welcome" };
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.templates.get(idOrAlias)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readFirstPositional10(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS9.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+
+// src/commands/templates/list.ts
+async function runListCommand7(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    const limitRaw = readFlag19(args, "--limit");
+    const cursor = readFlag19(args, "--cursor");
+    const status = readFlag19(args, "--status");
+    const result = await client.templates.list({
+      ...limitRaw ? { limit: Number(limitRaw) } : {},
+      ...cursor ? { cursor } : {},
+      ...status ? { status } : {}
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/templates/publish.ts
+var POSITIONAL_FLAGS10 = ["--api-key", "--base-url", "--id", "--alias"];
+async function runPublishCommand(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  const idOrAlias = readFlag19(args, "--id") || readFlag19(args, "--alias") || readFirstPositional11(args);
+  if (!idOrAlias) return { exitCode: 1, error: "Missing template id or alias. Pass --id tpl_\u2026 or --alias welcome" };
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.templates.publish(idOrAlias)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readFirstPositional11(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS10.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+
+// src/commands/templates/render-source.ts
+var HTML_EXTENSIONS = [".html", ".htm"];
+var TEXT_EXTENSIONS = [".txt", ".text"];
+var MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".jsx", ".ts", ".tsx"];
+var TYPESCRIPT_EXTENSIONS = [".ts", ".tsx", ".jsx"];
+function extensionOf(filePath) {
+  const match = /\.[^.\/\\]+$/.exec(filePath);
+  return match ? match[0].toLowerCase() : "";
+}
+async function defaultReadFile(filePath) {
+  const { readFile: readFile3 } = await import("fs/promises");
+  return readFile3(filePath, "utf8");
+}
+async function defaultImportModule(filePath) {
+  const { pathToFileURL } = await import("url");
+  const { resolve } = await import("path");
+  const url = pathToFileURL(resolve(filePath)).href;
+  try {
+    return await import(url);
+  } catch (error) {
+    if (!TYPESCRIPT_EXTENSIONS.includes(extensionOf(filePath))) throw error;
+    try {
+      const specifier = "tsx/esm/api";
+      const tsx = await import(specifier);
+      tsx.register();
+    } catch {
+      throw new Error(
+        `Cannot import ${filePath} directly. Install tsx to push TypeScript or JSX templates (npm install -D tsx), or pre-render the file to .html.`
+      );
+    }
+    return import(url);
+  }
+}
+async function loadReactEmailRender() {
+  try {
+    const mod = await import("@react-email/render");
+    const render = mod.render ?? mod.default?.render;
+    if (typeof render !== "function") throw new Error("missing render export");
+    return render;
+  } catch {
+    throw new Error(
+      "Rendering a React email requires @react-email/render. Install it with: npm install @react-email/render react"
+    );
+  }
+}
+async function toElement(mod, props) {
+  const record = mod;
+  const exported = record?.default ?? mod;
+  if (typeof exported === "function") {
+    const react = await import("./react-IXBRBSFN.js");
+    const createElement = react.createElement ?? react.default?.createElement;
+    if (typeof createElement !== "function") {
+      throw new Error("Rendering a React email requires react. Install it with: npm install react");
+    }
+    return createElement(exported, props);
+  }
+  if (!exported) {
+    throw new Error("The template module must export a React component as its default export.");
+  }
+  return exported;
+}
+async function loadTemplateSource(filePath, options = {}, deps = {}) {
+  const readFile3 = deps.readFile ?? defaultReadFile;
+  const importModule = deps.importModule ?? defaultImportModule;
+  const extension = extensionOf(filePath);
+  if (HTML_EXTENSIONS.includes(extension)) {
+    return { html: await readFile3(filePath) };
+  }
+  if (TEXT_EXTENSIONS.includes(extension)) {
+    return { text: await readFile3(filePath) };
+  }
+  if (!MODULE_EXTENSIONS.includes(extension)) {
+    throw new Error(
+      `Unsupported template file "${filePath}". Use .html, .txt, or a module exporting a React component (${MODULE_EXTENSIONS.join(", ")}).`
+    );
+  }
+  const mod = await importModule(filePath);
+  const element = await toElement(mod, options.props ?? {});
+  const render = await loadReactEmailRender();
+  const html = await render(element);
+  let text;
+  try {
+    text = await render(element, { plainText: true });
+  } catch {
+    text = void 0;
+  }
+  return { html, ...text ? { text } : {} };
+}
+
+// src/commands/templates/push.ts
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--alias",
+  "--subject",
+  "--name",
+  "--text",
+  "--preheader",
+  "--props",
+  "--api-key",
+  "--base-url"
+]);
+function readPositional(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg.startsWith("--")) {
+      if (VALUE_FLAGS.has(arg)) index += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+function statusOf(error) {
+  const status = error?.status;
+  return typeof status === "number" ? status : void 0;
+}
+async function runPushCommand(args, env = process.env, deps = {}) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const file = readFlag19(args, "--file") ?? readPositional(args);
+  if (!file) {
+    return { exitCode: 1, error: "Missing template file. Usage: templates push <file> --alias <alias>" };
+  }
+  const alias = readFlag19(args, "--alias");
+  if (!alias) {
+    return { exitCode: 1, error: "Missing --alias. The alias identifies which template to update." };
+  }
+  const subject = readFlag19(args, "--subject");
+  const name = readFlag19(args, "--name");
+  const preheader = readFlag19(args, "--preheader");
+  const textFile = readFlag19(args, "--text");
+  const propsRaw = readFlag19(args, "--props");
+  const shouldPublish = args.includes("--publish");
+  let props = {};
+  if (propsRaw) {
+    try {
+      const parsed = JSON.parse(propsRaw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("not an object");
+      }
+      props = parsed;
+    } catch {
+      return { exitCode: 1, error: `--props must be a JSON object, e.g. --props '{"name":"Ada"}'` };
+    }
+  }
+  try {
+    const source = await loadTemplateSource(file, { props }, deps);
+    if (textFile) {
+      const textSource = await loadTemplateSource(textFile, { props }, deps);
+      source.text = textSource.text ?? textSource.html;
+    }
+    if (!source.html && !source.text) {
+      return { exitCode: 1, error: `${file} produced no content to push.` };
+    }
+    const createClient2 = deps.createClient ?? createTemplatesClient;
+    const client = await createClient2(apiKey, options.baseUrl);
+    let existed = true;
+    try {
+      await client.templates.get(alias);
+    } catch (error) {
+      if (statusOf(error) !== 404) throw error;
+      existed = false;
+    }
+    const body = {
+      format: "html",
+      ...source.html ? { html: source.html } : {},
+      ...source.text ? { text: source.text } : {},
+      ...subject ? { subject } : {},
+      ...preheader ? { preheader } : {},
+      ...name ? { name } : {}
+    };
+    let result;
+    if (existed) {
+      result = await client.templates.update(alias, body);
+    } else {
+      if (!subject) {
+        return {
+          exitCode: 1,
+          error: `Template "${alias}" does not exist yet. Pass --subject to create it.`
+        };
+      }
+      result = await client.templates.create({
+        name: name || alias,
+        subject,
+        alias,
+        ...body
+      });
+    }
+    if (shouldPublish) {
+      result = await client.templates.publish(alias);
+    }
+    console.log(JSON.stringify({ ...result, pushed: { file, alias, created: !existed } }));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/templates/create.ts
+async function runCreateCommand3(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const name = readFlag19(args, "--name");
+  const subject = readFlag19(args, "--subject");
+  const html = readFlag19(args, "--html");
+  const text = readFlag19(args, "--text");
+  const alias = readFlag19(args, "--alias");
+  const category = readFlag19(args, "--category");
+  const unsubscribeEnabled = args.includes("--unsubscribe-enabled");
+  if (!name) {
+    return { exitCode: 1, error: 'Missing name. Pass --name "Welcome"' };
+  }
+  if (!subject) {
+    return { exitCode: 1, error: 'Missing subject. Pass --subject "Hello {{name}}"' };
+  }
+  if (!html && !text) {
+    return { exitCode: 1, error: 'Missing body. Pass --html "<p>Hi</p>" or --text "Hi"' };
+  }
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    const result = await client.templates.create({
+      name,
+      subject,
+      ...html ? { html } : {},
+      ...text ? { text } : {},
+      ...alias ? { alias } : {},
+      ...category ? { category } : {},
+      ...unsubscribeEnabled ? { unsubscribe_enabled: true } : {}
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/templates/update.ts
+var POSITIONAL_FLAGS11 = [
+  "--api-key",
+  "--base-url",
+  "--id",
+  "--alias",
+  "--set-alias",
+  "--name",
+  "--subject",
+  "--html",
+  "--text",
+  "--variable"
+];
+async function runUpdateCommand4(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const idOrAlias = readFlag19(args, "--id") || readFlag19(args, "--alias") || readFirstPositional12(args);
+  if (!idOrAlias) {
+    return { exitCode: 1, error: "Missing template id or alias. Pass --id tpl_\u2026 or --alias welcome" };
+  }
+  const name = readFlag19(args, "--name");
+  const subject = readFlag19(args, "--subject");
+  const html = readFlag19(args, "--html");
+  const text = readFlag19(args, "--text");
+  const alias = readFlag19(args, "--set-alias");
+  const variables = readFlags3(args, "--variable");
+  const category = readFlag19(args, "--category");
+  const unsubscribeEnabled = args.includes("--unsubscribe-enabled");
+  const unsubscribeDisabled = args.includes("--no-unsubscribe-enabled");
+  if (!name && !subject && !html && !text && !alias && variables.length === 0 && !category && !unsubscribeEnabled && !unsubscribeDisabled) {
+    return {
+      exitCode: 1,
+      error: "Nothing to update. Pass --name, --subject, --html, --text, --set-alias, --category, --variable, or unsubscribe flags."
+    };
+  }
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    const result = await client.templates.update(idOrAlias, {
+      ...name ? { name } : {},
+      ...subject ? { subject } : {},
+      ...html ? { html } : {},
+      ...text ? { text } : {},
+      ...alias ? { alias } : {},
+      ...variables.length > 0 ? { variables } : {},
+      ...category ? { category } : {},
+      ...unsubscribeEnabled ? { unsubscribe_enabled: true } : {},
+      ...unsubscribeDisabled ? { unsubscribe_enabled: false } : {}
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readFlags3(args, flag) {
+  const values = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === flag && args[i + 1]) values.push(args[i + 1]);
+  }
+  return values;
+}
+function readFirstPositional12(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS11.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+
+// src/commands/templates/from-starter.ts
+var POSITIONAL_FLAGS12 = ["--api-key", "--base-url", "--alias"];
+function readFirstPositional13(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS12.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+async function runFromStarterCommand(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const alias = readFlag19(args, "--alias") || readFirstPositional13(args);
+  if (!alias) {
+    return {
+      exitCode: 1,
+      error: "Missing starter alias. Pass password-reset (or --alias welcome). List: groundmail templates starters"
+    };
+  }
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.templates.fromStarter(alias)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function runListStartersCommand(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.templates.listStarters()));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/templates/versions.ts
+var POSITIONAL_FLAGS13 = ["--api-key", "--base-url", "--id", "--alias", "--version", "--from", "--to"];
+function readFirstPositional14(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (POSITIONAL_FLAGS13.includes(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+async function runVersionsCommand(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const idOrAlias = readFlag19(args, "--id") || readFlag19(args, "--alias") || readFirstPositional14(args);
+  if (!idOrAlias) {
+    return { exitCode: 1, error: "Missing template id or alias. Pass --id tpl_\u2026 or --alias welcome" };
+  }
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.templates.listVersions(idOrAlias)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function runRestoreCommand(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const idOrAlias = readFlag19(args, "--id") || readFlag19(args, "--alias") || readFirstPositional14(args);
+  const versionRaw = readFlag19(args, "--version");
+  const version2 = versionRaw ? Number.parseInt(versionRaw, 10) : NaN;
+  if (!idOrAlias || !Number.isFinite(version2) || version2 < 1) {
+    return {
+      exitCode: 1,
+      error: "Usage: groundmail templates restore --id <id|alias> --version <n>"
+    };
+  }
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.templates.restoreVersion(idOrAlias, version2)));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function runTestSendCommand(args, env = process.env) {
+  const options = parseTemplatesCommonArgs(args);
+  const apiKey = resolveApiKey7(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const idOrAlias = readFlag19(args, "--id") || readFlag19(args, "--alias") || readFirstPositional14(args);
+  const from = readFlag19(args, "--from");
+  const to = readFlag19(args, "--to");
+  if (!idOrAlias || !from || !to) {
+    return {
+      exitCode: 1,
+      error: "Usage: groundmail templates test-send --id <id|alias> --from <email> --to <email>"
+    };
+  }
+  try {
+    const client = await createTemplatesClient(apiKey, options.baseUrl);
+    console.log(JSON.stringify(await client.templates.testSend(idOrAlias, { from, to })));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/integrations/shared.ts
+function readFlag20(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  return args[index + 1];
+}
+function parseIntegrationsCommonArgs(args) {
+  return {
+    apiKey: readFlag20(args, "--api-key"),
+    baseUrl: readFlag20(args, "--base-url")
+  };
+}
+function resolveApiKey8(options, env) {
+  return options.apiKey || env.GROUNDMAIL_API_KEY || null;
+}
+async function createIntegrationsClient(apiKey, baseUrl) {
+  const { Groundmail } = await import("groundmail");
+  return new Groundmail(apiKey, baseUrl ? { baseUrl } : void 0);
+}
+
+// src/commands/integrations/twilio.ts
+async function runTwilioStatusCommand(args, env = process.env) {
+  const options = parseIntegrationsCommonArgs(args);
+  const apiKey = resolveApiKey8(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  try {
+    const client = await createIntegrationsClient(apiKey, options.baseUrl);
+    const result = await client.integrations.getTwilio();
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function runTwilioConnectCommand(args, env = process.env) {
+  const options = parseIntegrationsCommonArgs(args);
+  const apiKey = resolveApiKey8(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  const accountSid = readFlag20(args, "--account-sid") || env.TWILIO_ACCOUNT_SID || env.TWILIO_SID || "";
+  const authToken = readFlag20(args, "--auth-token") || env.TWILIO_AUTH_TOKEN || env.TWILIO_TOKEN || "";
+  const defaultFrom = readFlag20(args, "--from") || readFlag20(args, "--default-from") || env.TWILIO_DEFAULT_FROM || "";
+  const messagingServiceSid = readFlag20(args, "--messaging-service-sid") || readFlag20(args, "--messaging-sid") || env.TWILIO_MESSAGING_SERVICE_SID || "";
+  if (!accountSid.trim() || !authToken.trim()) {
+    return {
+      exitCode: 1,
+      error: "Required: --account-sid and --auth-token (or TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN)."
+    };
+  }
+  if (!defaultFrom.trim() && !messagingServiceSid.trim()) {
+    return {
+      exitCode: 1,
+      error: "Required: --from or --messaging-service-sid (or TWILIO_DEFAULT_FROM / TWILIO_MESSAGING_SERVICE_SID)."
+    };
+  }
+  try {
+    const client = await createIntegrationsClient(apiKey, options.baseUrl);
+    const result = await client.integrations.connectTwilio({
+      accountSid: accountSid.trim(),
+      authToken: authToken.trim(),
+      ...defaultFrom.trim() ? { defaultFrom: defaultFrom.trim() } : {},
+      ...messagingServiceSid.trim() ? { messagingServiceSid: messagingServiceSid.trim() } : {}
+    });
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function runTwilioDisconnectCommand(args, env = process.env) {
+  const options = parseIntegrationsCommonArgs(args);
+  const apiKey = resolveApiKey8(options, env);
+  if (!apiKey) {
+    return { exitCode: 1, error: "Missing API key. Set GROUNDMAIL_API_KEY or pass --api-key." };
+  }
+  try {
+    const client = await createIntegrationsClient(apiKey, options.baseUrl);
+    const result = await client.integrations.disconnectTwilio();
+    console.log(JSON.stringify(result));
+    return { exitCode: 0 };
+  } catch (error) {
+    return { exitCode: 1, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/commands/auth.ts
+async function runAuthCommand(subcommand, argv, deps = {}) {
+  const env = deps.env ?? process.env;
+  const brand = cliBrand(env);
+  const usage = `Usage: ${brand.bin} auth token [--scope <scopes>] [--workspace <name>] [--json]`;
+  if (subcommand === "token") return printToken(argv, deps, usage);
+  return { exitCode: EXIT_USAGE, error: subcommand ? `Unknown: auth ${subcommand}.
+${usage}` : usage };
+}
+async function printToken(argv, deps, usage) {
+  const io = deps.io ?? processIo;
+  const env = deps.env ?? process.env;
+  const brand = cliBrand(env);
+  const parsed = parseArgs(argv, { values: ["--scope", "--workspace"], booleans: ["--json"] });
+  if (!parsed.ok) return { exitCode: EXIT_USAGE, error: `${parsed.error}
+${usage}` };
+  const { args } = parsed;
+  if (args.positionals.length) return { exitCode: EXIT_USAGE, error: usage };
+  const scopeFlag = args.values["--scope"] ? parseScopeFlag(args.values["--scope"]) : null;
+  if (scopeFlag && !scopeFlag.ok) return { exitCode: EXIT_USAGE, error: `${scopeFlag.error}
+${usage}` };
+  const config = loadConfig(env);
+  const picked = args.values["--workspace"] ? findSavedWorkspace(config, args.values["--workspace"]) : currentSavedWorkspace(config, env);
+  if (!picked.ok) {
+    const reason = "error" in picked ? picked.error : `Not signed in to "${args.values["--workspace"]}" on this computer. Run ${brand.bin} login --workspace "${args.values["--workspace"]}".`;
+    return { exitCode: EXIT_FAILED, error: reason };
+  }
+  const workspace = picked.workspace;
+  if (!workspace.oauth) {
+    const envNote = envApiKey(env) ? ` ${brand.keyEnvVar} is an API key already; use it as the Bearer token directly.` : "";
+    return {
+      exitCode: EXIT_FAILED,
+      error: `The saved sign-in for ${workspace.name} is an API key from an older ${brand.bin} login, not OAuth. Run ${brand.bin} login to switch to tokens.${envNote}`
+    };
+  }
+  try {
+    const apiUrl = trimUrl(workspace.apiUrl) || defaultApiUrl(env);
+    const result = await accessTokenFor(workspace, apiUrl, {
+      scope: scopeFlag?.ok ? scopeFlag.scope : null,
+      env,
+      now: deps.now
+    });
+    if (!result.ok) return { exitCode: EXIT_FAILED, error: result.error };
+    if (args.booleans["--json"]) {
+      printJson(io, { access_token: result.token, token_type: "Bearer", scope: result.scope, workspace: { id: workspace.id, name: workspace.name } });
+    } else {
+      io.out(result.token);
+    }
+    return { exitCode: EXIT_OK };
+  } catch (error) {
+    if (error instanceof CliRequestError) return { exitCode: EXIT_FAILED, error: error.message };
+    throw error;
+  }
+}
+
+// src/commands/workspaces.ts
+async function runWorkspacesCommand(subcommand, argv, deps = {}) {
+  const env = deps.env ?? process.env;
+  const brand = cliBrand(env);
+  const usage = `Usage:
+  ${brand.bin} workspaces list
+  ${brand.bin} workspaces use <name|id>`;
+  if (subcommand === "list" || subcommand === "ls") return listWorkspaces(argv, deps);
+  if (subcommand === "use" || subcommand === "switch") return switchWorkspace(argv, deps);
+  return { exitCode: EXIT_USAGE, error: subcommand ? `Unknown: workspaces ${subcommand}.
+${usage}` : usage };
+}
+async function listWorkspaces(argv, deps) {
+  const io = deps.io ?? processIo;
+  const env = deps.env ?? process.env;
+  const brand = cliBrand(env);
+  const parsed = parseArgs(argv, { booleans: ["--json"] });
+  if (!parsed.ok) return { exitCode: EXIT_USAGE, error: parsed.error };
+  if (parsed.args.positionals.length) return { exitCode: EXIT_USAGE, error: `${brand.bin} workspaces list takes no arguments.` };
+  const config = loadConfig(env);
+  const all = savedWorkspaces(config);
+  const current = currentSavedWorkspace(config, env);
+  const currentId = current.ok ? current.workspace.id : null;
+  const envNote = envApiKey(env) ? "An API key is set in this environment; commands use it instead of these until you unset it." : null;
+  const addHint = `To add a workspace: ${brand.bin} login --workspace "<name>", and pick it in the browser.`;
+  if (wantsJson(parsed.args, io)) {
+    printJson(io, {
+      workspaces: all.map((workspace) => ({
+        id: workspace.id,
+        name: workspace.name,
+        current: workspace.id === currentId,
+        email: workspace.email ?? null,
+        ...workspace.apiUrl && workspace.apiUrl !== defaultApiUrl(env) ? { api_url: workspace.apiUrl } : {}
+      })),
+      current: currentId,
+      ...current.ok || current.reason === "none" ? {} : { next: current.error },
+      config_path: configPath(env),
+      ...envNote ? { note: envNote } : {}
+    });
+    return { exitCode: EXIT_OK };
+  }
+  if (!all.length) {
+    io.out(`No workspaces signed in on this computer. Run: ${brand.bin} login${envNote ? `
+${envNote}` : ""}`);
+    return { exitCode: EXIT_OK };
+  }
+  const lines = all.map(
+    (workspace) => `${workspace.id === currentId ? "*" : " "} ${workspace.name}  (${workspace.id})${workspace.email ? `  ${workspace.email}` : ""}${workspace.apiUrl && workspace.apiUrl !== defaultApiUrl(env) ? `  ${workspace.apiUrl}` : ""}`
+  );
+  if (!current.ok) lines.push("", current.error);
+  lines.push("", addHint);
+  if (envNote) lines.push(envNote);
+  io.out(lines.join("\n"));
+  return { exitCode: EXIT_OK };
+}
+async function switchWorkspace(argv, deps) {
+  const io = deps.io ?? processIo;
+  const env = deps.env ?? process.env;
+  const brand = cliBrand(env);
+  const parsed = parseArgs(argv, { booleans: ["--json"] });
+  if (!parsed.ok) return { exitCode: EXIT_USAGE, error: parsed.error };
+  const wanted = parsed.args.positionals.join(" ").trim();
+  if (!wanted) return { exitCode: EXIT_USAGE, error: `Name the workspace: ${brand.bin} workspaces use <name|id> (see ${brand.bin} workspaces list).` };
+  const config = loadConfig(env);
+  const match = findSavedWorkspace(config, wanted);
+  if (!match.ok) {
+    const saved = savedWorkspaces(config);
+    return {
+      exitCode: EXIT_FAILED,
+      error: match.reason === "ambiguous" ? `More than one saved workspace is called "${wanted}". Use its id: ${match.matches.map((w) => w.id).join(", ")}.` : `Not signed in to "${wanted}" on this computer.${saved.length ? ` Signed in: ${saved.map((w) => `"${w.name}"`).join(", ")}.` : ""} To add it: ${brand.bin} login --workspace "${wanted}".`
+    };
+  }
+  updateConfig((current) => ({ ...current, current: match.workspace.id }), env);
+  if (wantsJson(parsed.args, io)) {
+    printJson(io, { current: { id: match.workspace.id, name: match.workspace.name } });
+  } else {
+    io.out(`Now working in ${match.workspace.name}.`);
+  }
+  return { exitCode: EXIT_OK };
+}
+
+// src/cli.ts
+function printUsage() {
+  console.error("Usage:");
+  console.error("  groundmail login [--scope <scopes>] [--workspace <name>]   sign in through the browser (OAuth; no key to copy)");
+  console.error("  groundmail logout [--workspace <name>|--all]   revokes the sign-in server-side");
+  console.error("  groundmail whoami");
+  console.error("  groundmail auth token [--scope <scopes>]   print a short-lived access token (for agents and scripts)");
+  console.error("  groundmail workspaces list");
+  console.error("  groundmail workspaces use <name|id>");
+  console.error("  groundmail domains add example.com");
+  console.error("  groundmail domains apply example.com --provider cloudflare");
+  console.error("  groundmail domains apply example.com --provider vercel");
+  console.error("  groundmail domains apply example.com --provider godaddy");
+  console.error("  groundmail domains list");
+  console.error("  groundmail domains get example.com");
+  console.error("  groundmail domains update example.com --inbound true");
+  console.error("  groundmail domains verify example.com");
+  console.error("  groundmail domains delete example.com");
+  console.error("  groundmail received-emails list [--domain inbound.example.com]");
+  console.error("  groundmail received-emails get inb_...");
+  console.error('  groundmail emails send --from you@domain.com --to user@example.com --subject "Hello" --html "<p>Hi</p>" [--category transactional|product|newsletter] [--unsubscribe]');
+  console.error("  groundmail emails batch --file ./emails.json");
+  console.error("  groundmail emails list [--limit 25] [--cursor \u2026]");
+  console.error("  groundmail emails insights [--window 7d|30d]");
+  console.error("  groundmail emails get --id msg_\u2026");
+  console.error("  groundmail emails cancel --id msg_\u2026");
+  console.error("  groundmail emails resend --id msg_\u2026");
+  console.error(`  groundmail events send --name user.created --email user@example.com --data '{"name":"Ada"}'`);
+  console.error("  groundmail automations list");
+  console.error("  groundmail automations create --file ./welcome.json");
+  console.error(`  groundmail automations create --name Welcome --trigger user.created --steps '[{"type":"send_email","email":{...}}]'`);
+  console.error("  groundmail automations create --file ./otp-sms.json");
+  console.error("  groundmail automations get --id <automation-id>");
+  console.error("  groundmail automations update --id <automation-id> --file ./welcome.json");
+  console.error("  groundmail automations activate --id <automation-id>");
+  console.error("  groundmail automations pause --id <automation-id>");
+  console.error("  groundmail automations delete --id <automation-id>");
+  console.error("  groundmail webhooks list");
+  console.error("  groundmail webhooks create --url https://yourapp.com/hooks");
+  console.error("  groundmail webhooks get --id wh_\u2026");
+  console.error("  groundmail webhooks update --id wh_\u2026 [--url \u2026] [--event email.sent] [--enabled true|false]");
+  console.error("  groundmail webhooks delete --id <webhook-id>");
+  console.error("  groundmail suppressions list");
+  console.error("  groundmail suppressions add --email user@example.com [--reason \u2026]");
+  console.error("  groundmail suppressions remove --id <id> | --email user@example.com");
+  console.error("  groundmail templates list [--status draft|published]");
+  console.error("  groundmail templates starters");
+  console.error("  groundmail templates from-starter password-reset");
+  console.error('  groundmail templates create --name Welcome --subject "Hi" --html "<p>Hi</p>" [--category transactional|product|newsletter] [--unsubscribe-enabled]');
+  console.error("  groundmail templates get --id tpl_\u2026");
+  console.error("  groundmail templates update --id tpl_\u2026 [--name \u2026] [--subject \u2026] [--html \u2026] [--text \u2026] [--set-alias \u2026] [--category transactional|product|newsletter] [--unsubscribe-enabled|--no-unsubscribe-enabled]");
+  console.error("  groundmail templates publish --id tpl_\u2026");
+  console.error(
+    `  groundmail templates push ./emails/welcome.tsx --alias welcome [--subject "Welcome"] [--props '{"name":"Ada"}'] [--publish]`
+  );
+  console.error("  groundmail templates versions --id tpl_\u2026");
+  console.error("  groundmail templates restore --id tpl_\u2026 --version 2");
+  console.error("  groundmail templates test-send --id tpl_\u2026 --from you@domain.com --to you@domain.com");
+  console.error('  groundmail templates duplicate --id tpl_\u2026 [--name "Copy"]');
+  console.error("  groundmail templates delete --id tpl_\u2026");
+  console.error("  groundmail keys list");
+  console.error("  groundmail keys create [--name Default] [--scopes emails:send,domains:read] [--allowed-domains example.com]");
+  console.error("  groundmail keys delete --id <api-key-id>");
+  console.error("  groundmail integrations twilio status");
+  console.error("  groundmail integrations twilio connect --account-sid AC\u2026 --auth-token \u2026 --from +15551234567");
+  console.error("  groundmail integrations twilio disconnect");
+  console.error("");
+  console.error("Environment:");
+  console.error("  GROUNDMAIL_API_KEY=gm_\u2026   optional (CI): wins over the `groundmail login` sign-in");
+  console.error("  GROUNDMAIL_NO_KEYCHAIN=1  keep the refresh token in the config file (0600) instead of the OS keychain");
+  console.error("");
+  console.error("Scopes: full, emails:send, emails:read, domains:read, domains:write, webhooks:write, templates:write,");
+  console.error("        suppressions:write, account:read");
+  console.error("  TWILIO_ACCOUNT_SID=AC\u2026 TWILIO_AUTH_TOKEN=\u2026 TWILIO_DEFAULT_FROM=+1\u2026  (integrations twilio connect)");
+  console.error("  CLOUDFLARE_API_TOKEN=\u2026            (optional local apply; else uses dashboard Integrations)");
+  console.error("  VERCEL_API_TOKEN=\u2026 VERCEL_TEAM_ID=\u2026  (optional local apply; else uses dashboard Integrations)");
+  console.error("  GODADDY_API_KEY=\u2026 GODADDY_API_SECRET=\u2026  (domains apply --provider godaddy)");
+}
+async function finish(result) {
+  if (result.error) console.error(result.error);
+  process.exit(result.exitCode);
+}
+async function main() {
+  const [, , command, subcommand] = process.argv;
+  const args = process.argv.slice(3);
+  if (command === "help" || command === "--help" || command === "-h") {
+    printUsage();
+    process.exit(0);
+  }
+  if (command === "login") await finish(await runLoginCommand(args));
+  if (command === "logout") await finish(await runLogoutCommand(args));
+  if (command === "whoami") await finish(await runWhoamiCommand(args));
+  if (command === "workspaces" || command === "workspace") await finish(await runWorkspacesCommand(subcommand, args.slice(1)));
+  if (command === "auth") await finish(await runAuthCommand(subcommand, args.slice(1)));
+  const session = await applySavedSession(process.argv.slice(4));
+  if (session.notice) console.error(session.notice);
+  const rest = session.argv;
+  if (command === "domains") {
+    if (subcommand === "add" || subcommand === "create") {
+      const result = await runAddCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "apply") {
+      const result = await runApplyCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "get") {
+      const result = await runGetCommand3(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "list") {
+      const result = await runListCommand3(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "delete" || subcommand === "remove") {
+      const result = await runDeleteCommand2(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "update") {
+      const result = await runUpdateCommand2(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "verify") {
+      const result = await runVerifyCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+  }
+  if (command === "received-emails") {
+    if (subcommand === "list") {
+      const result = await runListCommand4(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "get") {
+      const result = await runGetCommand4(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+  }
+  if (command === "emails") {
+    if (subcommand === "send") {
+      const result = await runSendCommandWithClient(rest);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "batch") {
+      const result = await runBatchCommandWithClient(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "cancel") {
+      const result = await runCancelCommandWithClient(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "resend") {
+      const result = await runResendCommandWithClient(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "list") {
+      const result = await runListCommandWithClient(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "insights") {
+      const result = await runInsightsCommandWithClient(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "get") {
+      const result = await runGetCommandWithClient(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+  }
+  if (command === "events") {
+    if (subcommand === "send" || subcommand === "trigger") {
+      const result = await runSendEventCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+  }
+  if (command === "automations") {
+    if (subcommand === "list") {
+      const result = await runListCommand2(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "get") {
+      const result = await runGetCommand2(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "create" || subcommand === "add") {
+      const result = await runCreateCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "update") {
+      const result = await runUpdateCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "activate") {
+      const result = await runActivateCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "pause") {
+      const result = await runPauseCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "delete" || subcommand === "remove") {
+      const result = await runDeleteCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+  }
+  if (command === "webhooks") {
+    if (subcommand === "list") {
+      const result = await runListCommand5(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "get") {
+      const result = await runGetCommand5(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "create") {
+      const result = await runCreateCommand2(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "update") {
+      const result = await runUpdateCommand3(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "delete") {
+      const result = await runDeleteCommand3(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+  }
+  if (command === "suppressions") {
+    if (subcommand === "list") {
+      const result = await runListCommand6(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "add" || subcommand === "create") {
+      const result = await runAddCommand2(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "remove" || subcommand === "delete") {
+      const result = await runRemoveCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+  }
+  if (command === "templates") {
+    if (subcommand === "list") {
+      const result = await runListCommand7(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "starters") {
+      const result = await runListStartersCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "from-starter") {
+      const result = await runFromStarterCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "create" || subcommand === "add") {
+      const result = await runCreateCommand3(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "get") {
+      const result = await runGetCommand6(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "update") {
+      const result = await runUpdateCommand4(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "publish") {
+      const result = await runPublishCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "push") {
+      const result = await runPushCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "versions") {
+      const result = await runVersionsCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "restore") {
+      const result = await runRestoreCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "test-send") {
+      const result = await runTestSendCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "duplicate") {
+      const result = await runDuplicateCommand(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "delete" || subcommand === "remove") {
+      const result = await runDeleteCommand4(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+  }
+  if (command === "integrations") {
+    if (subcommand === "twilio") {
+      const action = rest[0];
+      const actionArgs = rest.slice(1);
+      if (action === "status" || action === "get") {
+        const result = await runTwilioStatusCommand(actionArgs);
+        if (result.error) console.error(result.error);
+        process.exit(result.exitCode);
+      }
+      if (action === "connect" || action === "set") {
+        const result = await runTwilioConnectCommand(actionArgs);
+        if (result.error) console.error(result.error);
+        process.exit(result.exitCode);
+      }
+      if (action === "disconnect" || action === "delete" || action === "remove") {
+        const result = await runTwilioDisconnectCommand(actionArgs);
+        if (result.error) console.error(result.error);
+        process.exit(result.exitCode);
+      }
+    }
+  }
+  if (command === "keys") {
+    if (subcommand === "list") {
+      const result = await runListKeysCommandWithClient(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "create") {
+      const result = await runCreateKeyCommandWithClient(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+    if (subcommand === "delete") {
+      const result = await runDeleteKeyCommandWithClient(rest);
+      if (result.error) console.error(result.error);
+      process.exit(result.exitCode);
+    }
+  }
+  printUsage();
+  process.exit(1);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});