create-loadout 1.0.0 → 1.0.2

package/README.md

@@ -76,10 +76,11 @@ your-app/
 | 🗄️  | **Neon + Drizzle** | Serverless Postgres with full CRUD example |
 | 🤖  | **AI SDK**         | OpenAI / Anthropic / Google                |
 | 📧  | **Resend**         | Email service + React email templates      |
+| 📬  | **Postmark**       | Transactional email with top deliverability |
 | 🔥  | **Firecrawl**      | Web scraping service                       |
 | ⏰  | **Inngest**        | Background jobs                            |
 | 📁  | **UploadThing**    | File uploads                               |
-| 💳  | **Stripe**         | Checkout, webhooks, customer portal        |
+| 💳  | **Stripe**         | Payment service with checkout + billing    |
 | 📊  | **PostHog**        | Product analytics                          |
 | 🐛  | **Sentry**         | Error tracking                             |
 
@@ -89,27 +90,94 @@ your-app/
 
 ## How It Works
 
-### 1. Run the CLI
+### Interactive Mode
 
 ```bash
 npx create-loadout
 ```
 
-### 2. Answer the Prompts
+Answer the prompts — project name, integrations, AI provider — and you're done.
 
-- Project name
-- Which integrations you need
-- AI provider (if using AI SDK)
+### Non-Interactive Mode
 
-### 3. Start Building
+Skip the prompts entirely with CLI flags:
+
+```bash
+npx create-loadout my-app --clerk --neon-drizzle --stripe
+```
+
+All available flags:
+
+```
+--clerk              Clerk authentication
+--neon-drizzle       Neon + Drizzle database
+--ai-sdk             Vercel AI SDK
+--ai-provider <p>    AI provider (openai, anthropic, google)
+--resend             Resend email
+--postmark           Postmark email
+--firecrawl          Firecrawl web scraping
+--inngest            Inngest background jobs
+--uploadthing        UploadThing file uploads
+--stripe             Stripe payments
+--posthog            PostHog analytics
+--sentry             Sentry error tracking
+```
+
+Add integrations to an existing project:
+
+```bash
+npx create-loadout --add --posthog --sentry
+```
+
+Use a config file:
+
+```bash
+npx create-loadout --config loadout.json
+```
+
+```json
+{
+  "name": "my-app",
+  "integrations": ["clerk", "neon-drizzle", "stripe"],
+  "aiProvider": "anthropic"
+}
+```
+
+List all integrations as JSON:
+
+```bash
+npx create-loadout --list
+```
+
+### Start Building
 
 ```bash
 cd your-app
-npm install
 npm run dev
 ```
 
-That's it. Fill in `.env.local` and you're live.
+Fill in `.env.local` and you're live.
+
+---
+
+## MCP Server for Claude Code
+
+Loadout ships an MCP server so Claude Code agents can scaffold and extend projects programmatically.
+
+### Register
+
+```bash
+claude mcp add create-loadout -- npx -y create-loadout-mcp
+```
+
+### Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_integrations` | List all integrations with metadata, env vars, and constraints |
+| `create_project` | Scaffold a new Next.js project with selected integrations |
+| `add_integrations` | Add integrations to an existing project |
+| `detect_project` | Check if a directory is a Next.js project, list installed/available integrations |
 
 ---
 

package/dist/claude-md.js

@@ -43,6 +43,13 @@ const stackSections = [
             { name: 'Resend', url: 'https://resend.com/docs', description: 'Email API' },
         ],
     },
+    {
+        id: 'postmark',
+        name: 'Email',
+        items: [
+            { name: 'Postmark', url: 'https://postmarkapp.com/developer', description: 'Transactional email' },
+        ],
+    },
     {
         id: 'firecrawl',
         name: 'Scraping',
@@ -142,8 +149,8 @@ npm run inngest:dev  # Start Inngest dev server for local testing
 ├── app/                    # Next.js App Router pages and API routes
 ├── components/             # React components (including shadcn/ui)
 `;
-    if (config.integrations.includes('resend')) {
-        content += `│   └── emails/             # React Email templates
+    if (config.integrations.includes('resend') || config.integrations.includes('postmark')) {
+        content += `│   └── emails/             # Email templates
 `;
     }
     if (hasPostHog || hasSentry) {

package/dist/cli.js

@@ -1,19 +1,16 @@
 import chalk from 'chalk';
 import ora from 'ora';
-import fs from 'fs/promises';
 import path from 'path';
 import { getProjectConfig, getAddIntegrationConfig } from './prompts.js';
-import { createNextApp } from './create-next.js';
-import { setupShadcn } from './setup-shadcn.js';
-import { installIntegrations } from './integrations/index.js';
-import { generateClaudeMd, appendClaudeMd } from './claude-md.js';
-import { generateEnvFiles, appendEnvFiles } from './env.js';
-import { generateConfig, appendConfig } from './config.js';
-import { generateReadme, generateGitignore } from './generate-readme.js';
-import { generateInstrumentationClient, generateInstrumentation, } from './instrumentation.js';
-import { zustandTemplates } from './templates/zustand.js';
-import { generateLandingPage } from './landing-page.js';
+import { createProject, addIntegrations } from './engine.js';
 import { isExistingProject, getInstalledIntegrations, getAvailableIntegrations, } from './detect.js';
+function oraReporter() {
+    const spinner = ora();
+    const callback = (step) => {
+        spinner.start(step);
+    };
+    return { spinner, callback };
+}
 export async function main() {
     console.log();
     console.log(chalk.bold.cyan('  create-loadout'));
@@ -37,36 +34,8 @@ export async function main() {
 async function newProjectFlow() {
     const config = await getProjectConfig();
     console.log();
-    const spinner = ora('Creating Next.js app...').start();
-    const projectPath = await createNextApp(config.name);
-    spinner.succeed('Next.js app created');
-    spinner.start('Setting up shadcn/ui...');
-    await setupShadcn(projectPath);
-    spinner.succeed('shadcn/ui configured');
-    await extendUtils(projectPath);
-    spinner.start('Installing base packages...');
-    const { execa } = await import('execa');
-    await execa('npm', ['install', 'zod@^3.24', 'zustand@^5', 'luxon@^3'], { cwd: projectPath });
-    await execa('npm', ['install', '-D', '@types/luxon'], { cwd: projectPath });
-    spinner.succeed('Base packages installed (zod, zustand, luxon)');
-    await fs.mkdir(path.join(projectPath, 'lib/stores'), { recursive: true });
-    await fs.writeFile(path.join(projectPath, 'lib/stores/counter.store.ts'), zustandTemplates.exampleStore);
-    if (config.integrations.length > 0) {
-        spinner.start(`Setting up ${config.integrations.length} integration(s)...`);
-        await installIntegrations(projectPath, config);
-        spinner.succeed('Integrations configured');
-    }
-    await generateInstrumentationClient(projectPath, config);
-    await generateInstrumentation(projectPath, config);
-    spinner.start('Generating config and environment files...');
-    await generateConfig(projectPath, config);
-    await generateEnvFiles(projectPath, config);
-    spinner.succeed('Config and environment files created');
-    spinner.start('Generating project files...');
-    await generateLandingPage(projectPath, config);
-    await generateGitignore(projectPath);
-    await generateReadme(projectPath, config);
-    await generateClaudeMd(projectPath, config);
+    const { spinner, callback } = oraReporter();
+    const result = await createProject(config, callback);
     spinner.succeed('Project files created');
     console.log();
     console.log(chalk.green.bold('  Success!') + ' Created ' + chalk.cyan(config.name));
@@ -117,21 +86,14 @@ async function addIntegrationFlow(projectPath) {
         return;
     }
     console.log();
-    const spinner = ora(`Installing ${addConfig.integrations.length} integration(s)...`).start();
     const config = {
         name: path.basename(projectPath),
         integrations: addConfig.integrations,
         aiProvider: addConfig.aiProvider,
     };
-    await installIntegrations(projectPath, config);
+    const { spinner, callback } = oraReporter();
+    const result = await addIntegrations(projectPath, config, callback);
     spinner.succeed('Integrations installed');
-    spinner.start('Updating config and environment files...');
-    await appendConfig(projectPath, addConfig.integrations, addConfig.aiProvider);
-    await appendEnvFiles(projectPath, addConfig.integrations, addConfig.aiProvider);
-    spinner.succeed('Config and environment files updated');
-    spinner.start('Updating CLAUDE.md...');
-    await appendClaudeMd(projectPath, addConfig.integrations);
-    spinner.succeed('CLAUDE.md updated');
     console.log();
     console.log(chalk.green.bold('  Success!') + ' Added integrations:');
     addConfig.integrations.forEach((integration) => {
@@ -155,32 +117,3 @@ async function addIntegrationFlow(projectPath) {
         console.log();
     }
 }
-async function extendUtils(projectPath) {
-    const utilsPath = path.join(projectPath, 'lib/utils.ts');
-    const existingContent = await fs.readFile(utilsPath, 'utf-8');
-    const additionalUtils = `
-import { DateTime } from 'luxon';
-
-export function formatDate(date: Date | string, format = 'LLL d, yyyy'): string {
-  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
-  return dt.toFormat(format);
-}
-
-export function formatRelative(date: Date | string): string {
-  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
-  return dt.toRelative() ?? dt.toFormat('LLL d, yyyy');
-}
-
-export function debounce<P extends unknown[], R>(
-  func: (...args: P) => R,
-  wait: number
-): (...args: P) => void {
-  let timeout: ReturnType<typeof setTimeout>;
-  return (...args: P) => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => func(...args), wait);
-  };
-}
-`;
-    await fs.writeFile(utilsPath, existingContent + additionalUtils);
-}

package/dist/config.js

@@ -14,6 +14,10 @@ const staticConfigVars = {
         { name: 'RESEND_API_KEY', envKey: 'RESEND_API_KEY', isPublic: false },
         { name: 'RESEND_FROM_EMAIL', envKey: 'RESEND_FROM_EMAIL', isPublic: false, defaultValue: 'onboarding@resend.dev' },
     ],
+    postmark: [
+        { name: 'POSTMARK_SERVER_TOKEN', envKey: 'POSTMARK_SERVER_TOKEN', isPublic: false },
+        { name: 'POSTMARK_FROM_EMAIL', envKey: 'POSTMARK_FROM_EMAIL', isPublic: false },
+    ],
     firecrawl: [
         { name: 'FIRECRAWL_API_KEY', envKey: 'FIRECRAWL_API_KEY', isPublic: false },
     ],

package/dist/create-next.js

@@ -11,7 +11,7 @@ export async function createNextApp(name) {
         '--import-alias', '@/*',
         '--yes',
     ], {
-        stdio: 'inherit',
+        stdio: 'pipe',
     });
     return path.resolve(process.cwd(), name);
 }

package/dist/detect.js

@@ -5,6 +5,7 @@ const integrationPackages = {
     'neon-drizzle': ['drizzle-orm', '@neondatabase/serverless'],
     'ai-sdk': ['ai'],
     resend: ['resend'],
+    postmark: ['postmark'],
     firecrawl: ['@mendable/firecrawl-js'],
     inngest: ['inngest'],
     uploadthing: ['uploadthing'],
@@ -49,6 +50,7 @@ export function getAvailableIntegrations(installed) {
         'neon-drizzle',
         'ai-sdk',
         'resend',
+        'postmark',
         'firecrawl',
         'inngest',
         'uploadthing',
@@ -56,5 +58,13 @@ export function getAvailableIntegrations(installed) {
         'posthog',
         'sentry',
     ];
-    return all.filter((id) => !installed.includes(id));
+    const emailProviders = ['resend', 'postmark'];
+    const hasEmail = emailProviders.some((id) => installed.includes(id));
+    return all.filter((id) => {
+        if (installed.includes(id))
+            return false;
+        if (hasEmail && emailProviders.includes(id))
+            return false;
+        return true;
+    });
 }

package/dist/engine.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectConfig, IntegrationId } from './types.js';
+export type ProgressCallback = (step: string) => void;
+export interface EngineResult {
+    projectPath: string;
+    integrations: IntegrationId[];
+    envVarsNeeded: string[];
+}
+export declare function createProject(config: ProjectConfig, onProgress?: ProgressCallback): Promise<EngineResult>;
+export declare function addIntegrations(projectPath: string, config: ProjectConfig, onProgress?: ProgressCallback): Promise<EngineResult>;

package/dist/engine.js

@@ -0,0 +1,84 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { createNextApp } from './create-next.js';
+import { setupShadcn } from './setup-shadcn.js';
+import { installIntegrations, getEnvVars } from './integrations/index.js';
+import { generateClaudeMd, appendClaudeMd } from './claude-md.js';
+import { generateEnvFiles, appendEnvFiles } from './env.js';
+import { generateConfig, appendConfig } from './config.js';
+import { generateReadme, generateGitignore } from './generate-readme.js';
+import { generateInstrumentationClient, generateInstrumentation, } from './instrumentation.js';
+import { zustandTemplates } from './templates/zustand.js';
+import { generateLandingPage } from './landing-page.js';
+export async function createProject(config, onProgress) {
+    onProgress?.('Creating Next.js app...');
+    const projectPath = await createNextApp(config.name);
+    onProgress?.('Setting up shadcn/ui...');
+    await setupShadcn(projectPath);
+    await extendUtils(projectPath);
+    onProgress?.('Installing base packages...');
+    const { execa } = await import('execa');
+    await execa('npm', ['install', 'zod@^3.24', 'zustand@^5', 'luxon@^3'], { cwd: projectPath });
+    await execa('npm', ['install', '-D', '@types/luxon'], { cwd: projectPath });
+    await fs.mkdir(path.join(projectPath, 'lib/stores'), { recursive: true });
+    await fs.writeFile(path.join(projectPath, 'lib/stores/counter.store.ts'), zustandTemplates.exampleStore);
+    if (config.integrations.length > 0) {
+        onProgress?.(`Setting up ${config.integrations.length} integration(s)...`);
+        await installIntegrations(projectPath, config);
+    }
+    await generateInstrumentationClient(projectPath, config);
+    await generateInstrumentation(projectPath, config);
+    onProgress?.('Generating config and environment files...');
+    await generateConfig(projectPath, config);
+    await generateEnvFiles(projectPath, config);
+    onProgress?.('Generating project files...');
+    await generateLandingPage(projectPath, config);
+    await generateGitignore(projectPath);
+    await generateReadme(projectPath, config);
+    await generateClaudeMd(projectPath, config);
+    const envVarsNeeded = collectEnvVars(config);
+    return { projectPath, integrations: config.integrations, envVarsNeeded };
+}
+export async function addIntegrations(projectPath, config, onProgress) {
+    onProgress?.(`Installing ${config.integrations.length} integration(s)...`);
+    await installIntegrations(projectPath, config);
+    onProgress?.('Updating config and environment files...');
+    await appendConfig(projectPath, config.integrations, config.aiProvider);
+    await appendEnvFiles(projectPath, config.integrations, config.aiProvider);
+    onProgress?.('Updating CLAUDE.md...');
+    await appendClaudeMd(projectPath, config.integrations);
+    const envVarsNeeded = collectEnvVars(config);
+    return { projectPath, integrations: config.integrations, envVarsNeeded };
+}
+async function extendUtils(projectPath) {
+    const utilsPath = path.join(projectPath, 'lib/utils.ts');
+    const existingContent = await fs.readFile(utilsPath, 'utf-8');
+    const additionalUtils = `
+import { DateTime } from 'luxon';
+
+export function formatDate(date: Date | string, format = 'LLL d, yyyy'): string {
+  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
+  return dt.toFormat(format);
+}
+
+export function formatRelative(date: Date | string): string {
+  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
+  return dt.toRelative() ?? dt.toFormat('LLL d, yyyy');
+}
+
+export function debounce<P extends unknown[], R>(
+  func: (...args: P) => R,
+  wait: number
+): (...args: P) => void {
+  let timeout: ReturnType<typeof setTimeout>;
+  return (...args: P) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func(...args), wait);
+  };
+}
+`;
+    await fs.writeFile(utilsPath, existingContent + additionalUtils);
+}
+function collectEnvVars(config) {
+    return getEnvVars(config).map((v) => v.key);
+}

package/dist/env.js

@@ -29,6 +29,14 @@ const staticEnvSections = {
             { key: 'RESEND_FROM_EMAIL', example: 'onboarding@resend.dev', description: 'Default from email address' },
         ],
     },
+    postmark: {
+        name: 'POSTMARK - Email',
+        url: 'https://account.postmarkapp.com/servers',
+        vars: [
+            { key: 'POSTMARK_SERVER_TOKEN', example: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx', description: 'Postmark server token' },
+            { key: 'POSTMARK_FROM_EMAIL', example: 'hello@yourdomain.com', description: 'Default from email address' },
+        ],
+    },
     firecrawl: {
         name: 'FIRECRAWL - Scraping',
         url: 'https://firecrawl.dev',

package/dist/generate-readme.js

@@ -5,6 +5,7 @@ const integrationNames = {
     'neon-drizzle': 'Neon + Drizzle',
     'ai-sdk': 'Vercel AI SDK',
     resend: 'Resend',
+    postmark: 'Postmark',
     firecrawl: 'Firecrawl',
     inngest: 'Inngest',
     uploadthing: 'UploadThing',
@@ -89,7 +90,7 @@ npm run inngest:dev  # Start Inngest dev server
 ├── lib/           # Utilities and clients
 ├── services/      # Business logic
 `;
-    if (config.integrations.includes('resend')) {
+    if (config.integrations.includes('resend') || config.integrations.includes('postmark')) {
         content += `├── emails/        # Email templates\n`;
     }
     content += `└── public/        # Static assets

package/dist/index.js

@@ -1,3 +1,158 @@
 #!/usr/bin/env node
+import { Command } from 'commander';
 import { main } from './cli.js';
-main();
+import { createProject, addIntegrations } from './engine.js';
+import { validateProjectConfig, validateIntegrationSelection, ALL_INTEGRATION_IDS } from './validate.js';
+import { listIntegrations } from './metadata.js';
+import { isExistingProject, getInstalledIntegrations } from './detect.js';
+import fs from 'fs/promises';
+import path from 'path';
+const program = new Command();
+program
+    .name('create-loadout')
+    .description('Custom Next.js scaffolding with SaaS integrations')
+    .version('1.0.1')
+    .argument('[name]', 'Project name')
+    .option('--clerk', 'Add Clerk authentication')
+    .option('--neon-drizzle', 'Add Neon + Drizzle database')
+    .option('--ai-sdk', 'Add Vercel AI SDK')
+    .option('--ai-provider <provider>', 'AI provider (openai, anthropic, google)')
+    .option('--resend', 'Add Resend email')
+    .option('--postmark', 'Add Postmark email')
+    .option('--firecrawl', 'Add Firecrawl web scraping')
+    .option('--inngest', 'Add Inngest background jobs')
+    .option('--uploadthing', 'Add UploadThing file uploads')
+    .option('--stripe', 'Add Stripe payments')
+    .option('--posthog', 'Add PostHog analytics')
+    .option('--sentry', 'Add Sentry error tracking')
+    .option('--config <path>', 'Path to loadout.json config file')
+    .option('--add', 'Add integrations to existing project')
+    .option('--list', 'List all available integrations as JSON')
+    .action(async (name, opts) => {
+    // --list: dump integration metadata and exit
+    if (opts.list) {
+        console.log(JSON.stringify(listIntegrations(), null, 2));
+        return;
+    }
+    // Detect if running non-interactive
+    const hasConfig = typeof opts.config === 'string';
+    const hasFlags = name || hasConfig || opts.add || integrationFlagsPresent(opts);
+    if (!hasFlags) {
+        // No flags → interactive mode (existing behavior)
+        await main();
+        return;
+    }
+    // Non-interactive mode
+    try {
+        if (hasConfig) {
+            await runFromConfigFile(opts.config);
+        }
+        else if (opts.add) {
+            await runAddMode(opts);
+        }
+        else {
+            await runCreateMode(name, opts);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+function integrationFlagsPresent(opts) {
+    return ALL_INTEGRATION_IDS.some((id) => opts[camelCase(id)] === true);
+}
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function collectIntegrations(opts) {
+    const integrations = [];
+    for (const id of ALL_INTEGRATION_IDS) {
+        if (opts[camelCase(id)] === true) {
+            integrations.push(id);
+        }
+    }
+    return integrations;
+}
+async function runCreateMode(name, opts) {
+    const integrations = collectIntegrations(opts);
+    const aiProvider = opts.aiProvider || undefined;
+    const config = { name, integrations, aiProvider };
+    const errors = validateProjectConfig(config);
+    if (errors.length > 0) {
+        console.error('Validation errors:');
+        errors.forEach((e) => console.error(`  - ${e.field}: ${e.message}`));
+        process.exit(1);
+    }
+    const result = await createProject(config, (step) => console.log(step));
+    console.log();
+    console.log(`Success! Created ${config.name} at ${result.projectPath}`);
+    if (result.integrations.length > 0) {
+        console.log(`Integrations: ${result.integrations.join(', ')}`);
+    }
+    if (result.envVarsNeeded.length > 0) {
+        console.log(`Environment variables to configure: ${result.envVarsNeeded.join(', ')}`);
+    }
+}
+async function runAddMode(opts) {
+    const cwd = process.cwd();
+    if (!(await isExistingProject(cwd))) {
+        console.error('Error: Not in a Next.js project directory. --add requires an existing project.');
+        process.exit(1);
+    }
+    const integrations = collectIntegrations(opts);
+    if (integrations.length === 0) {
+        console.error('Error: --add requires at least one integration flag (e.g. --clerk --stripe)');
+        process.exit(1);
+    }
+    const valErrors = validateIntegrationSelection(integrations);
+    if (valErrors.length > 0) {
+        console.error('Validation errors:');
+        valErrors.forEach((e) => console.error(`  - ${e.field}: ${e.message}`));
+        process.exit(1);
+    }
+    const installed = await getInstalledIntegrations(cwd);
+    const alreadyInstalled = integrations.filter((id) => installed.includes(id));
+    if (alreadyInstalled.length > 0) {
+        console.error(`Error: Already installed: ${alreadyInstalled.join(', ')}`);
+        process.exit(1);
+    }
+    const aiProvider = opts.aiProvider || undefined;
+    const config = {
+        name: path.basename(cwd),
+        integrations,
+        aiProvider,
+    };
+    const result = await addIntegrations(cwd, config, (step) => console.log(step));
+    console.log();
+    console.log(`Success! Added integrations: ${result.integrations.join(', ')}`);
+    if (result.envVarsNeeded.length > 0) {
+        console.log(`Environment variables to configure: ${result.envVarsNeeded.join(', ')}`);
+    }
+}
+async function runFromConfigFile(configPath) {
+    const resolved = path.resolve(configPath);
+    const raw = await fs.readFile(resolved, 'utf-8');
+    const parsed = JSON.parse(raw);
+    const config = {
+        name: parsed.name,
+        integrations: parsed.integrations || [],
+        aiProvider: parsed.aiProvider,
+    };
+    const errors = validateProjectConfig(config);
+    if (errors.length > 0) {
+        console.error('Config validation errors:');
+        errors.forEach((e) => console.error(`  - ${e.field}: ${e.message}`));
+        process.exit(1);
+    }
+    const result = await createProject(config, (step) => console.log(step));
+    console.log();
+    console.log(`Success! Created ${config.name} at ${result.projectPath}`);
+    if (result.integrations.length > 0) {
+        console.log(`Integrations: ${result.integrations.join(', ')}`);
+    }
+    if (result.envVarsNeeded.length > 0) {
+        console.log(`Environment variables to configure: ${result.envVarsNeeded.join(', ')}`);
+    }
+}
+program.parse();

package/dist/integrations/index.d.ts

@@ -1,4 +1,5 @@
 import type { Integration, IntegrationId, EnvVar, ProjectConfig } from '../types.js';
+export declare function getIntegration(id: IntegrationId, config: ProjectConfig): Integration;
 export declare function installIntegrations(projectPath: string, config: ProjectConfig): Promise<void>;
 export declare function getEnvVars(config: ProjectConfig): EnvVar[];
 export declare const integrations: Partial<Record<IntegrationId, Integration>>;

package/dist/integrations/index.js

@@ -7,6 +7,7 @@ import { firecrawlIntegration } from './firecrawl.js';
 import { inngestIntegration } from './inngest.js';
 import { uploadthingIntegration } from './uploadthing.js';
 import { stripeIntegration } from './stripe.js';
+import { postmarkIntegration } from './postmark.js';
 import { posthogIntegration } from './posthog.js';
 import { sentryIntegration } from './sentry.js';
 // Static integrations (don't need config)
@@ -18,11 +19,12 @@ const staticIntegrations = {
     inngest: inngestIntegration,
     uploadthing: uploadthingIntegration,
     stripe: stripeIntegration,
+    postmark: postmarkIntegration,
     posthog: posthogIntegration,
     sentry: sentryIntegration,
 };
 // Get integration, with dynamic ones using config
-function getIntegration(id, config) {
+export function getIntegration(id, config) {
     if (id === 'ai-sdk') {
         return createAiSdkIntegration(config.aiProvider ?? 'openai');
     }

package/dist/integrations/postmark.d.ts

@@ -0,0 +1,2 @@
+import type { Integration } from '../types.js';
+export declare const postmarkIntegration: Integration;

package/dist/integrations/postmark.js

@@ -0,0 +1,34 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { postmarkTemplates } from '../templates/postmark.js';
+export const postmarkIntegration = {
+    id: 'postmark',
+    name: 'Postmark',
+    description: 'Transactional email',
+    packages: ['postmark'],
+    envVars: [
+        {
+            key: 'POSTMARK_SERVER_TOKEN',
+            description: 'Postmark server token',
+            example: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
+        },
+        {
+            key: 'POSTMARK_FROM_EMAIL',
+            description: 'Default from email address',
+            example: 'hello@yourdomain.com',
+        },
+    ],
+    setup: async (projectPath) => {
+        // Create email service
+        await fs.mkdir(path.join(projectPath, 'services'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'services/email.service.ts'), postmarkTemplates.emailService);
+        // Create email templates in components/emails
+        await fs.mkdir(path.join(projectPath, 'components/emails'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'components/emails/welcome.tsx'), postmarkTemplates.welcomeEmail);
+        // Create API route
+        await fs.mkdir(path.join(projectPath, 'app/api/email/send'), {
+            recursive: true,
+        });
+        await fs.writeFile(path.join(projectPath, 'app/api/email/send/route.ts'), postmarkTemplates.sendRoute);
+    },
+};