kustom-mc 0.1.2 → 0.1.4

package/dist/bundler.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Options for creating a bundle.
+ */
+export interface BundleOptions {
+    /** Whether to generate and include the manifest (default: true) */
+    includeManifest?: boolean;
+    /** Whether to include TypeScript source files (default: false) */
+    includeSource?: boolean;
+}
+/**
+ * Result of a bundle operation.
+ */
+export interface BundleResult {
+    packId: string;
+    version: string;
+    fileCount: number;
+}
+/**
+ * Result of bundling to a buffer.
+ */
+export interface BufferBundleResult extends BundleResult {
+    buffer: Buffer;
+}
+/**
+ * Create a zip bundle in memory and return as a Buffer.
+ * Used by the push command for HTTP upload.
+ */
+export declare function bundleToBuffer(projectDir: string, options?: BundleOptions): Promise<BufferBundleResult>;
+/**
+ * Create a zip bundle and write it to a file on disk.
+ * Used by the bundle command for distribution.
+ */
+export declare function bundleToFile(projectDir: string, outputPath: string, options?: BundleOptions): Promise<BundleResult>;

package/dist/bundler.js

@@ -0,0 +1,195 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import archiver from 'archiver';
+import { loadConfig, generateManifest, validateManifest } from './config.js';
+/**
+ * Collect all files that should be included in the bundle.
+ * Returns a list of { absolutePath, archiveName } entries.
+ */
+async function collectBundleFiles(projectDir, config) {
+    const includePatterns = config.bundle?.include || [
+        '**/*.js',
+        'textures/**/*',
+        'gui/**/*',
+        'models/**/*',
+        'sounds/**/*'
+    ];
+    const outDir = config.outDir || 'dist';
+    const outDirResolved = path.resolve(projectDir, outDir);
+    const addedFiles = new Set();
+    const files = [];
+    for (const pattern of includePatterns) {
+        const isJsPattern = pattern.includes('*.js');
+        if (isJsPattern) {
+            // JS files live in outDir (e.g. dist/)
+            // Exclude types/ directory (generated .d.ts files) and zip files
+            const matches = await glob(pattern, {
+                cwd: outDirResolved,
+                nodir: true,
+                ignore: ['types/**', '*.zip', 'kustompack.json']
+            });
+            for (const file of matches) {
+                if (addedFiles.has(file))
+                    continue;
+                const absolutePath = path.resolve(outDirResolved, file);
+                if (fs.existsSync(absolutePath)) {
+                    files.push({ absolutePath, archiveName: file });
+                    addedFiles.add(file);
+                }
+            }
+        }
+        else {
+            // Asset files live in projectDir (source directory)
+            const matches = await glob(pattern, {
+                cwd: projectDir,
+                nodir: true,
+                ignore: ['node_modules/**', 'dist/**', '*.ts', 'kustompack.json']
+            });
+            for (const file of matches) {
+                if (addedFiles.has(file))
+                    continue;
+                const absolutePath = path.resolve(projectDir, file);
+                if (fs.existsSync(absolutePath)) {
+                    files.push({ absolutePath, archiveName: file });
+                    addedFiles.add(file);
+                }
+            }
+        }
+    }
+    return files;
+}
+/**
+ * Collect TypeScript source files for optional inclusion.
+ */
+async function collectSourceFiles(projectDir, config) {
+    const sourcePatterns = config.include || ['scripts/**/*.ts', 'blocks/**/*.ts', 'items/**/*.ts'];
+    const addedFiles = new Set();
+    const files = [];
+    for (const pattern of sourcePatterns) {
+        const matches = await glob(pattern, {
+            cwd: projectDir,
+            nodir: true,
+            ignore: config.exclude
+        });
+        for (const file of matches) {
+            if (addedFiles.has(file))
+                continue;
+            const absolutePath = path.resolve(projectDir, file);
+            if (fs.existsSync(absolutePath)) {
+                files.push({ absolutePath, archiveName: file });
+                addedFiles.add(file);
+            }
+        }
+    }
+    return files;
+}
+/**
+ * Populate an archiver instance with all bundle files.
+ * Returns the file count.
+ */
+async function populateArchive(archive, projectDir, config, options = {}) {
+    let fileCount = 0;
+    // Add manifest
+    if (options.includeManifest !== false) {
+        const manifestContent = generateManifest(config);
+        archive.append(manifestContent, { name: 'kustompack.json' });
+        fileCount++;
+    }
+    // Add compiled JS + assets
+    const bundleFiles = await collectBundleFiles(projectDir, config);
+    for (const file of bundleFiles) {
+        archive.file(file.absolutePath, { name: file.archiveName });
+        fileCount++;
+    }
+    // Optionally add source files
+    if (options.includeSource) {
+        const sourceFiles = await collectSourceFiles(projectDir, config);
+        for (const file of sourceFiles) {
+            archive.file(file.absolutePath, { name: file.archiveName });
+            fileCount++;
+        }
+    }
+    return { fileCount };
+}
+/**
+ * Validate config and return pack metadata.
+ * Throws on validation errors.
+ */
+function validateConfig(config) {
+    const errors = validateManifest(config);
+    if (errors.length > 0) {
+        throw new Error(`Manifest validation failed:\n  ${errors.join('\n  ')}`);
+    }
+    return {
+        packId: config.manifest?.id || 'kustompack',
+        version: config.manifest?.version || '1.0.0'
+    };
+}
+/**
+ * Create a zip bundle in memory and return as a Buffer.
+ * Used by the push command for HTTP upload.
+ */
+export async function bundleToBuffer(projectDir, options = {}) {
+    const config = loadConfig(projectDir);
+    const { packId, version } = validateConfig(config);
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        archive.on('data', (chunk) => chunks.push(chunk));
+        archive.on('error', reject);
+        archive.on('end', () => {
+            // fileCount is set by the async populate below before finalize
+        });
+        const run = async () => {
+            const { fileCount } = await populateArchive(archive, projectDir, config, options);
+            // Listen for end after we know fileCount
+            return new Promise((res) => {
+                archive.on('end', () => {
+                    res({
+                        buffer: Buffer.concat(chunks),
+                        packId,
+                        version,
+                        fileCount
+                    });
+                });
+                archive.finalize();
+            });
+        };
+        run().then(resolve).catch(reject);
+    });
+}
+/**
+ * Create a zip bundle and write it to a file on disk.
+ * Used by the bundle command for distribution.
+ */
+export async function bundleToFile(projectDir, outputPath, options = {}) {
+    const config = loadConfig(projectDir);
+    const { packId, version } = validateConfig(config);
+    // Ensure output directory exists
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(outputPath);
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        archive.on('warning', (err) => {
+            if (err.code !== 'ENOENT') {
+                reject(err);
+            }
+        });
+        archive.on('error', reject);
+        archive.pipe(output);
+        const run = async () => {
+            const { fileCount } = await populateArchive(archive, projectDir, config, options);
+            return new Promise((res) => {
+                output.on('close', () => {
+                    res({ packId, version, fileCount });
+                });
+                archive.finalize();
+            });
+        };
+        run().then(resolve).catch(reject);
+    });
+}

package/dist/commands/build.d.ts

@@ -1,2 +1,18 @@
 import { Command } from 'commander';
+import { type KustomConfig } from '../config.js';
 export declare const buildCommand: Command;
+/**
+ * Build all TypeScript files in the project.
+ * Exported for use by push and bundle commands.
+ */
+export declare function buildAll(config: KustomConfig, options: {
+    validate?: boolean;
+    verbose?: boolean;
+}): Promise<void>;
+/**
+ * Build a single TypeScript file to Rhino-compatible JavaScript.
+ * Exported for use by push --watch for incremental rebuilds.
+ */
+export declare function buildFile(file: string, config: KustomConfig, options: {
+    verbose?: boolean;
+}): Promise<string>;

package/dist/commands/build.js

@@ -11,7 +11,6 @@ import { prepare } from './prepare.js';
 export const buildCommand = new Command('build')
     .description('Compile TypeScript scripts to Rhino-compatible JavaScript')
     .option('-w, --watch', 'Watch for changes and rebuild')
-    .option('-d, --deploy', 'Copy compiled files to deploy target')
     .option('--no-validate', 'Skip validation')
     .option('-v, --verbose', 'Verbose output')
     .option('--clean', 'Clean output directory before building')
@@ -47,7 +46,11 @@ function getOutputPath(sourceFile, config) {
 function getOutDir(config) {
     return path.resolve(process.cwd(), config.outDir || 'dist');
 }
-async function buildAll(config, options) {
+/**
+ * Build all TypeScript files in the project.
+ * Exported for use by push and bundle commands.
+ */
+export async function buildAll(config, options) {
     // Validate manifest configuration
     const manifestErrors = validateManifest(config);
     if (manifestErrors.length > 0) {
@@ -115,9 +118,6 @@ async function buildAll(config, options) {
     }
     const elapsed = Date.now() - startTime;
     console.log(`\nBuild completed in ${elapsed}ms: ${successCount} succeeded, ${errorCount} failed`);
-    if (options.deploy && config.deploy?.target) {
-        await deployFiles(scriptFiles, config, options);
-    }
 }
 /**
  * esbuild plugin to mark relative script imports and cross-pack imports as external.
@@ -173,7 +173,11 @@ function externalScriptImportsPlugin(config) {
         }
     };
 }
-async function buildFile(file, config, options) {
+/**
+ * Build a single TypeScript file to Rhino-compatible JavaScript.
+ * Exported for use by push --watch for incremental rebuilds.
+ */
+export async function buildFile(file, config, options) {
     const inputPath = path.resolve(process.cwd(), file);
     const outputPath = getOutputPath(file, config);
     // Ensure output directory exists
@@ -207,25 +211,8 @@ async function buildFile(file, config, options) {
 }
 async function watchMode(config, options) {
     console.log('Starting watch mode...');
-    // Initial build (without deploy - we'll deploy separately)
-    await buildAll(config, { ...options, deploy: false });
-    // Initial deploy if requested (scripts + assets)
-    if (options.deploy && config.deploy?.target) {
-        const patterns = config.include || ['scripts/**/*.ts'];
-        const files = [];
-        for (const pattern of patterns) {
-            const matches = await glob(pattern, {
-                cwd: process.cwd(),
-                ignore: config.exclude || []
-            });
-            files.push(...matches);
-        }
-        const libDirs = config.lib || ['scripts/lib'];
-        const scriptFiles = files.filter(file => {
-            return !libDirs.some(lib => file.startsWith(lib + '/') || file.startsWith(lib + '\\'));
-        });
-        await deployFiles(scriptFiles, config, options);
-    }
+    // Initial build
+    await buildAll(config, options);
     // Watch for changes
     const patterns = config.include || ['scripts/**/*.ts'];
     const libDirs = config.lib || ['scripts/lib'];
@@ -234,7 +221,7 @@ async function watchMode(config, options) {
         ignoreInitial: true,
         ignored: config.exclude
     });
-    // Watch sounds folder for type regeneration and deployment
+    // Watch sounds folder for type regeneration
     const soundsWatcher = chokidar.watch('sounds/**/*.ogg', {
         cwd: process.cwd(),
         ignoreInitial: true
@@ -243,56 +230,19 @@ async function watchMode(config, options) {
         console.log(`\nSound added: ${file}`);
         console.log('Regenerating types...');
         await prepare(process.cwd());
-        if (options.deploy && config.deploy?.target) {
-            await deploySingleAsset(file, config);
-            console.log(`  Deployed: ${file}`);
-        }
-    });
-    soundsWatcher.on('change', async (file) => {
-        console.log(`\nSound changed: ${file}`);
-        if (options.deploy && config.deploy?.target) {
-            await deploySingleAsset(file, config);
-            console.log(`  Deployed: ${file}`);
-        }
     });
     soundsWatcher.on('unlink', async (file) => {
         console.log(`\nSound removed: ${file}`);
         console.log('Regenerating types...');
         await prepare(process.cwd());
     });
-    // Watch other asset folders (textures, models, gui)
-    const assetPatterns = [
-        'textures/**/*',
-        'models/**/*',
-        'gui/**/*',
-        'items/**/*',
-        'blocks/**/*'
-    ];
-    const assetsWatcher = chokidar.watch(assetPatterns, {
-        cwd: process.cwd(),
-        ignoreInitial: true
-    });
-    assetsWatcher.on('add', async (file) => {
-        if (options.deploy && config.deploy?.target) {
-            console.log(`\nAsset added: ${file}`);
-            await deploySingleAsset(file, config);
-            console.log(`  Deployed: ${file}`);
-        }
-    });
-    assetsWatcher.on('change', async (file) => {
-        if (options.deploy && config.deploy?.target) {
-            console.log(`\nAsset changed: ${file}`);
-            await deploySingleAsset(file, config);
-            console.log(`  Deployed: ${file}`);
-        }
-    });
     const rebuild = async (changedFile) => {
         const isLibFile = libDirs.some(lib => changedFile.startsWith(lib + '/') || changedFile.startsWith(lib + '\\'));
         if (isLibFile) {
             // Rebuild all files if a lib file changed
             console.log(`\nLib file changed: ${changedFile}`);
             console.log('Rebuilding all scripts...');
-            await buildAll(config, { ...options, deploy: options.deploy });
+            await buildAll(config, options);
         }
         else {
             // Rebuild just the changed file
@@ -300,9 +250,6 @@ async function watchMode(config, options) {
             try {
                 const outputPath = await buildFile(changedFile, config, options);
                 console.log(`  [OK] ${changedFile} -> ${path.relative(process.cwd(), outputPath)}`);
-                if (options.deploy && config.deploy?.target) {
-                    await deploySingleFile(changedFile, config);
-                }
             }
             catch (error) {
                 console.error(`  [ERROR] ${changedFile}: ${error instanceof Error ? error.message : error}`);
@@ -325,123 +272,6 @@ async function watchMode(config, options) {
         console.log('\nStopping watch mode...');
         watcher.close();
         soundsWatcher.close();
-        assetsWatcher.close();
         process.exit(0);
     });
 }
-async function deployFiles(sourceFiles, config, options = {}) {
-    if (!config.deploy?.target)
-        return;
-    const targetDir = path.resolve(process.cwd(), config.deploy.target);
-    console.log(`\nDeploying to ${targetDir}...`);
-    // Ensure target directory exists
-    if (!fs.existsSync(targetDir)) {
-        fs.mkdirSync(targetDir, { recursive: true });
-    }
-    // Deploy manifest
-    const outDir = getOutDir(config);
-    const manifestSource = path.resolve(outDir, 'kustompack.json');
-    const manifestTarget = path.join(targetDir, 'kustompack.json');
-    if (fs.existsSync(manifestSource)) {
-        fs.copyFileSync(manifestSource, manifestTarget);
-        console.log(`  Deployed kustompack.json`);
-    }
-    // Deploy compiled scripts
-    let deployedScripts = 0;
-    for (const sourceFile of sourceFiles) {
-        await deploySingleFile(sourceFile, config);
-        deployedScripts++;
-    }
-    console.log(`  Deployed ${deployedScripts} script(s)`);
-    // Deploy asset folders (sounds, textures, models, gui, etc.)
-    const deployedAssets = await deployAssets(config, options);
-    if (deployedAssets > 0) {
-        console.log(`  Deployed ${deployedAssets} asset folder(s)`);
-    }
-}
-/**
- * Deploy a single file from outDir to deploy target
- */
-async function deploySingleFile(sourceFile, config) {
-    if (!config.deploy?.target)
-        return;
-    // Source is in outDir
-    const outputPath = getOutputPath(sourceFile, config);
-    // Target preserves relative path structure
-    const relativePath = sourceFile.replace(/\.ts$/, '.js');
-    const targetDir = path.resolve(process.cwd(), config.deploy.target);
-    const targetPath = path.join(targetDir, relativePath);
-    // Ensure target subdirectory exists
-    const targetSubDir = path.dirname(targetPath);
-    if (!fs.existsSync(targetSubDir)) {
-        fs.mkdirSync(targetSubDir, { recursive: true });
-    }
-    // Copy file from outDir to deploy target
-    if (fs.existsSync(outputPath)) {
-        fs.copyFileSync(outputPath, targetPath);
-    }
-}
-/**
- * Asset folders that should be deployed alongside scripts
- */
-const ASSET_FOLDERS = ['sounds', 'textures', 'models', 'gui', 'items', 'blocks'];
-/**
- * Copy a folder recursively
- */
-function copyFolderRecursive(source, target) {
-    // Ensure target directory exists
-    if (!fs.existsSync(target)) {
-        fs.mkdirSync(target, { recursive: true });
-    }
-    const entries = fs.readdirSync(source, { withFileTypes: true });
-    for (const entry of entries) {
-        const sourcePath = path.join(source, entry.name);
-        const targetPath = path.join(target, entry.name);
-        if (entry.isDirectory()) {
-            copyFolderRecursive(sourcePath, targetPath);
-        }
-        else {
-            fs.copyFileSync(sourcePath, targetPath);
-        }
-    }
-}
-/**
- * Deploy asset folders (sounds, textures, models, gui, etc.) to deploy target
- */
-async function deployAssets(config, options) {
-    if (!config.deploy?.target)
-        return 0;
-    const targetDir = path.resolve(process.cwd(), config.deploy.target);
-    let deployedCount = 0;
-    for (const folder of ASSET_FOLDERS) {
-        const sourceDir = path.resolve(process.cwd(), folder);
-        if (fs.existsSync(sourceDir)) {
-            const targetSubDir = path.join(targetDir, folder);
-            copyFolderRecursive(sourceDir, targetSubDir);
-            deployedCount++;
-            if (options.verbose) {
-                console.log(`  Deployed ${folder}/`);
-            }
-        }
-    }
-    return deployedCount;
-}
-/**
- * Deploy a single asset file to deploy target
- */
-async function deploySingleAsset(assetFile, config) {
-    if (!config.deploy?.target)
-        return;
-    const sourcePath = path.resolve(process.cwd(), assetFile);
-    const targetDir = path.resolve(process.cwd(), config.deploy.target);
-    const targetPath = path.join(targetDir, assetFile);
-    // Ensure target subdirectory exists
-    const targetSubDir = path.dirname(targetPath);
-    if (!fs.existsSync(targetSubDir)) {
-        fs.mkdirSync(targetSubDir, { recursive: true });
-    }
-    // Copy file
-    if (fs.existsSync(sourcePath)) {
-        fs.copyFileSync(sourcePath, targetPath);
-    }
-}

package/dist/commands/bundle.js

@@ -1,17 +1,17 @@
 import { Command } from 'commander';
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-import archiver from 'archiver';
 import chalk from 'chalk';
-import { loadConfig, generateManifest, validateManifest } from '../config.js';
+import { loadConfig, validateManifest } from '../config.js';
+import { bundleToFile } from '../bundler.js';
+import { buildAll } from './build.js';
 export const bundleCommand = new Command('bundle')
-    .description('Create a distributable zip file with manifest')
+    .description('Build and create a distributable zip file')
     .option('-o, --output <file>', 'Output file name')
     .option('--include-source', 'Include TypeScript source files')
-    .option('--no-manifest', 'Skip manifest generation (use existing kustompack.json)')
+    .option('--no-manifest', 'Skip manifest generation')
+    .option('-v, --verbose', 'Verbose output')
     .action(async (options) => {
-    const config = loadConfig(process.cwd());
+    const projectDir = process.cwd();
+    const config = loadConfig(projectDir);
     // Validate manifest configuration
     const errors = validateManifest(config);
     if (errors.length > 0) {
@@ -23,136 +23,25 @@ export const bundleCommand = new Command('bundle')
     }
     const packId = config.manifest?.id || 'kustompack';
     const outputFile = options.output || config.bundle?.output || `dist/${packId}.zip`;
-    const outputPath = path.resolve(process.cwd(), outputFile);
+    // Auto-build before bundling
+    console.log(chalk.blue('Building before bundle...\n'));
+    await buildAll(config, { verbose: options.verbose });
+    console.log();
+    // Create bundle
     console.log(chalk.blue(`Creating bundle for pack: ${chalk.bold(packId)}`));
     console.log(`  Version: ${config.manifest?.version || '1.0.0'}`);
     console.log(`  Output: ${outputFile}`);
-    // Ensure output directory exists
-    const outputDir = path.dirname(outputPath);
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
-    }
-    // Generate manifest if enabled
-    let manifestContent = null;
-    if (options.manifest !== false) {
-        try {
-            manifestContent = generateManifest(config);
-            console.log(chalk.green('  Generated kustompack.json'));
-        }
-        catch (error) {
-            console.error(chalk.red(`Failed to generate manifest: ${error}`));
-            process.exit(1);
-        }
-    }
-    // Create zip archive
-    const output = fs.createWriteStream(outputPath);
-    const archive = archiver('zip', { zlib: { level: 9 } });
-    let fileCount = 0;
-    output.on('close', () => {
-        const sizeKB = (archive.pointer() / 1024).toFixed(2);
+    try {
+        const result = await bundleToFile(projectDir, outputFile, {
+            includeManifest: options.manifest !== false,
+            includeSource: options.includeSource
+        });
         console.log(chalk.green(`\nBundle created successfully!`));
         console.log(`  File: ${outputFile}`);
-        console.log(`  Size: ${sizeKB} KB`);
-        console.log(`  Files: ${fileCount}`);
-    });
-    archive.on('warning', (err) => {
-        if (err.code === 'ENOENT') {
-            console.warn(chalk.yellow('Warning:'), err.message);
-        }
-        else {
-            throw err;
-        }
-    });
-    archive.on('error', (err) => {
-        throw err;
-    });
-    archive.pipe(output);
-    // Add manifest first
-    if (manifestContent) {
-        archive.append(manifestContent, { name: 'kustompack.json' });
-        fileCount++;
-    }
-    else {
-        // Check for existing manifest
-        const existingManifest = path.resolve(process.cwd(), 'kustompack.json');
-        if (fs.existsSync(existingManifest)) {
-            archive.file(existingManifest, { name: 'kustompack.json' });
-            fileCount++;
-        }
-        else {
-            console.warn(chalk.yellow('Warning: No kustompack.json found. Pack may not load correctly.'));
-        }
+        console.log(`  Files: ${result.fileCount}`);
     }
-    // Add files based on bundle config
-    const includePatterns = config.bundle?.include || [
-        '**/*.js',
-        'textures/**/*',
-        'gui/**/*',
-        'models/**/*',
-        'sounds/**/*'
-    ];
-    const outDir = config.outDir || 'dist';
-    const outDirResolved = path.resolve(process.cwd(), outDir);
-    const addedFiles = new Set();
-    for (const pattern of includePatterns) {
-        const isJsPattern = pattern.includes('*.js');
-        if (isJsPattern) {
-            // JS files live in outDir (e.g. dist/)
-            const files = await glob(pattern, {
-                cwd: outDirResolved,
-                nodir: true,
-                ignore: ['node_modules/**', '*.ts', 'kustompack.json']
-            });
-            for (const file of files) {
-                if (addedFiles.has(file))
-                    continue;
-                const filePath = path.resolve(outDirResolved, file);
-                if (fs.existsSync(filePath)) {
-                    archive.file(filePath, { name: file });
-                    addedFiles.add(file);
-                    fileCount++;
-                }
-            }
-        }
-        else {
-            // Asset files live in cwd (source directory)
-            const files = await glob(pattern, {
-                cwd: process.cwd(),
-                nodir: true,
-                ignore: ['node_modules/**', 'dist/**', '*.ts', 'kustompack.json']
-            });
-            for (const file of files) {
-                if (addedFiles.has(file))
-                    continue;
-                const filePath = path.resolve(process.cwd(), file);
-                if (fs.existsSync(filePath)) {
-                    archive.file(filePath, { name: file });
-                    addedFiles.add(file);
-                    fileCount++;
-                }
-            }
-        }
-    }
-    // Optionally include source files
-    if (options.includeSource) {
-        const sourcePatterns = config.include || ['scripts/**/*.ts', 'blocks/**/*.ts', 'items/**/*.ts'];
-        for (const pattern of sourcePatterns) {
-            const files = await glob(pattern, {
-                cwd: process.cwd(),
-                nodir: true,
-                ignore: config.exclude
-            });
-            for (const file of files) {
-                if (addedFiles.has(file))
-                    continue;
-                const filePath = path.resolve(process.cwd(), file);
-                if (fs.existsSync(filePath)) {
-                    archive.file(filePath, { name: file });
-                    addedFiles.add(file);
-                    fileCount++;
-                }
-            }
-        }
+    catch (error) {
+        console.error(chalk.red(`\nFailed to create bundle: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
     }
-    await archive.finalize();
 });