superacli 1.1.4 → 1.1.6

package/temp_resend_cli/repo/tests/lib/client.test.ts

@@ -0,0 +1,71 @@
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Resend } from 'resend';
+import { afterEach, describe, expect, test } from 'vitest';
+import { captureTestEnv } from '../helpers';
+
+describe('createClient', () => {
+  const restoreEnv = captureTestEnv();
+
+  afterEach(() => {
+    restoreEnv();
+  });
+
+  test('returns Resend instance when flag value provided', async () => {
+    const { createClient } = await import('../../src/lib/client');
+    const client = createClient('re_test_key');
+    expect(client).toBeInstanceOf(Resend);
+  });
+
+  test('returns Resend instance when env var set', async () => {
+    process.env.RESEND_API_KEY = 're_env_key';
+    const { createClient } = await import('../../src/lib/client');
+    const client = createClient();
+    expect(client).toBeInstanceOf(Resend);
+  });
+
+  test('throws when no API key available', async () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend-test';
+    const { createClient } = await import('../../src/lib/client');
+    expect(() => createClient()).toThrow('No API key found');
+  });
+
+  test('flag value takes priority over env var', async () => {
+    process.env.RESEND_API_KEY = 're_env_key';
+    const { createClient } = await import('../../src/lib/client');
+    const client = createClient('re_flag_key');
+    expect(client).toBeInstanceOf(Resend);
+  });
+
+  test('team name is threaded through to resolveApiKey', async () => {
+    delete process.env.RESEND_API_KEY;
+    const tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmpDir, { recursive: true });
+    process.env.XDG_CONFIG_HOME = tmpDir;
+
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'default',
+        teams: {
+          default: { api_key: 're_default_key' },
+          staging: { api_key: 're_staging_key' },
+        },
+      }),
+    );
+
+    const { createClient } = await import('../../src/lib/client');
+    // Should not throw — resolves staging team's key
+    const client = createClient(undefined, 'staging');
+    expect(client).toBeInstanceOf(Resend);
+
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+});

package/temp_resend_cli/repo/tests/lib/config.test.ts

@@ -0,0 +1,451 @@
+import {
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import {
+  getConfigDir,
+  listTeams,
+  removeApiKey,
+  resolveApiKey,
+  resolveTeamName,
+  setActiveTeam,
+  storeApiKey,
+  validateTeamName,
+} 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 });
+    writeFileSync(
+      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 });
+    writeFileSync(
+      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 });
+    writeFileSync(
+      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 });
+    writeFileSync(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 });
+    writeFileSync(
+      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 });
+    writeFileSync(
+      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('removeApiKey', () => {
+  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');
+
+    removeApiKey('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');
+
+    removeApiKey('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');
+
+    removeApiKey('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(() => removeApiKey('nonexistent')).toThrow('not found');
+  });
+
+  test('throws when no credentials file', () => {
+    expect(() => removeApiKey('any')).toThrow('No credentials file');
+  });
+});
+
+describe('validateTeamName', () => {
+  test('accepts valid names', () => {
+    expect(validateTeamName('default')).toBeUndefined();
+    expect(validateTeamName('my-team')).toBeUndefined();
+    expect(validateTeamName('team_1')).toBeUndefined();
+    expect(validateTeamName('prod-2024')).toBeUndefined();
+    expect(validateTeamName('Production')).toBeUndefined();
+    expect(validateTeamName('MyTeam')).toBeUndefined();
+  });
+
+  test('rejects spaces and special characters', () => {
+    expect(validateTeamName('my team')).toContain('letters');
+    expect(validateTeamName('team@org')).toContain('letters');
+  });
+
+  test('rejects empty name', () => {
+    expect(validateTeamName('')).toContain('empty');
+  });
+
+  test('rejects names longer than 64 characters', () => {
+    const longName = 'a'.repeat(65);
+    expect(validateTeamName(longName)).toContain('64');
+  });
+
+  test('accepts name exactly 64 characters', () => {
+    const maxName = 'a'.repeat(64);
+    expect(validateTeamName(maxName)).toBeUndefined();
+  });
+});

package/temp_resend_cli/repo/tests/lib/files.test.ts

@@ -0,0 +1,73 @@
+import { unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  afterEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import { expectExit1, mockExitThrow } from '../helpers';
+
+const globalOpts = { json: false, apiKey: undefined };
+const jsonOpts = { json: true, apiKey: undefined };
+
+describe('readFile', () => {
+  const tmpFile = join(dirname(fileURLToPath(import.meta.url)), 'tmp-test.txt');
+  let errorSpy: MockInstance | undefined;
+  let exitSpy: MockInstance | 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', async () => {
+    writeFileSync(tmpFile, '<h1>Hello</h1>', 'utf-8');
+    const { readFile } = await import('../../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', async () => {
+    writeFileSync(tmpFile, '[{"id":1}]', 'utf-8');
+    const { readFile } = await import('../../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 = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { readFile } = await import('../../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 = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { readFile } = await import('../../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/temp_resend_cli/repo/tests/lib/help-text.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+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');
+  });
+});