superacli 1.1.5 → 1.1.6

package/temp_resend_cli/repo/src/lib/spinner.ts

@@ -0,0 +1,100 @@
+import type { GlobalOpts } from './client';
+import { errorMessage, outputError } from './output';
+import { isInteractive, isUnicodeSupported } from './tty';
+
+// Status symbols generated via String.fromCodePoint() — never literal Unicode in
+// source — to prevent UTF-8 → Latin-1 corruption when the npm package is bundled.
+const TICK = isUnicodeSupported ? String.fromCodePoint(0x2714) : 'v'; // ✔
+const WARN = isUnicodeSupported ? String.fromCodePoint(0x26a0) : '!'; // ⚠
+const CROSS = isUnicodeSupported ? String.fromCodePoint(0x2717) : 'x'; // ✗
+
+// Braille spinner: cycle through U+2800-block dot patterns.
+const SPINNER_FRAMES = [
+  '\u2839',
+  '\u2838',
+  '\u2834',
+  '\u2826',
+  '\u2807',
+  '\u280F',
+  '\u2819',
+  '\u2839',
+];
+const SPINNER_INTERVAL = 80;
+
+type SdkResponse<T> = { data: T | null; error: { message: string } | null };
+
+/**
+ * Wraps an SDK call with a spinner, unified error handling, and automatic stop/fail.
+ * Eliminates the repeated try/catch + spinner boilerplate across all command files.
+ */
+export async function withSpinner<T>(
+  messages: { loading: string; success: string; fail: string },
+  call: () => Promise<SdkResponse<T>>,
+  errorCode: string,
+  globalOpts: GlobalOpts,
+): Promise<T> {
+  const spinner = createSpinner(messages.loading, globalOpts.quiet);
+  try {
+    const { data, error } = await call();
+    if (error) {
+      spinner.fail(messages.fail);
+      outputError(
+        { message: error.message, code: errorCode },
+        { json: globalOpts.json },
+      );
+    }
+    if (data === null) {
+      spinner.fail(messages.fail);
+      outputError(
+        { message: 'Unexpected empty response', code: errorCode },
+        { json: globalOpts.json },
+      );
+    }
+    spinner.stop(messages.success);
+    return data;
+  } catch (err) {
+    spinner.fail(messages.fail);
+    return outputError(
+      { message: errorMessage(err, 'Unknown error'), code: errorCode },
+      { json: globalOpts.json },
+    );
+  }
+}
+
+export function createSpinner(message: string, quiet?: boolean) {
+  if (quiet || !isInteractive()) {
+    return {
+      update(_msg: string) {},
+      stop(_msg: string) {},
+      warn(_msg: string) {},
+      fail(_msg: string) {},
+    };
+  }
+
+  const frames = isUnicodeSupported ? SPINNER_FRAMES : ['-', '\\', '|', '/'];
+  const interval = SPINNER_INTERVAL;
+  let i = 0;
+  let text = message;
+
+  const timer = setInterval(() => {
+    process.stderr.write(`\r\x1B[2K  ${frames[i++ % frames.length]} ${text}`);
+  }, interval);
+
+  return {
+    update(msg: string) {
+      text = msg;
+    },
+    stop(msg: string) {
+      clearInterval(timer);
+      process.stderr.write(`\r\x1B[2K  ${TICK} ${msg}\n`);
+    },
+    warn(msg: string) {
+      clearInterval(timer);
+      process.stderr.write(`\r\x1B[2K  ${WARN} ${msg}\n`);
+    },
+    fail(msg: string) {
+      clearInterval(timer);
+      process.stderr.write(`\r\x1B[2K  ${CROSS} ${msg}\n`);
+    },
+  };
+}

package/temp_resend_cli/repo/src/lib/table.ts

@@ -0,0 +1,57 @@
+import { isUnicodeSupported } from './tty';
+
+// All box-drawing characters generated via String.fromCodePoint() — never literal
+// Unicode in source — to prevent UTF-8 → Latin-1 corruption in npm bundles.
+const BOX = isUnicodeSupported
+  ? {
+      h: String.fromCodePoint(0x2500), // ─
+      v: String.fromCodePoint(0x2502), // │
+      tl: String.fromCodePoint(0x250c), // ┌
+      tr: String.fromCodePoint(0x2510), // ┐
+      bl: String.fromCodePoint(0x2514), // └
+      br: String.fromCodePoint(0x2518), // ┘
+      lm: String.fromCodePoint(0x251c), // ├
+      rm: String.fromCodePoint(0x2524), // ┤
+      tm: String.fromCodePoint(0x252c), // ┬
+      bm: String.fromCodePoint(0x2534), // ┴
+      mm: String.fromCodePoint(0x253c), // ┼
+    }
+  : {
+      h: '-',
+      v: '|',
+      tl: '+',
+      tr: '+',
+      bl: '+',
+      br: '+',
+      lm: '+',
+      rm: '+',
+      tm: '+',
+      bm: '+',
+      mm: '+',
+    };
+
+export function renderTable(
+  headers: string[],
+  rows: string[][],
+  emptyMessage = '(no results)',
+): string {
+  if (rows.length === 0) {
+    return emptyMessage;
+  }
+  const widths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((r) => r[i].length)),
+  );
+  const top =
+    BOX.tl + widths.map((w) => BOX.h.repeat(w + 2)).join(BOX.tm) + BOX.tr;
+  const mid =
+    BOX.lm + widths.map((w) => BOX.h.repeat(w + 2)).join(BOX.mm) + BOX.rm;
+  const bot =
+    BOX.bl + widths.map((w) => BOX.h.repeat(w + 2)).join(BOX.bm) + BOX.br;
+  const row = (cells: string[]) =>
+    BOX.v +
+    ' ' +
+    cells.map((c, i) => c.padEnd(widths[i])).join(` ${BOX.v} `) +
+    ' ' +
+    BOX.v;
+  return [top, row(headers), mid, ...rows.map(row), bot].join('\n');
+}

package/temp_resend_cli/repo/src/lib/tty.ts

@@ -0,0 +1,28 @@
+export function isInteractive(): boolean {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return false;
+  }
+  if (process.env.CI === 'true' || process.env.CI === '1') {
+    return false;
+  }
+  if (process.env.GITHUB_ACTIONS) {
+    return false;
+  }
+  if (process.env.TERM === 'dumb') {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * True on macOS/Linux and on Windows terminals that support Unicode
+ * (Windows Terminal, VS Code integrated terminal).
+ * False on legacy Windows cmd.exe — callers should fall back to ASCII symbols.
+ *
+ * Generated via String.fromCodePoint() (never literal Unicode in source)
+ * to prevent UTF-8 → Latin-1 corruption when the npm package is bundled.
+ */
+export const isUnicodeSupported: boolean =
+  process.platform !== 'win32' ||
+  Boolean(process.env.WT_SESSION) ||
+  process.env.TERM_PROGRAM === 'vscode';

package/temp_resend_cli/repo/src/lib/update-check.ts

@@ -0,0 +1,169 @@
+import { 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 {
+  mkdirSync(getConfigDir(), { 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/temp_resend_cli/repo/src/lib/version.ts

@@ -0,0 +1,4 @@
+import pkg from '../../package.json';
+
+export const VERSION: string = pkg.version;
+export const PACKAGE_NAME: string = pkg.name;

package/temp_resend_cli/repo/tests/commands/api-keys/create.test.ts

@@ -0,0 +1,196 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockCreate = vi.fn(async () => ({
+  data: { id: 'test-key-id', token: 're_testtoken1234567890' },
+  error: null,
+}));
+
+vi.mock('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    apiKeys = { create: mockCreate };
+  },
+}));
+
+describe('api-keys create command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: MockInstance | undefined;
+  let stderrSpy: MockInstance | undefined;
+  let exitSpy: MockInstance | undefined;
+
+  beforeEach(() => {
+    process.env.RESEND_API_KEY = 're_test_key';
+    mockCreate.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('creates API key with --name flag', async () => {
+    spies = setupOutputSpies();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await createApiKeyCommand.parseAsync(['--name', 'Production'], {
+      from: 'user',
+    });
+
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.name).toBe('Production');
+  });
+
+  test('passes permission flag to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await createApiKeyCommand.parseAsync(
+      ['--name', 'CI Token', '--permission', 'sending_access'],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.permission).toBe('sending_access');
+  });
+
+  test('passes domain_id (snake_case) to SDK when --domain-id is provided', async () => {
+    spies = setupOutputSpies();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await createApiKeyCommand.parseAsync(
+      [
+        '--name',
+        'Domain Token',
+        '--permission',
+        'sending_access',
+        '--domain-id',
+        'domain-123',
+      ],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.domain_id).toBe('domain-123');
+  });
+
+  test('outputs JSON result when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await createApiKeyCommand.parseAsync(['--name', 'Production'], {
+      from: 'user',
+    });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('test-key-id');
+    expect(parsed.token).toBe('re_testtoken1234567890');
+  });
+
+  test('errors with missing_name when --name absent in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await expectExit1(() =>
+      createApiKeyCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('missing_name');
+  });
+
+  test('does not call SDK when missing_name error is raised', async () => {
+    setNonInteractive();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await expectExit1(() =>
+      createApiKeyCommand.parseAsync([], { from: 'user' }),
+    );
+
+    expect(mockCreate).not.toHaveBeenCalled();
+  });
+
+  test('errors with auth_error when no API key', async () => {
+    setNonInteractive();
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await expectExit1(() =>
+      createApiKeyCommand.parseAsync(['--name', 'Production'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with create_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockCreate.mockResolvedValueOnce(
+      mockSdkError('Name already taken', 'validation_error'),
+    );
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { createApiKeyCommand } = await import(
+      '../../../src/commands/api-keys/create'
+    );
+    await expectExit1(() =>
+      createApiKeyCommand.parseAsync(['--name', 'Production'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('create_error');
+  });
+});