resend-cli 1.1.0 → 1.2.1

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

@@ -0,0 +1,140 @@
+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: 'attachment' as const,
+    id: 'attach_abc123',
+    filename: 'invoice.pdf',
+    size: 51200,
+    content_type: 'application/pdf',
+    content_disposition: 'attachment' as const,
+    content_id: undefined,
+    download_url: 'https://storage.example.com/signed/invoice.pdf',
+    expires_at: '2026-02-18T13:00:00.000Z',
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    emails = { receiving: { attachments: { get: mockGet } } };
+  },
+}));
+
+describe('emails receiving attachment 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 emailId and attachmentId', async () => {
+    spies = setupOutputSpies();
+
+    const { getAttachmentCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachment'
+    );
+    await getAttachmentCommand.parseAsync(['rcv_email123', 'attach_abc123'], {
+      from: 'user',
+    });
+
+    expect(mockGet).toHaveBeenCalledTimes(1);
+    const args = mockGet.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.emailId).toBe('rcv_email123');
+    expect(args.id).toBe('attach_abc123');
+  });
+
+  test('outputs JSON with attachment fields when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { getAttachmentCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachment'
+    );
+    await getAttachmentCommand.parseAsync(['rcv_email123', 'attach_abc123'], {
+      from: 'user',
+    });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('attach_abc123');
+    expect(parsed.filename).toBe('invoice.pdf');
+    expect(parsed.content_type).toBe('application/pdf');
+    expect(parsed.download_url).toBe(
+      'https://storage.example.com/signed/invoice.pdf',
+    );
+  });
+
+  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 { getAttachmentCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachment'
+    );
+    await expectExit1(() =>
+      getAttachmentCommand.parseAsync(['rcv_email123', 'attach_abc123'], {
+        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('Not found', 'not_found'));
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { getAttachmentCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachment'
+    );
+    await expectExit1(() =>
+      getAttachmentCommand.parseAsync(['rcv_email123', 'attach_nonexistent'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('fetch_error');
+  });
+});

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

@@ -0,0 +1,168 @@
+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' as const,
+    has_more: false,
+    data: [
+      {
+        id: 'attach_abc123',
+        filename: 'invoice.pdf',
+        size: 51200,
+        content_type: 'application/pdf',
+        content_disposition: 'attachment' as const,
+        content_id: null,
+        download_url: 'https://storage.example.com/signed/invoice.pdf',
+        expires_at: '2026-02-18T13:00:00.000Z',
+      },
+    ],
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    emails = { receiving: { attachments: { list: mockList } } };
+  },
+}));
+
+describe('emails receiving attachments 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 emailId and default pagination', async () => {
+    spies = setupOutputSpies();
+
+    const { listAttachmentsCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachments'
+    );
+    await listAttachmentsCommand.parseAsync(['rcv_email123'], { from: 'user' });
+
+    expect(mockList).toHaveBeenCalledTimes(1);
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.emailId).toBe('rcv_email123');
+    expect(args.limit).toBe(10);
+  });
+
+  test('passes --limit to pagination options', async () => {
+    spies = setupOutputSpies();
+
+    const { listAttachmentsCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachments'
+    );
+    await listAttachmentsCommand.parseAsync(['rcv_email123', '--limit', '5'], {
+      from: 'user',
+    });
+
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.limit).toBe(5);
+  });
+
+  test('outputs JSON list with attachment data when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { listAttachmentsCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachments'
+    );
+    await listAttachmentsCommand.parseAsync(['rcv_email123'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(Array.isArray(parsed.data)).toBe(true);
+    expect(parsed.data[0].id).toBe('attach_abc123');
+    expect(parsed.data[0].filename).toBe('invoice.pdf');
+    expect(parsed.data[0].content_type).toBe('application/pdf');
+    expect(parsed.has_more).toBe(false);
+  });
+
+  test('errors with invalid_limit for out-of-range limit', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { listAttachmentsCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachments'
+    );
+    await expectExit1(() =>
+      listAttachmentsCommand.parseAsync(['rcv_email123', '--limit', '200'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_limit');
+  });
+
+  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 { listAttachmentsCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachments'
+    );
+    await expectExit1(() =>
+      listAttachmentsCommand.parseAsync(['rcv_email123'], { 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('Not found', 'not_found'));
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listAttachmentsCommand } = await import(
+      '../../../../src/commands/emails/receiving/attachments'
+    );
+    await expectExit1(() =>
+      listAttachmentsCommand.parseAsync(['rcv_nonexistent'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});

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

@@ -0,0 +1,140 @@
+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: 'email' as const,
+    id: 'rcv_abc123',
+    to: ['inbox@yourdomain.com'],
+    from: 'sender@external.com',
+    subject: 'Hello from outside',
+    created_at: '2026-02-18T12:00:00.000Z',
+    bcc: null,
+    cc: null,
+    reply_to: null,
+    html: '<p>Hello!</p>',
+    text: 'Hello!',
+    headers: { 'x-mailer': 'Thunderbird' },
+    message_id: '<hello@external.com>',
+    raw: {
+      download_url: 'https://storage.example.com/signed/raw-email',
+      expires_at: '2026-02-18T13:00:00.000Z',
+    },
+    attachments: [],
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    emails = { receiving: { get: mockGet } };
+  },
+}));
+
+describe('emails receiving 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 the provided id', async () => {
+    spies = setupOutputSpies();
+
+    const { getReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/get'
+    );
+    await getReceivingCommand.parseAsync(['rcv_abc123'], { from: 'user' });
+
+    expect(mockGet).toHaveBeenCalledTimes(1);
+    expect(mockGet.mock.calls[0][0]).toBe('rcv_abc123');
+  });
+
+  test('outputs JSON with full email fields when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { getReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/get'
+    );
+    await getReceivingCommand.parseAsync(['rcv_abc123'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('rcv_abc123');
+    expect(parsed.from).toBe('sender@external.com');
+    expect(parsed.subject).toBe('Hello from outside');
+    expect(parsed.text).toBe('Hello!');
+    expect(parsed.raw.download_url).toBe(
+      'https://storage.example.com/signed/raw-email',
+    );
+  });
+
+  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 { getReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/get'
+    );
+    await expectExit1(() =>
+      getReceivingCommand.parseAsync(['rcv_abc123'], { 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('Not found', 'not_found'));
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { getReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/get'
+    );
+    await expectExit1(() =>
+      getReceivingCommand.parseAsync(['rcv_nonexistent'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('fetch_error');
+  });
+});

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

@@ -0,0 +1,181 @@
+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' as const,
+    has_more: false,
+    data: [
+      {
+        id: 'rcv_abc123',
+        to: ['inbox@yourdomain.com'],
+        from: 'sender@external.com',
+        subject: 'Hello from outside',
+        created_at: '2026-02-18T12:00:00.000Z',
+        message_id: '<hello@external.com>',
+        bcc: null,
+        cc: null,
+        reply_to: null,
+        attachments: [],
+      },
+    ],
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    emails = { receiving: { list: mockList } };
+  },
+}));
+
+describe('emails receiving 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 default pagination', async () => {
+    spies = setupOutputSpies();
+
+    const { listReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/list'
+    );
+    await listReceivingCommand.parseAsync([], { from: 'user' });
+
+    expect(mockList).toHaveBeenCalledTimes(1);
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.limit).toBe(10);
+  });
+
+  test('passes --limit to pagination options', async () => {
+    spies = setupOutputSpies();
+
+    const { listReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/list'
+    );
+    await listReceivingCommand.parseAsync(['--limit', '5'], { from: 'user' });
+
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.limit).toBe(5);
+  });
+
+  test('passes --after cursor to pagination options', async () => {
+    spies = setupOutputSpies();
+
+    const { listReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/list'
+    );
+    await listReceivingCommand.parseAsync(['--after', 'rcv_cursor123'], {
+      from: 'user',
+    });
+
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.after).toBe('rcv_cursor123');
+  });
+
+  test('outputs JSON list with received email data when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { listReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/list'
+    );
+    await listReceivingCommand.parseAsync([], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(Array.isArray(parsed.data)).toBe(true);
+    expect(parsed.data[0].id).toBe('rcv_abc123');
+    expect(parsed.data[0].from).toBe('sender@external.com');
+    expect(parsed.data[0].subject).toBe('Hello from outside');
+    expect(parsed.has_more).toBe(false);
+  });
+
+  test('errors with invalid_limit for out-of-range limit', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { listReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/list'
+    );
+    await expectExit1(() =>
+      listReceivingCommand.parseAsync(['--limit', '200'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_limit');
+  });
+
+  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 { listReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/list'
+    );
+    await expectExit1(() =>
+      listReceivingCommand.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('Server error', 'server_error'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listReceivingCommand } = await import(
+      '../../../../src/commands/emails/receiving/list'
+    );
+    await expectExit1(() =>
+      listReceivingCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});