resend-cli 1.0.3 → 1.2.0

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

@@ -0,0 +1,178 @@
+import { afterEach, describe, expect, spyOn, test } from 'bun:test';
+import { expectExit1, mockExitThrow } from '../helpers';
+
+describe('promptForMissing', () => {
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy = undefined;
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+  });
+
+  test('returns options unchanged when nothing is missing', async () => {
+    const { promptForMissing } = require('../../src/lib/prompts');
+    const opts = { from: 'a@b.com', to: 'c@d.com', subject: 'Hi' };
+    const result = await promptForMissing(
+      opts,
+      [
+        { flag: 'from', message: 'From' },
+        { flag: 'to', message: 'To' },
+        { flag: 'subject', message: 'Subject' },
+      ],
+      {},
+    );
+    expect(result).toEqual(opts);
+  });
+
+  test('exits with missing_flags error in non-interactive mode', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { promptForMissing } = require('../../src/lib/prompts');
+
+    await expectExit1(() =>
+      promptForMissing(
+        { from: undefined, to: 'c@d.com', subject: undefined },
+        [
+          { flag: 'from', message: 'From' },
+          { flag: 'to', message: 'To' },
+          { flag: 'subject', message: 'Subject' },
+        ],
+        {},
+      ),
+    );
+
+    const allErrors = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(allErrors).toContain('--from');
+    expect(allErrors).toContain('--subject');
+    // --to should NOT be listed since it has a value
+    expect(allErrors).not.toContain('--to,');
+  });
+
+  test('errors output includes missing_flags code', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { promptForMissing } = require('../../src/lib/prompts');
+
+    await expectExit1(() =>
+      promptForMissing(
+        { from: undefined },
+        [{ flag: 'from', message: 'From' }],
+        {},
+      ),
+    );
+
+    const allErrors = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(allErrors).toContain('missing_flags');
+  });
+
+  test('skips fields marked as required=false', async () => {
+    const { promptForMissing } = require('../../src/lib/prompts');
+    const opts = { from: 'a@b.com', to: undefined };
+    const result = await promptForMissing(
+      opts,
+      [
+        { flag: 'from', message: 'From' },
+        { flag: 'to', message: 'To', required: false },
+      ],
+      {},
+    );
+    expect(result).toEqual(opts);
+  });
+});
+
+describe('confirmDelete', () => {
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy = undefined;
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+  });
+
+  test('exits with confirmation_required when non-interactive', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { confirmDelete } = require('../../src/lib/prompts');
+
+    await expectExit1(() =>
+      confirmDelete('res_123', 'Delete resource res_123?', { json: false }),
+    );
+
+    const output = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('confirmation_required');
+  });
+
+  test('outputs JSON confirmation_required error when json option is true', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { confirmDelete } = require('../../src/lib/prompts');
+    await expectExit1(() =>
+      confirmDelete('res_123', 'Delete?', { json: true }),
+    );
+
+    const raw = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    const parsed = JSON.parse(raw);
+    expect(parsed.error.code).toBe('confirmation_required');
+  });
+});

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

@@ -0,0 +1,146 @@
+import { afterEach, describe, expect, spyOn, test } from 'bun:test';
+
+describe('createSpinner', () => {
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  let stderrSpy: ReturnType<typeof spyOn>;
+
+  afterEach(() => {
+    stderrSpy?.mockRestore();
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+    delete process.env.CI;
+  });
+
+  test('returns no-op spinner in non-interactive mode', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('test message');
+
+    // Should not throw when calling any method
+    expect(() => spinner.stop('done')).not.toThrow();
+    expect(() => spinner.fail('error')).not.toThrow();
+    expect(() => spinner.warn('warning')).not.toThrow();
+    expect(() => spinner.update('updating')).not.toThrow();
+  });
+
+  test('returns functional spinner in interactive mode', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+
+    expect(spinner).toHaveProperty('stop');
+    expect(spinner).toHaveProperty('fail');
+    expect(spinner).toHaveProperty('warn');
+    expect(spinner).toHaveProperty('update');
+
+    // Stop to clean up the interval
+    spinner.stop('done');
+    expect(stderrSpy).toHaveBeenCalled();
+  });
+
+  test('stop writes checkmark to stderr', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+    spinner.stop('completed');
+
+    const lastCall = stderrSpy.mock.calls[
+      stderrSpy.mock.calls.length - 1
+    ][0] as string;
+    expect(lastCall).toContain('✔');
+    expect(lastCall).toContain('completed');
+  });
+
+  test('fail writes cross mark to stderr', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+    spinner.fail('error occurred');
+
+    const lastCall = stderrSpy.mock.calls[
+      stderrSpy.mock.calls.length - 1
+    ][0] as string;
+    expect(lastCall).toContain('✗');
+    expect(lastCall).toContain('error occurred');
+  });
+
+  test('warn writes warning icon to stderr', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+    spinner.warn('watch out');
+
+    const lastCall = stderrSpy.mock.calls[
+      stderrSpy.mock.calls.length - 1
+    ][0] as string;
+    expect(lastCall).toContain('⚠');
+    expect(lastCall).toContain('watch out');
+  });
+});

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

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'bun:test';
+import { renderTable } from '../../src/lib/table';
+
+describe('renderTable', () => {
+  test('renders a table with correct border characters', () => {
+    const output = renderTable(['Name', 'ID'], [['Alice', 'abc-123']]);
+    expect(output).toContain('┌');
+    expect(output).toContain('┐');
+    expect(output).toContain('└');
+    expect(output).toContain('┘');
+    expect(output).toContain('│');
+  });
+
+  test('includes headers in output', () => {
+    const output = renderTable(
+      ['Name', 'Status'],
+      [['my-domain.com', 'verified']],
+    );
+    expect(output).toContain('Name');
+    expect(output).toContain('Status');
+  });
+
+  test('includes row data in output', () => {
+    const output = renderTable(
+      ['Name', 'Status'],
+      [['my-domain.com', 'verified']],
+    );
+    expect(output).toContain('my-domain.com');
+    expect(output).toContain('verified');
+  });
+
+  test('pads columns to the widest cell in each column', () => {
+    const output = renderTable(
+      ['Key', 'Value'],
+      [
+        ['short', 'a very long value here'],
+        ['much longer key', 'v'],
+      ],
+    );
+    // All rows should have the same line length
+    const lines = output.split('\n');
+    const lengths = lines.map((l) => l.length);
+    expect(new Set(lengths).size).toBe(1);
+  });
+
+  test('renders multiple rows', () => {
+    const output = renderTable(
+      ['A', 'B'],
+      [
+        ['row1a', 'row1b'],
+        ['row2a', 'row2b'],
+      ],
+    );
+    expect(output).toContain('row1a');
+    expect(output).toContain('row2a');
+  });
+
+  test('contains a separator row between header and data', () => {
+    const output = renderTable(['Col'], [['val']]);
+    expect(output).toContain('├');
+    expect(output).toContain('┤');
+  });
+});

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

@@ -0,0 +1,85 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { captureTestEnv } from '../helpers';
+
+// We need to import the module fresh per test to pick up env changes,
+// so we use dynamic imports.
+
+describe('isInteractive', () => {
+  const restoreEnv = captureTestEnv();
+
+  afterEach(() => {
+    restoreEnv();
+  });
+
+  function setTTY(stdin: boolean, stdout: boolean) {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: stdin ? true : undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: stdout ? true : undefined,
+      writable: true,
+    });
+  }
+
+  test('returns true when stdin and stdout are TTY and no CI env', () => {
+    setTTY(true, true);
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(true);
+  });
+
+  test('returns false when stdin is not TTY', () => {
+    setTTY(false, true);
+    delete process.env.CI;
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when stdout is not TTY', () => {
+    setTTY(true, false);
+    delete process.env.CI;
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when CI=true', () => {
+    setTTY(true, true);
+    process.env.CI = 'true';
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when CI=1', () => {
+    setTTY(true, true);
+    process.env.CI = '1';
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when GITHUB_ACTIONS is set', () => {
+    setTTY(true, true);
+    delete process.env.CI;
+    process.env.GITHUB_ACTIONS = 'true';
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when TERM=dumb', () => {
+    setTTY(true, true);
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    process.env.TERM = 'dumb';
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+});

package/.claude/worktrees/emails-list/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/.github/scripts/pr-title-check.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+
+const eventPath = process.env.GITHUB_EVENT_PATH;
+if (!eventPath) {
+  console.error(
+    'GITHUB_EVENT_PATH is not set. This script must run inside GitHub Actions.',
+  );
+  process.exit(1);
+}
+
+const eventJson = JSON.parse(fs.readFileSync(eventPath, 'utf8'));
+const prTitle = eventJson.pull_request?.title;
+if (!prTitle) {
+  console.error('Could not read pull_request.title from event payload.');
+  process.exit(1);
+}
+
+const isValidType = (title) =>
+  /^(feat|fix|chore|refactor)(\([a-zA-Z0-9-]+\))?:\s[a-z0-9].*$/.test(title);
+
+const validateTitle = (title) => {
+  if (!isValidType(title)) {
+    console.error(
+      `PR title does not follow the required format "[type]: [description]"
+  Examples: "feat: add --cc flag"  |  "fix: domain fetch timeout"
+  Types:    feat · fix · chore · refactor
+  Rules:    lowercase after the colon`,
+    );
+    process.exit(1);
+  }
+  console.info(`PR title valid: "${title}"`);
+};
+
+validateTitle(prTitle);

package/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  lint:
+    runs-on: blacksmith-2vcpu-ubuntu-2204
+    steps:
+      - uses: actions/checkout@v6
+      - uses: oven-sh/setup-bun@v2
+      - run: bun install --frozen-lockfile
+      - run: bun run lint
+
+  typecheck:
+    runs-on: blacksmith-2vcpu-ubuntu-2204
+    steps:
+      - uses: actions/checkout@v6
+      - uses: oven-sh/setup-bun@v2
+      - run: bun install --frozen-lockfile
+      - run: bun run typecheck
+
+  test:
+    runs-on: blacksmith-2vcpu-ubuntu-2204
+    steps:
+      - uses: actions/checkout@v6
+      - uses: oven-sh/setup-bun@v2
+      - run: bun install --frozen-lockfile
+      - run: bun run test

package/.github/workflows/pr-title-check.yml

@@ -0,0 +1,13 @@
+name: PR Title Check
+on:
+  pull_request:
+    types: [opened, edited, synchronize, reopened]
+permissions:
+  contents: read
+  pull-requests: read
+jobs:
+  pr-title-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - run: node .github/scripts/pr-title-check.js

package/.github/workflows/release.yml

@@ -0,0 +1,93 @@
+name: Release
+on:
+  push:
+    tags:
+      - 'v*'
+permissions:
+  contents: write
+concurrency:
+  group: release
+  cancel-in-progress: false
+jobs:
+  release:
+    runs-on: blacksmith-2vcpu-ubuntu-2204
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: oven-sh/setup-bun@v2
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Build binaries
+        run: |
+          bun build --compile --minify --sourcemap --bytecode src/cli.ts --target=bun-darwin-arm64  --outfile dist/resend-darwin-arm64
+          bun build --compile --minify --sourcemap --bytecode src/cli.ts --target=bun-darwin-x64    --outfile dist/resend-darwin-x64
+          bun build --compile --minify --sourcemap --bytecode src/cli.ts --target=bun-linux-x64     --outfile dist/resend-linux-x64
+          bun build --compile --minify --sourcemap --bytecode src/cli.ts --target=bun-linux-arm64   --outfile dist/resend-linux-arm64
+          bun build --compile --minify --sourcemap src/cli.ts --target=bun-windows-x64   --outfile dist/resend-windows-x64.exe
+
+      - name: Verify binaries
+        run: |
+          for f in dist/resend-darwin-arm64 dist/resend-darwin-x64 \
+                    dist/resend-linux-x64 dist/resend-linux-arm64 \
+                    dist/resend-windows-x64.exe; do
+            [ -s "$f" ] || { echo "Missing or empty: $f"; exit 1; }
+          done
+
+      - name: Package archives
+        run: |
+          cd dist
+          for bin in resend-darwin-arm64 resend-darwin-x64 resend-linux-x64 resend-linux-arm64; do
+            cp "$bin" resend
+            chmod +x resend
+            tar -czf "${bin}.tar.gz" resend
+            rm resend
+          done
+          cp resend-windows-x64.exe resend.exe
+          zip resend-windows-x64.zip resend.exe
+          rm resend.exe
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+          body: |
+            ## Install
+
+            **macOS / Linux**
+            ```sh
+            curl -fsSL https://resend.com/install.sh | bash
+            ```
+
+            **Windows (PowerShell)**
+            ```pwsh
+            irm https://resend.com/install.ps1 | iex
+            ```
+
+            **GitHub CLI** _(use while repo is private)_
+            ```sh
+            gh release download --repo resend/resend-cli --pattern "resend-darwin-arm64.tar.gz"
+            tar -xzf resend-darwin-arm64.tar.gz && sudo mv resend /usr/local/bin/ && rm resend-darwin-arm64.tar.gz
+            ```
+          files: |
+            dist/resend-darwin-arm64.tar.gz
+            dist/resend-darwin-x64.tar.gz
+            dist/resend-linux-x64.tar.gz
+            dist/resend-linux-arm64.tar.gz
+            dist/resend-windows-x64.zip
+
+  notify-tap:
+    name: Trigger Homebrew Tap Update
+    needs: release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Dispatch publish-release workflow on tap
+        env:
+          GH_TOKEN: ${{ secrets.RELEASE_CLI_ON_HOMEBREW }}
+        run: |
+          gh workflow run publish-release.yml \
+            --repo resend/homebrew-cli \
+            --field version="${GITHUB_REF_NAME}"