resend-cli 1.2.1 → 1.2.2

package/.claude/worktrees/emails-list/src/commands/webhooks/create.ts

@@ -1,128 +0,0 @@
-import * as p from '@clack/prompts';
-import { Command } from '@commander-js/extra-typings';
-import type { WebhookEvent } from 'resend';
-import { runCreate } from '../../lib/actions';
-import type { GlobalOpts } from '../../lib/client';
-import { buildHelpText } from '../../lib/help-text';
-import { outputError } from '../../lib/output';
-import { cancelAndExit, requireText } from '../../lib/prompts';
-import { isInteractive } from '../../lib/tty';
-import { ALL_WEBHOOK_EVENTS } from './utils';
-
-export const createWebhookCommand = new Command('create')
-  .description(
-    'Register a new webhook endpoint to receive real-time event notifications',
-  )
-  .option(
-    '--endpoint <endpoint>',
-    'HTTPS URL to receive webhook events (required)',
-  )
-  .option(
-    '--events <events...>',
-    'Event types to subscribe to. Use "all" as shorthand for all 17 events.',
-  )
-  .addHelpText(
-    'after',
-    buildHelpText({
-      context: `Webhooks deliver real-time event notifications to your HTTPS endpoint.
-Events fire per-recipient: a batch email to 3 recipients generates 3 email.sent events.
-
---endpoint must use HTTPS.
-
---events accepts space-separated event types or the special value "all":
-  resend webhooks create --endpoint https://... --events email.sent email.delivered
-  resend webhooks create --endpoint https://... --events all
-
-Available event types (17 total):
-  Email:   email.sent, email.delivered, email.delivery_delayed, email.bounced,
-           email.complained, email.opened, email.clicked, email.failed,
-           email.scheduled, email.suppressed, email.received
-  Contact: contact.created, contact.updated, contact.deleted
-  Domain:  domain.created, domain.updated, domain.deleted
-
-The signing_secret in the response is shown ONCE — save it immediately to verify
-webhook payloads using Svix signature headers (svix-id, svix-timestamp, svix-signature).
-Use resend.webhooks.verify() in your application to validate incoming payloads.
-
-Non-interactive: --endpoint and --events are required.`,
-      output: `  {"object":"webhook","id":"<uuid>","signing_secret":"<whsec_...>"}`,
-      errorCodes: [
-        'auth_error',
-        'missing_endpoint',
-        'missing_events',
-        'create_error',
-      ],
-      examples: [
-        'resend webhooks create --endpoint https://app.example.com/hooks/resend --events all',
-        'resend webhooks create --endpoint https://app.example.com/hooks/resend --events email.sent email.bounced',
-        'resend webhooks create --endpoint https://app.example.com/hooks/resend --events all --json',
-      ],
-    }),
-  )
-  .action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
-
-    const endpoint = await requireText(
-      opts.endpoint,
-      {
-        message: 'Webhook endpoint URL',
-        placeholder: 'https://your-app.com/webhooks/resend',
-        validate: (v) => {
-          if (!v) {
-            return 'Endpoint URL is required';
-          }
-          if (!v.startsWith('https://')) {
-            return 'Endpoint must use HTTPS';
-          }
-          return undefined;
-        },
-      },
-      { message: 'Missing --endpoint flag.', code: 'missing_endpoint' },
-      globalOpts,
-    );
-
-    let selectedEvents: WebhookEvent[];
-
-    if (opts.events?.includes('all')) {
-      selectedEvents = ALL_WEBHOOK_EVENTS;
-    } else if (opts.events?.length) {
-      selectedEvents = opts.events as WebhookEvent[];
-    } else {
-      if (!isInteractive()) {
-        outputError(
-          { message: 'Missing --events flag.', code: 'missing_events' },
-          { json: globalOpts.json },
-        );
-      }
-      const result = await p.multiselect({
-        message: 'Select event types to subscribe to',
-        options: ALL_WEBHOOK_EVENTS.map((e) => ({ value: e, label: e })),
-      });
-      if (p.isCancel(result)) {
-        cancelAndExit('Cancelled.');
-      }
-      selectedEvents = result;
-    }
-
-    await runCreate(
-      {
-        spinner: {
-          loading: 'Creating webhook...',
-          success: 'Webhook created',
-          fail: 'Failed to create webhook',
-        },
-        sdkCall: (resend) =>
-          resend.webhooks.create({
-            endpoint,
-            events: selectedEvents,
-          }),
-        onInteractive: (d) => {
-          console.log(`\nWebhook created`);
-          console.log(`ID:             ${d.id}`);
-          console.log(`Signing Secret: ${d.signing_secret}`);
-          console.log(`\nSave the signing secret — it is only shown once.`);
-        },
-      },
-      globalOpts,
-    );
-  });

package/.claude/worktrees/emails-list/src/commands/webhooks/delete.ts

@@ -1,49 +0,0 @@
-import { Command } from '@commander-js/extra-typings';
-import { runDelete } from '../../lib/actions';
-import type { GlobalOpts } from '../../lib/client';
-import { buildHelpText } from '../../lib/help-text';
-
-export const deleteWebhookCommand = new Command('delete')
-  .alias('rm')
-  .description('Delete a webhook endpoint and stop all event deliveries to it')
-  .argument('<id>', 'Webhook UUID')
-  .option(
-    '--yes',
-    'Skip the confirmation prompt (required in non-interactive mode)',
-  )
-  .addHelpText(
-    'after',
-    buildHelpText({
-      context: `Warning: Deleting a webhook immediately stops event delivery to the endpoint.
-  In-flight events may still be attempted once before the deletion takes effect.
-  To temporarily pause delivery without losing configuration, use:
-    resend webhooks update <id> --status disabled
-
-Non-interactive: --yes is required to confirm deletion when stdin/stdout is not a TTY.`,
-      output: `  {"object":"webhook","id":"<uuid>","deleted":true}`,
-      errorCodes: ['auth_error', 'confirmation_required', 'delete_error'],
-      examples: [
-        'resend webhooks delete wh_abc123 --yes',
-        'resend webhooks delete wh_abc123 --yes --json',
-      ],
-    }),
-  )
-  .action(async (id, opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
-    await runDelete(
-      id,
-      !!opts.yes,
-      {
-        confirmMessage: `Delete webhook ${id}?\nEvents will no longer be delivered to this endpoint.`,
-        spinner: {
-          loading: 'Deleting webhook...',
-          success: 'Webhook deleted',
-          fail: 'Failed to delete webhook',
-        },
-        object: 'webhook',
-        successMsg: 'Webhook deleted.',
-        sdkCall: (resend) => resend.webhooks.remove(id),
-      },
-      globalOpts,
-    );
-  });

package/.claude/worktrees/emails-list/src/commands/webhooks/get.ts

@@ -1,42 +0,0 @@
-import { Command } from '@commander-js/extra-typings';
-import { runGet } from '../../lib/actions';
-import type { GlobalOpts } from '../../lib/client';
-import { buildHelpText } from '../../lib/help-text';
-
-export const getWebhookCommand = new Command('get')
-  .description('Retrieve a webhook endpoint configuration by ID')
-  .argument('<id>', 'Webhook UUID')
-  .addHelpText(
-    'after',
-    buildHelpText({
-      context: `Note: The signing_secret is not returned by the get endpoint.
-To rotate secrets, delete the webhook and recreate it.`,
-      output: `  {"object":"webhook","id":"<uuid>","endpoint":"<url>","events":["<event>"],"status":"enabled|disabled","created_at":"<iso-date>","signing_secret":"<whsec_...>"}`,
-      errorCodes: ['auth_error', 'fetch_error'],
-      examples: [
-        'resend webhooks get wh_abc123',
-        'resend webhooks get wh_abc123 --json',
-      ],
-    }),
-  )
-  .action(async (id, _opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
-    await runGet(
-      {
-        spinner: {
-          loading: 'Fetching webhook...',
-          success: 'Webhook fetched',
-          fail: 'Failed to fetch webhook',
-        },
-        sdkCall: (resend) => resend.webhooks.get(id),
-        onInteractive: (d) => {
-          console.log(`\n${d.endpoint}`);
-          console.log(`ID:      ${d.id}`);
-          console.log(`Status:  ${d.status}`);
-          console.log(`Events:  ${(d.events ?? []).join(', ') || '(none)'}`);
-          console.log(`Created: ${d.created_at}`);
-        },
-      },
-      globalOpts,
-    );
-  });

package/.claude/worktrees/emails-list/src/commands/webhooks/index.ts

@@ -1,44 +0,0 @@
-import { Command } from '@commander-js/extra-typings';
-import { buildHelpText } from '../../lib/help-text';
-import { createWebhookCommand } from './create';
-import { deleteWebhookCommand } from './delete';
-import { getWebhookCommand } from './get';
-import { listWebhooksCommand } from './list';
-import { updateWebhookCommand } from './update';
-
-export const webhooksCommand = new Command('webhooks')
-  .description('Manage webhook endpoints for real-time event notifications')
-  .addHelpText(
-    'after',
-    buildHelpText({
-      context: `Webhooks let you receive real-time event notifications from Resend at an HTTPS endpoint.
-Payloads are signed with Svix headers for verification.
-
-As of January 2026, webhook events fire per-recipient. A batch email to 3 recipients
-generates 3 email.sent events. The "to" field remains an array for backward compatibility
-but contains one entry per event.
-
-Event categories (17 total):
-  Email:   email.sent, email.delivered, email.delivery_delayed, email.bounced,
-           email.complained, email.opened, email.clicked, email.failed,
-           email.scheduled, email.suppressed, email.received
-  Contact: contact.created, contact.updated, contact.deleted
-  Domain:  domain.created, domain.updated, domain.deleted
-
-Signature verification (Svix):
-  Each delivery includes headers: svix-id, svix-timestamp, svix-signature
-  Verify payloads in your application using: resend.webhooks.verify({ payload, headers, webhookSecret })`,
-      examples: [
-        'resend webhooks list',
-        'resend webhooks create --endpoint https://app.example.com/hooks/resend --events all',
-        'resend webhooks get wh_abc123',
-        'resend webhooks update wh_abc123 --status disabled',
-        'resend webhooks delete wh_abc123 --yes',
-      ],
-    }),
-  )
-  .addCommand(createWebhookCommand)
-  .addCommand(getWebhookCommand)
-  .addCommand(listWebhooksCommand, { isDefault: true })
-  .addCommand(updateWebhookCommand)
-  .addCommand(deleteWebhookCommand);

package/.claude/worktrees/emails-list/src/commands/webhooks/list.ts

@@ -1,55 +0,0 @@
-import { Command } from '@commander-js/extra-typings';
-import { runList } from '../../lib/actions';
-import type { GlobalOpts } from '../../lib/client';
-import { buildHelpText } from '../../lib/help-text';
-import {
-  buildPaginationOpts,
-  parseLimitOpt,
-  printPaginationHint,
-} from '../../lib/pagination';
-import { renderWebhooksTable } from './utils';
-
-export const listWebhooksCommand = new Command('list')
-  .alias('ls')
-  .description('List all registered webhook endpoints')
-  .option('--limit <n>', 'Maximum number of webhooks to return (1-100)', '10')
-  .option('--after <cursor>', 'Return webhooks after this cursor (next page)')
-  .option(
-    '--before <cursor>',
-    'Return webhooks before this cursor (previous page)',
-  )
-  .addHelpText(
-    'after',
-    buildHelpText({
-      context: `Pagination: use --after or --before with a webhook ID as the cursor.
-Only one of --after or --before may be used at a time.
-The response includes has_more: true when additional pages exist.`,
-      output: `  {"object":"list","data":[{"id":"<uuid>","endpoint":"<url>","events":["<event>"],"status":"enabled","created_at":"<iso-date>"}],"has_more":false}`,
-      errorCodes: ['auth_error', 'invalid_limit', 'list_error'],
-      examples: [
-        'resend webhooks list',
-        'resend webhooks list --limit 25 --json',
-        'resend webhooks list --after wh_abc123 --json',
-      ],
-    }),
-  )
-  .action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
-    const limit = parseLimitOpt(opts.limit, globalOpts);
-    const paginationOpts = buildPaginationOpts(limit, opts.after, opts.before);
-    await runList(
-      {
-        spinner: {
-          loading: 'Fetching webhooks...',
-          success: 'Webhooks fetched',
-          fail: 'Failed to list webhooks',
-        },
-        sdkCall: (resend) => resend.webhooks.list(paginationOpts),
-        onInteractive: (list) => {
-          console.log(renderWebhooksTable(list.data));
-          printPaginationHint(list);
-        },
-      },
-      globalOpts,
-    );
-  });

package/.claude/worktrees/emails-list/src/commands/webhooks/update.ts

@@ -1,83 +0,0 @@
-import { Command, Option } from '@commander-js/extra-typings';
-import type { WebhookEvent } from 'resend';
-import { runWrite } from '../../lib/actions';
-import type { GlobalOpts } from '../../lib/client';
-import { buildHelpText } from '../../lib/help-text';
-import { outputError } from '../../lib/output';
-import { ALL_WEBHOOK_EVENTS } from './utils';
-
-export const updateWebhookCommand = new Command('update')
-  .description(
-    "Update a webhook's endpoint URL, event subscriptions, or enabled status",
-  )
-  .argument('<id>', 'Webhook UUID')
-  .option('--endpoint <endpoint>', 'New HTTPS URL for this webhook')
-  .option(
-    '--events <events...>',
-    'Replace the full event subscription list. Use "all" for all 17 events.',
-  )
-  .addOption(
-    new Option(
-      '--status <status>',
-      'Enable or disable event delivery for this webhook',
-    ).choices(['enabled', 'disabled'] as const),
-  )
-  .addHelpText(
-    'after',
-    buildHelpText({
-      context: `At least one of --endpoint, --events, or --status must be provided.
-
---events replaces the entire event list (it is not additive).
-Use "all" as a shorthand for all 17 event types.
-
---status controls whether events are delivered to this endpoint:
-  enabled   Events are delivered (default on creation)
-  disabled  Events are suppressed without deleting the webhook`,
-      output: `  {"object":"webhook","id":"<uuid>"}`,
-      errorCodes: ['auth_error', 'no_changes', 'update_error'],
-      examples: [
-        'resend webhooks update wh_abc123 --endpoint https://new-app.example.com/hooks/resend',
-        'resend webhooks update wh_abc123 --events email.sent email.bounced',
-        'resend webhooks update wh_abc123 --events all',
-        'resend webhooks update wh_abc123 --status disabled',
-        'resend webhooks update wh_abc123 --endpoint https://new-app.example.com/hooks/resend --events all --json',
-      ],
-    }),
-  )
-  .action(async (id, opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
-
-    if (!opts.endpoint && !opts.events?.length && !opts.status) {
-      outputError(
-        {
-          message:
-            'Provide at least one option to update: --endpoint, --events, or --status.',
-          code: 'no_changes',
-        },
-        { json: globalOpts.json },
-      );
-    }
-
-    const selectedEvents = opts.events?.includes('all')
-      ? ALL_WEBHOOK_EVENTS
-      : (opts.events as WebhookEvent[] | undefined);
-
-    await runWrite(
-      {
-        spinner: {
-          loading: 'Updating webhook...',
-          success: 'Webhook updated',
-          fail: 'Failed to update webhook',
-        },
-        sdkCall: (resend) =>
-          resend.webhooks.update(id, {
-            ...(opts.endpoint && { endpoint: opts.endpoint }),
-            ...(selectedEvents?.length && { events: selectedEvents }),
-            ...(opts.status && { status: opts.status }),
-          }),
-        errorCode: 'update_error',
-        successMsg: `Webhook updated: ${id}`,
-      },
-      globalOpts,
-    );
-  });

package/.claude/worktrees/emails-list/src/commands/webhooks/utils.ts

@@ -1,36 +0,0 @@
-import type { Webhook, WebhookEvent } from 'resend';
-import { renderTable } from '../../lib/table';
-
-export const ALL_WEBHOOK_EVENTS: WebhookEvent[] = [
-  'email.sent',
-  'email.delivered',
-  'email.delivery_delayed',
-  'email.bounced',
-  'email.complained',
-  'email.opened',
-  'email.clicked',
-  'email.failed',
-  'email.scheduled',
-  'email.suppressed',
-  'email.received',
-  'contact.created',
-  'contact.updated',
-  'contact.deleted',
-  'domain.created',
-  'domain.updated',
-  'domain.deleted',
-];
-
-export function renderWebhooksTable(webhooks: Webhook[]): string {
-  const rows = webhooks.map((w) => {
-    const eventsStr = (w.events ?? []).join(', ');
-    const events =
-      eventsStr.length > 60 ? `${eventsStr.slice(0, 57)}...` : eventsStr;
-    return [w.endpoint, events, w.status, w.id];
-  });
-  return renderTable(
-    ['Endpoint', 'Events', 'Status', 'ID'],
-    rows,
-    '(no webhooks)',
-  );
-}

package/.claude/worktrees/emails-list/src/commands/whoami.ts

@@ -1,71 +0,0 @@
-import { Command } from '@commander-js/extra-typings';
-import type { GlobalOpts } from '../lib/client';
-import { maskKey, resolveApiKey, resolveTeamName } from '../lib/config';
-import { buildHelpText } from '../lib/help-text';
-import { outputError, outputResult } from '../lib/output';
-import { isInteractive } from '../lib/tty';
-
-export const whoamiCommand = new Command('whoami')
-  .description('Show current authentication status')
-  .addHelpText(
-    'after',
-    buildHelpText({
-      setup: true,
-      context: `Local only — no network calls.
-Shows which team is active and where the API key comes from.`,
-      output: `  {"authenticated":true,"team":"production","api_key":"re_...abcd","source":"config"}
-  {"authenticated":false}`,
-      examples: [
-        'resend whoami',
-        'resend whoami --json',
-        'resend whoami --team production',
-      ],
-    }),
-  )
-  .action((_opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
-    const teamName = globalOpts.team;
-    const resolved = resolveApiKey(globalOpts.apiKey, teamName);
-
-    if (!resolved) {
-      if (globalOpts.json || !isInteractive()) {
-        outputResult(
-          { authenticated: false },
-          { json: globalOpts.json, exitCode: 1 },
-        );
-        // outputResult with exitCode calls process.exit, but TS doesn't know
-        return;
-      }
-      outputError(
-        {
-          message: 'Not authenticated.\nRun `resend login` to get started.',
-          code: 'not_authenticated',
-        },
-        { json: false },
-      );
-      return;
-    }
-
-    const team = resolved.team ?? resolveTeamName(teamName);
-
-    if (globalOpts.json || !isInteractive()) {
-      outputResult(
-        {
-          authenticated: true,
-          team,
-          api_key: maskKey(resolved.key),
-          source: resolved.source,
-        },
-        { json: globalOpts.json },
-      );
-      return;
-    }
-
-    console.log('');
-    console.log(`  Team:    ${team}`);
-    console.log(`  API Key: ${maskKey(resolved.key)}`);
-    console.log(
-      `  Source:  ${resolved.source === 'config' ? 'config file' : resolved.source === 'env' ? 'environment variable' : 'flag'}`,
-    );
-    console.log('');
-  });

package/.claude/worktrees/emails-list/src/lib/actions.ts

@@ -1,157 +0,0 @@
-import type { Resend } from 'resend';
-import type { GlobalOpts } from './client';
-import { requireClient } from './client';
-import { outputResult } from './output';
-import { confirmDelete } from './prompts';
-import { withSpinner } from './spinner';
-import { isInteractive } from './tty';
-
-type SdkCall<T> = (
-  resend: Resend,
-) => Promise<{ data: T | null; error: { message: string } | null }>;
-type SpinnerMessages = { loading: string; success: string; fail: string };
-
-/**
- * Shared pattern for all get commands:
- *   requireClient → withSpinner(fetch_error) → if/else output
- */
-export async function runGet<T>(
-  config: {
-    spinner: SpinnerMessages;
-    sdkCall: SdkCall<T>;
-    onInteractive: (data: T) => void;
-  },
-  globalOpts: GlobalOpts,
-): Promise<void> {
-  const resend = requireClient(globalOpts);
-  const data = await withSpinner(
-    config.spinner,
-    () => config.sdkCall(resend),
-    'fetch_error',
-    globalOpts,
-  );
-  if (!globalOpts.json && isInteractive()) {
-    config.onInteractive(data);
-  } else {
-    outputResult(data, { json: globalOpts.json });
-  }
-}
-
-/**
- * Shared pattern for all delete commands:
- *   requireClient → confirmDelete (if needed) → withSpinner → if/else output
- */
-export async function runDelete(
-  id: string,
-  skipConfirm: boolean,
-  config: {
-    confirmMessage: string;
-    spinner: SpinnerMessages;
-    object: string;
-    successMsg: string;
-    sdkCall: SdkCall<unknown>;
-  },
-  globalOpts: GlobalOpts,
-): Promise<void> {
-  const resend = requireClient(globalOpts);
-  if (!skipConfirm) {
-    await confirmDelete(id, config.confirmMessage, globalOpts);
-  }
-  await withSpinner(
-    config.spinner,
-    () => config.sdkCall(resend),
-    'delete_error',
-    globalOpts,
-  );
-  if (!globalOpts.json && isInteractive()) {
-    console.log(config.successMsg);
-  } else {
-    outputResult(
-      { object: config.object, id, deleted: true },
-      { json: globalOpts.json },
-    );
-  }
-}
-
-/**
- * Shared pattern for create commands:
- *   requireClient → withSpinner('create_error') → if/else output
- */
-export async function runCreate<T>(
-  config: {
-    spinner: SpinnerMessages;
-    sdkCall: SdkCall<T>;
-    onInteractive: (data: T) => void;
-  },
-  globalOpts: GlobalOpts,
-): Promise<void> {
-  const resend = requireClient(globalOpts);
-  const data = await withSpinner(
-    config.spinner,
-    () => config.sdkCall(resend),
-    'create_error',
-    globalOpts,
-  );
-  if (!globalOpts.json && isInteractive()) {
-    config.onInteractive(data);
-  } else {
-    outputResult(data, { json: globalOpts.json });
-  }
-}
-
-/**
- * Shared pattern for write commands (update/verify/remove-segment) where
- * interactive output is a single status message:
- *   requireClient → withSpinner(errorCode) → if/else output
- */
-export async function runWrite<T>(
-  config: {
-    spinner: SpinnerMessages;
-    sdkCall: SdkCall<T>;
-    errorCode: string;
-    successMsg: string;
-  },
-  globalOpts: GlobalOpts,
-): Promise<void> {
-  const resend = requireClient(globalOpts);
-  const data = await withSpinner(
-    config.spinner,
-    () => config.sdkCall(resend),
-    config.errorCode,
-    globalOpts,
-  );
-  if (!globalOpts.json && isInteractive()) {
-    console.log(config.successMsg);
-  } else {
-    outputResult(data, { json: globalOpts.json });
-  }
-}
-
-/**
- * Shared pattern for all list commands:
- *   requireClient → withSpinner → if/else output
- *
- * Callers pass pagination opts (if any) via the sdkCall closure.
- * The onInteractive callback handles table rendering and pagination hints.
- */
-export async function runList<T>(
-  config: {
-    spinner: SpinnerMessages;
-    sdkCall: SdkCall<T>;
-    onInteractive: (result: T) => void;
-  },
-  globalOpts: GlobalOpts,
-): Promise<void> {
-  const resend = requireClient(globalOpts);
-  const result = await withSpinner(
-    config.spinner,
-    () => config.sdkCall(resend),
-    'list_error',
-    globalOpts,
-  );
-  if (!globalOpts.json && isInteractive()) {
-    config.onInteractive(result);
-  } else {
-    outputResult(result, { json: globalOpts.json });
-  }
-}