@cakemail-org/cakemail-cli 1.5.0 → 2.0.0

package/src/utils/auth.ts

@@ -0,0 +1,272 @@
+import inquirer from 'inquirer';
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { CakemailClient as SDK } from '@cakemail-org/cakemail-sdk';
+import chalk from 'chalk';
+import { ProfileType, PROFILE_DESCRIPTIONS } from '../types/profile.js';
+import { updateConfigFile, configFileExists } from './config-file.js';
+
+export interface Credentials {
+  email: string;
+  password: string;
+}
+
+/**
+ * Prompts the user to select their profile type
+ */
+export async function promptForProfile(): Promise<ProfileType> {
+  console.log(chalk.cyan('\n✨ One more thing - let\'s personalize your experience!\n'));
+  console.log(chalk.white('What best describes how you\'ll use Cakemail CLI?\n'));
+
+  // Build choices from profile descriptions
+  const choices = Object.entries(PROFILE_DESCRIPTIONS).map(([key, info], index) => {
+    const description = info.description.map(d => `     ${chalk.gray('•')} ${d}`).join('\n');
+    return {
+      name: `${index + 1}. ${info.name}\n${description}\n`,
+      value: key as ProfileType,
+      short: info.name
+    };
+  });
+
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'profile',
+      message: 'Choose your profile:',
+      choices,
+      pageSize: 10
+    }
+  ]);
+
+  console.log(chalk.gray(`\n💡 You can change this anytime with: ${chalk.cyan('cakemail config profile <type>')}\n`));
+
+  return answer.profile;
+}
+
+/**
+ * Prompts the user for their Cakemail credentials
+ */
+export async function promptForCredentials(): Promise<Credentials> {
+  console.log(chalk.yellow('⚠ Not authenticated'));
+  console.log(chalk.gray('Please enter your Cakemail credentials:\n'));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'email',
+      message: 'Email:',
+      validate: (input: string) => {
+        if (!input || !input.includes('@')) {
+          return 'Please enter a valid email address';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'password',
+      name: 'password',
+      message: 'Password:',
+      mask: '*',
+      validate: (input: string) => {
+        if (!input || input.length < 1) {
+          return 'Please enter your password';
+        }
+        return true;
+      }
+    }
+  ]);
+
+  return {
+    email: answers.email,
+    password: answers.password
+  };
+}
+
+/**
+ * Tests credentials by attempting to authenticate with the API
+ * Returns token information if successful
+ */
+export async function testCredentials(email: string, password: string): Promise<{
+  valid: boolean;
+  accessToken?: string;
+  refreshToken?: string;
+  expiresIn?: number;
+  accounts?: number[];
+}> {
+  try {
+    const sdk = new SDK({
+      email,
+      password,
+      baseURL: process.env.CAKEMAIL_API_BASE || 'https://api.cakemail.dev'
+    });
+
+    // Get tokens using the TokenService
+    const tokenResponse = await sdk.tokenService.createToken({
+      formData: {
+        grant_type: 'password',
+        username: email,
+        password: password
+      }
+    });
+
+    // Handle potential MFA challenge
+    if ('challenge' in tokenResponse) {
+      // MFA is enabled - for now we'll return false
+      // TODO: Implement MFA flow
+      console.log(chalk.yellow('⚠ Multi-factor authentication is enabled on this account'));
+      console.log(chalk.gray('MFA support is coming soon. Please disable MFA temporarily.'));
+      return { valid: false };
+    }
+
+    return {
+      valid: true,
+      accessToken: tokenResponse.access_token,
+      refreshToken: tokenResponse.refresh_token,
+      expiresIn: tokenResponse.expires_in,
+      accounts: tokenResponse.accounts
+    };
+  } catch (error: any) {
+    return { valid: false };
+  }
+}
+
+/**
+ * Saves credentials to .env file in current working directory
+ */
+export function saveCredentials(email: string, password: string, accountId?: string): void {
+  const envPath = join(process.cwd(), '.env');
+  let envContent = '';
+
+  // Read existing .env if it exists
+  if (existsSync(envPath)) {
+    envContent = readFileSync(envPath, 'utf-8');
+  }
+
+  // Parse existing env variables
+  const envLines = envContent.split('\n');
+  const envVars: Record<string, string> = {};
+
+  envLines.forEach(line => {
+    const match = line.match(/^([^=]+)=(.*)$/);
+    if (match) {
+      envVars[match[1].trim()] = match[2].trim();
+    }
+  });
+
+  // Update credentials
+  envVars['CAKEMAIL_EMAIL'] = email;
+  envVars['CAKEMAIL_PASSWORD'] = password;
+
+  if (accountId !== undefined) {
+    envVars['CAKEMAIL_CURRENT_ACCOUNT_ID'] = accountId;
+  }
+
+  // Rebuild .env content
+  const newEnvContent = Object.entries(envVars)
+    .map(([key, value]) => `${key}=${value}`)
+    .join('\n') + '\n';
+
+  writeFileSync(envPath, newEnvContent, 'utf-8');
+}
+
+/**
+ * Interactive authentication flow - prompts for credentials and saves them
+ */
+export async function authenticateInteractively(): Promise<Credentials> {
+  const credentials = await promptForCredentials();
+
+  console.log(chalk.gray('\nValidating credentials...'));
+
+  const authResult = await testCredentials(credentials.email, credentials.password);
+
+  if (!authResult.valid) {
+    console.log(chalk.red('✗ Invalid credentials. Please try again.\n'));
+    // Retry
+    return authenticateInteractively();
+  }
+
+  console.log(chalk.green('✓ Authenticated'));
+
+  // Fetch account info to show welcome message
+  let accountId: string | undefined;
+  try {
+    const sdk = new SDK({
+      email: credentials.email,
+      password: credentials.password,
+      baseURL: process.env.CAKEMAIL_API_BASE || 'https://api.cakemail.dev'
+    });
+
+    const accountResponse = await sdk.accountService.getSelfAccount();
+    const account = accountResponse.data;
+    accountId = account.id;
+
+    // List all accessible accounts with count
+    const accountsResponse = await sdk.subAccountService.listAccounts({
+      partnerAccountId: parseInt(account.id),
+      recursive: true,
+      withCount: true
+    });
+
+    // Use actual count from pagination if available, otherwise show "X+" for first page
+    const subAccountCount = accountsResponse.pagination?.count ?? accountsResponse.data?.length ?? 0;
+    const totalAccounts = 1 + subAccountCount;
+    const hasMorePages = accountsResponse.pagination?.count === null && (accountsResponse.data?.length || 0) >= 50;
+
+    const accountMessage = hasMorePages
+      ? `Welcome! You have access to ${totalAccounts}+ accounts.`
+      : `Welcome! You have access to ${totalAccounts} account${totalAccounts > 1 ? 's' : ''}.`;
+
+    console.log(chalk.cyan(`\n${accountMessage}`));
+
+    if (totalAccounts > 1) {
+      console.log(chalk.gray(`Use 'cakemail account list' to see all accounts.`));
+      console.log(chalk.gray(`Use 'cakemail account use <id>' to switch accounts.`));
+    }
+  } catch (error) {
+    // If we can't fetch account info, just show basic welcome
+    console.log(chalk.cyan('\nWelcome!\n'));
+  }
+
+  // Check if this is first-time setup (no config file exists yet)
+  const isFirstTimeSetup = !configFileExists();
+
+  // Prompt for profile selection on first-time setup
+  let selectedProfile: ProfileType | undefined;
+  if (isFirstTimeSetup) {
+    selectedProfile = await promptForProfile();
+    console.log(chalk.green(`✓ Profile set to: ${PROFILE_DESCRIPTIONS[selectedProfile].name}`));
+  }
+
+  // Save to config file (preferred) or fallback to .env
+  if (isFirstTimeSetup || configFileExists()) {
+    // Save to config file with tokens
+    const configUpdate: any = {
+      version: '1.0',
+      auth: {
+        method: 'token',
+        access_token: authResult.accessToken,
+        refresh_token: authResult.refreshToken,
+        expires_in: authResult.expiresIn,
+        email: credentials.email,
+        base_url: process.env.CAKEMAIL_API_BASE || 'https://api.cakemail.dev'
+      },
+      defaults: accountId ? { account_id: accountId } : undefined
+    };
+
+    // Only set profile during first-time setup to avoid overwriting user's profile choice
+    if (isFirstTimeSetup) {
+      configUpdate.profile = selectedProfile || 'balanced';
+    }
+
+    updateConfigFile(configUpdate);
+    console.log(chalk.green('✓ Configuration saved to ~/.cakemail/config.json'));
+  } else {
+    // Fallback to .env for backward compatibility
+    saveCredentials(credentials.email, credentials.password, accountId);
+    console.log(chalk.green('✓ Credentials saved to .env'));
+  }
+
+  console.log(chalk.gray('\n' + '─'.repeat(50) + '\n'));
+
+  return credentials;
+}

package/src/utils/config-file.ts

@@ -0,0 +1,96 @@
+// ABOUTME: Persists CLI configuration to ~/.{binaryName}/config.json.
+// ABOUTME: Stores profile choice, auth credentials, and default values.
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { getProfileConfig, type ProfileType, type ProfileConfig } from '../types/profile.js';
+
+const CONFIG_DIR = join(homedir(), '.cakemail');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+export interface ConfigFile {
+  version: string;
+  profile?: ProfileType;
+  auth?: {
+    method?: 'password' | 'token';
+    email?: string;
+    access_token?: string;
+    refresh_token?: string;
+    expires_in?: number;
+    base_url?: string;
+  };
+  profiles?: Partial<Record<ProfileType, Partial<ProfileConfig>>>;
+  defaults?: {
+    list_id?: number;
+    sender_id?: number;
+    account_id?: number;
+  };
+}
+
+function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function configFileExists(): boolean {
+  return existsSync(CONFIG_FILE);
+}
+
+export function loadConfigFile(): ConfigFile | undefined {
+  if (!configFileExists()) return undefined;
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(content) as ConfigFile;
+  } catch {
+    return undefined;
+  }
+}
+
+export function saveConfigFile(config: ConfigFile): void {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+export function updateConfigFile(updates: Partial<ConfigFile>): void {
+  const current = loadConfigFile() || { version: '1.0.0' };
+  const merged = { ...current, ...updates };
+  saveConfigFile(merged);
+}
+
+export function getCurrentProfile(): ProfileType {
+  const config = loadConfigFile();
+  return config?.profile ?? 'balanced';
+}
+
+export function setCurrentProfile(profile: ProfileType): void {
+  updateConfigFile({ profile });
+}
+
+export function getResolvedProfileConfig(profileType?: ProfileType): ProfileConfig {
+  const type = profileType ?? getCurrentProfile();
+  const base = getProfileConfig(type);
+  const config = loadConfigFile();
+  const overrides = config?.profiles?.[type];
+
+  if (!overrides) return base;
+
+  return {
+    output: { ...base.output, ...overrides.output },
+    behavior: { ...base.behavior, ...overrides.behavior },
+    display: { ...base.display, ...overrides.display },
+  };
+}
+
+export function getDefaults(): { list_id?: number; sender_id?: number; account_id?: number } {
+  const config = loadConfigFile();
+  return config?.defaults ?? {};
+}
+
+export function setDefault(key: 'list_id' | 'sender_id' | 'account_id', value: number): void {
+  const config = loadConfigFile() || { version: '1.0.0' };
+  if (!config.defaults) config.defaults = {};
+  config.defaults[key] = value;
+  saveConfigFile(config);
+}

package/src/utils/config.ts

@@ -0,0 +1,134 @@
+import { config } from 'dotenv';
+import { CakemailConfig } from '../client.js';
+import { authenticateInteractively } from './auth.js';
+import { ProfileType, ProfileConfig, OutputFormat } from '../types/profile.js';
+import {
+  loadConfigFile,
+  getProfileConfig,
+  getCurrentProfile,
+  migrateFromEnv,
+  ConfigFile
+} from './config-file.js';
+
+// Load .env from current working directory (fallback for backward compatibility)
+config({ path: process.cwd() + '/.env' });
+
+// Re-export types for backward compatibility
+export type { OutputFormat, ProfileType, ProfileConfig };
+
+export interface FullConfig extends CakemailConfig {
+  outputFormat?: OutputFormat;
+  currentAccountId?: string;
+  profile?: ProfileType;
+  profileConfig?: ProfileConfig;
+  refreshToken?: string;
+  expiresIn?: number;
+}
+
+export async function getConfig(required: boolean = true, interactive: boolean = true): Promise<FullConfig> {
+  // Try to load from config file first
+  let configFile = loadConfigFile();
+
+  // If no config file exists, try to migrate from .env
+  if (!configFile) {
+    configFile = migrateFromEnv();
+  }
+
+  // Load credentials from config file or .env
+  let accessToken = configFile?.auth?.access_token || configFile?.auth?.token || process.env.CAKEMAIL_ACCESS_TOKEN;
+  let refreshToken = configFile?.auth?.refresh_token;
+  let expiresIn = configFile?.auth?.expires_in;
+  let email = configFile?.auth?.email || process.env.CAKEMAIL_EMAIL || process.env.CAKEMAIL_USERNAME;
+  let password = process.env.CAKEMAIL_PASSWORD; // Password not stored in config (security)
+  const baseURL = process.env.CAKEMAIL_API_BASE || configFile?.auth?.base_url;
+  const currentAccountId = configFile?.defaults?.account_id || process.env.CAKEMAIL_CURRENT_ACCOUNT_ID || undefined;
+
+  // Load profile configuration
+  const profile = getCurrentProfile();
+  const profileConfig = getProfileConfig(profile);
+
+  // Output format priority: env var > profile config > default
+  const outputFormat = (process.env.CAKEMAIL_OUTPUT_FORMAT as OutputFormat) || profileConfig.output.format;
+
+  // If credentials are missing and interactive mode is enabled, prompt the user
+  if (required && !accessToken && (!email || !password)) {
+    if (interactive) {
+      // Interactive authentication flow
+      const credentials = await authenticateInteractively();
+      email = credentials.email;
+      password = credentials.password;
+
+      // Reload config file (it was updated by auth flow)
+      configFile = loadConfigFile();
+
+      // Reload .env to get any updates from authentication (backward compatibility)
+      config({ path: process.cwd() + '/.env', override: true });
+    } else {
+      throw new Error(
+        'Missing credentials. Set CAKEMAIL_ACCESS_TOKEN or (CAKEMAIL_EMAIL and CAKEMAIL_PASSWORD) in environment variables, .env file, or run authentication'
+      );
+    }
+  }
+
+  return {
+    accessToken,
+    refreshToken,
+    expiresIn,
+    email,
+    password,
+    baseURL,
+    outputFormat,
+    currentAccountId,
+    profile,
+    profileConfig,
+  };
+}
+
+/**
+ * Synchronous version of getConfig for backwards compatibility
+ * Use this only when you're certain credentials are already set
+ */
+export function getConfigSync(required: boolean = true): FullConfig {
+  // Try to load from config file first
+  let configFile = loadConfigFile();
+
+  // If no config file exists, try to migrate from .env
+  if (!configFile) {
+    configFile = migrateFromEnv();
+  }
+
+  // Load credentials from config file or .env
+  const accessToken = configFile?.auth?.access_token || configFile?.auth?.token || process.env.CAKEMAIL_ACCESS_TOKEN;
+  const refreshToken = configFile?.auth?.refresh_token;
+  const expiresIn = configFile?.auth?.expires_in;
+  const email = configFile?.auth?.email || process.env.CAKEMAIL_EMAIL || process.env.CAKEMAIL_USERNAME;
+  const password = process.env.CAKEMAIL_PASSWORD; // Password not stored in config (security)
+  const baseURL = process.env.CAKEMAIL_API_BASE || configFile?.auth?.base_url;
+  const currentAccountId = configFile?.defaults?.account_id || process.env.CAKEMAIL_CURRENT_ACCOUNT_ID || undefined;
+
+  // Load profile configuration
+  const profile = getCurrentProfile();
+  const profileConfig = getProfileConfig(profile);
+
+  // Output format priority: env var > profile config > default
+  const outputFormat = (process.env.CAKEMAIL_OUTPUT_FORMAT as OutputFormat) || profileConfig.output.format;
+
+  if (required && !accessToken && (!email || !password)) {
+    throw new Error(
+      'Missing credentials. Set CAKEMAIL_ACCESS_TOKEN or (CAKEMAIL_EMAIL and CAKEMAIL_PASSWORD) in environment variables, .env file, or run authentication'
+    );
+  }
+
+  return {
+    accessToken,
+    refreshToken,
+    expiresIn,
+    email,
+    password,
+    baseURL,
+    outputFormat,
+    currentAccountId,
+    profile,
+    profileConfig,
+  };
+}

package/src/utils/confirm.ts

@@ -0,0 +1,32 @@
+// ABOUTME: Profile-aware confirmation prompt for destructive operations.
+// ABOUTME: Skips in developer profile or batch mode.
+
+import * as readline from 'node:readline';
+import type { ProfileConfig } from '../types/profile.js';
+
+export async function confirmDelete(
+  resourceType: string,
+  resourceId: string,
+  profileConfig?: ProfileConfig,
+): Promise<boolean> {
+  const shouldConfirm = profileConfig?.behavior.confirm_destructive ?? true;
+
+  if (!shouldConfirm || !process.stdout.isTTY || process.argv.includes('--batch')) {
+    return true;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(
+      `Delete ${resourceType} "${resourceId}"? This cannot be undone. [y/N] `,
+      (answer) => {
+        rl.close();
+        resolve(answer.toLowerCase() === 'y');
+      },
+    );
+  });
+}

package/src/utils/defaults.ts

@@ -0,0 +1,99 @@
+// ABOUTME: Smart auto-detection for common resources.
+// ABOUTME: Uses session cache and config defaults to reduce required flags.
+
+import { getDefaults, setDefault } from './config-file.js';
+import type { OutputFormatter } from './output.js';
+
+interface CachedResource {
+  id: number | string;
+  name?: string;
+  timestamp: number;
+}
+
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const sessionCache = new Map<string, CachedResource>();
+
+export async function autoDetectList(
+  client: any,
+  formatter: OutputFormatter,
+  providedListId?: number,
+): Promise<number | undefined> {
+  if (providedListId) {
+    sessionCache.set('list', { id: providedListId, timestamp: Date.now() });
+    return providedListId;
+  }
+
+  // Check session cache
+  const cached = sessionCache.get('list');
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    return cached.id as number;
+  }
+
+  // Check config defaults
+  const defaults = getDefaults();
+  if (defaults.list_id) return defaults.list_id;
+
+  // Fetch all lists and auto-select if only one
+  try {
+    const result = await client.listService?.listLists?.({ page: 1, perPage: 2 });
+    const lists = result?.data ?? [];
+
+    if (lists.length === 1) {
+      const listId = lists[0].id;
+      sessionCache.set('list', { id: listId, name: lists[0].name, timestamp: Date.now() });
+      formatter.info(`Using list: ${lists[0].name} (${listId})`);
+      return listId;
+    }
+
+    if (lists.length > 1) {
+      formatter.info('Multiple lists found. Use --list-id to specify.');
+    }
+  } catch {
+    // Auto-detection is best-effort
+  }
+
+  return undefined;
+}
+
+export async function autoDetectSender(
+  client: any,
+  formatter: OutputFormatter,
+  providedSenderId?: number,
+): Promise<number | undefined> {
+  if (providedSenderId) {
+    sessionCache.set('sender', { id: providedSenderId, timestamp: Date.now() });
+    return providedSenderId;
+  }
+
+  const cached = sessionCache.get('sender');
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    return cached.id as number;
+  }
+
+  const defaults = getDefaults();
+  if (defaults.sender_id) return defaults.sender_id;
+
+  try {
+    const result = await client.senderService?.listSenders?.({ page: 1, perPage: 2 });
+    const senders = (result?.data ?? []).filter((s: any) => s.confirmed);
+
+    if (senders.length === 1) {
+      const senderId = senders[0].id;
+      sessionCache.set('sender', { id: senderId, name: senders[0].email, timestamp: Date.now() });
+      formatter.info(`Using sender: ${senders[0].email} (${senderId})`);
+      return senderId;
+    }
+
+    if (senders.length > 1) {
+      formatter.info('Multiple senders found. Use --sender-id to specify.');
+    }
+  } catch {
+    // Auto-detection is best-effort
+  }
+
+  return undefined;
+}
+
+export function clearCache(): void {
+  sessionCache.clear();
+}