superacli 1.1.5 → 1.1.6

package/temp_resend_cli/repo/tests/commands/domains/verify.test.ts

@@ -0,0 +1,118 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockVerify = vi.fn(async () => ({
+  data: { object: 'domain', id: 'test-domain-id' },
+  error: null,
+}));
+
+vi.mock('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    domains = { verify: mockVerify };
+  },
+}));
+
+describe('domains verify command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: MockInstance | undefined;
+  let stderrSpy: MockInstance | undefined;
+  let exitSpy: MockInstance | undefined;
+
+  beforeEach(() => {
+    process.env.RESEND_API_KEY = 're_test_key';
+    mockVerify.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('calls SDK verify with correct id', async () => {
+    spies = setupOutputSpies();
+
+    const { verifyDomainCommand } = await import(
+      '../../../src/commands/domains/verify'
+    );
+    await verifyDomainCommand.parseAsync(['test-domain-id'], { from: 'user' });
+
+    expect(mockVerify).toHaveBeenCalledWith('test-domain-id');
+  });
+
+  test('outputs JSON object in non-interactive mode (stdout not a TTY)', async () => {
+    spies = setupOutputSpies();
+
+    const { verifyDomainCommand } = await import(
+      '../../../src/commands/domains/verify'
+    );
+    await verifyDomainCommand.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.object).toBe('domain');
+  });
+
+  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 = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { verifyDomainCommand } = await import(
+      '../../../src/commands/domains/verify'
+    );
+    await expectExit1(() =>
+      verifyDomainCommand.parseAsync(['test-domain-id'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with verify_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockVerify.mockResolvedValueOnce(
+      mockSdkError('Domain not found', 'not_found'),
+    );
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { verifyDomainCommand } = await import(
+      '../../../src/commands/domains/verify'
+    );
+    await expectExit1(() =>
+      verifyDomainCommand.parseAsync(['test-domain-id'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('verify_error');
+  });
+});

package/temp_resend_cli/repo/tests/commands/emails/batch.test.ts

@@ -0,0 +1,324 @@
+import { writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockBatchSend = vi.fn(async () => ({
+  data: { data: [{ id: 'abc123' }, { id: 'def456' }] },
+  error: null,
+}));
+
+vi.mock('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    batch = { send: mockBatchSend };
+  },
+}));
+
+const VALID_EMAILS = [
+  {
+    from: 'you@domain.com',
+    to: ['user1@example.com'],
+    subject: 'Hello 1',
+    html: '<p>Hello 1</p>',
+  },
+  {
+    from: 'you@domain.com',
+    to: ['user2@example.com'],
+    subject: 'Hello 2',
+    text: 'Hello 2',
+  },
+];
+
+describe('batch command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: MockInstance | undefined;
+  let stderrSpy: MockInstance | undefined;
+  let exitSpy: MockInstance | undefined;
+  let tmpFile: string;
+
+  beforeEach(() => {
+    process.env.RESEND_API_KEY = 're_test_key';
+    mockBatchSend.mockClear();
+  });
+
+  afterEach(async () => {
+    restoreEnv();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+    if (tmpFile) {
+      const { unlinkSync } = require('node:fs');
+      try {
+        unlinkSync(tmpFile);
+      } catch {}
+      tmpFile = '';
+    }
+  });
+
+  async function writeTmpJson(content: unknown): Promise<string> {
+    const path = join(
+      dirname(fileURLToPath(import.meta.url)),
+      '__test_batch.json',
+    );
+    writeFileSync(path, JSON.stringify(content));
+    tmpFile = path;
+    return path;
+  }
+
+  test('sends emails from a JSON file', async () => {
+    spies = setupOutputSpies();
+
+    const file = await writeTmpJson(VALID_EMAILS);
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await batchCommand.parseAsync(['--file', file], { from: 'user' });
+
+    expect(mockBatchSend).toHaveBeenCalledTimes(1);
+    const emails = mockBatchSend.mock.calls[0][0] as unknown[];
+    expect(emails).toHaveLength(2);
+  });
+
+  test('outputs array of IDs on success in JSON mode', async () => {
+    // Non-interactive mode (no TTY) automatically triggers JSON output via outputResult
+    spies = setupOutputSpies();
+
+    const file = await writeTmpJson(VALID_EMAILS);
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await batchCommand.parseAsync(['--file', file], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed).toEqual([{ id: 'abc123' }, { id: 'def456' }]);
+  });
+
+  test('errors with missing_file when no --file in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await expectExit1(() => batchCommand.parseAsync([], { from: 'user' }));
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('missing_file');
+  });
+
+  test('errors with file_read_error when file does not exist', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await expectExit1(() =>
+      batchCommand.parseAsync(
+        ['--file', '/tmp/nonexistent-resend-batch.json'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('file_read_error');
+  });
+
+  test('errors with invalid_json when file is not valid JSON', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const path = join(
+      dirname(fileURLToPath(import.meta.url)),
+      '__test_batch_bad.json',
+    );
+    writeFileSync(path, 'not valid json{{{');
+    tmpFile = path;
+
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await expectExit1(() =>
+      batchCommand.parseAsync(['--file', path], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_json');
+  });
+
+  test('errors with invalid_format when file content is not an array', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const file = await writeTmpJson({
+      from: 'you@domain.com',
+      to: ['user@example.com'],
+    });
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await expectExit1(() =>
+      batchCommand.parseAsync(['--file', file], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_format');
+    // Regression: invalid_format check was inside the try block; ExitError thrown by
+    // outputError (when process.exit is mocked) would be caught, firing invalid_json too.
+    expect(output).not.toContain('invalid_json');
+  });
+
+  test('rejects entries with attachments', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const emails = [
+      {
+        ...VALID_EMAILS[0],
+        attachments: [{ filename: 'test.txt', content: 'hello' }],
+      },
+    ];
+    const file = await writeTmpJson(emails);
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await expectExit1(() =>
+      batchCommand.parseAsync(['--file', file], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('attachments');
+  });
+
+  test('rejects entries with scheduled_at', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const emails = [
+      { ...VALID_EMAILS[0], scheduled_at: '2026-01-01T00:00:00Z' },
+    ];
+    const file = await writeTmpJson(emails);
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await expectExit1(() =>
+      batchCommand.parseAsync(['--file', file], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('scheduled_at');
+  });
+
+  test('warns but continues when array length exceeds 100', async () => {
+    spies = setupOutputSpies();
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const emails = Array.from({ length: 101 }, (_, i) => ({
+      from: 'you@domain.com',
+      to: [`user${i}@example.com`],
+      subject: `Hello ${i}`,
+      text: `Hello ${i}`,
+    }));
+    const file = await writeTmpJson(emails);
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await batchCommand.parseAsync(['--file', file], { from: 'user' });
+
+    expect(mockBatchSend).toHaveBeenCalledTimes(1);
+
+    warnSpy.mockRestore();
+  });
+
+  test('passes idempotency key to batch.send', async () => {
+    spies = setupOutputSpies();
+
+    const file = await writeTmpJson(VALID_EMAILS);
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await batchCommand.parseAsync(
+      ['--file', file, '--idempotency-key', 'my-key-123'],
+      { from: 'user' },
+    );
+
+    expect(mockBatchSend).toHaveBeenCalledTimes(1);
+    const opts = mockBatchSend.mock.calls[0][1] as Record<string, unknown>;
+    expect(opts?.idempotencyKey).toBe('my-key-123');
+  });
+
+  test('errors with auth_error when no API key in non-interactive mode', async () => {
+    setNonInteractive();
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const file = await writeTmpJson(VALID_EMAILS);
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await expectExit1(() =>
+      batchCommand.parseAsync(['--file', file], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('outputs human-readable summary in terminal mode', async () => {
+    // Make it look like a TTY so outputResult uses human-readable format
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+
+    const file = await writeTmpJson(VALID_EMAILS);
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await batchCommand.parseAsync(['--file', file], { from: 'user' });
+
+    const allOutput = logSpy.mock.calls.map((c) => c[0]).join('\n');
+    expect(allOutput).toContain('2');
+    expect(allOutput).toContain('abc123');
+    expect(allOutput).toContain('def456');
+
+    logSpy.mockRestore();
+  });
+
+  test('errors with batch_error when SDK returns an error', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    mockBatchSend.mockImplementationOnce(async () => ({
+      data: null,
+      error: { message: 'Rate limit exceeded', name: 'rate_limit_exceeded' },
+    }));
+
+    const file = await writeTmpJson(VALID_EMAILS);
+    const { batchCommand } = await import('../../../src/commands/emails/batch');
+    await expectExit1(() =>
+      batchCommand.parseAsync(['--file', file], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('batch_error');
+  });
+});

package/temp_resend_cli/repo/tests/commands/emails/get.test.ts

@@ -0,0 +1,132 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockGet = vi.fn(async () => ({
+  data: {
+    object: 'email' as const,
+    id: 'email_abc123',
+    from: 'you@domain.com',
+    to: ['user@example.com'],
+    subject: 'Hello',
+    html: '<p>Hi</p>',
+    text: 'Hi',
+    created_at: '2026-02-18T12:00:00.000Z',
+    scheduled_at: null,
+    last_event: 'delivered' as const,
+    bcc: null,
+    cc: null,
+    reply_to: null,
+  },
+  error: null,
+}));
+
+vi.mock('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    emails = { get: mockGet };
+  },
+}));
+
+describe('emails get command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: MockInstance | undefined;
+  let stderrSpy: MockInstance | undefined;
+  let exitSpy: MockInstance | undefined;
+
+  beforeEach(() => {
+    process.env.RESEND_API_KEY = 're_test_key';
+    mockGet.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    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 { getEmailCommand } = await import(
+      '../../../src/commands/emails/get'
+    );
+    await getEmailCommand.parseAsync(['email_abc123'], { from: 'user' });
+
+    expect(mockGet).toHaveBeenCalledWith('email_abc123');
+  });
+
+  test('outputs JSON with full email fields when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { getEmailCommand } = await import(
+      '../../../src/commands/emails/get'
+    );
+    await getEmailCommand.parseAsync(['email_abc123'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('email_abc123');
+    expect(parsed.from).toBe('you@domain.com');
+    expect(parsed.subject).toBe('Hello');
+    expect(parsed.last_event).toBe('delivered');
+  });
+
+  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 = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { getEmailCommand } = await import(
+      '../../../src/commands/emails/get'
+    );
+    await expectExit1(() =>
+      getEmailCommand.parseAsync(['email_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 = vi.spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { getEmailCommand } = await import(
+      '../../../src/commands/emails/get'
+    );
+    await expectExit1(() =>
+      getEmailCommand.parseAsync(['email_nonexistent'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('fetch_error');
+  });
+});