resend-cli 1.2.1 → 1.2.2

package/src/lib/update-check.ts

@@ -0,0 +1,172 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getConfigDir } from './config';
+import { VERSION } from './version';
+
+const CHECK_INTERVAL_MS = 1 * 60 * 60 * 1000; // 1 hour
+export const GITHUB_RELEASES_URL =
+  'https://api.github.com/repos/resend/resend-cli/releases/latest';
+
+type UpdateState = {
+  lastChecked: number;
+  latestVersion: string;
+};
+
+function getStatePath(): string {
+  return join(getConfigDir(), 'update-state.json');
+}
+
+function readState(): UpdateState | null {
+  try {
+    return JSON.parse(readFileSync(getStatePath(), 'utf-8')) as UpdateState;
+  } catch {
+    return null;
+  }
+}
+
+function writeState(state: UpdateState): void {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+  writeFileSync(getStatePath(), JSON.stringify(state), { mode: 0o600 });
+}
+
+/**
+ * Compare two semver strings. Returns true if remote > local.
+ */
+function isNewer(local: string, remote: string): boolean {
+  const parse = (v: string) => v.replace(/^v/, '').split('.').map(Number);
+  const [lMaj, lMin, lPat] = parse(local);
+  const [rMaj, rMin, rPat] = parse(remote);
+  if (rMaj !== lMaj) {
+    return rMaj > lMaj;
+  }
+  if (rMin !== lMin) {
+    return rMin > lMin;
+  }
+  return rPat > lPat;
+}
+
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const res = await fetch(GITHUB_RELEASES_URL, {
+      headers: { Accept: 'application/vnd.github.v3+json' },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) {
+      return null;
+    }
+    const data = (await res.json()) as {
+      tag_name?: string;
+      prerelease?: boolean;
+      draft?: boolean;
+    };
+    // /releases/latest already excludes prereleases, but guard anyway
+    if (data.prerelease || data.draft) {
+      return null;
+    }
+    const version = data.tag_name?.replace(/^v/, '');
+    if (!version || !/^\d+\.\d+\.\d+$/.test(version)) {
+      return null;
+    }
+    return version;
+  } catch {
+    return null;
+  }
+}
+
+function shouldSkipCheck(): boolean {
+  if (process.env.RESEND_NO_UPDATE_NOTIFIER === '1') {
+    return true;
+  }
+  if (process.env.CI === 'true' || process.env.CI === '1') {
+    return true;
+  }
+  if (process.env.GITHUB_ACTIONS) {
+    return true;
+  }
+  if (!process.stdout.isTTY) {
+    return true;
+  }
+  return false;
+}
+
+function detectInstallMethod(): string {
+  const execPath = process.execPath || process.argv[0] || '';
+
+  // Homebrew
+  if (/\/(Cellar|homebrew)\//i.test(execPath)) {
+    return 'brew upgrade resend';
+  }
+
+  // npm / npx global install
+  if (/node_modules/.test(execPath) || process.env.npm_execpath) {
+    return 'npm install -g resend-cli';
+  }
+
+  // Install script (default install location)
+  if (/[/\\]\.resend[/\\]bin[/\\]/.test(execPath)) {
+    if (process.platform === 'win32') {
+      return 'irm https://resend.com/install.ps1 | iex';
+    }
+    return 'curl -fsSL https://resend.com/install.sh | bash';
+  }
+
+  // Default: install script
+  if (process.platform === 'win32') {
+    return 'irm https://resend.com/install.ps1 | iex';
+  }
+  return 'curl -fsSL https://resend.com/install.sh | bash';
+}
+
+function formatNotice(latestVersion: string): string {
+  const upgrade = detectInstallMethod();
+  const isUrl = upgrade.startsWith('http');
+
+  const dim = '\x1B[2m';
+  const yellow = '\x1B[33m';
+  const cyan = '\x1B[36m';
+  const reset = '\x1B[0m';
+
+  return [
+    '',
+    `${dim}Update available: ${yellow}v${VERSION}${reset}${dim} → ${cyan}v${latestVersion}${reset}`,
+    `${dim}${isUrl ? 'Visit' : 'Run'}: ${cyan}${upgrade}${reset}`,
+    '',
+  ].join('\n');
+}
+
+/**
+ * Check for updates and print a notice to stderr if one is available.
+ * Designed to be called after the main command completes — never blocks
+ * or throws.
+ */
+export async function checkForUpdates(): Promise<void> {
+  if (shouldSkipCheck()) {
+    return;
+  }
+
+  const state = readState();
+  const now = Date.now();
+
+  // If we have a cached check that's still fresh, just use it
+  if (state && now - state.lastChecked < CHECK_INTERVAL_MS) {
+    if (isNewer(VERSION, state.latestVersion)) {
+      process.stderr.write(formatNotice(state.latestVersion));
+    }
+    return;
+  }
+
+  // Stale or missing — fetch in the background
+  const latest = await fetchLatestVersion();
+  if (!latest) {
+    return;
+  }
+
+  writeState({ lastChecked: now, latestVersion: latest });
+
+  if (isNewer(VERSION, latest)) {
+    process.stderr.write(formatNotice(latest));
+  }
+}

package/tests/commands/auth/login.test.ts

@@ -116,4 +116,41 @@ describe('login command', () => {
     // Original team should still exist
     expect(data.teams.production.api_key).toBe('re_old_key_1234');
   });
+
+  test('auto-switches to team specified via --team flag', async () => {
+    spies = setupOutputSpies();
+
+    const { Command } = await import('@commander-js/extra-typings');
+    const { loginCommand } = await import('../../../src/commands/auth/login');
+    const program = new Command()
+      .option('--team <name>')
+      .option('--json')
+      .option('--api-key <key>')
+      .option('-q, --quiet')
+      .addCommand(loginCommand);
+
+    // First store a default key
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'default',
+        teams: { default: { api_key: 're_old_key_1234' } },
+      }),
+    );
+
+    await program.parseAsync(
+      ['login', '--key', 're_staging_key_123', '--team', 'staging'],
+      { from: 'user' },
+    );
+
+    // @ts-expect-error — reset parent to avoid polluting the shared singleton
+    loginCommand.parent = null;
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.active_team).toBe('staging');
+    expect(data.teams.staging.api_key).toBe('re_staging_key_123');
+  });
 });

package/tests/lib/config.test.ts

@@ -5,11 +5,12 @@ import { join } from 'node:path';
 import {
   getConfigDir,
   listTeams,
-  removeTeam,
+  removeApiKey,
   resolveApiKey,
   resolveTeamName,
   setActiveTeam,
   storeApiKey,
+  validateTeamName,
 } from '../../src/lib/config';
 import { captureTestEnv } from '../helpers';
 
@@ -354,7 +355,7 @@ describe('setActiveTeam', () => {
   });
 });
 
-describe('removeTeam', () => {
+describe('removeApiKey', () => {
   const restoreEnv = captureTestEnv();
   let tmpDir: string;
 
@@ -375,7 +376,7 @@ describe('removeTeam', () => {
     storeApiKey('re_default', 'default');
     storeApiKey('re_staging', 'staging');
 
-    removeTeam('staging');
+    removeApiKey('staging');
 
     const teams = listTeams();
     expect(teams).toEqual([{ name: 'default', active: true }]);
@@ -386,7 +387,7 @@ describe('removeTeam', () => {
     storeApiKey('re_staging', 'staging');
     setActiveTeam('staging');
 
-    removeTeam('staging');
+    removeApiKey('staging');
 
     const configPath = join(tmpDir, 'resend', 'credentials.json');
     const data = JSON.parse(readFileSync(configPath, 'utf-8'));
@@ -396,7 +397,7 @@ describe('removeTeam', () => {
   test('deletes file when last team removed', () => {
     storeApiKey('re_only', 'only');
 
-    removeTeam('only');
+    removeApiKey('only');
 
     const { existsSync } = require('node:fs');
     const configPath = join(tmpDir, 'resend', 'credentials.json');
@@ -405,10 +406,40 @@ describe('removeTeam', () => {
 
   test('throws when team does not exist', () => {
     storeApiKey('re_default');
-    expect(() => removeTeam('nonexistent')).toThrow('not found');
+    expect(() => removeApiKey('nonexistent')).toThrow('not found');
   });
 
   test('throws when no credentials file', () => {
-    expect(() => removeTeam('any')).toThrow('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/tests/lib/update-check.test.ts

@@ -0,0 +1,169 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { checkForUpdates } from '../../src/lib/update-check';
+import { VERSION } from '../../src/lib/version';
+import { captureTestEnv } from '../helpers';
+
+// Use a version guaranteed to be "newer" than whatever VERSION is
+const NEWER_VERSION = '99.0.0';
+
+const testConfigDir = join(tmpdir(), `resend-update-check-test-${process.pid}`);
+const testResendDir = join(testConfigDir, 'resend');
+const statePath = join(testResendDir, 'update-state.json');
+
+describe('checkForUpdates', () => {
+  const restoreEnv = captureTestEnv();
+  let stderrOutput: string;
+  let stderrSpy: ReturnType<typeof spyOn>;
+  let fetchSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    mkdirSync(testResendDir, { recursive: true });
+    stderrOutput = '';
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+      stderrOutput += String(chunk);
+      return true;
+    });
+
+    // Point getConfigDir() at our temp dir via XDG_CONFIG_HOME
+    process.env.XDG_CONFIG_HOME = testConfigDir;
+
+    // Ensure TTY and no CI
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.RESEND_NO_UPDATE_NOTIFIER;
+  });
+
+  afterEach(() => {
+    stderrSpy.mockRestore();
+    if (fetchSpy) {
+      fetchSpy.mockRestore();
+    }
+    restoreEnv();
+    if (existsSync(testConfigDir)) {
+      rmSync(testConfigDir, { recursive: true, force: true });
+    }
+  });
+
+  function mockFetch(tagName: string, extra: Record<string, unknown> = {}) {
+    fetchSpy = spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ tag_name: tagName, ...extra }),
+    } as Response);
+  }
+
+  function mockFetchFailure() {
+    fetchSpy = spyOn(globalThis, 'fetch').mockRejectedValue(
+      new Error('network error'),
+    );
+  }
+
+  test('skips check when RESEND_NO_UPDATE_NOTIFIER=1', async () => {
+    process.env.RESEND_NO_UPDATE_NOTIFIER = '1';
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('skips check when CI=true', async () => {
+    process.env.CI = 'true';
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('skips check when not a TTY', async () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('prints notice when newer version available from fresh fetch', async () => {
+    mockFetch(`v${NEWER_VERSION}`);
+    await checkForUpdates();
+
+    expect(stderrOutput).toContain('Update available');
+    expect(stderrOutput).toContain(`v${VERSION}`);
+    expect(stderrOutput).toContain(`v${NEWER_VERSION}`);
+  });
+
+  test('prints nothing when already on latest', async () => {
+    mockFetch(`v${VERSION}`);
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('uses cached state when fresh (no fetch)', async () => {
+    writeFileSync(
+      statePath,
+      JSON.stringify({ lastChecked: Date.now(), latestVersion: NEWER_VERSION }),
+    );
+
+    mockFetch(`v${NEWER_VERSION}`);
+    await checkForUpdates();
+
+    expect(fetchSpy).not.toHaveBeenCalled();
+    expect(stderrOutput).toContain(`v${NEWER_VERSION}`);
+  });
+
+  test('refetches when cache is stale', async () => {
+    const staleTime = Date.now() - 25 * 60 * 60 * 1000; // 25 hours ago
+    writeFileSync(
+      statePath,
+      JSON.stringify({ lastChecked: staleTime, latestVersion: VERSION }),
+    );
+
+    mockFetch(`v${NEWER_VERSION}`);
+    await checkForUpdates();
+
+    expect(fetchSpy).toHaveBeenCalled();
+    expect(stderrOutput).toContain(`v${NEWER_VERSION}`);
+    // Verify cache was updated
+    const state = JSON.parse(readFileSync(statePath, 'utf-8'));
+    expect(state.latestVersion).toBe(NEWER_VERSION);
+  });
+
+  test('handles fetch failure gracefully', async () => {
+    mockFetchFailure();
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('writes state file after successful fetch', async () => {
+    mockFetch(`v${VERSION}`);
+    await checkForUpdates();
+
+    expect(existsSync(statePath)).toBe(true);
+    const state = JSON.parse(readFileSync(statePath, 'utf-8'));
+    expect(state.latestVersion).toBe(VERSION);
+  });
+
+  test('ignores prerelease versions', async () => {
+    fetchSpy = spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ tag_name: 'v99.0.0', prerelease: true }),
+    } as Response);
+
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('ignores non-semver tag names', async () => {
+    mockFetch('canary-20260311');
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+});

package/.claude/worktrees/emails-list/.claude/settings.local.json

@@ -1,5 +0,0 @@
-{
-  "permissions": {
-    "allow": ["Bash(npx biome:*)"]
-  }
-}

package/.claude/worktrees/emails-list/.github/scripts/pr-title-check.js

@@ -1,34 +0,0 @@
-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/.claude/worktrees/emails-list/.github/workflows/ci.yml

@@ -1,32 +0,0 @@
-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@v4
-      - 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@v4
-      - 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@v4
-      - uses: oven-sh/setup-bun@v2
-      - run: bun install --frozen-lockfile
-      - run: bun run test

package/.claude/worktrees/emails-list/.github/workflows/pr-title-check.yml

@@ -1,13 +0,0 @@
-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@v4
-      - run: node .github/scripts/pr-title-check.js

package/.claude/worktrees/emails-list/.github/workflows/release.yml

@@ -1,93 +0,0 @@
-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@v4
-
-      - 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 --bytecode 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}"

package/.claude/worktrees/emails-list/CHANGELOG.md

@@ -1,31 +0,0 @@
-# Changelog
-
-## [0.2.0] - 2026-02-18
-
-### Added
-
-- `resend domains` — create, verify, get, list, update, delete sending domains
-- `resend api-keys` — create, list, delete API keys
-- `resend broadcasts` — full broadcast lifecycle (create, send, get, list, update, delete)
-- `resend contacts` — manage contacts, segments, and topics across all CRUD operations
-- `resend emails batch` — send up to 100 emails in a single request from a JSON file
-- Shared pagination (`--limit`, `--after`, `--before`) on all list commands
-- `--html-file` flag on `emails send` and `broadcasts create` to read body from a file
-
-### Fixed
-
-- `isInteractive()` now checks both `stdin` and `stdout` TTY — CI environments are correctly detected as non-interactive
-- `domains delete` now returns a consistent `{ id, deleted: true }` object instead of an empty `{}`
-
-### Changed
-
-- All delete commands return a uniform `{ object, id, deleted: true }` response
-- `--help` improved across all commands with output shape, error codes, and usage examples
-
----
-
-## [0.1.0] - 2026-02-18
-
-- Initial release: `auth login`, `emails send`, `doctor`
-- Auto JSON output when stdout is not a TTY (`--json`)
-- Cross-platform binaries for macOS, Linux, and Windows via GitHub Actions