resend-cli 1.1.0 → 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/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
   lint:
     runs-on: blacksmith-2vcpu-ubuntu-2204
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: oven-sh/setup-bun@v2
       - run: bun install --frozen-lockfile
       - run: bun run lint
@@ -18,7 +18,7 @@ jobs:
   typecheck:
     runs-on: blacksmith-2vcpu-ubuntu-2204
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: oven-sh/setup-bun@v2
       - run: bun install --frozen-lockfile
       - run: bun run typecheck
@@ -26,7 +26,7 @@ jobs:
   test:
     runs-on: blacksmith-2vcpu-ubuntu-2204
     steps:
-      - uses: actions/checkout@v4
+      - 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

@@ -9,5 +9,5 @@ jobs:
   pr-title-check:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - run: node .github/scripts/pr-title-check.js

package/.github/workflows/release.yml

@@ -12,7 +12,7 @@ jobs:
   release:
     runs-on: blacksmith-2vcpu-ubuntu-2204
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - uses: oven-sh/setup-bun@v2
 
@@ -25,7 +25,7 @@ jobs:
           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 --bytecode src/cli.ts --target=bun-windows-x64   --outfile dist/resend-windows-x64.exe
+          bun build --compile --minify --sourcemap src/cli.ts --target=bun-windows-x64   --outfile dist/resend-windows-x64.exe
 
       - name: Verify binaries
         run: |

package/.github/workflows/test-build-windows.yml

@@ -0,0 +1,44 @@
+name: Test Windows Build
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    paths:
+      - src/**
+      - .github/workflows/test-build-windows.yml
+      - .github/workflows/release.yml
+      - bun.lock
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: oven-sh/setup-bun@v2
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Build Windows binary
+        run: bun build --compile --minify --sourcemap src/cli.ts --target=bun-windows-x64 --outfile dist/resend-windows-x64.exe
+
+      - name: Verify binary exists
+        shell: pwsh
+        run: |
+          if (-not (Test-Path dist\resend-windows-x64.exe)) {
+            Write-Error "Binary not found"
+            exit 1
+          }
+
+      - name: Verify binary runs
+        shell: pwsh
+        run: |
+          & dist\resend-windows-x64.exe --version
+          if ($LASTEXITCODE -ne 0) {
+            Write-Error "resend --version failed"
+            exit 1
+          }

package/.github/workflows/test-install-windows.yml

@@ -0,0 +1,48 @@
+name: Test Windows Installer
+
+on:
+  pull_request:
+    paths:
+      - install.ps1
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Run install.ps1 from repo
+        shell: pwsh
+        run: .\install.ps1
+
+      - name: Verify binary exists
+        shell: pwsh
+        run: |
+          $exe = "$env:USERPROFILE\.resend\bin\resend.exe"
+          if (-not (Test-Path $exe)) {
+            Write-Error "Binary not found at $exe"
+            exit 1
+          }
+          Write-Host "Found binary at $exe"
+
+      - name: Verify binary runs
+        shell: pwsh
+        run: |
+          $exe = "$env:USERPROFILE\.resend\bin\resend.exe"
+          & $exe --version
+          if ($LASTEXITCODE -ne 0) {
+            Write-Error "resend --version failed"
+            exit 1
+          }
+
+      - name: Verify PATH was updated
+        shell: pwsh
+        run: |
+          $binDir = "$env:USERPROFILE\.resend\bin"
+          $path = [Environment]::GetEnvironmentVariable("PATH", "User")
+          if ($path -notlike "*$binDir*") {
+            Write-Error "$binDir was not added to PATH"
+            exit 1
+          }
+          Write-Host "PATH correctly updated"

package/README.md

@@ -4,6 +4,14 @@ Command-line interface for the [Resend](https://resend.com) email API. Works for
 
 ## Install
 
+### Homebrew (macOS)
+
+```bash
+brew install resend/cli/resend
+```
+
+### Shell script (macOS and Linux)
+
 ```bash
 curl -fsSL https://resend.com/install.sh | bash
 ```