superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,157 @@
+import type { Resend } from 'resend';
+import type { GlobalOpts } from './client';
+import { requireClient } from './client';
+import { outputResult } from './output';
+import { confirmDelete } from './prompts';
+import { withSpinner } from './spinner';
+import { isInteractive } from './tty';
+
+type SdkCall<T> = (
+  resend: Resend,
+) => Promise<{ data: T | null; error: { message: string } | null }>;
+type SpinnerMessages = { loading: string; success: string; fail: string };
+
+/**
+ * Shared pattern for all get commands:
+ *   requireClient → withSpinner(fetch_error) → if/else output
+ */
+export async function runGet<T>(
+  config: {
+    spinner: SpinnerMessages;
+    sdkCall: SdkCall<T>;
+    onInteractive: (data: T) => void;
+  },
+  globalOpts: GlobalOpts,
+): Promise<void> {
+  const resend = requireClient(globalOpts);
+  const data = await withSpinner(
+    config.spinner,
+    () => config.sdkCall(resend),
+    'fetch_error',
+    globalOpts,
+  );
+  if (!globalOpts.json && isInteractive()) {
+    config.onInteractive(data);
+  } else {
+    outputResult(data, { json: globalOpts.json });
+  }
+}
+
+/**
+ * Shared pattern for all delete commands:
+ *   requireClient → confirmDelete (if needed) → withSpinner → if/else output
+ */
+export async function runDelete(
+  id: string,
+  skipConfirm: boolean,
+  config: {
+    confirmMessage: string;
+    spinner: SpinnerMessages;
+    object: string;
+    successMsg: string;
+    sdkCall: SdkCall<unknown>;
+  },
+  globalOpts: GlobalOpts,
+): Promise<void> {
+  const resend = requireClient(globalOpts);
+  if (!skipConfirm) {
+    await confirmDelete(id, config.confirmMessage, globalOpts);
+  }
+  await withSpinner(
+    config.spinner,
+    () => config.sdkCall(resend),
+    'delete_error',
+    globalOpts,
+  );
+  if (!globalOpts.json && isInteractive()) {
+    console.log(config.successMsg);
+  } else {
+    outputResult(
+      { object: config.object, id, deleted: true },
+      { json: globalOpts.json },
+    );
+  }
+}
+
+/**
+ * Shared pattern for create commands:
+ *   requireClient → withSpinner('create_error') → if/else output
+ */
+export async function runCreate<T>(
+  config: {
+    spinner: SpinnerMessages;
+    sdkCall: SdkCall<T>;
+    onInteractive: (data: T) => void;
+  },
+  globalOpts: GlobalOpts,
+): Promise<void> {
+  const resend = requireClient(globalOpts);
+  const data = await withSpinner(
+    config.spinner,
+    () => config.sdkCall(resend),
+    'create_error',
+    globalOpts,
+  );
+  if (!globalOpts.json && isInteractive()) {
+    config.onInteractive(data);
+  } else {
+    outputResult(data, { json: globalOpts.json });
+  }
+}
+
+/**
+ * Shared pattern for write commands (update/verify/remove-segment) where
+ * interactive output is a single status message:
+ *   requireClient → withSpinner(errorCode) → if/else output
+ */
+export async function runWrite<T>(
+  config: {
+    spinner: SpinnerMessages;
+    sdkCall: SdkCall<T>;
+    errorCode: string;
+    successMsg: string;
+  },
+  globalOpts: GlobalOpts,
+): Promise<void> {
+  const resend = requireClient(globalOpts);
+  const data = await withSpinner(
+    config.spinner,
+    () => config.sdkCall(resend),
+    config.errorCode,
+    globalOpts,
+  );
+  if (!globalOpts.json && isInteractive()) {
+    console.log(config.successMsg);
+  } else {
+    outputResult(data, { json: globalOpts.json });
+  }
+}
+
+/**
+ * Shared pattern for all list commands:
+ *   requireClient → withSpinner → if/else output
+ *
+ * Callers pass pagination opts (if any) via the sdkCall closure.
+ * The onInteractive callback handles table rendering and pagination hints.
+ */
+export async function runList<T>(
+  config: {
+    spinner: SpinnerMessages;
+    sdkCall: SdkCall<T>;
+    onInteractive: (result: T) => void;
+  },
+  globalOpts: GlobalOpts,
+): Promise<void> {
+  const resend = requireClient(globalOpts);
+  const result = await withSpinner(
+    config.spinner,
+    () => config.sdkCall(resend),
+    'list_error',
+    globalOpts,
+  );
+  if (!globalOpts.json && isInteractive()) {
+    config.onInteractive(result);
+  } else {
+    outputResult(result, { json: globalOpts.json });
+  }
+}

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

@@ -0,0 +1,37 @@
+import { Resend } from 'resend';
+import { resolveApiKey } from './config';
+import { errorMessage, outputError } from './output';
+import { VERSION } from './version';
+
+export type GlobalOpts = {
+  apiKey?: string;
+  json?: boolean;
+  quiet?: boolean;
+  team?: string;
+};
+
+process.env.RESEND_USER_AGENT = `resend-cli:${VERSION}`;
+
+export function createClient(flagValue?: string, teamName?: string): Resend {
+  const resolved = resolveApiKey(flagValue, teamName);
+  if (!resolved) {
+    throw new Error(
+      'No API key found. Set RESEND_API_KEY, use --api-key, or run: resend login',
+    );
+  }
+  return new Resend(resolved.key);
+}
+
+export function requireClient(opts: GlobalOpts): Resend {
+  try {
+    return createClient(opts.apiKey, opts.team);
+  } catch (err) {
+    outputError(
+      {
+        message: errorMessage(err, 'Failed to create client'),
+        code: 'auth_error',
+      },
+      { json: opts.json },
+    );
+  }
+}

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

@@ -0,0 +1,217 @@
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export type ApiKeySource = 'flag' | 'env' | 'config';
+export type ResolvedKey = { key: string; source: ApiKeySource; team?: string };
+
+export type TeamProfile = { api_key: string };
+export type CredentialsFile = {
+  active_team: string;
+  teams: Record<string, TeamProfile>;
+};
+
+export function getConfigDir(): string {
+  if (process.env.XDG_CONFIG_HOME) {
+    return join(process.env.XDG_CONFIG_HOME, 'resend');
+  }
+  if (process.platform === 'win32' && process.env.APPDATA) {
+    return join(process.env.APPDATA, 'resend');
+  }
+  return join(homedir(), '.config', 'resend');
+}
+
+function getCredentialsPath(): string {
+  return join(getConfigDir(), 'credentials.json');
+}
+
+export function readCredentials(): CredentialsFile | null {
+  try {
+    const data = JSON.parse(readFileSync(getCredentialsPath(), 'utf-8'));
+    // Support legacy format: { api_key: "re_xxx" }
+    if (data.api_key && !data.teams) {
+      return {
+        active_team: 'default',
+        teams: { default: { api_key: data.api_key } },
+      };
+    }
+    if (data.teams) {
+      return data as CredentialsFile;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function writeCredentials(creds: CredentialsFile): string {
+  const configDir = getConfigDir();
+  mkdirSync(configDir, { recursive: true, mode: 0o700 });
+
+  const configPath = getCredentialsPath();
+  writeFileSync(configPath, `${JSON.stringify(creds, null, 2)}\n`, {
+    mode: 0o600,
+  });
+  chmodSync(configPath, 0o600);
+
+  return configPath;
+}
+
+export function resolveTeamName(flagValue?: string): string {
+  if (flagValue) {
+    return flagValue;
+  }
+
+  const envTeam = process.env.RESEND_TEAM;
+  if (envTeam) {
+    return envTeam;
+  }
+
+  const creds = readCredentials();
+  if (creds?.active_team) {
+    return creds.active_team;
+  }
+
+  return 'default';
+}
+
+export function resolveApiKey(
+  flagValue?: string,
+  teamName?: string,
+): ResolvedKey | null {
+  if (flagValue) {
+    return { key: flagValue, source: 'flag' };
+  }
+
+  const envKey = process.env.RESEND_API_KEY;
+  if (envKey) {
+    return { key: envKey, source: 'env' };
+  }
+
+  const creds = readCredentials();
+  if (creds) {
+    const team = resolveTeamName(teamName);
+    const profile = creds.teams[team];
+    if (profile?.api_key) {
+      return { key: profile.api_key, source: 'config', team };
+    }
+  }
+
+  return null;
+}
+
+export function storeApiKey(apiKey: string, teamName?: string): string {
+  const team = teamName || 'default';
+  const validationError = validateTeamName(team);
+  if (validationError) {
+    throw new Error(validationError);
+  }
+  const creds = readCredentials() || { active_team: 'default', teams: {} };
+
+  creds.teams[team] = { api_key: apiKey };
+
+  // If this is the first team, set it as active
+  if (Object.keys(creds.teams).length === 1) {
+    creds.active_team = team;
+  }
+
+  return writeCredentials(creds);
+}
+
+export function removeAllApiKeys(): string {
+  const configPath = getCredentialsPath();
+  unlinkSync(configPath);
+  return configPath;
+}
+
+export function removeApiKey(teamName?: string): string {
+  const creds = readCredentials();
+  if (!creds) {
+    const configPath = getCredentialsPath();
+    if (!existsSync(configPath)) {
+      throw new Error('No credentials file found.');
+    }
+    // Try to delete legacy file
+    unlinkSync(configPath);
+    return configPath;
+  }
+
+  const team = teamName || resolveTeamName();
+  if (!creds.teams[team]) {
+    throw new Error(
+      `Team "${team}" not found. Available teams: ${Object.keys(creds.teams).join(', ')}`,
+    );
+  }
+  delete creds.teams[team];
+
+  // If we removed the active team, switch to first available or "default"
+  if (creds.active_team === team) {
+    const remaining = Object.keys(creds.teams);
+    creds.active_team = remaining[0] || 'default';
+  }
+
+  // If no teams left, delete the file
+  if (Object.keys(creds.teams).length === 0) {
+    const configPath = getCredentialsPath();
+    unlinkSync(configPath);
+    return configPath;
+  }
+
+  return writeCredentials(creds);
+}
+
+export function setActiveTeam(teamName: string): void {
+  const validationError = validateTeamName(teamName);
+  if (validationError) {
+    throw new Error(validationError);
+  }
+  const creds = readCredentials();
+  if (!creds) {
+    throw new Error('No credentials file found. Run: resend login');
+  }
+  if (!creds.teams[teamName]) {
+    throw new Error(
+      `Team "${teamName}" not found. Available teams: ${Object.keys(creds.teams).join(', ')}`,
+    );
+  }
+  creds.active_team = teamName;
+  writeCredentials(creds);
+}
+
+export function listTeams(): Array<{ name: string; active: boolean }> {
+  const creds = readCredentials();
+  if (!creds) {
+    return [];
+  }
+  return Object.keys(creds.teams).map((name) => ({
+    name,
+    active: name === creds.active_team,
+  }));
+}
+
+export function validateTeamName(name: string): string | undefined {
+  if (!name || name.length === 0) {
+    return 'Team name must not be empty';
+  }
+  if (name.length > 64) {
+    return 'Team name must be 64 characters or fewer';
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    return 'Team name must contain only letters, numbers, dashes, and underscores';
+  }
+  return undefined;
+}
+
+export function maskKey(key: string): string {
+  if (key.length <= 7) {
+    return `${key.slice(0, 3)}...`;
+  }
+  return `${key.slice(0, 3)}...${key.slice(-4)}`;
+}

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

@@ -0,0 +1,15 @@
+import { readFileSync } from 'node:fs';
+import type { GlobalOpts } from './client';
+import { outputError } from './output';
+
+/** Read a text file, exiting with file_read_error if unreadable. */
+export function readFile(filePath: string, globalOpts: GlobalOpts): string {
+  try {
+    return readFileSync(filePath, 'utf-8');
+  } catch {
+    outputError(
+      { message: `Failed to read file: ${filePath}`, code: 'file_read_error' },
+      { json: globalOpts.json },
+    );
+  }
+}

package/temp_resend_cli/repo/src/lib/help-text.ts

@@ -0,0 +1,38 @@
+export interface HelpTextOptions {
+  context?: string; // All text before Global options (includes Non-interactive line if needed)
+  output?: string; // Content after "Output (--json or piped):" header (raw string, may be multi-line)
+  errorCodes?: string[]; // ['auth_error', 'list_error'] — joined with ' | '
+  examples: string[]; // Command strings without '$ ' prefix (added automatically)
+  setup?: boolean; // true = --json only (no --api-key); default false = full API variant
+}
+
+const GLOBAL_OPTS_FULL = `Global options:
+  --api-key <key>   API key (or set RESEND_API_KEY env var)
+  --team <name>     Team profile to use (overrides RESEND_TEAM)
+  --json            Force JSON output (also auto-enabled when stdout is piped)
+  -q, --quiet       Suppress spinners and status output (implies --json)`;
+
+const GLOBAL_OPTS_SETUP = `Global options:
+  --team <name>  Team profile to save the key to
+  --json         Force JSON output
+  -q, --quiet    Suppress spinners and status output (implies --json)`;
+
+const ERROR_ENVELOPE = `  {"error":{"message":"<message>","code":"<code>"}}`;
+
+export function buildHelpText(opts: HelpTextOptions): string {
+  const parts: string[] = [];
+  if (opts.context != null) {
+    parts.push(opts.context);
+  }
+  parts.push(opts.setup ? GLOBAL_OPTS_SETUP : GLOBAL_OPTS_FULL);
+  if (opts.output != null) {
+    parts.push(`Output (--json or piped):\n${opts.output}`);
+  }
+  if (opts.errorCodes != null) {
+    parts.push(
+      `Errors (exit code 1):\n${ERROR_ENVELOPE}\n  Codes: ${opts.errorCodes.join(' | ')}`,
+    );
+  }
+  parts.push(`Examples:\n${opts.examples.map((e) => `  $ ${e}`).join('\n')}`);
+  return `\n${parts.join('\n\n')}`;
+}

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

@@ -0,0 +1,56 @@
+import pc from 'picocolors';
+
+export function errorMessage(err: unknown, fallback: string): string {
+  return err instanceof Error ? err.message : fallback;
+}
+
+export interface OutputOptions {
+  json?: boolean;
+  exitCode?: number;
+}
+
+function shouldOutputJson(json?: boolean): boolean {
+  if (json) {
+    return true;
+  }
+  if (!process.stdout.isTTY) {
+    return true;
+  }
+  return false;
+}
+
+export function outputResult(data: unknown, opts: OutputOptions = {}): void {
+  if (shouldOutputJson(opts.json)) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    if (typeof data === 'string') {
+      console.log(data);
+    } else {
+      console.log(JSON.stringify(data, null, 2));
+    }
+  }
+  if (opts.exitCode !== undefined) {
+    process.exit(opts.exitCode);
+  }
+}
+
+export function outputError(
+  error: { message: string; code?: string },
+  opts: OutputOptions = {},
+): never {
+  const exitCode = opts.exitCode ?? 1;
+
+  if (shouldOutputJson(opts.json)) {
+    console.error(
+      JSON.stringify(
+        { error: { message: error.message, code: error.code ?? 'unknown' } },
+        null,
+        2,
+      ),
+    );
+  } else {
+    console.error(`${pc.red('Error:')} ${error.message}`);
+  }
+
+  process.exit(exitCode);
+}

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

@@ -0,0 +1,36 @@
+import type { GlobalOpts } from './client';
+import { outputError } from './output';
+
+export function parseLimitOpt(raw: string, globalOpts: GlobalOpts): number {
+  const limit = parseInt(raw, 10);
+  if (Number.isNaN(limit) || limit < 1 || limit > 100) {
+    outputError(
+      {
+        message: '--limit must be an integer between 1 and 100',
+        code: 'invalid_limit',
+      },
+      { json: globalOpts.json },
+    );
+  }
+  return limit;
+}
+
+export function buildPaginationOpts(
+  limit: number,
+  after?: string,
+  before?: string,
+) {
+  return after ? { limit, after } : before ? { limit, before } : { limit };
+}
+
+export function printPaginationHint(list: {
+  has_more: boolean;
+  data: Array<{ id: string }>;
+}): void {
+  if (list.has_more && list.data.length > 0) {
+    const last = list.data[list.data.length - 1];
+    console.log(
+      `\nMore results available. Use --after ${last.id} to fetch the next page.`,
+    );
+  }
+}

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

@@ -0,0 +1,149 @@
+import * as p from '@clack/prompts';
+import type { GlobalOpts } from './client';
+import { outputError } from './output';
+import { isInteractive } from './tty';
+
+export interface FieldSpec {
+  flag: string;
+  message: string;
+  placeholder?: string;
+  required?: boolean;
+  validate?: (value: string | undefined) => string | undefined;
+}
+
+export function cancelAndExit(message: string): never {
+  p.cancel(message);
+  process.exit(0);
+}
+
+/**
+ * Guard a delete action: error in non-interactive mode (no --yes), or show a
+ * confirmation prompt in interactive mode. Exits the process on cancel/rejection.
+ */
+export async function confirmDelete(
+  _id: string,
+  confirmMessage: string,
+  globalOpts: GlobalOpts,
+): Promise<void> {
+  if (!isInteractive()) {
+    outputError(
+      {
+        message: 'Use --yes to confirm deletion in non-interactive mode.',
+        code: 'confirmation_required',
+      },
+      { json: globalOpts.json },
+    );
+  }
+
+  const confirmed = await p.confirm({ message: confirmMessage });
+  if (p.isCancel(confirmed) || !confirmed) {
+    cancelAndExit('Deletion cancelled.');
+  }
+}
+
+export async function requireText(
+  value: string | undefined,
+  prompt: {
+    message: string;
+    placeholder?: string;
+    validate?: (value: string | undefined) => string | Error | undefined;
+  },
+  error: { message: string; code: string },
+  globalOpts: GlobalOpts,
+): Promise<string> {
+  if (value) {
+    return value;
+  }
+
+  if (!isInteractive()) {
+    outputError(error, { json: globalOpts.json });
+  }
+
+  const result = await p.text({
+    message: prompt.message,
+    placeholder: prompt.placeholder,
+    validate:
+      prompt.validate ??
+      ((v) =>
+        !v || v.length === 0 ? `${prompt.message} is required` : undefined),
+  });
+  if (p.isCancel(result)) {
+    cancelAndExit('Cancelled.');
+  }
+  return result;
+}
+
+export async function requireSelect<V extends string>(
+  value: V | undefined,
+  prompt: {
+    message: string;
+    options: Parameters<typeof p.select<V>>[0]['options'];
+  },
+  error: { message: string; code: string },
+  globalOpts: GlobalOpts,
+): Promise<V> {
+  if (value) {
+    return value;
+  }
+
+  if (!isInteractive()) {
+    outputError(error, { json: globalOpts.json });
+  }
+
+  const result = await p.select<V>({
+    message: prompt.message,
+    options: prompt.options,
+  });
+  if (p.isCancel(result)) {
+    cancelAndExit('Cancelled.');
+  }
+  return result;
+}
+
+export async function promptForMissing<
+  T extends Record<string, string | undefined>,
+>(
+  current: T,
+  fields: FieldSpec[],
+  globalOpts: GlobalOpts,
+): Promise<{ [K in keyof T]: string }> {
+  const missing = fields.filter(
+    (f) => f.required !== false && !current[f.flag],
+  );
+
+  if (missing.length === 0) {
+    return current as { [K in keyof T]: string };
+  }
+
+  if (!isInteractive()) {
+    const flags = missing.map((f) => `--${f.flag}`).join(', ');
+    outputError(
+      { message: `Missing required flags: ${flags}`, code: 'missing_flags' },
+      { json: globalOpts.json },
+    );
+  }
+
+  const result = await p.group(
+    Object.fromEntries(
+      missing.map((field) => [
+        field.flag,
+        () =>
+          p.text({
+            message: field.message,
+            placeholder: field.placeholder,
+            validate:
+              field.validate ??
+              ((v) =>
+                !v || v.length === 0
+                  ? `${field.message} is required`
+                  : undefined),
+          }),
+      ]),
+    ),
+    {
+      onCancel: () => cancelAndExit('Operation cancelled.'),
+    },
+  );
+
+  return { ...current, ...result } as { [K in keyof T]: string };
+}