superacli 1.1.4 → 1.1.6

package/temp_resend_cli/repo/renovate.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": ["config:recommended"]
+}

package/temp_resend_cli/repo/src/cli.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { Command } from '@commander-js/extra-typings';
+import pc from 'picocolors';
+import { apiKeysCommand } from './commands/api-keys/index';
+import { loginCommand } from './commands/auth/login';
+import { logoutCommand } from './commands/auth/logout';
+import { broadcastsCommand } from './commands/broadcasts/index';
+import { contactPropertiesCommand } from './commands/contact-properties/index';
+import { contactsCommand } from './commands/contacts/index';
+import { doctorCommand } from './commands/doctor';
+import { domainsCommand } from './commands/domains/index';
+import { emailsCommand } from './commands/emails/index';
+import { openCommand } from './commands/open';
+import { segmentsCommand } from './commands/segments/index';
+import { teamsCommand } from './commands/teams/index';
+import { topicsCommand } from './commands/topics/index';
+import { webhooksCommand } from './commands/webhooks/index';
+import { whoamiCommand } from './commands/whoami';
+import { errorMessage, outputError } from './lib/output';
+import { checkForUpdates } from './lib/update-check';
+import { PACKAGE_NAME, VERSION } from './lib/version';
+
+const program = new Command()
+  .name('resend')
+  .description('Resend CLI — email for developers')
+  .configureHelp({
+    showGlobalOptions: true,
+    styleTitle: (str) => pc.gray(str),
+  })
+  .configureOutput({
+    writeErr: (str) => {
+      process.stderr.write(str.replace(/^error:/, () => pc.red('error:')));
+    },
+  })
+  .version(
+    `${PACKAGE_NAME} v${VERSION}`,
+    '-v, --version',
+    'Output the current version',
+  )
+  .option('--api-key <key>', 'Resend API key (overrides env/config)')
+  .option('--team <name>', 'Team profile to use (overrides RESEND_TEAM)')
+  .option('--json', 'Force JSON output')
+  .option('-q, --quiet', 'Suppress spinners and status output (implies --json)')
+  .hook('preAction', (thisCommand, actionCommand) => {
+    if (actionCommand.optsWithGlobals().quiet) {
+      thisCommand.setOptionValue('json', true);
+    }
+  })
+  .addHelpText(
+    'after',
+    `
+${pc.gray('Environment:')}
+  RESEND_API_KEY    API key — checked after --api-key, before stored credentials
+                    Priority: --api-key flag > RESEND_API_KEY > ~/.config/resend/credentials.json
+  RESEND_TEAM       Team profile — checked after --team flag, before active_team in config
+                    Priority: --team flag > RESEND_TEAM > active_team in config > "default"
+
+${pc.gray('Output:')}
+  Human-readable by default. Pass --json or pipe stdout for machine-readable JSON.
+  Use --quiet (-q) in CI to suppress spinners and status messages (implies --json).
+  Errors always exit with code 1: {"error":{"message":"...","code":"..."}}
+
+${pc.gray('Examples:')}
+
+- Login to Resend
+
+  ${pc.blue('$ resend login')}
+
+- Send an email
+
+  ${pc.blue('$ resend emails send')}
+`,
+  )
+  .addCommand(loginCommand)
+  .addCommand(logoutCommand)
+  .addCommand(emailsCommand)
+  .addCommand(domainsCommand)
+  .addCommand(apiKeysCommand)
+  .addCommand(broadcastsCommand)
+  .addCommand(contactsCommand)
+  .addCommand(contactPropertiesCommand)
+  .addCommand(segmentsCommand)
+  .addCommand(topicsCommand)
+  .addCommand(webhooksCommand)
+  .addCommand(doctorCommand)
+  .addCommand(teamsCommand)
+  .addCommand(openCommand)
+  .addCommand(whoamiCommand);
+
+program
+  .parseAsync()
+  .then(() => checkForUpdates().catch(() => {}))
+  .catch((err) => {
+    outputError({
+      message: errorMessage(err, 'An unexpected error occurred'),
+      code: 'unexpected_error',
+    });
+  });

package/temp_resend_cli/repo/src/commands/api-keys/create.ts

@@ -0,0 +1,114 @@
+import * as p from '@clack/prompts';
+import { Command, Option } from '@commander-js/extra-typings';
+import { runCreate } from '../../lib/actions';
+import type { GlobalOpts } from '../../lib/client';
+import { buildHelpText } from '../../lib/help-text';
+import { outputError } from '../../lib/output';
+import { cancelAndExit } from '../../lib/prompts';
+import { isInteractive } from '../../lib/tty';
+
+export const createApiKeyCommand = new Command('create')
+  .description(
+    'Create a new API key and display the token (shown once — store it immediately)',
+  )
+  .option('--name <name>', 'API key name (max 50 characters)')
+  .addOption(
+    new Option('--permission <permission>', 'Permission level').choices([
+      'full_access',
+      'sending_access',
+    ] as const),
+  )
+  .option(
+    '--domain-id <id>',
+    'Restrict a sending_access key to a single domain ID',
+  )
+  .addHelpText(
+    'after',
+    buildHelpText({
+      context: `Non-interactive: --name is required (no prompts when stdin/stdout is not a TTY).
+
+Permissions:
+  full_access     Full API access (default)
+  sending_access  Send-only access; optionally scope to a domain with --domain-id`,
+      output: `  {"id":"<id>","token":"<token>"}
+  The token is only returned at creation time and cannot be retrieved again.`,
+      errorCodes: ['auth_error', 'missing_name', 'create_error'],
+      examples: [
+        'resend api-keys create --name "Production"',
+        'resend api-keys create --name "CI Token" --permission sending_access',
+        'resend api-keys create --name "Domain Token" --permission sending_access --domain-id <domain-id>',
+        'resend api-keys create --name "Production" --json',
+      ],
+    }),
+  )
+  .action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+
+    let name = opts.name;
+    let permission = opts.permission;
+
+    if (!name) {
+      if (!isInteractive()) {
+        outputError(
+          { message: 'Missing --name flag.', code: 'missing_name' },
+          { json: globalOpts.json },
+        );
+      }
+
+      const nameResult = await p.text({
+        message: 'Key name',
+        placeholder: 'My API Key',
+        validate: (v) => {
+          if (!v) {
+            return 'Name is required';
+          }
+          if (v.length > 50) {
+            return 'Name must be 50 characters or less';
+          }
+          return undefined;
+        },
+      });
+      if (p.isCancel(nameResult)) {
+        cancelAndExit('Cancelled.');
+      }
+      name = nameResult;
+
+      const permissionResult = await p.select({
+        message: 'Permission level',
+        options: [
+          { value: 'full_access' as const, label: 'Full access' },
+          { value: 'sending_access' as const, label: 'Sending access only' },
+        ],
+      });
+      if (p.isCancel(permissionResult)) {
+        cancelAndExit('Cancelled.');
+      }
+      permission = permissionResult;
+    }
+
+    await runCreate(
+      {
+        spinner: {
+          loading: 'Creating API key...',
+          success: 'API key created',
+          fail: 'Failed to create API key',
+        },
+        sdkCall: (resend) =>
+          resend.apiKeys.create({
+            name,
+            ...(permission && { permission }),
+            ...(opts.domainId && { domain_id: opts.domainId }),
+          }),
+        onInteractive: (d) => {
+          console.log('\nAPI key created!\n');
+          console.log(`  Name:    ${name}`);
+          console.log(`  ID:      ${d.id}`);
+          console.log(`  Token:   ${d.token}`);
+          console.log(
+            '\n⚠  Store this token now — it cannot be retrieved again.',
+          );
+        },
+      },
+      globalOpts,
+    );
+  });

package/temp_resend_cli/repo/src/commands/api-keys/delete.ts

@@ -0,0 +1,47 @@
+import { Command } from '@commander-js/extra-typings';
+import { runDelete } from '../../lib/actions';
+import type { GlobalOpts } from '../../lib/client';
+import { buildHelpText } from '../../lib/help-text';
+
+export const deleteApiKeyCommand = new Command('delete')
+  .alias('rm')
+  .description(
+    'Delete an API key — any services using it will immediately lose access',
+  )
+  .argument('<id>', 'API key ID')
+  .option('--yes', 'Skip confirmation prompt')
+  .addHelpText(
+    'after',
+    buildHelpText({
+      context: `Non-interactive: --yes is required to confirm deletion when stdin/stdout is not a TTY.
+
+Warning: Deleting a key is immediate and irreversible. Any service using this key
+will stop authenticating instantly. The current key (used to call this command)
+can delete itself — the API does not prevent self-deletion.`,
+      output: `  {"object":"api-key","id":"<id>","deleted":true}`,
+      errorCodes: ['auth_error', 'confirmation_required', 'delete_error'],
+      examples: [
+        'resend api-keys delete dacf4072-aa82-4ff3-97de-514ae3000ee0 --yes',
+        'resend api-keys delete dacf4072-aa82-4ff3-97de-514ae3000ee0 --yes --json',
+      ],
+    }),
+  )
+  .action(async (id, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    await runDelete(
+      id,
+      !!opts.yes,
+      {
+        confirmMessage: `Delete API key ${id}?\nAny services using this key will stop working.`,
+        spinner: {
+          loading: 'Deleting API key...',
+          success: 'API key deleted',
+          fail: 'Failed to delete API key',
+        },
+        object: 'api-key',
+        successMsg: 'API key deleted.',
+        sdkCall: (resend) => resend.apiKeys.remove(id),
+      },
+      globalOpts,
+    );
+  });

package/temp_resend_cli/repo/src/commands/api-keys/index.ts

@@ -0,0 +1,26 @@
+import { Command } from '@commander-js/extra-typings';
+import { buildHelpText } from '../../lib/help-text';
+import { createApiKeyCommand } from './create';
+import { deleteApiKeyCommand } from './delete';
+import { listApiKeysCommand } from './list';
+
+export const apiKeysCommand = new Command('api-keys')
+  .description('Manage API keys for authentication')
+  .addHelpText(
+    'after',
+    buildHelpText({
+      context: `Security notes:
+  - Tokens are only shown at creation time and cannot be retrieved again.
+  - Use sending_access keys with --domain-id for per-domain CI tokens.
+  - Deleting a key is immediate — any service using it loses access instantly.`,
+      examples: [
+        'resend api-keys list',
+        'resend api-keys create --name "Production"',
+        'resend api-keys create --name "CI Token" --permission sending_access --domain-id <domain-id>',
+        'resend api-keys delete <id> --yes',
+      ],
+    }),
+  )
+  .addCommand(createApiKeyCommand)
+  .addCommand(listApiKeysCommand, { isDefault: true })
+  .addCommand(deleteApiKeyCommand);

package/temp_resend_cli/repo/src/commands/api-keys/list.ts

@@ -0,0 +1,35 @@
+import { Command } from '@commander-js/extra-typings';
+import { runList } from '../../lib/actions';
+import type { GlobalOpts } from '../../lib/client';
+import { buildHelpText } from '../../lib/help-text';
+import { renderApiKeysTable } from './utils';
+
+export const listApiKeysCommand = new Command('list')
+  .alias('ls')
+  .description(
+    'List all API keys (IDs and names — tokens are never returned by this endpoint)',
+  )
+  .addHelpText(
+    'after',
+    buildHelpText({
+      output: `  {"object":"list","data":[{"id":"<id>","name":"<name>","created_at":"<date>"}]}
+  Tokens are never included in list responses.`,
+      errorCodes: ['auth_error', 'list_error'],
+      examples: ['resend api-keys list', 'resend api-keys list --json'],
+    }),
+  )
+  .action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    await runList(
+      {
+        spinner: {
+          loading: 'Fetching API keys...',
+          success: 'API keys fetched',
+          fail: 'Failed to list API keys',
+        },
+        sdkCall: (resend) => resend.apiKeys.list(),
+        onInteractive: (list) => console.log(renderApiKeysTable(list.data)),
+      },
+      globalOpts,
+    );
+  });

package/temp_resend_cli/repo/src/commands/api-keys/utils.ts

@@ -0,0 +1,8 @@
+import { renderTable } from '../../lib/table';
+
+export function renderApiKeysTable(
+  keys: Array<{ id: string; name: string; created_at: string }>,
+): string {
+  const rows = keys.map((k) => [k.name, k.id, k.created_at]);
+  return renderTable(['Name', 'ID', 'Created'], rows, '(no API keys)');
+}

package/temp_resend_cli/repo/src/commands/auth/index.ts

@@ -0,0 +1,20 @@
+import { Command } from '@commander-js/extra-typings';
+import { buildHelpText } from '../../lib/help-text';
+import { loginCommand } from './login';
+import { logoutCommand } from './logout';
+
+export const authCommand = new Command('auth')
+  .description('Manage authentication')
+  .addHelpText(
+    'after',
+    buildHelpText({
+      setup: true,
+      examples: [
+        'resend login',
+        'resend login --key re_123456789',
+        'resend logout',
+      ],
+    }),
+  )
+  .addCommand(loginCommand)
+  .addCommand(logoutCommand);

package/temp_resend_cli/repo/src/commands/auth/login.ts

@@ -0,0 +1,234 @@
+import { execFile } from 'node:child_process';
+import * as p from '@clack/prompts';
+import { Command } from '@commander-js/extra-typings';
+import { Resend } from 'resend';
+import type { GlobalOpts } from '../../lib/client';
+import {
+  listTeams,
+  resolveApiKey,
+  setActiveTeam,
+  storeApiKey,
+  validateTeamName,
+} from '../../lib/config';
+import { buildHelpText } from '../../lib/help-text';
+import { errorMessage, outputError, outputResult } from '../../lib/output';
+import { cancelAndExit } from '../../lib/prompts';
+import { createSpinner } from '../../lib/spinner';
+import { isInteractive } from '../../lib/tty';
+
+const RESEND_API_KEYS_URL = 'https://resend.com/api-keys?new=true';
+
+function openInBrowser(url: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    // `start` on Windows is a shell built-in, not an executable.
+    // Must invoke via `cmd.exe /c start <url>`.
+    const cmd =
+      process.platform === 'win32'
+        ? 'cmd.exe'
+        : process.platform === 'darwin'
+          ? 'open'
+          : 'xdg-open';
+    const args =
+      process.platform === 'win32' ? ['/c', 'start', '""', url] : [url];
+    execFile(cmd, args, { timeout: 5000 }, (err) => resolve(!err));
+  });
+}
+
+export const loginCommand = new Command('login')
+  .description('Save a Resend API key to the local credentials file')
+  .option('--key <key>', 'API key to store (required in non-interactive mode)')
+  .addHelpText(
+    'after',
+    buildHelpText({
+      setup: true,
+      context:
+        'Non-interactive: --key is required (no prompts will appear when stdin/stdout is not a TTY).',
+      output: `  {"success":true,"config_path":"<path>"}`,
+      errorCodes: ['missing_key', 'invalid_key_format', 'validation_failed'],
+      examples: [
+        'resend login --key re_123456789',
+        'resend login                      (interactive — prompts and opens browser)',
+        'RESEND_API_KEY=re_123 resend emails send ...  (skip login; use env var directly)',
+      ],
+    }),
+  )
+  .action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals() as GlobalOpts;
+    let apiKey = opts.key;
+
+    if (!apiKey) {
+      if (!isInteractive()) {
+        outputError(
+          {
+            message:
+              'Missing --key flag. Provide your API key in non-interactive mode.',
+            code: 'missing_key',
+          },
+          { json: globalOpts.json },
+        );
+      }
+
+      p.intro('Resend Authentication');
+
+      const existing = resolveApiKey();
+      if (existing) {
+        p.log.info(
+          `Existing API key found (source: ${existing.source}). Enter a new key to replace it.`,
+        );
+      }
+
+      const method = await p.select({
+        message: 'How would you like to get your API key?',
+        options: [
+          {
+            value: 'browser' as const,
+            label: 'Open resend.com/api-keys in browser',
+          },
+          { value: 'manual' as const, label: 'Enter API key manually' },
+        ],
+      });
+
+      if (p.isCancel(method)) {
+        cancelAndExit('Login cancelled.');
+      }
+
+      if (method === 'browser') {
+        const opened = await openInBrowser(RESEND_API_KEYS_URL);
+        if (opened) {
+          p.log.info(`Opened ${RESEND_API_KEYS_URL}`);
+        } else {
+          p.log.warn(
+            `Could not open browser. Visit ${RESEND_API_KEYS_URL} manually.`,
+          );
+        }
+      }
+
+      const result = await p.password({
+        message: 'Enter your Resend API key:',
+        validate: (value) => {
+          if (!value) {
+            return 'API key is required';
+          }
+          if (!value.startsWith('re_')) {
+            return 'API key must start with re_';
+          }
+          return undefined;
+        },
+      });
+
+      if (p.isCancel(result)) {
+        cancelAndExit('Login cancelled.');
+      }
+
+      apiKey = result;
+    }
+
+    if (!apiKey.startsWith('re_')) {
+      outputError(
+        {
+          message: 'Invalid API key format. Key must start with re_',
+          code: 'invalid_key_format',
+        },
+        { json: globalOpts.json },
+      );
+    }
+
+    const spinner = createSpinner('Validating API key...', globalOpts.quiet);
+
+    try {
+      const resend = new Resend(apiKey);
+      await resend.domains.list();
+      spinner.stop('API key is valid');
+    } catch (err) {
+      spinner.fail('API key validation failed');
+      outputError(
+        {
+          message: errorMessage(err, 'Failed to validate API key'),
+          code: 'validation_failed',
+        },
+        { json: globalOpts.json },
+      );
+    }
+
+    let teamName = globalOpts.team;
+
+    if (teamName) {
+      const teamError = validateTeamName(teamName);
+      if (teamError) {
+        outputError(
+          { message: teamError, code: 'invalid_team_name' },
+          { json: globalOpts.json },
+        );
+        return;
+      }
+    }
+
+    if (!teamName && isInteractive()) {
+      const existingTeams = listTeams();
+      if (existingTeams.length > 0) {
+        const options = [
+          ...existingTeams.map((t) => ({
+            value: t.name,
+            label: `${t.name} (overwrite)`,
+          })),
+          { value: '__new__' as const, label: '+ Create new team' },
+        ];
+
+        const choice = await p.select({
+          message: 'Save API key to which team?',
+          options,
+        });
+
+        if (p.isCancel(choice)) {
+          cancelAndExit('Login cancelled.');
+        }
+
+        if (choice === '__new__') {
+          const newName = await p.text({
+            message: 'Enter a name for the new team:',
+            validate: (v) => validateTeamName(v as string),
+          });
+          if (p.isCancel(newName)) {
+            cancelAndExit('Login cancelled.');
+          }
+          teamName = newName;
+        } else {
+          teamName = choice;
+        }
+      } else {
+        teamName = 'default';
+      }
+    }
+
+    const configPath = storeApiKey(apiKey, teamName);
+    const teamLabel = teamName || 'default';
+
+    // Auto-switch to the newly added team
+    if (teamName) {
+      try {
+        setActiveTeam(teamName);
+      } catch (err) {
+        outputError(
+          {
+            message: errorMessage(err, 'Failed to switch team'),
+            code: 'switch_failed',
+          },
+          { json: globalOpts.json },
+        );
+      }
+    }
+
+    if (globalOpts.json) {
+      outputResult(
+        { success: true, config_path: configPath, team: teamLabel },
+        { json: true },
+      );
+    } else {
+      const msg = `API key stored for team '${teamLabel}' at ${configPath}`;
+      if (isInteractive()) {
+        p.outro(msg);
+      } else {
+        console.log(msg);
+      }
+    }
+  });