resend-cli 1.0.3 → 1.2.0

package/.claude/worktrees/emails-list/tests/lib/config.test.ts

@@ -0,0 +1,414 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  getConfigDir,
+  listTeams,
+  removeTeam,
+  resolveApiKey,
+  resolveTeamName,
+  setActiveTeam,
+  storeApiKey,
+} from '../../src/lib/config';
+import { captureTestEnv } from '../helpers';
+
+describe('getConfigDir', () => {
+  const restoreEnv = captureTestEnv();
+
+  afterEach(() => {
+    restoreEnv();
+  });
+
+  test('respects XDG_CONFIG_HOME', () => {
+    process.env.XDG_CONFIG_HOME = '/custom/config';
+    expect(getConfigDir()).toBe('/custom/config/resend');
+  });
+
+  test('falls back to ~/.config/resend on non-Windows', () => {
+    delete process.env.XDG_CONFIG_HOME;
+    const dir = getConfigDir();
+    expect(dir).toMatch(/\.config\/resend$/);
+  });
+});
+
+describe('resolveApiKey', () => {
+  const restoreEnv = captureTestEnv();
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmpDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('flag value takes highest priority', () => {
+    process.env.RESEND_API_KEY = 're_env_key';
+    const result = resolveApiKey('re_flag_key');
+    expect(result).toEqual({ key: 're_flag_key', source: 'flag' });
+  });
+
+  test('env var is second priority', () => {
+    process.env.RESEND_API_KEY = 're_env_key';
+    const result = resolveApiKey();
+    expect(result).toEqual({ key: 're_env_key', source: 'env' });
+  });
+
+  test('config file is third priority', () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = tmpDir;
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    Bun.write(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'default',
+        teams: { default: { api_key: 're_config_key' } },
+      }),
+    );
+
+    const result = resolveApiKey();
+    expect(result).toEqual({
+      key: 're_config_key',
+      source: 'config',
+      team: 'default',
+    });
+  });
+
+  test('reads legacy format (api_key at root)', () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = tmpDir;
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    Bun.write(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({ api_key: 're_legacy_key' }),
+    );
+
+    const result = resolveApiKey();
+    expect(result).toEqual({
+      key: 're_legacy_key',
+      source: 'config',
+      team: 'default',
+    });
+  });
+
+  test('resolves specific team from config', () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = tmpDir;
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    Bun.write(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'default',
+        teams: {
+          default: { api_key: 're_default' },
+          staging: { api_key: 're_staging' },
+        },
+      }),
+    );
+
+    const result = resolveApiKey(undefined, 'staging');
+    expect(result).toEqual({
+      key: 're_staging',
+      source: 'config',
+      team: 'staging',
+    });
+  });
+
+  test('returns null when no key found', () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = tmpDir;
+    const result = resolveApiKey();
+    expect(result).toBeNull();
+  });
+
+  test('returns null on malformed config JSON', () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = tmpDir;
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    Bun.write(join(configDir, 'credentials.json'), 'not json');
+
+    const result = resolveApiKey();
+    expect(result).toBeNull();
+  });
+
+  test('returns null when team does not exist in config', () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = tmpDir;
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    Bun.write(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'default',
+        teams: { default: { api_key: 're_default' } },
+      }),
+    );
+
+    const result = resolveApiKey(undefined, 'nonexistent');
+    expect(result).toBeNull();
+  });
+});
+
+describe('resolveTeamName', () => {
+  const restoreEnv = captureTestEnv();
+  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();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('flag value takes highest priority', () => {
+    process.env.RESEND_TEAM = 'env_team';
+    expect(resolveTeamName('flag_team')).toBe('flag_team');
+  });
+
+  test('env var is second priority', () => {
+    process.env.RESEND_TEAM = 'env_team';
+    expect(resolveTeamName()).toBe('env_team');
+  });
+
+  test('active_team from config is third priority', () => {
+    delete process.env.RESEND_TEAM;
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    Bun.write(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'production',
+        teams: { production: { api_key: 're_xxx' } },
+      }),
+    );
+
+    expect(resolveTeamName()).toBe('production');
+  });
+
+  test('defaults to "default" when nothing configured', () => {
+    delete process.env.RESEND_TEAM;
+    expect(resolveTeamName()).toBe('default');
+  });
+});
+
+describe('storeApiKey', () => {
+  const restoreEnv = captureTestEnv();
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    process.env.XDG_CONFIG_HOME = tmpDir;
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('writes credentials.json with team structure', () => {
+    const configPath = storeApiKey('re_test_key_123');
+    expect(configPath).toContain('credentials.json');
+
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.active_team).toBe('default');
+    expect(data.teams.default.api_key).toBe('re_test_key_123');
+  });
+
+  test('stores key under specific team name', () => {
+    const configPath = storeApiKey('re_staging_key', 'staging');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.teams.staging.api_key).toBe('re_staging_key');
+  });
+
+  test('preserves existing teams when adding new one', () => {
+    storeApiKey('re_default_key');
+    storeApiKey('re_staging_key', 'staging');
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.teams.default.api_key).toBe('re_default_key');
+    expect(data.teams.staging.api_key).toBe('re_staging_key');
+  });
+
+  test('creates config directory if it does not exist', () => {
+    storeApiKey('re_test_key');
+    const configDir = join(tmpDir, 'resend');
+    const stat = statSync(configDir);
+    expect(stat.isDirectory()).toBe(true);
+  });
+
+  test('sets file permissions to 0600', () => {
+    const configPath = storeApiKey('re_test_key');
+    const stat = statSync(configPath);
+    const mode = stat.mode & 0o777;
+    expect(mode).toBe(0o600);
+  });
+
+  test('overwrites existing team key', () => {
+    storeApiKey('re_first_key');
+    storeApiKey('re_second_key');
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.teams.default.api_key).toBe('re_second_key');
+  });
+
+  test('sets first team as active', () => {
+    storeApiKey('re_first_key', 'myteam');
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.active_team).toBe('myteam');
+  });
+});
+
+describe('listTeams', () => {
+  const restoreEnv = captureTestEnv();
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    process.env.XDG_CONFIG_HOME = tmpDir;
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('returns empty array when no config', () => {
+    expect(listTeams()).toEqual([]);
+  });
+
+  test('returns teams with active flag', () => {
+    storeApiKey('re_default', 'default');
+    storeApiKey('re_staging', 'staging');
+
+    const teams = listTeams();
+    expect(teams).toEqual([
+      { name: 'default', active: true },
+      { name: 'staging', active: false },
+    ]);
+  });
+});
+
+describe('setActiveTeam', () => {
+  const restoreEnv = captureTestEnv();
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    process.env.XDG_CONFIG_HOME = tmpDir;
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('switches active team', () => {
+    storeApiKey('re_default', 'default');
+    storeApiKey('re_staging', 'staging');
+
+    setActiveTeam('staging');
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.active_team).toBe('staging');
+  });
+
+  test('throws when team does not exist', () => {
+    storeApiKey('re_default');
+    expect(() => setActiveTeam('nonexistent')).toThrow('not found');
+  });
+
+  test('throws when no credentials file', () => {
+    expect(() => setActiveTeam('any')).toThrow('No credentials file');
+  });
+});
+
+describe('removeTeam', () => {
+  const restoreEnv = captureTestEnv();
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    process.env.XDG_CONFIG_HOME = tmpDir;
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('removes a team entry', () => {
+    storeApiKey('re_default', 'default');
+    storeApiKey('re_staging', 'staging');
+
+    removeTeam('staging');
+
+    const teams = listTeams();
+    expect(teams).toEqual([{ name: 'default', active: true }]);
+  });
+
+  test('adjusts active_team when active is removed', () => {
+    storeApiKey('re_default', 'default');
+    storeApiKey('re_staging', 'staging');
+    setActiveTeam('staging');
+
+    removeTeam('staging');
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.active_team).toBe('default');
+  });
+
+  test('deletes file when last team removed', () => {
+    storeApiKey('re_only', 'only');
+
+    removeTeam('only');
+
+    const { existsSync } = require('node:fs');
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    expect(existsSync(configPath)).toBe(false);
+  });
+
+  test('throws when team does not exist', () => {
+    storeApiKey('re_default');
+    expect(() => removeTeam('nonexistent')).toThrow('not found');
+  });
+
+  test('throws when no credentials file', () => {
+    expect(() => removeTeam('any')).toThrow('No credentials file');
+  });
+});

package/.claude/worktrees/emails-list/tests/lib/files.test.ts

@@ -0,0 +1,65 @@
+import { afterEach, describe, expect, spyOn, test } from 'bun:test';
+import { unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { expectExit1, mockExitThrow } from '../helpers';
+
+const globalOpts = { json: false, apiKey: undefined };
+const jsonOpts = { json: true, apiKey: undefined };
+
+describe('readFile', () => {
+  const tmpFile = join(import.meta.dir, 'tmp-test.txt');
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy?.mockRestore();
+    exitSpy = undefined;
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+      /* already removed */
+    }
+  });
+
+  test('reads file content and returns it as a string', () => {
+    writeFileSync(tmpFile, '<h1>Hello</h1>', 'utf-8');
+    const { readFile } = require('../../src/lib/files');
+    const content = readFile(tmpFile, globalOpts);
+    expect(content).toBe('<h1>Hello</h1>');
+  });
+
+  test('reads JSON file content and returns it as a string', () => {
+    writeFileSync(tmpFile, '[{"id":1}]', 'utf-8');
+    const { readFile } = require('../../src/lib/files');
+    const content = readFile(tmpFile, globalOpts);
+    expect(content).toBe('[{"id":1}]');
+  });
+
+  test('exits with file_read_error when file does not exist', async () => {
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { readFile } = require('../../src/lib/files');
+    await expectExit1(async () =>
+      readFile('/nonexistent/path/data.txt', globalOpts),
+    );
+
+    const output = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('Failed to read file:');
+  });
+
+  test('outputs JSON error with file_read_error code when json option is true', async () => {
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { readFile } = require('../../src/lib/files');
+    await expectExit1(async () => readFile('/nonexistent/file.txt', jsonOpts));
+
+    const raw = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    const parsed = JSON.parse(raw);
+    expect(parsed.error.code).toBe('file_read_error');
+    expect(parsed.error.message).toContain('Failed to read file:');
+  });
+});

package/.claude/worktrees/emails-list/tests/lib/help-text.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'bun:test';
+import { buildHelpText } from '../../src/lib/help-text';
+
+describe('buildHelpText', () => {
+  it('full leaf command — all options, setup: false', () => {
+    const result = buildHelpText({
+      context: 'Some context line\n\nNon-interactive: --required-flag <value>',
+      output: '  {"id":"em_123"}',
+      errorCodes: ['auth_error', 'send_error'],
+      examples: [
+        'resend emails send --to user@example.com --subject Hi --text Hello',
+      ],
+      setup: false,
+    });
+
+    expect(result).toBe(
+      '\n' +
+        'Some context line\n\nNon-interactive: --required-flag <value>' +
+        '\n\n' +
+        'Global options:\n' +
+        '  --api-key <key>   API key (or set RESEND_API_KEY env var)\n' +
+        '  --team <name>     Team profile to use (overrides RESEND_TEAM)\n' +
+        '  --json            Force JSON output (also auto-enabled when stdout is piped)\n' +
+        '  -q, --quiet       Suppress spinners and status output (implies --json)' +
+        '\n\n' +
+        'Output (--json or piped):\n' +
+        '  {"id":"em_123"}' +
+        '\n\n' +
+        'Errors (exit code 1):\n' +
+        '  {"error":{"message":"<message>","code":"<code>"}}\n' +
+        '  Codes: auth_error | send_error' +
+        '\n\n' +
+        'Examples:\n' +
+        '  $ resend emails send --to user@example.com --subject Hi --text Hello',
+    );
+  });
+
+  it('setup variant — no --api-key line, short --json form', () => {
+    const result = buildHelpText({
+      context: 'Setup context',
+      output: '  {"configured":true}',
+      errorCodes: ['write_error'],
+      examples: ['resend setup cursor'],
+      setup: true,
+    });
+
+    expect(result).not.toContain('--api-key');
+    expect(result).toContain('--json         Force JSON output');
+    expect(result).not.toContain('--json            Force JSON output');
+    expect(result).toContain('Global options:');
+  });
+
+  it('index command — no output, no errorCodes', () => {
+    const result = buildHelpText({
+      context: 'Manage emails.',
+      examples: ['resend emails send', 'resend emails receiving list'],
+    });
+
+    expect(result).not.toContain('Output (--json or piped):');
+    expect(result).not.toContain('Errors (exit code 1):');
+    expect(result).toContain('Global options:');
+    expect(result).toContain('Examples:');
+    expect(result).toContain('  $ resend emails send');
+    expect(result).toContain('  $ resend emails receiving list');
+  });
+
+  it('no context — string starts with newline then Global options header directly', () => {
+    const result = buildHelpText({
+      output: '  {"id":"dm_abc"}',
+      errorCodes: ['auth_error'],
+      examples: ['resend domains list'],
+    });
+
+    expect(result.startsWith('\nGlobal options:')).toBe(true);
+  });
+
+  it('multi-line output — verbatim after the Output header', () => {
+    const multiLineOutput =
+      '  {"id":"em_123"}\n  // or with all fields:\n  {"id":"em_456","to":["a@b.com"]}';
+    const result = buildHelpText({
+      output: multiLineOutput,
+      errorCodes: ['auth_error'],
+      examples: ['resend emails send --to a@b.com --subject Hi --text Hi'],
+    });
+
+    expect(result).toContain(`Output (--json or piped):\n${multiLineOutput}`);
+  });
+
+  it('error codes join — uses " | " separator', () => {
+    const result = buildHelpText({
+      errorCodes: ['auth_error', 'list_error', 'fetch_error'],
+      examples: ['resend domains list'],
+    });
+
+    expect(result).toContain('Codes: auth_error | list_error | fetch_error');
+  });
+});

package/.claude/worktrees/emails-list/tests/lib/output.test.ts

@@ -0,0 +1,127 @@
+import { afterEach, describe, expect, spyOn, test } from 'bun:test';
+import { outputError, outputResult } from '../../src/lib/output';
+
+describe('outputResult', () => {
+  let logSpy: ReturnType<typeof spyOn>;
+  const originalIsTTY = process.stdout.isTTY;
+
+  afterEach(() => {
+    logSpy?.mockRestore();
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalIsTTY,
+      writable: true,
+    });
+  });
+
+  test('outputs JSON when json option is true', () => {
+    logSpy = spyOn(console, 'log').mockImplementation(() => {});
+    outputResult({ id: '123' }, { json: true });
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: '123' }, null, 2));
+  });
+
+  test('outputs JSON when stdout is not TTY', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    logSpy = spyOn(console, 'log').mockImplementation(() => {});
+    outputResult({ id: '123' });
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: '123' }, null, 2));
+  });
+
+  test('outputs string directly for human-readable mode', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    logSpy = spyOn(console, 'log').mockImplementation(() => {});
+    outputResult('Email sent successfully');
+    expect(logSpy).toHaveBeenCalledWith('Email sent successfully');
+  });
+
+  test('outputs JSON for objects in human mode (fallback)', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    logSpy = spyOn(console, 'log').mockImplementation(() => {});
+    outputResult({ id: '123' });
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: '123' }, null, 2));
+  });
+});
+
+describe('outputError', () => {
+  let errorSpy: ReturnType<typeof spyOn>;
+  let exitSpy: ReturnType<typeof spyOn>;
+  const originalIsTTY = process.stdout.isTTY;
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalIsTTY,
+      writable: true,
+    });
+  });
+
+  test('outputs JSON error when json is true', () => {
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = spyOn(process, 'exit').mockImplementation(
+      () => undefined as never,
+    );
+
+    outputError({ message: 'not found', code: 'not_found' }, { json: true });
+
+    const expected = JSON.stringify(
+      { error: { message: 'not found', code: 'not_found' } },
+      null,
+      2,
+    );
+    expect(errorSpy).toHaveBeenCalledWith(expected);
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test('outputs text error when TTY and no json flag', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = spyOn(process, 'exit').mockImplementation(
+      () => undefined as never,
+    );
+
+    outputError({ message: 'something broke' });
+
+    expect(errorSpy).toHaveBeenCalledWith('Error: something broke');
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test('uses custom exit code', () => {
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = spyOn(process, 'exit').mockImplementation(
+      () => undefined as never,
+    );
+
+    outputError({ message: 'error' }, { exitCode: 2, json: true });
+
+    expect(exitSpy).toHaveBeenCalledWith(2);
+  });
+
+  test('defaults error code to "unknown" when not provided', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = spyOn(process, 'exit').mockImplementation(
+      () => undefined as never,
+    );
+
+    outputError({ message: 'oops' });
+
+    const output = errorSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.error.code).toBe('unknown');
+  });
+});