appshot-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chris Van Buskirk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,381 @@
+# Appshot 📸
+
+> 🎉 **Now available on NPM!** Install with `npm install -g appshot-cli`
+
+Generate beautiful, App Store-ready screenshots with device frames, gradients, and captions.
+
+[![CI](https://github.com/chrisvanbuskirk/appshot/actions/workflows/ci.yml/badge.svg)](https://github.com/chrisvanbuskirk/appshot/actions/workflows/ci.yml)
+[![npm version](https://badge.fury.io/js/appshot-cli.svg)](https://www.npmjs.com/package/appshot-cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🖼️ **Smart Frames** - Automatically detects portrait/landscape and selects appropriate device frame
+- 🎨 **Gradients** - Beautiful gradient backgrounds with customizable colors
+- ✏️ **Captions** - Add marketing text with full typography control (above or overlay)
+- 🌍 **Localization** - Multi-language support for international app stores
+- 📱 **Multi-Device** - Support for iPhone, iPad, Mac, Apple TV, Vision Pro, and Apple Watch
+- 📏 **App Store Specs** - Built-in support for all official App Store screenshot resolutions
+- ✅ **Validation** - Verify screenshots meet App Store requirements
+- 🔄 **Orientation Detection** - Intelligently handles both portrait and landscape screenshots
+- ⚡ **Fast** - Parallel processing with configurable concurrency
+- 🛠️ **CLI** - Simple command-line interface
+
+## Quick Start
+
+### Installation
+
+```bash
+npm install -g appshot-cli
+```
+
+> **Note**: The package is called `appshot-cli` on NPM, but the command is still `appshot`
+
+### Initialize a new project
+
+```bash
+appshot init
+```
+
+This creates:
+- `appshot.json` - Configuration file
+- `screenshots/` - Directory structure for your screenshots
+- Device-specific folders with `captions.json` files
+
+### Add your screenshots
+
+Place your app screenshots in the appropriate device folders:
+```
+screenshots/
+├── iphone/
+├── ipad/
+├── mac/
+└── watch/
+```
+
+### Add captions
+
+Use the interactive caption editor with autocomplete:
+
+```bash
+appshot caption --device iphone
+```
+
+Features:
+- 🔍 **Autocomplete** - Smart suggestions as you type
+- 📊 **Frequency tracking** - Most-used captions appear first  
+- 🎯 **Device-specific** - Suggestions tailored to device type
+- ⌨️ **Keyboard shortcuts** - Tab to complete, arrows to navigate
+
+### Build final screenshots
+
+Generate your App Store-ready screenshots:
+
+```bash
+appshot build
+```
+
+Output appears in the `final/` directory, ready for upload!
+
+## Configuration
+
+Edit `appshot.json` to customize your screenshots:
+
+```json
+{
+  "output": "./final",
+  "frames": "./frames",
+  "gradient": {
+    "colors": ["#FF5733", "#FFC300"],
+    "direction": "top-bottom"
+  },
+  "caption": {
+    "font": "SF Pro",
+    "fontsize": 64,
+    "color": "#FFFFFF",
+    "align": "center",
+    "paddingTop": 100
+  },
+  "devices": {
+    "iphone": {
+      "input": "./screenshots/iphone",
+      "resolution": "1284x2778",
+      "autoFrame": true,
+      "preferredFrame": "iphone-15-pro-max"
+    }
+  }
+}
+```
+
+### Gradient Options
+
+- **colors**: Array of hex color codes
+- **direction**: `top-bottom`, `bottom-top`, `left-right`, `right-left`, `diagonal`
+
+### Caption Options
+
+- **font**: Font family name
+- **fontsize**: Size in pixels
+- **color**: Hex color code
+- **align**: `left`, `center`, `right`
+- **paddingTop**: Space from top in pixels
+- **paddingBottom**: Space from bottom in pixels
+- **position**: `above` (above device frame) or `overlay` (on gradient)
+
+### Device Options
+
+- **input**: Directory containing screenshots
+- **resolution**: Output resolution (use App Store specs or custom)
+- **autoFrame**: Enable automatic frame selection based on screenshot orientation (default: true)
+- **preferredFrame**: Preferred frame name from the registry (optional)
+- **partialFrame**: Cut off bottom portion of frame for dynamic look (default: false)
+- **frameOffset**: Percentage to cut off when partialFrame is true (default: 25)
+
+## Commands
+
+### `appshot init`
+Initialize a new appshot project with scaffolding.
+
+Options:
+- `--force` - Overwrite existing files
+
+### `appshot caption`
+Interactively add or edit captions for screenshots with intelligent autocomplete.
+
+Features:
+- **Autocomplete suggestions** - Shows previous captions as you type
+- **Fuzzy search** - Finds captions even with typos
+- **Usage tracking** - Frequently used captions appear first
+- **Learning system** - Improves suggestions over time
+- **Device-specific** - Prioritizes captions used for the same device
+
+Options:
+- `--device <name>` - Device name (required)
+- `--lang <code>` - Language code (default: en)
+
+Keyboard shortcuts:
+- **Tab** - Autocomplete the top suggestion
+- **↑↓** - Navigate through suggestions
+- **Enter** - Select current suggestion
+- **Esc** - Dismiss suggestions
+
+### `appshot build`
+Generate final screenshots with frames, gradients, and captions.
+
+Options:
+- `--devices <list>` - Comma-separated device list
+- `--preset <ids>` - Use specific App Store presets (e.g., iphone-6-9,ipad-13)
+- `--config <file>` - Use specific config file (default: appshot.json)
+- `--langs <list>` - Comma-separated language codes
+- `--preview` - Generate low-res previews
+- `--concurrency <n>` - Parallel processing limit
+- `--no-frame` - Skip device frames
+- `--no-gradient` - Skip gradient backgrounds
+- `--no-caption` - Skip captions
+
+### `appshot specs`
+Display device specifications and resolutions.
+
+### `appshot clean`
+Remove generated screenshots and temporary files.
+
+Options:
+- `--all` - Remove all generated files including .appshot/ directory
+- `--history` - Clear caption autocomplete history
+- `--keep-history` - Preserve caption history when using --all
+- `--yes` - Skip confirmation prompt
+
+Options:
+- `--device <name>` - Filter by device type
+- `--json` - Output as JSON
+
+### `appshot check`
+Validate project configuration and assets.
+
+Options:
+- `--fix` - Attempt to fix issues automatically
+
+### `appshot presets`
+Manage App Store screenshot presets for all official resolutions.
+
+Options:
+- `--list` - List all available presets
+- `--required` - Show only required presets for App Store submission
+- `--generate <ids>` - Generate config for specific preset IDs (comma-separated)
+- `--category <type>` - Filter by category (iphone, ipad, mac, appletv, visionpro, watch)
+- `--output <file>` - Output file for generated config (default: appshot-presets.json)
+
+### `appshot validate`
+Validate screenshots against App Store requirements.
+
+Options:
+- `--strict` - Validate against required presets only
+- `--fix` - Suggest fixes for invalid screenshots
+
+### `appshot localize` (Coming Soon)
+Generate translations for captions using AI providers.
+
+Options:
+- `--langs <codes>` - Target languages
+- `--device <name>` - Specific device or all
+- `--provider <name>` - Translation provider
+
+## Multi-Language Support
+
+Captions support multiple languages:
+
+```json
+{
+  "home.png": {
+    "en": "Organize your life",
+    "fr": "Organisez votre vie",
+    "es": "Organiza tu vida"
+  }
+}
+```
+
+Build for specific languages:
+
+```bash
+appshot build --langs en,fr,es
+```
+
+## App Store Specifications
+
+Appshot includes all official App Store screenshot resolutions. View them with:
+
+```bash
+# Show all presets
+appshot presets
+
+# Show only required presets
+appshot presets --required
+
+# Generate config for specific devices
+appshot presets --generate iphone-6-9,ipad-13,mac-2880,watch-ultra
+```
+
+### Required Resolutions
+
+**iPhone** (choose one):
+- **6.9" Display**: 1290×2796 (iPhone 16 Pro Max, 15 Pro Max, etc.)
+- **6.5" Display**: 1284×2778 (iPhone 14 Plus, 13 Pro Max, etc.)
+
+**iPad** (required):
+- **13" Display**: 2064×2752 or 2048×2732
+
+**Mac** (for Mac apps):
+- **16:10 aspect ratio**: 2880×1800, 2560×1600, 1440×900, or 1280×800
+
+**Apple Watch** (for Watch apps):
+- **Ultra**: 410×502
+- **Series 10**: 416×496
+- **Series 9/8/7**: 396×484
+
+### Quick Preset Usage
+
+```bash
+# Build with iPhone 6.9" and iPad 13" presets
+appshot build --preset iphone-6-9,ipad-13
+
+# Validate existing screenshots
+appshot validate --strict
+```
+
+## Examples
+
+See the `examples/minimal-project` directory for a complete example setup.
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/chrisvanbuskirk/appshot.git
+cd appshot
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run tests
+npm test
+
+# Link for local development
+npm link
+```
+
+## Contributing
+
+We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+## Security
+
+For security issues, please see [SECURITY.md](SECURITY.md).
+
+## License
+
+MIT © Chris Van Buskirk
+
+## Advanced Features
+
+### Smart Frame Selection
+
+Appshot automatically detects whether your screenshots are portrait or landscape and selects the appropriate device frame:
+
+- **iPhone screenshots** automatically use portrait frames for vertical shots and landscape frames for horizontal ones
+- **iPad screenshots** work seamlessly in both orientations  
+- **Mac screenshots** always use landscape frames
+- **Watch screenshots** always use portrait frames
+
+Override automatic selection with `preferredFrame` in your device configuration.
+
+### Partial Frames
+
+Create dynamic App Store screenshots with partial device frames:
+
+```json
+{
+  "devices": {
+    "iphone": {
+      "partialFrame": true,
+      "frameOffset": 25  // Cut off bottom 25%
+    }
+  }
+}
+```
+
+### Caption Positioning
+
+Place captions above the device frame (recommended) or as an overlay:
+
+```json
+{
+  "caption": {
+    "position": "above",  // or "overlay"
+    "paddingTop": 120,
+    "paddingBottom": 80
+  }
+}
+```
+
+## Roadmap
+
+- [x] Official App Store specifications support
+- [x] Caption positioning (above/overlay)  
+- [x] Partial frame support
+- [x] Intelligent caption autocomplete
+- [x] Apple Watch optimizations
+- [ ] AI-powered translations
+- [ ] Cloud rendering service
+- [ ] Android device support
+- [ ] Custom frame designer
+- [ ] Figma plugin
+- [ ] Web dashboard
+
+## Support
+
+- [Report issues](https://github.com/chrisvanbuskirk/appshot/issues)
+- [Request features](https://github.com/chrisvanbuskirk/appshot/issues/new?labels=enhancement)
+- [Documentation](https://github.com/chrisvanbuskirk/appshot/wiki)

package/bin/appshot.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import('../dist/cli.js').catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import pc from 'picocolors';
+import initCmd from './commands/init.js';
+import captionCmd from './commands/caption.js';
+import localizeCmd from './commands/localize.js';
+import buildCmd from './commands/build.js';
+import specsCmd from './commands/specs.js';
+import checkCmd from './commands/check.js';
+import presetsCmd from './commands/presets.js';
+import validateCmd from './commands/validate.js';
+import { createCleanCommand } from './commands/clean.js';
+const program = new Command();
+program
+    .name('appshot')
+    .description('Generate App Store–ready screenshots with frames, gradients, and captions.')
+    .version('0.1.0');
+program.addCommand(initCmd());
+program.addCommand(captionCmd());
+program.addCommand(localizeCmd());
+program.addCommand(buildCmd());
+program.addCommand(specsCmd());
+program.addCommand(checkCmd());
+program.addCommand(presetsCmd());
+program.addCommand(validateCmd());
+program.addCommand(createCleanCommand());
+program.showHelpAfterError(pc.dim('\nUse --help for usage.'));
+program.parseAsync().catch((err) => {
+    console.error(pc.red('Error:'), err.message);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,OAAO,MAAM,oBAAoB,CAAC;AACzC,OAAO,UAAU,MAAM,uBAAuB,CAAC;AAC/C,OAAO,WAAW,MAAM,wBAAwB,CAAC;AACjD,OAAO,QAAQ,MAAM,qBAAqB,CAAC;AAC3C,OAAO,QAAQ,MAAM,qBAAqB,CAAC;AAC3C,OAAO,QAAQ,MAAM,qBAAqB,CAAC;AAC3C,OAAO,UAAU,MAAM,uBAAuB,CAAC;AAC/C,OAAO,WAAW,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;AAE9B,OAAO;KACJ,IAAI,CAAC,SAAS,CAAC;KACf,WAAW,CAAC,4EAA4E,CAAC;KACzF,OAAO,CAAC,OAAO,CAAC,CAAC;AAEpB,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;AAC9B,OAAO,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC,CAAC;AACjC,OAAO,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;AAClC,OAAO,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;AAC/B,OAAO,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;AAC/B,OAAO,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;AAC/B,OAAO,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC,CAAC;AACjC,OAAO,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;AAClC,OAAO,CAAC,UAAU,CAAC,kBAAkB,EAAE,CAAC,CAAC;AAEzC,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC,CAAC;AAE9D,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACjC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IAC7C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/commands/build.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export default function buildCmd(): Command;
+//# sourceMappingURL=build.d.ts.map

package/dist/commands/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/commands/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,MAAM,CAAC,OAAO,UAAU,QAAQ,YA6N/B"}

package/dist/commands/build.js

@@ -0,0 +1,200 @@
+import { Command } from 'commander';
+import { promises as fs } from 'fs';
+import path from 'path';
+import pc from 'picocolors';
+import sharp from 'sharp';
+import { loadConfig, loadCaptions } from '../core/files.js';
+import { autoSelectFrame, getImageDimensions, initializeFrameRegistry } from '../core/devices.js';
+import { composeAppStoreScreenshot } from '../core/compose.js';
+export default function buildCmd() {
+    const cmd = new Command('build')
+        .description('Render screenshots using frames, gradients, and captions')
+        .option('--devices <list>', 'comma-separated device list (e.g., iphone,ipad)', 'iphone,ipad,mac,watch')
+        .option('--preset <ids>', 'use specific App Store presets (e.g., iphone-6-9,ipad-13)')
+        .option('--config <file>', 'use specific config file', 'appshot.json')
+        .option('--langs <list>', 'comma-separated language codes (e.g., en,fr,de)', 'en')
+        .option('--preview', 'generate low-res preview images')
+        .option('--concurrency <n>', 'number of parallel renders', '4')
+        .option('--no-frame', 'skip device frames')
+        .option('--no-gradient', 'skip gradient backgrounds')
+        .option('--no-caption', 'skip captions')
+        .action(async (opts) => {
+        try {
+            console.log(pc.bold('Building screenshots...'));
+            // Load configuration
+            const config = await loadConfig();
+            const devices = opts.devices.split(',').map((d) => d.trim());
+            const langs = opts.langs.split(',').map((l) => l.trim());
+            const concurrency = parseInt(opts.concurrency, 10);
+            // Initialize frame registry from Frames.json if available
+            await initializeFrameRegistry(path.resolve(config.frames));
+            // Ensure output directory exists
+            await fs.mkdir(config.output, { recursive: true });
+            let totalProcessed = 0;
+            let totalErrors = 0;
+            // Process each device
+            for (const device of devices) {
+                if (!config.devices[device]) {
+                    console.log(pc.yellow('⚠'), `Device '${device}' not configured in appshot.json`);
+                    continue;
+                }
+                const deviceConfig = config.devices[device];
+                const inputDir = path.resolve(deviceConfig.input);
+                const outputDir = path.join(config.output, device);
+                // Check if input directory exists
+                try {
+                    await fs.access(inputDir);
+                }
+                catch {
+                    console.log(pc.yellow('⚠'), `Input directory not found: ${inputDir}`);
+                    continue;
+                }
+                // Create device output directory
+                await fs.mkdir(outputDir, { recursive: true });
+                // Get screenshots
+                const screenshots = (await fs.readdir(inputDir))
+                    .filter(f => f.match(/\.(png|jpg|jpeg)$/i))
+                    .sort();
+                if (screenshots.length === 0) {
+                    console.log(pc.yellow('⚠'), `No screenshots found in ${inputDir}`);
+                    continue;
+                }
+                // Load captions from .appshot/captions/
+                const captionsPath = path.join(process.cwd(), '.appshot', 'captions', `${device}.json`);
+                const captions = await loadCaptions(captionsPath);
+                console.log(pc.cyan(`\n${device}:`), `Processing ${screenshots.length} screenshots`);
+                // Process each language
+                for (const lang of langs) {
+                    const langDir = langs.length > 1 ? path.join(outputDir, lang) : outputDir;
+                    await fs.mkdir(langDir, { recursive: true });
+                    // Process screenshots in batches
+                    for (let i = 0; i < screenshots.length; i += concurrency) {
+                        const batch = screenshots.slice(i, i + concurrency);
+                        const promises = batch.map(async (screenshot) => {
+                            try {
+                                const inputPath = path.join(inputDir, screenshot);
+                                const outputPath = path.join(langDir, screenshot);
+                                // Get caption for this screenshot and language
+                                const captionData = captions[screenshot];
+                                let captionText = '';
+                                if (typeof captionData === 'string') {
+                                    captionText = captionData;
+                                }
+                                else if (captionData && typeof captionData === 'object') {
+                                    captionText = captionData[lang] || '';
+                                }
+                                // Get screenshot dimensions and orientation
+                                const { orientation } = await getImageDimensions(inputPath);
+                                // Load screenshot
+                                let screenshotBuffer;
+                                try {
+                                    // First verify the file exists and is readable
+                                    await fs.access(inputPath, fs.constants.R_OK);
+                                    // Load the screenshot into a buffer
+                                    screenshotBuffer = await sharp(inputPath)
+                                        .png() // Ensure output is PNG
+                                        .toBuffer();
+                                }
+                                catch (error) {
+                                    console.error(pc.red(`  ✗ ${path.basename(inputPath)}`), `Failed to load screenshot: ${error instanceof Error ? error.message : String(error)}`);
+                                    return;
+                                }
+                                // Parse resolution for output dimensions
+                                const [configWidth, configHeight] = deviceConfig.resolution.split('x').map(Number);
+                                // Ensure output dimensions match screenshot orientation
+                                let outWidth;
+                                let outHeight;
+                                if (orientation === 'portrait') {
+                                    // For portrait, ensure height > width
+                                    outWidth = Math.min(configWidth, configHeight);
+                                    outHeight = Math.max(configWidth, configHeight);
+                                }
+                                else {
+                                    // For landscape, ensure width > height
+                                    outWidth = Math.max(configWidth, configHeight);
+                                    outHeight = Math.min(configWidth, configHeight);
+                                }
+                                // Warn if orientation mismatch detected
+                                const configOrientation = configWidth > configHeight ? 'landscape' : 'portrait';
+                                if (configOrientation !== orientation) {
+                                    console.log(pc.yellow('    ⚠'), pc.dim(`Config specifies ${configOrientation} (${deviceConfig.resolution}) but screenshot is ${orientation} - auto-adjusting`));
+                                }
+                                // Auto-select frame if enabled
+                                let frame = null;
+                                let frameMetadata = null;
+                                let frameUsed = false;
+                                if (opts.frame !== false && (deviceConfig.autoFrame !== false)) {
+                                    const result = await autoSelectFrame(inputPath, path.resolve(config.frames), device, deviceConfig.preferredFrame);
+                                    frame = result.frame;
+                                    frameMetadata = result.metadata;
+                                    if (frame && frameMetadata) {
+                                        frameUsed = true;
+                                        console.log(pc.dim(`    Using ${frameMetadata.displayName} ${orientation} frame`));
+                                    }
+                                    else if (frameMetadata && !frame) {
+                                        console.error(pc.red('    ERROR: Frame metadata found but image failed to load!'));
+                                    }
+                                }
+                                // Use the new compose function
+                                let image;
+                                try {
+                                    image = await composeAppStoreScreenshot({
+                                        screenshot: screenshotBuffer,
+                                        frame: frame,
+                                        frameMetadata: frameMetadata ? {
+                                            frameWidth: frameMetadata.frameWidth,
+                                            frameHeight: frameMetadata.frameHeight,
+                                            screenRect: frameMetadata.screenRect,
+                                            maskPath: frameMetadata.maskPath,
+                                            deviceType: frameMetadata.deviceType,
+                                            displayName: frameMetadata.displayName,
+                                            name: frameMetadata.name
+                                        } : undefined,
+                                        caption: opts.caption !== false ? captionText : undefined,
+                                        captionConfig: config.caption,
+                                        gradientConfig: config.gradient,
+                                        deviceConfig: deviceConfig,
+                                        outputWidth: outWidth,
+                                        outputHeight: outHeight
+                                    });
+                                }
+                                catch (error) {
+                                    console.error(pc.red(`  ✗ ${path.basename(inputPath)}`), error instanceof Error ? error.message : String(error));
+                                    return;
+                                }
+                                // Save final image
+                                await sharp(image)
+                                    .resize(opts.preview ? 800 : undefined, undefined, {
+                                    fit: 'inside',
+                                    withoutEnlargement: true
+                                })
+                                    .png() // Ensure output is PNG
+                                    .toFile(outputPath);
+                                console.log(pc.green('  ✓'), path.basename(outputPath), pc.dim(`[${orientation}${frameUsed ? ', framed' : ''}${captionText ? ', captioned' : ''}]`));
+                                totalProcessed++;
+                            }
+                            catch (error) {
+                                console.log(pc.red('  ✗'), screenshot, pc.dim(error instanceof Error ? error.message : String(error)));
+                                totalErrors++;
+                            }
+                        });
+                        await Promise.all(promises);
+                    }
+                }
+            }
+            // Summary
+            console.log('\n' + pc.bold('Build complete!'));
+            console.log(pc.green(`✓ ${totalProcessed} screenshots processed`));
+            if (totalErrors > 0) {
+                console.log(pc.red(`✗ ${totalErrors} errors`));
+            }
+            console.log(pc.dim(`Output directory: ${config.output}`));
+        }
+        catch (error) {
+            console.error(pc.red('Error:'), error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=build.js.map