resend-cli 1.2.0 → 1.2.2

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 });
-  }
-}

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

@@ -1,34 +0,0 @@
-import { Resend } from 'resend';
-import { resolveApiKey } from './config';
-import { errorMessage, outputError } from './output';
-
-export type GlobalOpts = {
-  apiKey?: string;
-  json?: boolean;
-  quiet?: boolean;
-  team?: string;
-};
-
-export function createClient(flagValue?: string, teamName?: string): Resend {
-  const resolved = resolveApiKey(flagValue, teamName);
-  if (!resolved) {
-    throw new Error(
-      'No API key found. Set RESEND_API_KEY, use --api-key, or run: resend login',
-    );
-  }
-  return new Resend(resolved.key);
-}
-
-export function requireClient(opts: GlobalOpts): Resend {
-  try {
-    return createClient(opts.apiKey, opts.team);
-  } catch (err) {
-    outputError(
-      {
-        message: errorMessage(err, 'Failed to create client'),
-        code: 'auth_error',
-      },
-      { json: opts.json },
-    );
-  }
-}