superacli 1.1.5 → 1.1.6

package/temp_resend_cli/repo/tests/commands/webhooks/list.test.ts

@@ -0,0 +1,178 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockList = vi.fn(async () => ({
+  data: {
+    object: 'list' as const,
+    has_more: false,
+    data: [
+      {
+        id: 'wh_abc123',
+        endpoint: 'https://app.example.com/hooks/resend',
+        events: ['email.sent', 'email.bounced'] as string[],
+        status: 'enabled' as const,
+        created_at: '2026-01-01T00:00:00.000Z',
+      },
+    ],
+  },
+  error: null,
+}));
+
+vi.mock('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    webhooks = { list: mockList };
+  },
+}));
+
+describe('webhooks list 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';
+    mockList.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('calls SDK list method with default pagination', async () => {
+    spies = setupOutputSpies();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await listWebhooksCommand.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 { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await listWebhooksCommand.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 { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await listWebhooksCommand.parseAsync(['--after', 'wh_cursor123'], {
+      from: 'user',
+    });
+
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.after).toBe('wh_cursor123');
+  });
+
+  test('outputs JSON list with webhook data when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await listWebhooksCommand.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('wh_abc123');
+    expect(parsed.data[0].endpoint).toBe(
+      'https://app.example.com/hooks/resend',
+    );
+    expect(parsed.has_more).toBe(false);
+  });
+
+  test('errors with invalid_limit for out-of-range limit', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await expectExit1(() =>
+      listWebhooksCommand.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 = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await expectExit1(() =>
+      listWebhooksCommand.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 = vi.spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await expectExit1(() =>
+      listWebhooksCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});

package/temp_resend_cli/repo/tests/commands/webhooks/update.test.ts

@@ -0,0 +1,207 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockUpdate = vi.fn(async () => ({
+  data: { object: 'webhook' as const, id: 'wh_abc123' },
+  error: null,
+}));
+
+vi.mock('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    webhooks = { update: mockUpdate };
+  },
+}));
+
+describe('webhooks update 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';
+    mockUpdate.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('updates endpoint with --endpoint flag', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(
+      ['wh_abc123', '--endpoint', 'https://new-app.example.com/hooks'],
+      { from: 'user' },
+    );
+
+    expect(mockUpdate).toHaveBeenCalledTimes(1);
+    expect(mockUpdate.mock.calls[0][0]).toBe('wh_abc123');
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.endpoint).toBe('https://new-app.example.com/hooks');
+  });
+
+  test('updates events with --events flag', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(
+      ['wh_abc123', '--events', 'email.sent', 'email.bounced'],
+      { from: 'user' },
+    );
+
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.events).toEqual(['email.sent', 'email.bounced']);
+  });
+
+  test('expands "all" shorthand in --events to 17 events', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(['wh_abc123', '--events', 'all'], {
+      from: 'user',
+    });
+
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.events).toHaveLength(17);
+  });
+
+  test('updates status with --status flag', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(
+      ['wh_abc123', '--status', 'disabled'],
+      { from: 'user' },
+    );
+
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.status).toBe('disabled');
+  });
+
+  test('outputs JSON result when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(
+      ['wh_abc123', '--status', 'enabled'],
+      { from: 'user' },
+    );
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.object).toBe('webhook');
+    expect(parsed.id).toBe('wh_abc123');
+  });
+
+  test('errors with no_changes when no flags are provided', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await expectExit1(() =>
+      updateWebhookCommand.parseAsync(['wh_abc123'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('no_changes');
+  });
+
+  test('does not call SDK when no_changes error is raised', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await expectExit1(() =>
+      updateWebhookCommand.parseAsync(['wh_abc123'], { from: 'user' }),
+    );
+
+    expect(mockUpdate).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 = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await expectExit1(() =>
+      updateWebhookCommand.parseAsync(['wh_abc123', '--status', 'enabled'], {
+        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('Webhook not found', 'not_found'),
+    );
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await expectExit1(() =>
+      updateWebhookCommand.parseAsync(
+        ['wh_nonexistent', '--status', 'disabled'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('update_error');
+  });
+});

package/temp_resend_cli/repo/tests/commands/whoami.test.ts

@@ -0,0 +1,98 @@
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+} from 'vitest';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  setupOutputSpies,
+} from '../helpers';
+
+describe('whoami command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: MockInstance | undefined;
+  let exitSpy: MockInstance | 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;
+    delete process.env.RESEND_API_KEY;
+    delete process.env.RESEND_TEAM;
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies = undefined;
+    errorSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy?.mockRestore();
+    exitSpy = undefined;
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('exits 1 when not authenticated (non-interactive)', async () => {
+    spies = setupOutputSpies();
+    exitSpy = mockExitThrow();
+
+    const { whoamiCommand } = await import('../../src/commands/whoami');
+    await expectExit1(() => whoamiCommand.parseAsync([], { from: 'user' }));
+
+    const output = spies.logSpy.mock.calls[0]?.[0] as string | undefined;
+    if (output) {
+      const parsed = JSON.parse(output);
+      expect(parsed.authenticated).toBe(false);
+    }
+  });
+
+  test('shows authenticated JSON when key exists in config', async () => {
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'production',
+        teams: { production: { api_key: 're_test_key_abcd' } },
+      }),
+    );
+
+    spies = setupOutputSpies();
+
+    const { whoamiCommand } = await import('../../src/commands/whoami');
+    await whoamiCommand.parseAsync([], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.authenticated).toBe(true);
+    expect(parsed.team).toBe('production');
+    expect(parsed.api_key).toBe('re_...abcd');
+    expect(parsed.source).toBe('config');
+  });
+
+  test('shows env source when RESEND_API_KEY is set', async () => {
+    process.env.RESEND_API_KEY = 're_env_key_5678';
+
+    spies = setupOutputSpies();
+
+    const { whoamiCommand } = await import('../../src/commands/whoami');
+    await whoamiCommand.parseAsync([], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.authenticated).toBe(true);
+    expect(parsed.source).toBe('env');
+  });
+});

package/temp_resend_cli/repo/tests/e2e/smoke.test.ts

@@ -0,0 +1,93 @@
+/**
+ * E2E smoke tests — runs real CLI commands against the Resend API.
+ *
+ * These are NOT part of the normal test suite. Run them manually:
+ *
+ *   npm run test:e2e
+ *
+ * Requirements:
+ *   - A valid API key via RESEND_API_KEY env var or `resend login`
+ *
+ * These tests are read-only — they list resources and validate the CLI
+ * can talk to the API and format responses. Nothing is created or deleted.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { describe, expect, test } from 'vitest';
+
+const CLI = resolve(import.meta.dirname, '../../src/cli.ts');
+
+function run(...args: string[]): { stdout: string; exitCode: number } {
+  try {
+    const stdout = execFileSync('npx', ['tsx', CLI, ...args, '--json', '-q'], {
+      encoding: 'utf-8',
+      timeout: 30_000,
+      env: { ...process.env, NO_COLOR: '1' },
+    });
+    return { stdout: stdout.trim(), exitCode: 0 };
+  } catch (err) {
+    const e = err as { stdout?: string; status?: number };
+    return {
+      stdout: (e.stdout ?? '').trim(),
+      exitCode: e.status ?? 1,
+    };
+  }
+}
+
+function parseJson(stdout: string): unknown {
+  const parsed = JSON.parse(stdout);
+  expect(parsed).toBeDefined();
+  return parsed;
+}
+
+describe('e2e smoke', () => {
+  test('doctor reports check results', () => {
+    const { stdout } = run('doctor');
+    const data = parseJson(stdout) as { checks: unknown[] };
+    expect(data.checks).toBeInstanceOf(Array);
+    expect(data.checks.length).toBeGreaterThan(0);
+    // If API key is valid, ok should be true; either way the shape is correct
+    expect(data).toHaveProperty('ok');
+  });
+
+  test('domains list returns valid json', () => {
+    const { stdout, exitCode } = run('domains', 'list');
+    expect(exitCode).toBe(0);
+    const data = parseJson(stdout) as { object: string; data: unknown[] };
+    expect(data.object).toBe('list');
+    expect(data.data).toBeInstanceOf(Array);
+  });
+
+  test('api-keys list returns valid json', () => {
+    const { stdout, exitCode } = run('api-keys', 'list');
+    expect(exitCode).toBe(0);
+    const data = parseJson(stdout) as { object: string; data: unknown[] };
+    expect(data.object).toBe('list');
+    expect(data.data).toBeInstanceOf(Array);
+  });
+
+  test('broadcasts list returns valid json', () => {
+    const { stdout, exitCode } = run('broadcasts', 'list');
+    expect(exitCode).toBe(0);
+    const data = parseJson(stdout) as { object: string; data: unknown[] };
+    expect(data.object).toBe('list');
+    expect(data.data).toBeInstanceOf(Array);
+  });
+
+  test('webhooks list returns valid json', () => {
+    const { stdout, exitCode } = run('webhooks', 'list');
+    expect(exitCode).toBe(0);
+    const data = parseJson(stdout) as { object: string; data: unknown[] };
+    expect(data.object).toBe('list');
+    expect(data.data).toBeInstanceOf(Array);
+  });
+
+  test('topics list returns valid json', () => {
+    const { stdout, exitCode } = run('topics', 'list');
+    expect(exitCode).toBe(0);
+    const data = parseJson(stdout) as { object: string; data: unknown[] };
+    expect(data.object).toBe('list');
+    expect(data.data).toBeInstanceOf(Array);
+  });
+});

package/temp_resend_cli/repo/tests/helpers.ts

@@ -0,0 +1,86 @@
+import { expect, type MockInstance, vi } from 'vitest';
+
+export class ExitError extends Error {
+  constructor(public code: number) {
+    super(`process.exit(${code})`);
+  }
+}
+
+export function setNonInteractive(): void {
+  Object.defineProperty(process.stdin, 'isTTY', {
+    value: undefined,
+    writable: true,
+  });
+  Object.defineProperty(process.stdout, 'isTTY', {
+    value: undefined,
+    writable: true,
+  });
+}
+
+export function mockExitThrow(): MockInstance {
+  return vi.spyOn(process, 'exit').mockImplementation((code?: number) => {
+    throw new ExitError(code ?? 0);
+  });
+}
+
+/**
+ * Captures current env and TTY state and returns a function that restores it.
+ * Call once at the top of a describe block (not inside beforeEach) so state
+ * is captured before any test runs.
+ */
+export function captureTestEnv(): () => void {
+  const originalEnv = { ...process.env };
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  return () => {
+    process.env = { ...originalEnv };
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+  };
+}
+
+/**
+ * Sets non-interactive mode and mocks console.log + process.stderr.write.
+ * Returns the spies and a restore() function. Use in happy-path tests.
+ */
+export function setupOutputSpies() {
+  setNonInteractive();
+  const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  const stderrSpy = vi
+    .spyOn(process.stderr, 'write')
+    .mockImplementation(() => true);
+  return { logSpy, stderrSpy };
+}
+
+/**
+ * Asserts that fn throws ExitError with code 1.
+ * Eliminates the expect(true).toBe(false) anti-pattern in error-path tests.
+ */
+/**
+ * Returns a properly-typed SDK error response without needing `as any`.
+ */
+export function mockSdkError(message: string, name = 'error') {
+  return { data: null, error: { message, name }, headers: null };
+}
+
+export async function expectExit1(fn: () => Promise<unknown>): Promise<void> {
+  let threw = false;
+  try {
+    await fn();
+  } catch (err) {
+    threw = true;
+    expect(err).toBeInstanceOf(ExitError);
+    expect((err as ExitError).code).toBe(1);
+  }
+  if (!threw) {
+    throw new Error(
+      'Expected command to exit with code 1 but it completed successfully',
+    );
+  }
+}