resend-cli 1.0.3 → 1.2.0

package/src/lib/output.ts

@@ -0,0 +1,54 @@
+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);
+}

package/src/lib/pagination.ts

@@ -0,0 +1,36 @@
+import type { GlobalOpts } from './client';
+import { outputError } from './output';
+
+export function parseLimitOpt(raw: string, globalOpts: GlobalOpts): number {
+  const limit = parseInt(raw, 10);
+  if (Number.isNaN(limit) || limit < 1 || limit > 100) {
+    outputError(
+      {
+        message: '--limit must be an integer between 1 and 100',
+        code: 'invalid_limit',
+      },
+      { json: globalOpts.json },
+    );
+  }
+  return limit;
+}
+
+export function buildPaginationOpts(
+  limit: number,
+  after?: string,
+  before?: string,
+) {
+  return after ? { limit, after } : before ? { limit, before } : { limit };
+}
+
+export function printPaginationHint(list: {
+  has_more: boolean;
+  data: Array<{ id: string }>;
+}): void {
+  if (list.has_more && list.data.length > 0) {
+    const last = list.data[list.data.length - 1];
+    console.log(
+      `\nMore results available. Use --after ${last.id} to fetch the next page.`,
+    );
+  }
+}

package/src/lib/prompts.ts

@@ -0,0 +1,149 @@
+import * as p from '@clack/prompts';
+import type { GlobalOpts } from './client';
+import { outputError } from './output';
+import { isInteractive } from './tty';
+
+export interface FieldSpec {
+  flag: string;
+  message: string;
+  placeholder?: string;
+  required?: boolean;
+  validate?: (value: string | undefined) => string | undefined;
+}
+
+export function cancelAndExit(message: string): never {
+  p.cancel(message);
+  process.exit(0);
+}
+
+/**
+ * Guard a delete action: error in non-interactive mode (no --yes), or show a
+ * confirmation prompt in interactive mode. Exits the process on cancel/rejection.
+ */
+export async function confirmDelete(
+  _id: string,
+  confirmMessage: string,
+  globalOpts: GlobalOpts,
+): Promise<void> {
+  if (!isInteractive()) {
+    outputError(
+      {
+        message: 'Use --yes to confirm deletion in non-interactive mode.',
+        code: 'confirmation_required',
+      },
+      { json: globalOpts.json },
+    );
+  }
+
+  const confirmed = await p.confirm({ message: confirmMessage });
+  if (p.isCancel(confirmed) || !confirmed) {
+    cancelAndExit('Deletion cancelled.');
+  }
+}
+
+export async function requireText(
+  value: string | undefined,
+  prompt: {
+    message: string;
+    placeholder?: string;
+    validate?: (value: string | undefined) => string | Error | undefined;
+  },
+  error: { message: string; code: string },
+  globalOpts: GlobalOpts,
+): Promise<string> {
+  if (value) {
+    return value;
+  }
+
+  if (!isInteractive()) {
+    outputError(error, { json: globalOpts.json });
+  }
+
+  const result = await p.text({
+    message: prompt.message,
+    placeholder: prompt.placeholder,
+    validate:
+      prompt.validate ??
+      ((v) =>
+        !v || v.length === 0 ? `${prompt.message} is required` : undefined),
+  });
+  if (p.isCancel(result)) {
+    cancelAndExit('Cancelled.');
+  }
+  return result;
+}
+
+export async function requireSelect<V extends string>(
+  value: V | undefined,
+  prompt: {
+    message: string;
+    options: Parameters<typeof p.select<V>>[0]['options'];
+  },
+  error: { message: string; code: string },
+  globalOpts: GlobalOpts,
+): Promise<V> {
+  if (value) {
+    return value;
+  }
+
+  if (!isInteractive()) {
+    outputError(error, { json: globalOpts.json });
+  }
+
+  const result = await p.select<V>({
+    message: prompt.message,
+    options: prompt.options,
+  });
+  if (p.isCancel(result)) {
+    cancelAndExit('Cancelled.');
+  }
+  return result;
+}
+
+export async function promptForMissing<
+  T extends Record<string, string | undefined>,
+>(
+  current: T,
+  fields: FieldSpec[],
+  globalOpts: GlobalOpts,
+): Promise<{ [K in keyof T]: string }> {
+  const missing = fields.filter(
+    (f) => f.required !== false && !current[f.flag],
+  );
+
+  if (missing.length === 0) {
+    return current as { [K in keyof T]: string };
+  }
+
+  if (!isInteractive()) {
+    const flags = missing.map((f) => `--${f.flag}`).join(', ');
+    outputError(
+      { message: `Missing required flags: ${flags}`, code: 'missing_flags' },
+      { json: globalOpts.json },
+    );
+  }
+
+  const result = await p.group(
+    Object.fromEntries(
+      missing.map((field) => [
+        field.flag,
+        () =>
+          p.text({
+            message: field.message,
+            placeholder: field.placeholder,
+            validate:
+              field.validate ??
+              ((v) =>
+                !v || v.length === 0
+                  ? `${field.message} is required`
+                  : undefined),
+          }),
+      ]),
+    ),
+    {
+      onCancel: () => cancelAndExit('Operation cancelled.'),
+    },
+  );
+
+  return { ...current, ...result } as { [K in keyof T]: string };
+}

package/src/lib/spinner.ts

@@ -0,0 +1,93 @@
+import spinners from 'unicode-animations';
+import type { GlobalOpts } from './client';
+import { errorMessage, outputError } from './output';
+import { isInteractive, isUnicodeSupported } from './tty';
+
+// Status symbols generated via String.fromCodePoint() — never literal Unicode in
+// source — to prevent UTF-8 → Latin-1 corruption when the npm package is bundled.
+const TICK = isUnicodeSupported ? String.fromCodePoint(0x2714) : 'v'; // ✔
+const WARN = isUnicodeSupported ? String.fromCodePoint(0x26a0) : '!'; // ⚠
+const CROSS = isUnicodeSupported ? String.fromCodePoint(0x2717) : 'x'; // ✗
+
+type SdkResponse<T> = { data: T | null; error: { message: string } | null };
+
+/**
+ * Wraps an SDK call with a spinner, unified error handling, and automatic stop/fail.
+ * Eliminates the repeated try/catch + spinner boilerplate across all command files.
+ */
+export async function withSpinner<T>(
+  messages: { loading: string; success: string; fail: string },
+  call: () => Promise<SdkResponse<T>>,
+  errorCode: string,
+  globalOpts: GlobalOpts,
+): Promise<T> {
+  const spinner = createSpinner(messages.loading, 'braille', globalOpts.quiet);
+  try {
+    const { data, error } = await call();
+    if (error) {
+      spinner.fail(messages.fail);
+      outputError(
+        { message: error.message, code: errorCode },
+        { json: globalOpts.json },
+      );
+    }
+    if (data === null) {
+      spinner.fail(messages.fail);
+      outputError(
+        { message: 'Unexpected empty response', code: errorCode },
+        { json: globalOpts.json },
+      );
+    }
+    spinner.stop(messages.success);
+    return data;
+  } catch (err) {
+    spinner.fail(messages.fail);
+    return outputError(
+      { message: errorMessage(err, 'Unknown error'), code: errorCode },
+      { json: globalOpts.json },
+    );
+  }
+}
+
+export type SpinnerName = keyof typeof spinners;
+
+export function createSpinner(
+  message: string,
+  name: SpinnerName = 'braille',
+  quiet?: boolean,
+) {
+  if (quiet || !isInteractive()) {
+    return {
+      update(_msg: string) {},
+      stop(_msg: string) {},
+      warn(_msg: string) {},
+      fail(_msg: string) {},
+    };
+  }
+
+  const { frames, interval } = spinners[name];
+  let i = 0;
+  let text = message;
+
+  const timer = setInterval(() => {
+    process.stderr.write(`\r\x1B[2K  ${frames[i++ % frames.length]} ${text}`);
+  }, interval);
+
+  return {
+    update(msg: string) {
+      text = msg;
+    },
+    stop(msg: string) {
+      clearInterval(timer);
+      process.stderr.write(`\r\x1B[2K  ${TICK} ${msg}\n`);
+    },
+    warn(msg: string) {
+      clearInterval(timer);
+      process.stderr.write(`\r\x1B[2K  ${WARN} ${msg}\n`);
+    },
+    fail(msg: string) {
+      clearInterval(timer);
+      process.stderr.write(`\r\x1B[2K  ${CROSS} ${msg}\n`);
+    },
+  };
+}

package/src/lib/table.ts

@@ -0,0 +1,57 @@
+import { isUnicodeSupported } from './tty';
+
+// All box-drawing characters generated via String.fromCodePoint() — never literal
+// Unicode in source — to prevent UTF-8 → Latin-1 corruption in npm bundles.
+const BOX = isUnicodeSupported
+  ? {
+      h: String.fromCodePoint(0x2500), // ─
+      v: String.fromCodePoint(0x2502), // │
+      tl: String.fromCodePoint(0x250c), // ┌
+      tr: String.fromCodePoint(0x2510), // ┐
+      bl: String.fromCodePoint(0x2514), // └
+      br: String.fromCodePoint(0x2518), // ┘
+      lm: String.fromCodePoint(0x251c), // ├
+      rm: String.fromCodePoint(0x2524), // ┤
+      tm: String.fromCodePoint(0x252c), // ┬
+      bm: String.fromCodePoint(0x2534), // ┴
+      mm: String.fromCodePoint(0x253c), // ┼
+    }
+  : {
+      h: '-',
+      v: '|',
+      tl: '+',
+      tr: '+',
+      bl: '+',
+      br: '+',
+      lm: '+',
+      rm: '+',
+      tm: '+',
+      bm: '+',
+      mm: '+',
+    };
+
+export function renderTable(
+  headers: string[],
+  rows: string[][],
+  emptyMessage = '(no results)',
+): string {
+  if (rows.length === 0) {
+    return emptyMessage;
+  }
+  const widths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((r) => r[i].length)),
+  );
+  const top =
+    BOX.tl + widths.map((w) => BOX.h.repeat(w + 2)).join(BOX.tm) + BOX.tr;
+  const mid =
+    BOX.lm + widths.map((w) => BOX.h.repeat(w + 2)).join(BOX.mm) + BOX.rm;
+  const bot =
+    BOX.bl + widths.map((w) => BOX.h.repeat(w + 2)).join(BOX.bm) + BOX.br;
+  const row = (cells: string[]) =>
+    BOX.v +
+    ' ' +
+    cells.map((c, i) => c.padEnd(widths[i])).join(` ${BOX.v} `) +
+    ' ' +
+    BOX.v;
+  return [top, row(headers), mid, ...rows.map(row), bot].join('\n');
+}

package/src/lib/tty.ts

@@ -0,0 +1,28 @@
+export function isInteractive(): boolean {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return false;
+  }
+  if (process.env.CI === 'true' || process.env.CI === '1') {
+    return false;
+  }
+  if (process.env.GITHUB_ACTIONS) {
+    return false;
+  }
+  if (process.env.TERM === 'dumb') {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * True on macOS/Linux and on Windows terminals that support Unicode
+ * (Windows Terminal, VS Code integrated terminal).
+ * False on legacy Windows cmd.exe — callers should fall back to ASCII symbols.
+ *
+ * Generated via String.fromCodePoint() (never literal Unicode in source)
+ * to prevent UTF-8 → Latin-1 corruption when the npm package is bundled.
+ */
+export const isUnicodeSupported: boolean =
+  process.platform !== 'win32' ||
+  Boolean(process.env.WT_SESSION) ||
+  process.env.TERM_PROGRAM === 'vscode';

package/src/lib/version.ts

@@ -0,0 +1,4 @@
+import pkg from '../../package.json';
+
+export const VERSION: string = pkg.version;
+export const PACKAGE_NAME: string = pkg.name;

package/tests/commands/api-keys/create.test.ts

@@ -0,0 +1,195 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockCreate = mock(async () => ({
+  data: { id: 'test-key-id', token: 're_testtoken1234567890' },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    apiKeys = { create: mockCreate };
+  },
+}));
+
+describe('api-keys create command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let stderrSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+
+  beforeEach(() => {
+    process.env.RESEND_API_KEY = 're_test_key';
+    mockCreate.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('creates API key with --name flag', async () => {
+    spies = setupOutputSpies();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await createApiKeyCommand.parseAsync(['--name', 'Production'], {
+      from: 'user',
+    });
+
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.name).toBe('Production');
+  });
+
+  test('passes permission flag to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await createApiKeyCommand.parseAsync(
+      ['--name', 'CI Token', '--permission', 'sending_access'],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.permission).toBe('sending_access');
+  });
+
+  test('passes domain_id (snake_case) to SDK when --domain-id is provided', async () => {
+    spies = setupOutputSpies();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await createApiKeyCommand.parseAsync(
+      [
+        '--name',
+        'Domain Token',
+        '--permission',
+        'sending_access',
+        '--domain-id',
+        'domain-123',
+      ],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.domain_id).toBe('domain-123');
+  });
+
+  test('outputs JSON result when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await createApiKeyCommand.parseAsync(['--name', 'Production'], {
+      from: 'user',
+    });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('test-key-id');
+    expect(parsed.token).toBe('re_testtoken1234567890');
+  });
+
+  test('errors with missing_name when --name absent in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await expectExit1(() =>
+      createApiKeyCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('missing_name');
+  });
+
+  test('does not call SDK when missing_name error is raised', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await expectExit1(() =>
+      createApiKeyCommand.parseAsync([], { from: 'user' }),
+    );
+
+    expect(mockCreate).not.toHaveBeenCalled();
+  });
+
+  test('errors with auth_error when no API key', async () => {
+    setNonInteractive();
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await expectExit1(() =>
+      createApiKeyCommand.parseAsync(['--name', 'Production'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with create_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockCreate.mockResolvedValueOnce(
+      mockSdkError('Name already taken', 'validation_error'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await expectExit1(() =>
+      createApiKeyCommand.parseAsync(['--name', 'Production'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('create_error');
+  });
+});