npm - resend-cli - Versions diffs - 1.1.0 → 1.2.1 - Mend

resend-cli 1.1.0 → 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (198) hide show

package/.claude/worktrees/emails-list/src/commands/emails/send.ts ADDED Viewed

@@ -0,0 +1,189 @@
+import * as p from '@clack/prompts';
+import { Command } from '@commander-js/extra-typings';
+import type { Resend } from 'resend';
+import type { GlobalOpts } from '../../lib/client';
+import { requireClient } from '../../lib/client';
+import { readFile } from '../../lib/files';
+import { buildHelpText } from '../../lib/help-text';
+import { outputResult } from '../../lib/output';
+import {
+  cancelAndExit,
+  promptForMissing,
+  requireText,
+} from '../../lib/prompts';
+import { withSpinner } from '../../lib/spinner';
+import { isInteractive } from '../../lib/tty';
+export async function fetchVerifiedDomains(resend: Resend): Promise<string[]> {
+  try {
+    const { data, error } = await resend.domains.list();
+    if (error || !data) {
+      return [];
+    }
+    return data.data
+      .filter(
+        (d) => d.status === 'verified' && d.capabilities.sending === 'enabled',
+      )
+      .map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+const FROM_PREFIXES = ['noreply', 'hello', 'hi', 'info', 'support', 'team'];
+async function promptForFromAddress(domains: string[]): Promise<string> {
+  let domain: string;
+  if (domains.length === 1) {
+    domain = domains[0];
+  } else {
+    const result = await p.select({
+      message: 'Select a verified domain',
+      options: domains.map((d) => ({ value: d, label: d })),
+    });
+    if (p.isCancel(result)) {
+      cancelAndExit('Send cancelled.');
+    }
+    domain = result;
+  }
+  const options: Array<{ value: string | null; label: string }> =
+    FROM_PREFIXES.map((prefix) => ({
+      value: `${prefix}@${domain}`,
+      label: `${prefix}@${domain}`,
+    }));
+  options.push({ value: null, label: 'Custom address...' });
+  const result = await p.select({
+    message: `From address (@${domain})`,
+    options,
+  });
+  if (p.isCancel(result)) {
+    cancelAndExit('Send cancelled.');
+  }
+  if (result === null) {
+    const custom = await p.text({
+      message: 'From address',
+      placeholder: `you@${domain}`,
+      validate: (v) =>
+        !v || !v.includes('@') ? 'Enter a valid email address' : undefined,
+    });
+    if (p.isCancel(custom)) {
+      cancelAndExit('Send cancelled.');
+    }
+    return custom;
+  }
+  return result;
+}
+export const sendCommand = new Command('send')
+  .description('Send an email')
+  .option('--from <address>', 'Sender address (required)')
+  .option('--to <addresses...>', 'Recipient address(es) (required)')
+  .option('--subject <subject>', 'Email subject (required)')
+  .option('--html <html>', 'HTML body')
+  .option('--html-file <path>', 'Path to an HTML file for the body')
+  .option('--text <text>', 'Plain-text body')
+  .option('--cc <addresses...>', 'CC recipients')
+  .option('--bcc <addresses...>', 'BCC recipients')
+  .option('--reply-to <address>', 'Reply-to address')
+  .addHelpText(
+    'after',
+    buildHelpText({
+      context:
+        'Required: --from, --to, --subject, and one of --text | --html | --html-file',
+      output: '  {"id":"<email-id>"}',
+      errorCodes: ['auth_error', 'missing_body', 'send_error'],
+      examples: [
+        'resend emails send --from you@domain.com --to user@example.com --subject "Hello" --text "Hi"',
+        'resend emails send --from you@domain.com --to a@example.com --to b@example.com --subject "Hi" --html "<b>Hi</b>" --json',
+        'resend emails send --from you@domain.com --to user@example.com --subject "Hi" --html-file ./email.html --json',
+        'RESEND_API_KEY=re_123 resend emails send --from you@domain.com --to user@example.com --subject "Hi" --text "Hi"',
+      ],
+    }),
+  )
+  .action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    const resend = requireClient(globalOpts);
+    // Only fetch verified domains in interactive mode — non-interactive
+    // callers (CI, agents, scripts) must pass --from explicitly.
+    let fromAddress = opts.from;
+    if (!fromAddress && isInteractive()) {
+      const domains = await fetchVerifiedDomains(resend);
+      if (domains.length > 0) {
+        fromAddress = await promptForFromAddress(domains);
+      }
+    }
+    const filled = await promptForMissing(
+      { from: fromAddress, to: opts.to?.[0], subject: opts.subject },
+      [
+        {
+          flag: 'from',
+          message: 'From address',
+          placeholder: 'you@example.com',
+        },
+        {
+          flag: 'to',
+          message: 'To address',
+          placeholder: 'recipient@example.com',
+        },
+        { flag: 'subject', message: 'Subject', placeholder: 'Hello!' },
+      ],
+      globalOpts,
+    );
+    let html = opts.html;
+    const text = opts.text;
+    if (opts.htmlFile) {
+      html = readFile(opts.htmlFile, globalOpts);
+    }
+    let body: string | undefined = text;
+    if (!html && !text) {
+      body = await requireText(
+        undefined,
+        {
+          message: 'Email body (plain text)',
+          placeholder: 'Type your message...',
+        },
+        {
+          message: 'Missing email body. Provide --html, --html-file, or --text',
+          code: 'missing_body',
+        },
+        globalOpts,
+      );
+    }
+    const toAddresses = opts.to ?? [filled.to];
+    const data = await withSpinner(
+      {
+        loading: 'Sending email...',
+        success: 'Email sent',
+        fail: 'Failed to send email',
+      },
+      () =>
+        resend.emails.send({
+          from: filled.from,
+          to: toAddresses,
+          subject: filled.subject,
+          ...(html ? { html } : { text: body as string }),
+          ...(opts.cc && { cc: opts.cc }),
+          ...(opts.bcc && { bcc: opts.bcc }),
+          ...(opts.replyTo && { replyTo: opts.replyTo }),
+        }),
+      'send_error',
+      globalOpts,
+    );
+    if (!globalOpts.json && isInteractive()) {
+      console.log(`\nEmail sent: ${data.id}`);
+    } else {
+      outputResult(data, { json: globalOpts.json });
+    }
+  });

package/.claude/worktrees/emails-list/src/commands/open.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import { Command } from '@commander-js/extra-typings';
+import { buildHelpText } from '../lib/help-text';
+export const openCommand = new Command('open')
+  .description('Open the Resend dashboard in your browser')
+  .addHelpText(
+    'after',
+    buildHelpText({
+      context: 'Opens https://resend.com/emails in your default browser.',
+      examples: ['resend open'],
+    }),
+  )
+  .action(async () => {
+    const url = 'https://resend.com/emails';
+    const { platform } = process;
+    const args =
+      platform === 'darwin'
+        ? ['open', url]
+        : platform === 'win32'
+          ? ['cmd', '/c', 'start', url]
+          : ['xdg-open', url];
+    Bun.spawn(args, { stdio: ['ignore', 'ignore', 'ignore'] });
+  });

package/.claude/worktrees/emails-list/src/commands/segments/create.ts ADDED Viewed

@@ -0,0 +1,50 @@
+import { Command } from '@commander-js/extra-typings';
+import { runCreate } from '../../lib/actions';
+import type { GlobalOpts } from '../../lib/client';
+import { buildHelpText } from '../../lib/help-text';
+import { requireText } from '../../lib/prompts';
+export const createSegmentCommand = new Command('create')
+  .description('Create a new segment')
+  .option('--name <name>', 'Segment name (required)')
+  .addHelpText(
+    'after',
+    buildHelpText({
+      context: `Segments are named groups of contacts. Broadcasts target segments via segment_id.
+Contacts can belong to multiple segments. Audiences are deprecated — use segments instead.
+Non-interactive: --name is required.`,
+      output: `  {"object":"segment","id":"<uuid>","name":"<name>"}`,
+      errorCodes: ['auth_error', 'missing_name', 'create_error'],
+      examples: [
+        'resend segments create --name "Newsletter Subscribers"',
+        'resend segments create --name "Beta Users" --json',
+      ],
+    }),
+  )
+  .action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    const name = await requireText(
+      opts.name,
+      { message: 'Segment name', placeholder: 'Newsletter Subscribers' },
+      { message: 'Missing --name flag.', code: 'missing_name' },
+      globalOpts,
+    );
+    await runCreate(
+      {
+        spinner: {
+          loading: 'Creating segment...',
+          success: 'Segment created',
+          fail: 'Failed to create segment',
+        },
+        sdkCall: (resend) => resend.segments.create({ name }),
+        onInteractive: (data) => {
+          console.log(`\nSegment created: ${data.id}`);
+          console.log(`Name: ${data.name}`);
+        },
+      },
+      globalOpts,
+    );
+  });

package/.claude/worktrees/emails-list/src/commands/segments/delete.ts ADDED Viewed

@@ -0,0 +1,47 @@
+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 deleteSegmentCommand = new Command('delete')
+  .alias('rm')
+  .description('Delete a segment')
+  .argument('<id>', 'Segment UUID')
+  .option(
+    '--yes',
+    'Skip the confirmation prompt (required in non-interactive mode)',
+  )
+  .addHelpText(
+    'after',
+    buildHelpText({
+      context: `Warning: Deleting a segment removes it as a target for future broadcasts,
+  but does NOT delete the contacts within it.
+Non-interactive: --yes is required to confirm deletion when stdin/stdout is not a TTY.`,
+      output: `  {"object":"segment","id":"<uuid>","deleted":true}`,
+      errorCodes: ['auth_error', 'confirmation_required', 'delete_error'],
+      examples: [
+        'resend segments delete 78261eea-8f8b-4381-83c6-79fa7120f1cf --yes',
+        'resend segments delete 78261eea-8f8b-4381-83c6-79fa7120f1cf --yes --json',
+      ],
+    }),
+  )
+  .action(async (id, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    await runDelete(
+      id,
+      !!opts.yes,
+      {
+        confirmMessage: `Delete segment ${id}?\nContacts will not be deleted, but broadcasts targeting this segment will no longer work.`,
+        spinner: {
+          loading: 'Deleting segment...',
+          success: 'Segment deleted',
+          fail: 'Failed to delete segment',
+        },
+        object: 'segment',
+        successMsg: 'Segment deleted.',
+        sdkCall: (resend) => resend.segments.remove(id),
+      },
+      globalOpts,
+    );
+  });

package/.claude/worktrees/emails-list/src/commands/segments/get.ts ADDED Viewed

@@ -0,0 +1,38 @@
+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 getSegmentCommand = new Command('get')
+  .description('Retrieve a segment by ID')
+  .argument('<id>', 'Segment UUID')
+  .addHelpText(
+    'after',
+    buildHelpText({
+      output: `  {"object":"segment","id":"<uuid>","name":"<name>","created_at":"<iso-date>"}`,
+      errorCodes: ['auth_error', 'fetch_error'],
+      examples: [
+        'resend segments get 78261eea-8f8b-4381-83c6-79fa7120f1cf',
+        'resend segments get 78261eea-8f8b-4381-83c6-79fa7120f1cf --json',
+      ],
+    }),
+  )
+  .action(async (id, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    await runGet(
+      {
+        spinner: {
+          loading: 'Fetching segment...',
+          success: 'Segment fetched',
+          fail: 'Failed to fetch segment',
+        },
+        sdkCall: (resend) => resend.segments.get(id),
+        onInteractive: (data) => {
+          console.log(`\n${data.name}`);
+          console.log(`ID: ${data.id}`);
+          console.log(`Created: ${data.created_at}`);
+        },
+      },
+      globalOpts,
+    );
+  });

package/.claude/worktrees/emails-list/src/commands/segments/index.ts ADDED Viewed

@@ -0,0 +1,36 @@
+import { Command } from '@commander-js/extra-typings';
+import { buildHelpText } from '../../lib/help-text';
+import { createSegmentCommand } from './create';
+import { deleteSegmentCommand } from './delete';
+import { getSegmentCommand } from './get';
+import { listSegmentsCommand } from './list';
+export const segmentsCommand = new Command('segments')
+  .description(
+    'Manage segments — named groups of contacts used to target broadcasts',
+  )
+  .addHelpText(
+    'after',
+    buildHelpText({
+      context: `Segments are the modern replacement for Audiences (deprecated).
+A segment is a named group of contacts. Broadcasts target segments via segment_id.
+Contacts can belong to multiple segments.
+Segment membership is managed through the contacts namespace:
+  resend contacts add-segment <contactId> --segment-id <segmentId>
+  resend contacts remove-segment <contactId> <segmentId>
+  resend contacts segments <contactId>
+There is no "update" endpoint — to rename a segment, delete it and recreate.`,
+      examples: [
+        'resend segments list',
+        'resend segments create --name "Newsletter Subscribers"',
+        'resend segments get 78261eea-8f8b-4381-83c6-79fa7120f1cf',
+        'resend segments delete 78261eea-8f8b-4381-83c6-79fa7120f1cf --yes',
+      ],
+    }),
+  )
+  .addCommand(createSegmentCommand)
+  .addCommand(getSegmentCommand)
+  .addCommand(listSegmentsCommand, { isDefault: true })
+  .addCommand(deleteSegmentCommand);

package/.claude/worktrees/emails-list/src/commands/segments/list.ts ADDED Viewed

@@ -0,0 +1,58 @@
+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 { renderSegmentsTable } from './utils';
+export const listSegmentsCommand = new Command('list')
+  .alias('ls')
+  .description('List all segments')
+  .option('--limit <n>', 'Maximum number of segments to return (1-100)', '10')
+  .option('--after <cursor>', 'Return segments after this cursor (next page)')
+  .option(
+    '--before <cursor>',
+    'Return segments before this cursor (previous page)',
+  )
+  .addHelpText(
+    'after',
+    buildHelpText({
+      context: `Pagination: use --after or --before with a segment 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.
+Use "resend segments list" to discover segment IDs for use with broadcasts
+or "resend contacts add-segment".`,
+      output: `  {"object":"list","data":[{"id":"<uuid>","name":"<name>","created_at":"<iso-date>"}],"has_more":false}`,
+      errorCodes: ['auth_error', 'invalid_limit', 'list_error'],
+      examples: [
+        'resend segments list',
+        'resend segments list --limit 25 --json',
+        'resend segments list --after 78261eea-8f8b-4381-83c6-79fa7120f1cf --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 segments...',
+          success: 'Segments fetched',
+          fail: 'Failed to list segments',
+        },
+        sdkCall: (resend) => resend.segments.list(paginationOpts),
+        onInteractive: (list) => {
+          console.log(renderSegmentsTable(list.data));
+          printPaginationHint(list);
+        },
+      },
+      globalOpts,
+    );
+  });

package/.claude/worktrees/emails-list/src/commands/segments/utils.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { Segment } from 'resend';
+import { renderTable } from '../../lib/table';
+export function renderSegmentsTable(segments: Segment[]): string {
+  const rows = segments.map((s) => [s.name, s.id, s.created_at]);
+  return renderTable(['Name', 'ID', 'Created'], rows, '(no segments)');
+}

package/.claude/worktrees/emails-list/src/commands/teams/index.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { Command } from '@commander-js/extra-typings';
+import { listCommand } from './list';
+import { removeCommand } from './remove';
+import { switchCommand } from './switch';
+export const teamsCommand = new Command('teams')
+  .description('Manage team profiles for multiple API keys')
+  .addCommand(listCommand)
+  .addCommand(switchCommand)
+  .addCommand(removeCommand);

package/.claude/worktrees/emails-list/src/commands/teams/list.ts ADDED Viewed

@@ -0,0 +1,35 @@
+import { Command } from '@commander-js/extra-typings';
+import type { GlobalOpts } from '../../lib/client';
+import { listTeams } from '../../lib/config';
+import { outputResult } from '../../lib/output';
+import { isInteractive } from '../../lib/tty';
+export const listCommand = new Command('list')
+  .description('List all team profiles')
+  .action((_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    const teams = listTeams();
+    if (globalOpts.json) {
+      outputResult({ teams }, { json: true });
+      return;
+    }
+    if (teams.length === 0) {
+      console.log('No teams configured. Run: resend login');
+      return;
+    }
+    if (isInteractive()) {
+      console.log('\n  Teams\n');
+    }
+    for (const team of teams) {
+      const marker = team.active ? ' (active)' : '';
+      console.log(`  ${team.active ? '▸' : ' '} ${team.name}${marker}`);
+    }
+    if (isInteractive()) {
+      console.log('');
+    }
+  });

package/.claude/worktrees/emails-list/src/commands/teams/remove.ts ADDED Viewed

@@ -0,0 +1,83 @@
+import * as p from '@clack/prompts';
+import { Command } from '@commander-js/extra-typings';
+import type { GlobalOpts } from '../../lib/client';
+import { listTeams, removeTeam } from '../../lib/config';
+import { errorMessage, outputError, outputResult } from '../../lib/output';
+import { cancelAndExit } from '../../lib/prompts';
+import { isInteractive } from '../../lib/tty';
+export const removeCommand = new Command('remove')
+  .description('Remove a team profile')
+  .argument('[name]', 'Team name to remove')
+  .action(async (name, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    let teamName = name;
+    if (!teamName) {
+      if (!isInteractive()) {
+        outputError(
+          {
+            message:
+              'Missing team name. Provide a team name in non-interactive mode.',
+            code: 'missing_name',
+          },
+          { json: globalOpts.json },
+        );
+      }
+      const teams = listTeams();
+      if (teams.length === 0) {
+        outputError(
+          {
+            message: 'No teams configured. Run `resend login` first.',
+            code: 'no_teams',
+          },
+          { json: globalOpts.json },
+        );
+      }
+      const choice = await p.select({
+        message: 'Remove which team?',
+        options: teams.map((t) => ({
+          value: t.name,
+          label: t.name,
+          hint: t.active ? 'active' : undefined,
+        })),
+      });
+      if (p.isCancel(choice)) {
+        cancelAndExit('Remove cancelled.');
+      }
+      teamName = choice;
+    }
+    if (!globalOpts.json && isInteractive()) {
+      const confirmed = await p.confirm({
+        message: `Remove team '${teamName}' and its API key?`,
+      });
+      if (p.isCancel(confirmed) || !confirmed) {
+        cancelAndExit('Remove cancelled.');
+      }
+    }
+    try {
+      removeTeam(teamName);
+    } catch (err) {
+      outputError(
+        {
+          message: errorMessage(err, 'Failed to remove team'),
+          code: 'remove_failed',
+        },
+        { json: globalOpts.json },
+      );
+    }
+    if (globalOpts.json) {
+      outputResult({ success: true, removed_team: teamName }, { json: true });
+    } else if (isInteractive()) {
+      console.log(`Team '${teamName}' removed.`);
+    }
+  });

package/.claude/worktrees/emails-list/src/commands/teams/switch.ts ADDED Viewed

@@ -0,0 +1,73 @@
+import * as p from '@clack/prompts';
+import { Command } from '@commander-js/extra-typings';
+import type { GlobalOpts } from '../../lib/client';
+import { listTeams, setActiveTeam } from '../../lib/config';
+import { errorMessage, outputError, outputResult } from '../../lib/output';
+import { cancelAndExit } from '../../lib/prompts';
+import { isInteractive } from '../../lib/tty';
+export const switchCommand = new Command('switch')
+  .description('Switch the active team profile')
+  .argument('[name]', 'Team name to switch to')
+  .action(async (name, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    let teamName = name;
+    if (!teamName) {
+      if (!isInteractive()) {
+        outputError(
+          {
+            message:
+              'Missing team name. Provide a team name in non-interactive mode.',
+            code: 'missing_name',
+          },
+          { json: globalOpts.json },
+        );
+      }
+      const teams = listTeams();
+      if (teams.length === 0) {
+        outputError(
+          {
+            message: 'No teams configured. Run `resend login` first.',
+            code: 'no_teams',
+          },
+          { json: globalOpts.json },
+        );
+      }
+      const choice = await p.select({
+        message: 'Switch to which team?',
+        options: teams.map((t) => ({
+          value: t.name,
+          label: t.name,
+          hint: t.active ? 'active' : undefined,
+        })),
+      });
+      if (p.isCancel(choice)) {
+        cancelAndExit('Switch cancelled.');
+      }
+      teamName = choice;
+    }
+    try {
+      setActiveTeam(teamName);
+    } catch (err) {
+      outputError(
+        {
+          message: errorMessage(err, 'Failed to switch team'),
+          code: 'switch_failed',
+        },
+        { json: globalOpts.json },
+      );
+    }
+    if (globalOpts.json) {
+      outputResult({ success: true, active_team: teamName }, { json: true });
+    } else if (isInteractive()) {
+      console.log(`Switched to team '${teamName}'.`);
+    }
+  });