resend-cli 1.0.3 → 1.1.0

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

@@ -0,0 +1,156 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockRemove = mock(async () => ({
+  data: {},
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    apiKeys = { remove: mockRemove };
+  },
+}));
+
+describe('api-keys delete 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';
+    mockRemove.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('deletes API key with --yes flag', async () => {
+    spies = setupOutputSpies();
+
+    const { deleteApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/delete'
+    );
+    await deleteApiKeyCommand.parseAsync(['test-key-id', '--yes'], {
+      from: 'user',
+    });
+
+    expect(mockRemove).toHaveBeenCalledWith('test-key-id');
+  });
+
+  test('outputs synthesized deleted JSON on success', async () => {
+    spies = setupOutputSpies();
+
+    const { deleteApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/delete'
+    );
+    await deleteApiKeyCommand.parseAsync(['test-key-id', '--yes'], {
+      from: 'user',
+    });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.deleted).toBe(true);
+    expect(parsed.id).toBe('test-key-id');
+  });
+
+  test('errors with confirmation_required when --yes absent in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { deleteApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/delete'
+    );
+    await expectExit1(() =>
+      deleteApiKeyCommand.parseAsync(['test-key-id'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('confirmation_required');
+  });
+
+  test('does not call SDK when confirmation is required but not given', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { deleteApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/delete'
+    );
+    await expectExit1(() =>
+      deleteApiKeyCommand.parseAsync(['test-key-id'], { from: 'user' }),
+    );
+
+    expect(mockRemove).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 { deleteApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/delete'
+    );
+    await expectExit1(() =>
+      deleteApiKeyCommand.parseAsync(['test-key-id', '--yes'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with delete_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockRemove.mockResolvedValueOnce(
+      mockSdkError('API key not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { deleteApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/delete'
+    );
+    await expectExit1(() =>
+      deleteApiKeyCommand.parseAsync(['test-key-id', '--yes'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('delete_error');
+  });
+});

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

@@ -0,0 +1,133 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockList = mock(async () => ({
+  data: {
+    object: 'list',
+    data: [
+      {
+        id: 'key-id-1',
+        name: 'Production Key',
+        created_at: '2026-01-01T00:00:00.000Z',
+      },
+      {
+        id: 'key-id-2',
+        name: 'Staging Key',
+        created_at: '2026-01-02T00:00:00.000Z',
+      },
+    ],
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    apiKeys = { list: mockList };
+  },
+}));
+
+describe('api-keys list 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';
+    mockList.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('calls SDK list with no arguments', async () => {
+    spies = setupOutputSpies();
+
+    const { listApiKeysCommand } = await import(
+      '../../../src/commands/api-keys/list'
+    );
+    await listApiKeysCommand.parseAsync([], { from: 'user' });
+
+    expect(mockList).toHaveBeenCalledTimes(1);
+  });
+
+  test('outputs JSON list when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { listApiKeysCommand } = await import(
+      '../../../src/commands/api-keys/list'
+    );
+    await listApiKeysCommand.parseAsync([], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.object).toBe('list');
+    expect(parsed.data).toHaveLength(2);
+    expect(parsed.data[0].id).toBe('key-id-1');
+    expect(parsed.data[0].name).toBe('Production Key');
+  });
+
+  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 { listApiKeysCommand } = await import(
+      '../../../src/commands/api-keys/list'
+    );
+    await expectExit1(() =>
+      listApiKeysCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with list_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockList.mockResolvedValueOnce(
+      mockSdkError('Unauthorized', 'unauthorized'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listApiKeysCommand } = await import(
+      '../../../src/commands/api-keys/list'
+    );
+    await expectExit1(() =>
+      listApiKeysCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});

package/tests/commands/auth/login.test.ts

@@ -0,0 +1,119 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  setupOutputSpies,
+} from '../../helpers';
+
+// Mock the Resend SDK
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    domains = {
+      list: mock(async () => ({ data: { data: [] }, error: null })),
+    };
+  },
+}));
+
+describe('login command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmpDir, { recursive: true });
+    process.env.XDG_CONFIG_HOME = tmpDir;
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    spies = undefined;
+    errorSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy?.mockRestore();
+    exitSpy = undefined;
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('rejects key not starting with re_', async () => {
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { loginCommand } = await import('../../../src/commands/auth/login');
+    await expectExit1(() =>
+      loginCommand.parseAsync(['--key', 'bad_key'], { from: 'user' }),
+    );
+  });
+
+  test('stores valid key to credentials.json', async () => {
+    spies = setupOutputSpies();
+
+    const { loginCommand } = await import('../../../src/commands/auth/login');
+    await loginCommand.parseAsync(['--key', 're_valid_test_key_123'], {
+      from: 'user',
+    });
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.teams.default.api_key).toBe('re_valid_test_key_123');
+  });
+
+  test('requires --key in non-interactive mode', async () => {
+    spies = setupOutputSpies();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { loginCommand } = await import('../../../src/commands/auth/login');
+    await expectExit1(() => loginCommand.parseAsync([], { from: 'user' }));
+
+    expect(errorSpy).toBeDefined();
+    const output = errorSpy?.mock.calls[0][0] as string;
+    expect(output).toContain('missing_key');
+  });
+
+  test('non-interactive login stores as default when teams exist', async () => {
+    // Pre-populate credentials with an existing team
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'production',
+        teams: { production: { api_key: 're_old_key_1234' } },
+      }),
+    );
+
+    spies = setupOutputSpies();
+
+    const { loginCommand } = await import('../../../src/commands/auth/login');
+    await loginCommand.parseAsync(['--key', 're_new_key_5678'], {
+      from: 'user',
+    });
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    // Non-interactive without --team flag stores as 'default' (no picker)
+    expect(data.teams.default.api_key).toBe('re_new_key_5678');
+    // Original team should still exist
+    expect(data.teams.production.api_key).toBe('re_old_key_1234');
+  });
+});

package/tests/commands/auth/logout.test.ts

@@ -0,0 +1,146 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  setupOutputSpies,
+} from '../../helpers';
+
+describe('logout command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmpDir, { recursive: true });
+    process.env.XDG_CONFIG_HOME = tmpDir;
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    spies = undefined;
+    errorSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy?.mockRestore();
+    exitSpy = undefined;
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function writeCredentials(
+    teams: Record<string, string> = { default: 're_test_key_123' },
+  ) {
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    const creds = {
+      active_team: Object.keys(teams)[0],
+      teams: Object.fromEntries(
+        Object.entries(teams).map(([name, key]) => [name, { api_key: key }]),
+      ),
+    };
+    writeFileSync(
+      join(configDir, 'credentials.json'),
+      `${JSON.stringify(creds, null, 2)}\n`,
+    );
+  }
+
+  test('removes credentials file when it exists (non-interactive)', async () => {
+    spies = setupOutputSpies();
+    writeCredentials();
+
+    const { logoutCommand } = await import('../../../src/commands/auth/logout');
+    await logoutCommand.parseAsync([], { from: 'user' });
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    expect(existsSync(configPath)).toBe(false);
+
+    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
+    expect(output.success).toBe(true);
+    expect(output.config_path).toContain('credentials.json');
+  });
+
+  test('exits cleanly when no credentials file exists (non-interactive)', async () => {
+    spies = setupOutputSpies();
+
+    const { logoutCommand } = await import('../../../src/commands/auth/logout');
+    await logoutCommand.parseAsync([], { from: 'user' });
+
+    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
+    expect(output.success).toBe(true);
+    expect(output.already_logged_out).toBe(true);
+  });
+
+  test('logout without --team removes all teams', async () => {
+    spies = setupOutputSpies();
+    writeCredentials({ staging: 're_staging_key', production: 're_prod_key' });
+
+    const { logoutCommand } = await import('../../../src/commands/auth/logout');
+    await logoutCommand.parseAsync([], { from: 'user' });
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    expect(existsSync(configPath)).toBe(false);
+
+    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
+    expect(output.success).toBe(true);
+    expect(output.team).toBe('all');
+  });
+
+  test('logout with --team removes only that team', async () => {
+    spies = setupOutputSpies();
+    writeCredentials({ staging: 're_staging_key', production: 're_prod_key' });
+
+    // Use the full CLI program so --team global option is recognized
+    const { Command } = await import('@commander-js/extra-typings');
+    const { logoutCommand } = await import('../../../src/commands/auth/logout');
+    const program = new Command()
+      .option('--team <name>')
+      .option('--json')
+      .option('--api-key <key>')
+      .addCommand(logoutCommand);
+
+    await program.parseAsync(['logout', '--team', 'staging'], {
+      from: 'user',
+    });
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    expect(existsSync(configPath)).toBe(true);
+
+    const remaining = JSON.parse(
+      require('node:fs').readFileSync(configPath, 'utf-8'),
+    );
+    expect(remaining.teams.staging).toBeUndefined();
+    expect(remaining.teams.production).toBeDefined();
+
+    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
+    expect(output.success).toBe(true);
+    expect(output.team).toBe('staging');
+  });
+
+  test('exits with error when file removal fails', async () => {
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+    spies = setupOutputSpies();
+    writeCredentials();
+
+    // Make the credentials file a directory so unlinkSync throws
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    rmSync(configPath);
+    mkdirSync(configPath); // replace file with a directory — unlinkSync will throw EISDIR
+
+    const { logoutCommand } = await import('../../../src/commands/auth/logout');
+    await expectExit1(() => logoutCommand.parseAsync([], { from: 'user' }));
+
+    expect(errorSpy).toBeDefined();
+    const output = JSON.parse(errorSpy?.mock.calls[0][0] as string);
+    expect(output.error.code).toBe('remove_failed');
+  });
+});