@cakemail-org/cakemail-cli 1.5.0 → 2.0.0

package/package.json

@@ -1,59 +1,25 @@
 {
   "name": "@cakemail-org/cakemail-cli",
-  "version": "1.5.0",
-  "description": "Official Cakemail CLI - Command-line interface for the Cakemail API",
+  "version": "2.0.0",
+  "description": "CLI for the Cakemail API API",
   "type": "module",
-  "main": "./dist/index.js",
   "bin": {
     "cakemail": "./dist/cli.js"
   },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
   "scripts": {
-    "build": "tsc && chmod +x dist/cli.js",
-    "dev": "tsc --watch",
-    "start": "node dist/cli.js",
-    "clean": "rm -rf dist",
-    "rebuild": "npm run clean && npm run build",
-    "generate:types": "openapi-typescript https://api.cakemail.com/openapi.json -o src/types/api.ts",
-    "test": "echo \"Tests not yet implemented\" && exit 0"
+    "build": "tsc",
+    "dev": "tsx src/cli.ts"
   },
-  "keywords": [
-    "cakemail",
-    "cli",
-    "email",
-    "email-marketing",
-    "api",
-    "command-line",
-    "campaigns",
-    "transactional-email",
-    "analytics"
-  ],
-  "author": {
-    "name": "François Lane",
-    "email": "francois@cakemail.com"
-  },
-  "license": "MIT",
   "dependencies": {
-    "@cakemail-org/cakemail-sdk": "^2.0.0",
-    "axios": "^1.6.0",
-    "chalk": "^5.3.0",
-    "cli-table3": "^0.6.3",
-    "commander": "^12.0.0",
-    "dotenv": "^16.4.0",
-    "inquirer": "^9.3.8",
-    "ora": "^8.0.1"
+    "@cakemail-org/cakemail-sdk": "^2.2.0",
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0",
+    "ora": "^8.2.0"
   },
   "devDependencies": {
-    "@types/inquirer": "^9.0.9",
-    "@types/node": "^20.11.0",
-    "openapi-typescript": "^7.8.0",
-    "typescript": "^5.8.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
+    "@types/node": "^22.15.21",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
   }
-}
+}

package/src/cli.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+// ABOUTME: CLI entry point for cakemail.
+// ABOUTME: Registers all command groups and handles global options.
+
+import { Command } from 'commander';
+import { createClient } from './client.js';
+import { OutputFormatter } from './utils/output.js';
+import { getProfileConfig, type ProfileType, type ProfileConfig } from './types/profile.js';
+import { displayError } from './utils/errors.js';
+import { createAccountsCommand } from './commands/accounts.js';
+import { createActionsCommand } from './commands/actions.js';
+import { createCampaignBlueprintsCommand } from './commands/campaign-blueprints.js';
+import { createCampaignsCommand } from './commands/campaigns.js';
+import { createContactsCommand } from './commands/contacts.js';
+import { createCustomAttributesCommand } from './commands/custom-attributes.js';
+import { createDkimsCommand } from './commands/dkims.js';
+import { createDomainsCommand } from './commands/domains.js';
+import { createEmailApisCommand } from './commands/email-apis.js';
+import { createFormsCommand } from './commands/forms.js';
+import { createInterestsCommand } from './commands/interests.js';
+import { createLinksCommand } from './commands/links.js';
+import { createListsCommand } from './commands/lists.js';
+import { createLogosCommand } from './commands/logos.js';
+import { createLogsCommand } from './commands/logs.js';
+import { createReportsCommand } from './commands/reports.js';
+import { createSegmentsCommand } from './commands/segments.js';
+import { createSendersCommand } from './commands/senders.js';
+import { createSubAccountsCommand } from './commands/sub-accounts.js';
+import { createSuppressedEmailsCommand } from './commands/suppressed-emails.js';
+import { createSystemEmailsCommand } from './commands/system-emails.js';
+import { createTagsCommand } from './commands/tags.js';
+import { createTasksCommand } from './commands/tasks.js';
+import { createTemplatesCommand } from './commands/templates.js';
+import { createTokensCommand } from './commands/tokens.js';
+import { createTransactionalEmailsCommand } from './commands/transactional-emails.js';
+import { createUsersCommand } from './commands/users.js';
+import { createWebhooksCommand } from './commands/webhooks.js';
+import { createWorkflowBlueprintsCommand } from './commands/workflow-blueprints.js';
+import { createWorkflowsCommand } from './commands/workflows.js';
+
+async function main() {
+  const program = new Command();
+
+  program
+    .name('cakemail')
+    .description('CLI for the Cakemail API API')
+    .version('1.0.0')
+    .option('-f, --format <format>', 'Output format (json|table|compact)')
+    .option('--profile <type>', 'Profile (developer|marketer|balanced)')
+    .option('--access-token <token>', 'Access token (overrides env)')
+    .option('--batch', 'Run in batch/scripting mode');
+
+  const args = process.argv.slice(2);
+  const isHelp = args.includes('-h') || args.includes('--help');
+  const isVersion = args.length === 1 && (args[0] === '-V' || args[0] === '--version');
+
+  if (isVersion) {
+    await program.parseAsync(process.argv);
+    return;
+  }
+
+  try {
+    // Parse to get options before command execution
+    program.parseOptions(process.argv);
+    const opts = program.opts();
+
+    // Resolve profile
+    const profileType = (opts.profile || 'balanced') as ProfileType;
+    const profileConfig = getProfileConfig(profileType);
+
+    // Override format from CLI flag or use profile default
+    const format = opts.format || profileConfig.output.format;
+
+    // Apply batch mode
+    if (opts.batch) {
+      profileConfig.behavior.interactive_prompts = false;
+      profileConfig.behavior.confirm_destructive = false;
+      profileConfig.behavior.show_progress = false;
+    }
+
+    const client = createClient({
+      accessToken: opts.accessToken || process.env.CAKEMAIL_ACCESS_TOKEN,
+    });
+
+    const formatter = new OutputFormatter(format, profileConfig);
+
+    program.addCommand(createAccountsCommand(client, formatter));
+    program.addCommand(createActionsCommand(client, formatter));
+    program.addCommand(createCampaignBlueprintsCommand(client, formatter));
+    program.addCommand(createCampaignsCommand(client, formatter));
+    program.addCommand(createContactsCommand(client, formatter));
+    program.addCommand(createCustomAttributesCommand(client, formatter));
+    program.addCommand(createDkimsCommand(client, formatter));
+    program.addCommand(createDomainsCommand(client, formatter));
+    program.addCommand(createEmailApisCommand(client, formatter));
+    program.addCommand(createFormsCommand(client, formatter));
+    program.addCommand(createInterestsCommand(client, formatter));
+    program.addCommand(createLinksCommand(client, formatter));
+    program.addCommand(createListsCommand(client, formatter));
+    program.addCommand(createLogosCommand(client, formatter));
+    program.addCommand(createLogsCommand(client, formatter));
+    program.addCommand(createReportsCommand(client, formatter));
+    program.addCommand(createSegmentsCommand(client, formatter));
+    program.addCommand(createSendersCommand(client, formatter));
+    program.addCommand(createSubAccountsCommand(client, formatter));
+    program.addCommand(createSuppressedEmailsCommand(client, formatter));
+    program.addCommand(createSystemEmailsCommand(client, formatter));
+    program.addCommand(createTagsCommand(client, formatter));
+    program.addCommand(createTasksCommand(client, formatter));
+    program.addCommand(createTemplatesCommand(client, formatter));
+    program.addCommand(createTokensCommand(client, formatter));
+    program.addCommand(createTransactionalEmailsCommand(client, formatter));
+    program.addCommand(createUsersCommand(client, formatter));
+    program.addCommand(createWebhooksCommand(client, formatter));
+    program.addCommand(createWorkflowBlueprintsCommand(client, formatter));
+    program.addCommand(createWorkflowsCommand(client, formatter));
+
+    await program.parseAsync(process.argv);
+  } catch (error: any) {
+    displayError(error, { command: 'cakemail' });
+    process.exit(1);
+  }
+}
+
+main();

package/src/client.ts

@@ -0,0 +1,16 @@
+// ABOUTME: SDK wrapper for CLI usage.
+// ABOUTME: Configures the SDK client with authentication from CLI options or env vars.
+
+import { createClient as createSdkClient } from '@cakemail-org/cakemail-sdk';
+
+export interface ClientConfig {
+  accessToken?: string;
+  baseUrl?: string;
+}
+
+export function createClient(config: ClientConfig) {
+  return createSdkClient({
+    accessToken: config.accessToken,
+    baseUrl: config.baseUrl,
+  });
+}

package/src/commands/account.ts

@@ -0,0 +1,267 @@
+import { Command } from 'commander';
+import { CakemailClient } from '../client.js';
+import { OutputFormatter } from '../utils/output.js';
+import { saveCredentials, testCredentials } from '../utils/auth.js';
+import { readFileSync, existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import ora from '../utils/spinner.js';
+import chalk from 'chalk';
+import { confirmAction } from '../utils/confirm.js';
+
+export function createAccountCommand(client: CakemailClient, formatter: OutputFormatter): Command {
+  const account = new Command('account')
+    .description('Manage account context and multi-tenant access');
+
+  // Show current account
+  account
+    .command('show')
+    .description('Display current account details')
+    .action(async () => {
+      const spinner = ora('Fetching account details...').start();
+      try {
+        const data = await client.sdk.accountService.getSelfAccount();
+        spinner.stop();
+
+        const currentAccountId = process.env.CAKEMAIL_CURRENT_ACCOUNT_ID;
+        if (currentAccountId) {
+          formatter.info(`Current account context: ${currentAccountId}`);
+        }
+
+        formatter.output(data);
+      } catch (error: any) {
+        spinner.stop();
+        formatter.error(error.message);
+        process.exit(1);
+      }
+    });
+
+  // List all accessible accounts
+  account
+    .command('list')
+    .description('List all accessible accounts (parent and sub-accounts)')
+    .option('-r, --recursive', 'Include nested sub-accounts')
+    .action(async (options) => {
+      const spinner = ora('Fetching accessible accounts...').start();
+      try {
+        // Get main account
+        const mainAccount = await client.sdk.accountService.getSelfAccount();
+        const accounts: Array<{ id: string; name?: string }> = [mainAccount.data];
+
+        // Get sub-accounts
+        const subAccounts = await client.sdk.subAccountService.listAccounts({
+          partnerAccountId: parseInt(mainAccount.data.id),
+          recursive: options.recursive !== false
+        });
+
+        if (subAccounts.data && subAccounts.data.length > 0) {
+          accounts.push(...subAccounts.data);
+        }
+
+        spinner.stop();
+
+        // Mark current account
+        const currentAccountId = process.env.CAKEMAIL_CURRENT_ACCOUNT_ID || mainAccount.data.id;
+
+        // Add current marker to each account for display
+        const accountsWithMarker = accounts.map(acc => ({
+          ...acc,
+          current: acc.id === currentAccountId
+        }));
+
+        formatter.output({ data: accountsWithMarker, count: accounts.length });
+      } catch (error: any) {
+        spinner.stop();
+        formatter.error(error.message);
+        process.exit(1);
+      }
+    });
+
+  // Switch active account
+  account
+    .command('use <id>')
+    .description('Switch active account context')
+    .action(async (id: string) => {
+      const spinner = ora('Switching account context...').start();
+      try {
+        const accountId = id;
+
+        // Verify the account exists and is accessible
+        // First check if it's the main account
+        const mainAccount = await client.sdk.accountService.getSelfAccount();
+
+        if (mainAccount.data.id === accountId) {
+          // It's the main account
+          spinner.stop();
+        } else {
+          // Check sub-accounts
+          const subAccounts = await client.sdk.subAccountService.listAccounts({
+            partnerAccountId: parseInt(mainAccount.data.id),
+            recursive: true
+          });
+
+          const hasAccess = subAccounts.data?.some(acc => acc.id === accountId);
+
+          if (!hasAccess) {
+            spinner.stop();
+            formatter.error(`Account ${accountId} not found or not accessible`);
+            process.exit(1);
+          }
+
+          spinner.stop();
+        }
+
+        // Update .env file with new account context
+        const envPath = join(process.cwd(), '.env');
+        let envContent = '';
+
+        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 account ID
+        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');
+
+        // Get account name for confirmation
+        let accountName = `Account ${accountId}`;
+        if (mainAccount.data.id === accountId) {
+          accountName = mainAccount.data.name || accountName;
+        } else {
+          const subAccounts = await client.sdk.subAccountService.listAccounts({
+            partnerAccountId: parseInt(mainAccount.data.id),
+            recursive: true
+          });
+          const targetAccount = subAccounts.data?.find(acc => acc.id === accountId);
+          if (targetAccount) {
+            accountName = targetAccount.name || accountName;
+          }
+        }
+
+        formatter.success(`Now using: ${accountName} (ID: ${accountId})`);
+      } catch (error: any) {
+        spinner.stop();
+        formatter.error(error.message);
+        process.exit(1);
+      }
+    });
+
+  // Test current credentials
+  account
+    .command('test')
+    .description('Validate current credentials')
+    .action(async () => {
+      const spinner = ora('Testing credentials...').start();
+      try {
+        const email = process.env.CAKEMAIL_EMAIL;
+        const password = process.env.CAKEMAIL_PASSWORD;
+
+        if (!email || !password) {
+          spinner.stop();
+          formatter.error('No credentials found in .env file');
+          process.exit(1);
+        }
+
+        const isValid = await testCredentials(email, password);
+
+        spinner.stop();
+
+        if (isValid) {
+          formatter.success('Credentials are valid');
+
+          // Show account info
+          const accountData = await client.sdk.accountService.getSelfAccount();
+          const account = accountData.data;
+          formatter.output({
+            authenticated_as: email,
+            account: account.name || `ID ${account.id}`,
+            ...account
+          });
+        } else {
+          formatter.error('Invalid credentials');
+          process.exit(1);
+        }
+      } catch (error: any) {
+        spinner.stop();
+        formatter.error(error.message);
+        process.exit(1);
+      }
+    });
+
+  // Logout (remove credentials)
+  account
+    .command('logout')
+    .description('Remove credentials from .env file')
+    .option('-f, --force', 'Skip confirmation prompt')
+    .action(async (options) => {
+      // Interactive confirmation (unless --force is used)
+      if (!options.force) {
+        const confirmed = await confirmAction('Log out and remove credentials?', [
+          'Credentials will be removed from .env file',
+          'You will need to re-authenticate'
+        ], 'low');
+
+        if (!confirmed) {
+          formatter.info('Logout cancelled');
+          return;
+        }
+      }
+
+      try {
+        const envPath = join(process.cwd(), '.env');
+
+        if (!existsSync(envPath)) {
+          formatter.info('No .env file found');
+          return;
+        }
+
+        const envContent = readFileSync(envPath, 'utf-8');
+        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();
+          }
+        });
+
+        // Remove auth-related variables
+        delete envVars['CAKEMAIL_EMAIL'];
+        delete envVars['CAKEMAIL_PASSWORD'];
+        delete envVars['CAKEMAIL_ACCESS_TOKEN'];
+        delete envVars['CAKEMAIL_CURRENT_ACCOUNT_ID'];
+
+        // Rebuild .env content
+        const newEnvContent = Object.entries(envVars)
+          .map(([key, value]) => `${key}=${value}`)
+          .join('\n') + '\n';
+
+        writeFileSync(envPath, newEnvContent, 'utf-8');
+
+        formatter.success('Logged out successfully');
+        formatter.info('Credentials removed from .env file');
+      } catch (error: any) {
+        formatter.error(error.message);
+        process.exit(1);
+      }
+    });
+
+  return account;
+}

package/src/commands/accounts.ts

@@ -0,0 +1,78 @@
+// ABOUTME: CLI commands for Account.
+// ABOUTME: Generated by api-kit from the OpenAPI spec.
+
+import { Command } from 'commander';
+import { createSpinner } from '../utils/spinner.js';
+
+export function createAccountsCommand(
+  client: any,
+  formatter: any
+): Command {
+  const cmd = new Command('accounts')
+    .description('Manage the authenticated user's own account. An account represents an organization on the platform with its own contacts, campaigns, and settings. Use these endpoints to view or update account details, address, and domains. To manage sub-accounts under a partner account, see the Sub-Account endpoints.');
+
+
+  cmd
+    .command('get-self')
+    .description('Show my account details')
+    .action(async () => {
+      const spinner = createSpinner('Fetching account...').start();
+      try {
+        const data = await client.getSelfAccount({
+        });
+
+        spinner.stop();
+        formatter.output(data);
+      } catch (error: any) {
+        spinner.stop();
+        formatter.error(error.message);
+        process.exit(1);
+      }
+    });
+
+
+  cmd
+    .command('patch-self')
+    .description('Update my account')
+    .requiredOption('--data <value>', 'Request body as JSON string')
+    .action(async (options) => {
+      const spinner = createSpinner('Updating account...').start();
+      try {
+        const body = JSON.parse(options.data);
+        const data = await client.patchSelfAccount({
+          ...body,
+        });
+
+        spinner.stop();
+        formatter.success('Account updated successfully');
+        formatter.output(data);
+      } catch (error: any) {
+        spinner.stop();
+        formatter.error(error.message);
+        process.exit(1);
+      }
+    });
+
+
+  cmd
+    .command('convert-self-account-to-organization')
+    .description('Convert my account to an Organization')
+    .action(async () => {
+      const spinner = createSpinner('Creating account...').start();
+      try {
+        const data = await client.convertSelfAccountToOrganization({
+        });
+
+        spinner.stop();
+        formatter.success('Account created successfully');
+        formatter.output(data);
+      } catch (error: any) {
+        spinner.stop();
+        formatter.error(error.message);
+        process.exit(1);
+      }
+    });
+
+
+  return cmd;
+}