resend-cli 1.1.0 → 1.2.0

package/.claude/worktrees/emails-list/tests/commands/domains/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: { object: 'domain', id: 'test-domain-id', deleted: true },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    domains = { remove: mockRemove };
+  },
+}));
+
+describe('domains 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 domain with --yes flag', async () => {
+    spies = setupOutputSpies();
+
+    const { deleteDomainCommand } = await import(
+      '../../../src/commands/domains/delete'
+    );
+    await deleteDomainCommand.parseAsync(['test-domain-id', '--yes'], {
+      from: 'user',
+    });
+
+    expect(mockRemove).toHaveBeenCalledWith('test-domain-id');
+  });
+
+  test('outputs deleted domain JSON on success', async () => {
+    spies = setupOutputSpies();
+
+    const { deleteDomainCommand } = await import(
+      '../../../src/commands/domains/delete'
+    );
+    await deleteDomainCommand.parseAsync(['test-domain-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-domain-id');
+  });
+
+  test('errors with confirmation_required when --yes absent in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { deleteDomainCommand } = await import(
+      '../../../src/commands/domains/delete'
+    );
+    await expectExit1(() =>
+      deleteDomainCommand.parseAsync(['test-domain-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 { deleteDomainCommand } = await import(
+      '../../../src/commands/domains/delete'
+    );
+    await expectExit1(() =>
+      deleteDomainCommand.parseAsync(['test-domain-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 { deleteDomainCommand } = await import(
+      '../../../src/commands/domains/delete'
+    );
+    await expectExit1(() =>
+      deleteDomainCommand.parseAsync(['test-domain-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('Domain not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { deleteDomainCommand } = await import(
+      '../../../src/commands/domains/delete'
+    );
+    await expectExit1(() =>
+      deleteDomainCommand.parseAsync(['test-domain-id', '--yes'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('delete_error');
+  });
+});

package/.claude/worktrees/emails-list/tests/commands/domains/get.test.ts

@@ -0,0 +1,137 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockGet = mock(async () => ({
+  data: {
+    object: 'domain',
+    id: 'test-domain-id',
+    name: 'example.com',
+    status: 'verified',
+    created_at: '2026-01-01T00:00:00.000Z',
+    region: 'us-east-1',
+    records: [
+      {
+        record: 'SPF',
+        type: 'MX',
+        name: 'send',
+        ttl: 'Auto',
+        status: 'verified',
+        value: 'feedback-smtp.us-east-1.amazonses.com',
+        priority: 10,
+      },
+    ],
+    capabilities: { sending: 'enabled', receiving: 'disabled' },
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    domains = { get: mockGet };
+  },
+}));
+
+describe('domains get 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';
+    mockGet.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('calls SDK get with correct id', async () => {
+    spies = setupOutputSpies();
+
+    const { getDomainCommand } = await import(
+      '../../../src/commands/domains/get'
+    );
+    await getDomainCommand.parseAsync(['test-domain-id'], { from: 'user' });
+
+    expect(mockGet).toHaveBeenCalledWith('test-domain-id');
+  });
+
+  test('outputs full domain JSON in non-interactive mode', async () => {
+    spies = setupOutputSpies();
+
+    const { getDomainCommand } = await import(
+      '../../../src/commands/domains/get'
+    );
+    await getDomainCommand.parseAsync(['test-domain-id'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('test-domain-id');
+    expect(parsed.status).toBe('verified');
+    expect(parsed.records).toHaveLength(1);
+  });
+
+  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 { getDomainCommand } = await import(
+      '../../../src/commands/domains/get'
+    );
+    await expectExit1(() =>
+      getDomainCommand.parseAsync(['test-domain-id'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with fetch_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockGet.mockResolvedValueOnce(
+      mockSdkError('Domain not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { getDomainCommand } = await import(
+      '../../../src/commands/domains/get'
+    );
+    await expectExit1(() =>
+      getDomainCommand.parseAsync(['test-domain-id'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('fetch_error');
+  });
+});

package/.claude/worktrees/emails-list/tests/commands/domains/list.test.ts

@@ -0,0 +1,164 @@
+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: 'domain-1',
+        name: 'example.com',
+        status: 'verified',
+        region: 'us-east-1',
+        created_at: '2026-01-01T00:00:00.000Z',
+        capabilities: { sending: 'enabled', receiving: 'disabled' },
+      },
+      {
+        id: 'domain-2',
+        name: 'test.com',
+        status: 'pending',
+        region: 'eu-west-1',
+        created_at: '2026-01-02T00:00:00.000Z',
+        capabilities: { sending: 'enabled', receiving: 'disabled' },
+      },
+    ],
+    has_more: false,
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    domains = { list: mockList };
+  },
+}));
+
+describe('domains 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 and outputs domains as JSON', async () => {
+    spies = setupOutputSpies();
+
+    const { listDomainsCommand } = await import(
+      '../../../src/commands/domains/list'
+    );
+    await listDomainsCommand.parseAsync([], { from: 'user' });
+
+    expect(mockList).toHaveBeenCalledTimes(1);
+    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);
+  });
+
+  test('passes limit to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { listDomainsCommand } = await import(
+      '../../../src/commands/domains/list'
+    );
+    await listDomainsCommand.parseAsync(['--limit', '25'], { from: 'user' });
+
+    const callArgs = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(callArgs.limit).toBe(25);
+  });
+
+  test('passes after cursor to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { listDomainsCommand } = await import(
+      '../../../src/commands/domains/list'
+    );
+    await listDomainsCommand.parseAsync(['--after', 'some-cursor'], {
+      from: 'user',
+    });
+
+    const callArgs = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(callArgs.after).toBe('some-cursor');
+  });
+
+  test('uses default limit of 10 when not specified', async () => {
+    spies = setupOutputSpies();
+
+    const { listDomainsCommand } = await import(
+      '../../../src/commands/domains/list'
+    );
+    await listDomainsCommand.parseAsync([], { from: 'user' });
+
+    const callArgs = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(callArgs.limit).toBe(10);
+  });
+
+  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 { listDomainsCommand } = await import(
+      '../../../src/commands/domains/list'
+    );
+    await expectExit1(() =>
+      listDomainsCommand.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', 'auth_error'));
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listDomainsCommand } = await import(
+      '../../../src/commands/domains/list'
+    );
+    await expectExit1(() =>
+      listDomainsCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});

package/.claude/worktrees/emails-list/tests/commands/domains/update.test.ts

@@ -0,0 +1,223 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockUpdate = mock(async () => ({
+  data: { object: 'domain', id: 'test-domain-id' },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    domains = { update: mockUpdate };
+  },
+}));
+
+describe('domains update 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';
+    mockUpdate.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('calls SDK update with correct id', async () => {
+    spies = setupOutputSpies();
+
+    const { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await updateDomainCommand.parseAsync(
+      ['test-domain-id', '--tls', 'enforced'],
+      { from: 'user' },
+    );
+
+    expect(mockUpdate).toHaveBeenCalledTimes(1);
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.id).toBe('test-domain-id');
+    expect(args.tls).toBe('enforced');
+  });
+
+  test('passes openTracking=true when --open-tracking is set', async () => {
+    spies = setupOutputSpies();
+
+    const { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await updateDomainCommand.parseAsync(
+      ['test-domain-id', '--open-tracking'],
+      { from: 'user' },
+    );
+
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.openTracking).toBe(true);
+  });
+
+  test('passes openTracking=false when --no-open-tracking is set', async () => {
+    spies = setupOutputSpies();
+
+    const { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await updateDomainCommand.parseAsync(
+      ['test-domain-id', '--no-open-tracking'],
+      { from: 'user' },
+    );
+
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.openTracking).toBe(false);
+  });
+
+  test('does not include tracking keys in payload when no tracking flags are passed', async () => {
+    spies = setupOutputSpies();
+
+    const { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await updateDomainCommand.parseAsync(
+      ['test-domain-id', '--tls', 'enforced'],
+      { from: 'user' },
+    );
+
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.openTracking).toBeUndefined();
+    expect(args.clickTracking).toBeUndefined();
+  });
+
+  test('passes clickTracking=true when --click-tracking is set', async () => {
+    spies = setupOutputSpies();
+
+    const { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await updateDomainCommand.parseAsync(
+      ['test-domain-id', '--click-tracking'],
+      { from: 'user' },
+    );
+
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.clickTracking).toBe(true);
+  });
+
+  test('passes clickTracking=false when --no-click-tracking is set', async () => {
+    spies = setupOutputSpies();
+
+    const { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await updateDomainCommand.parseAsync(
+      ['test-domain-id', '--no-click-tracking'],
+      { from: 'user' },
+    );
+
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.clickTracking).toBe(false);
+  });
+
+  test('errors with no_changes when no update flags are provided', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await expectExit1(() =>
+      updateDomainCommand.parseAsync(['test-domain-id'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('no_changes');
+    expect(mockUpdate).not.toHaveBeenCalled();
+  });
+
+  test('outputs domain JSON on success', async () => {
+    spies = setupOutputSpies();
+
+    const { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await updateDomainCommand.parseAsync(
+      ['test-domain-id', '--tls', 'opportunistic'],
+      { from: 'user' },
+    );
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.object).toBe('domain');
+    expect(parsed.id).toBe('test-domain-id');
+  });
+
+  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 { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await expectExit1(() =>
+      updateDomainCommand.parseAsync(['test-domain-id', '--tls', 'enforced'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with update_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockUpdate.mockResolvedValueOnce(
+      mockSdkError('Domain not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { updateDomainCommand } = await import(
+      '../../../src/commands/domains/update'
+    );
+    await expectExit1(() =>
+      updateDomainCommand.parseAsync(['test-domain-id', '--tls', 'enforced'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('update_error');
+  });
+});