resend-cli 1.2.1 → 1.3.0

package/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/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/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/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/src/lib/client.ts

@@ -1,37 +0,0 @@
-import { Resend } from 'resend';
-import { resolveApiKey } from './config';
-import { errorMessage, outputError } from './output';
-import { VERSION } from './version';
-
-export type GlobalOpts = {
-  apiKey?: string;
-  json?: boolean;
-  quiet?: boolean;
-  team?: string;
-};
-
-process.env.RESEND_USER_AGENT = `resend-cli:${VERSION}`;
-
-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 },
-    );
-  }
-}

package/src/lib/config.ts

@@ -1,211 +0,0 @@
-import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-
-export type ApiKeySource = 'flag' | 'env' | 'config';
-export type ResolvedKey = { key: string; source: ApiKeySource; team?: string };
-
-export type TeamProfile = { api_key: string };
-export type CredentialsFile = {
-  active_team: string;
-  teams: Record<string, TeamProfile>;
-};
-
-export function getConfigDir(): string {
-  if (process.env.XDG_CONFIG_HOME) {
-    return join(process.env.XDG_CONFIG_HOME, 'resend');
-  }
-  if (process.platform === 'win32' && process.env.APPDATA) {
-    return join(process.env.APPDATA, 'resend');
-  }
-  return join(homedir(), '.config', 'resend');
-}
-
-function getCredentialsPath(): string {
-  return join(getConfigDir(), 'credentials.json');
-}
-
-export function readCredentials(): CredentialsFile | null {
-  try {
-    const data = JSON.parse(readFileSync(getCredentialsPath(), 'utf-8'));
-    // Support legacy format: { api_key: "re_xxx" }
-    if (data.api_key && !data.teams) {
-      return {
-        active_team: 'default',
-        teams: { default: { api_key: data.api_key } },
-      };
-    }
-    if (data.teams) {
-      return data as CredentialsFile;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-export function writeCredentials(creds: CredentialsFile): string {
-  const configDir = getConfigDir();
-  mkdirSync(configDir, { recursive: true, mode: 0o700 });
-
-  const configPath = getCredentialsPath();
-  writeFileSync(configPath, `${JSON.stringify(creds, null, 2)}\n`, {
-    mode: 0o600,
-  });
-  chmodSync(configPath, 0o600);
-
-  return configPath;
-}
-
-export function resolveTeamName(flagValue?: string): string {
-  if (flagValue) {
-    return flagValue;
-  }
-
-  const envTeam = process.env.RESEND_TEAM;
-  if (envTeam) {
-    return envTeam;
-  }
-
-  const creds = readCredentials();
-  if (creds?.active_team) {
-    return creds.active_team;
-  }
-
-  return 'default';
-}
-
-export function resolveApiKey(
-  flagValue?: string,
-  teamName?: string,
-): ResolvedKey | null {
-  if (flagValue) {
-    return { key: flagValue, source: 'flag' };
-  }
-
-  const envKey = process.env.RESEND_API_KEY;
-  if (envKey) {
-    return { key: envKey, source: 'env' };
-  }
-
-  const creds = readCredentials();
-  if (creds) {
-    const team = resolveTeamName(teamName);
-    const profile = creds.teams[team];
-    if (profile?.api_key) {
-      return { key: profile.api_key, source: 'config', team };
-    }
-  }
-
-  return null;
-}
-
-export function storeApiKey(apiKey: string, teamName?: string): string {
-  const team = teamName || 'default';
-  const creds = readCredentials() || { active_team: 'default', teams: {} };
-
-  creds.teams[team] = { api_key: apiKey };
-
-  // If this is the first team, set it as active
-  if (Object.keys(creds.teams).length === 1) {
-    creds.active_team = team;
-  }
-
-  return writeCredentials(creds);
-}
-
-export function removeAllApiKeys(): string {
-  const configPath = getCredentialsPath();
-  const { unlinkSync } = require('node:fs');
-  unlinkSync(configPath);
-  return configPath;
-}
-
-export function removeApiKey(teamName?: string): string {
-  const creds = readCredentials();
-  if (!creds) {
-    const configPath = getCredentialsPath();
-    // Try to delete legacy file
-    const { unlinkSync } = require('node:fs');
-    unlinkSync(configPath);
-    return configPath;
-  }
-
-  const team = teamName || resolveTeamName();
-  delete creds.teams[team];
-
-  // If we removed the active team, switch to first available or "default"
-  if (creds.active_team === team) {
-    const remaining = Object.keys(creds.teams);
-    creds.active_team = remaining[0] || 'default';
-  }
-
-  // If no teams left, delete the file
-  if (Object.keys(creds.teams).length === 0) {
-    const { unlinkSync } = require('node:fs');
-    const configPath = getCredentialsPath();
-    unlinkSync(configPath);
-    return configPath;
-  }
-
-  return writeCredentials(creds);
-}
-
-export function setActiveTeam(teamName: string): void {
-  const creds = readCredentials();
-  if (!creds) {
-    throw new Error('No credentials file found. Run: resend login');
-  }
-  if (!creds.teams[teamName]) {
-    throw new Error(
-      `Team "${teamName}" not found. Available teams: ${Object.keys(creds.teams).join(', ')}`,
-    );
-  }
-  creds.active_team = teamName;
-  writeCredentials(creds);
-}
-
-export function listTeams(): Array<{ name: string; active: boolean }> {
-  const creds = readCredentials();
-  if (!creds) {
-    return [];
-  }
-  return Object.keys(creds.teams).map((name) => ({
-    name,
-    active: name === creds.active_team,
-  }));
-}
-
-export function maskKey(key: string): string {
-  if (key.length <= 7) {
-    return `${key.slice(0, 3)}...`;
-  }
-  return `${key.slice(0, 3)}...${key.slice(-4)}`;
-}
-
-export function removeTeam(teamName: string): void {
-  const creds = readCredentials();
-  if (!creds) {
-    throw new Error('No credentials file found.');
-  }
-  if (!creds.teams[teamName]) {
-    throw new Error(
-      `Team "${teamName}" not found. Available teams: ${Object.keys(creds.teams).join(', ')}`,
-    );
-  }
-
-  delete creds.teams[teamName];
-
-  if (creds.active_team === teamName) {
-    const remaining = Object.keys(creds.teams);
-    creds.active_team = remaining[0] || 'default';
-  }
-
-  if (Object.keys(creds.teams).length === 0) {
-    const { unlinkSync } = require('node:fs');
-    unlinkSync(getCredentialsPath());
-    return;
-  }
-
-  writeCredentials(creds);
-}

package/src/lib/files.ts

@@ -1,15 +0,0 @@
-import { readFileSync } from 'node:fs';
-import type { GlobalOpts } from './client';
-import { outputError } from './output';
-
-/** Read a text file, exiting with file_read_error if unreadable. */
-export function readFile(filePath: string, globalOpts: GlobalOpts): string {
-  try {
-    return readFileSync(filePath, 'utf-8');
-  } catch {
-    outputError(
-      { message: `Failed to read file: ${filePath}`, code: 'file_read_error' },
-      { json: globalOpts.json },
-    );
-  }
-}

package/src/lib/help-text.ts

@@ -1,38 +0,0 @@
-export interface HelpTextOptions {
-  context?: string; // All text before Global options (includes Non-interactive line if needed)
-  output?: string; // Content after "Output (--json or piped):" header (raw string, may be multi-line)
-  errorCodes?: string[]; // ['auth_error', 'list_error'] — joined with ' | '
-  examples: string[]; // Command strings without '$ ' prefix (added automatically)
-  setup?: boolean; // true = --json only (no --api-key); default false = full API variant
-}
-
-const GLOBAL_OPTS_FULL = `Global options:
-  --api-key <key>   API key (or set RESEND_API_KEY env var)
-  --team <name>     Team profile to use (overrides RESEND_TEAM)
-  --json            Force JSON output (also auto-enabled when stdout is piped)
-  -q, --quiet       Suppress spinners and status output (implies --json)`;
-
-const GLOBAL_OPTS_SETUP = `Global options:
-  --team <name>  Team profile to save the key to
-  --json         Force JSON output
-  -q, --quiet    Suppress spinners and status output (implies --json)`;
-
-const ERROR_ENVELOPE = `  {"error":{"message":"<message>","code":"<code>"}}`;
-
-export function buildHelpText(opts: HelpTextOptions): string {
-  const parts: string[] = [];
-  if (opts.context != null) {
-    parts.push(opts.context);
-  }
-  parts.push(opts.setup ? GLOBAL_OPTS_SETUP : GLOBAL_OPTS_FULL);
-  if (opts.output != null) {
-    parts.push(`Output (--json or piped):\n${opts.output}`);
-  }
-  if (opts.errorCodes != null) {
-    parts.push(
-      `Errors (exit code 1):\n${ERROR_ENVELOPE}\n  Codes: ${opts.errorCodes.join(' | ')}`,
-    );
-  }
-  parts.push(`Examples:\n${opts.examples.map((e) => `  $ ${e}`).join('\n')}`);
-  return `\n${parts.join('\n\n')}`;
-}

package/src/lib/output.ts

@@ -1,54 +0,0 @@
-export function errorMessage(err: unknown, fallback: string): string {
-  return err instanceof Error ? err.message : fallback;
-}
-
-export interface OutputOptions {
-  json?: boolean;
-  exitCode?: number;
-}
-
-function shouldOutputJson(json?: boolean): boolean {
-  if (json) {
-    return true;
-  }
-  if (!process.stdout.isTTY) {
-    return true;
-  }
-  return false;
-}
-
-export function outputResult(data: unknown, opts: OutputOptions = {}): void {
-  if (shouldOutputJson(opts.json)) {
-    console.log(JSON.stringify(data, null, 2));
-  } else {
-    if (typeof data === 'string') {
-      console.log(data);
-    } else {
-      console.log(JSON.stringify(data, null, 2));
-    }
-  }
-  if (opts.exitCode !== undefined) {
-    process.exit(opts.exitCode);
-  }
-}
-
-export function outputError(
-  error: { message: string; code?: string },
-  opts: OutputOptions = {},
-): never {
-  const exitCode = opts.exitCode ?? 1;
-
-  if (shouldOutputJson(opts.json)) {
-    console.error(
-      JSON.stringify(
-        { error: { message: error.message, code: error.code ?? 'unknown' } },
-        null,
-        2,
-      ),
-    );
-  } else {
-    console.error(`Error: ${error.message}`);
-  }
-
-  process.exit(exitCode);
-}