kustom-mc 0.1.1 → 0.1.3

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,112 +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++;
+        console.log(`  Files: ${result.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.'));
-        }
-    }
-    // Add files based on bundle config
-    const includePatterns = config.bundle?.include || [
-        '**/*.js',
-        'textures/**/*',
-        'gui/**/*',
-        'models/**/*',
-        'sounds/**/*'
-    ];
-    const addedFiles = new Set();
-    for (const pattern of includePatterns) {
-        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();
 });

package/dist/commands/init.js

@@ -88,7 +88,7 @@ export const initCommand = new Command('init')
             "**/*.test.ts",
             "**/*.spec.ts"
         ],
-        outDir: ".",
+        outDir: "dist",
         lib: ["scripts/lib"],
         manifest: {
             id: packId,
@@ -103,10 +103,6 @@ export const initCommand = new Command('init')
         server: {
             url: "http://localhost:8765"
         },
-        deploy: {
-            target: "../run/plugins/kustom-plugin/packs",
-            reloadCommand: "/kustom pack reload"
-        },
         bundle: {
             output: `dist/${packId}.zip`,
             include: [
@@ -127,12 +123,11 @@ export const initCommand = new Command('init')
         version: "1.0.0",
         type: "module",
         scripts: {
+            push: "kustom push",
+            dev: "kustom push --watch",
             build: "kustom build",
-            watch: "kustom build --watch",
-            deploy: "kustom build --deploy",
             bundle: "kustom bundle",
-            validate: "kustom validate",
-            push: "kustom push"
+            validate: "kustom validate"
         },
         devDependencies: {
             "kustom-mc": "^0.1.0",
@@ -186,8 +181,6 @@ export function delay(ms: number): Promise<void> {
     const gitignore = `node_modules/
 dist/
 .kustom/
-*.js
-!scripts/lib/**/*.js
 `;
     fs.writeFileSync(path.join(targetDir, '.gitignore'), gitignore);
     console.log(chalk.green('\nProject initialized successfully!'));
@@ -210,10 +203,10 @@ dist/
         console.log(chalk.cyan(`  cd ${projectName}`));
     }
     console.log(chalk.cyan('  npm install'));
-    console.log(chalk.cyan('  npm run build'));
+    console.log(chalk.cyan('  npm run push'));
     console.log('\n' + chalk.bold('Available commands:'));
-    console.log('  npm run build    - Compile TypeScript');
-    console.log('  npm run watch    - Watch mode');
-    console.log('  npm run deploy   - Build and deploy to server');
+    console.log('  npm run push     - Build and push to server');
+    console.log('  npm run dev      - Watch mode + auto-push');
+    console.log('  npm run build    - Compile TypeScript only');
     console.log('  npm run bundle   - Create distributable zip');
 });

package/dist/commands/push.d.ts

@@ -1,9 +1,16 @@
 import { Command } from 'commander';
 /**
- * Push command - bundle and upload pack to server.
+ * Push command — build, bundle, and upload pack to server.
+ *
+ * This is the primary deployment command. It:
+ * 1. Builds all TypeScript files
+ * 2. Bundles compiled JS + assets into a zip
+ * 3. Uploads the zip to the server via HTTP
  *
  * Usage:
- *   npx kustom-mc push              # Push to configured server
- *   npx kustom-mc push --server <url>  # Push to specific server
+ *   kustom push                    # One-shot build + push
+ *   kustom push --watch            # Watch + auto-push on changes
+ *   kustom push --server <url>     # Push to specific server
+ *   kustom push --dry-run          # Build + bundle, don't upload
  */
 export declare const pushCommand: Command;

package/dist/commands/push.js

@@ -2,113 +2,181 @@ import { Command } from 'commander';
 import * as fs from 'fs';
 import * as path from 'path';
 import chalk from 'chalk';
-import { glob } from 'glob';
-import archiver from 'archiver';
-import { loadConfig, generateManifest, validateManifest } from '../config.js';
+import chokidar from 'chokidar';
+import { loadConfig } from '../config.js';
 import { getServerToken, normalizeServerUrl, getServerCredential } from '../credentials.js';
+import { bundleToBuffer } from '../bundler.js';
+import { uploadPack } from '../upload.js';
+import { buildAll, buildFile } from './build.js';
+import { prepare } from './prepare.js';
+/** Debounce delay in milliseconds before auto-pushing after a change */
+const PUSH_DEBOUNCE_MS = 500;
 /**
- * Create a zip bundle in memory and return as Buffer.
+ * Build, bundle, and upload the pack to the server.
+ * Returns true on success, false on failure.
  */
-async function createBundle(projectDir) {
-    const config = loadConfig(projectDir);
-    // Validate manifest
-    const errors = validateManifest(config);
-    if (errors.length > 0) {
-        throw new Error(`Manifest validation failed:\n  ${errors.join('\n  ')}`);
+async function doPush(projectDir, serverUrl, token, options) {
+    try {
+        const { buffer, packId, version, fileCount } = await bundleToBuffer(projectDir);
+        const sizeKB = (buffer.length / 1024).toFixed(2);
+        if (options.verbose) {
+            console.log(`  Bundle: ${fileCount} files, ${sizeKB} KB`);
+        }
+        const result = await uploadPack(serverUrl, token, buffer, packId);
+        if (result.success) {
+            console.log(chalk.green(`  Pushed ${packId} v${version} (${sizeKB} KB)`));
+            return true;
+        }
+        else {
+            console.error(chalk.red(`  Push failed: ${result.error || 'Unknown error'}`));
+            return false;
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`  Push failed: ${error instanceof Error ? error.message : error}`));
+        return false;
     }
-    const packId = config.manifest?.id || 'kustompack';
-    const version = config.manifest?.version || '1.0.0';
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        const archive = archiver('zip', { zlib: { level: 9 } });
-        archive.on('data', (chunk) => chunks.push(chunk));
-        archive.on('end', () => resolve({
-            buffer: Buffer.concat(chunks),
-            packId,
-            version
-        }));
-        archive.on('error', reject);
-        // Generate and add manifest
-        const manifestContent = generateManifest(config);
-        archive.append(manifestContent, { name: 'kustompack.json' });
-        // Add files based on bundle config
-        const includePatterns = config.bundle?.include || [
-            '**/*.js',
-            'textures/**/*',
-            'gui/**/*',
-            'models/**/*',
-            'sounds/**/*'
-        ];
-        const addFiles = async () => {
-            const addedFiles = new Set();
-            for (const pattern of includePatterns) {
-                const files = await glob(pattern, {
-                    cwd: projectDir,
-                    nodir: true,
-                    ignore: ['node_modules/**', 'dist/**', '*.ts', 'kustompack.json']
-                });
-                for (const file of files) {
-                    if (addedFiles.has(file))
-                        continue;
-                    const filePath = path.resolve(projectDir, file);
-                    if (fs.existsSync(filePath)) {
-                        archive.file(filePath, { name: file });
-                        addedFiles.add(file);
-                    }
-                }
-            }
-            archive.finalize();
-        };
-        addFiles().catch(reject);
-    });
 }
 /**
- * Upload a pack to the server.
- *
- * Currently sends raw zip bytes for simplicity and performance.
- *
- * TODO: If a web UI is added later, consider supporting multipart/form-data
- * uploads on the server side (Option 2). This would require:
- * - Adding multipart parsing to PackRegistryServer.java (Apache Commons FileUpload or manual)
- * - Keeping raw zip support for CLI (faster)
- * - Adding multipart support for browser uploads
+ * Watch mode: rebuild and auto-push on file changes with debounce.
  */
-async function uploadPack(serverUrl, token, buffer, packId) {
-    const url = `${normalizeServerUrl(serverUrl)}/packs/upload`;
-    // Send raw zip bytes (faster than multipart, server already supports this)
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': 'application/zip',
-            'X-Pack-Id': packId // Optional hint for server
-        },
-        body: buffer
-    });
-    if (response.status === 401) {
-        throw new Error('Authentication failed. Token may be invalid or expired. Run: npx kustom-mc login');
-    }
-    if (response.status === 403) {
-        throw new Error('Permission denied. You may not have upload permissions.');
-    }
-    const result = await response.json();
-    if (!response.ok) {
-        throw new Error(result.error || result.message || `Server returned ${response.status}`);
+async function pushWatchMode(config, projectDir, serverUrl, token, options) {
+    console.log(chalk.blue('Starting push watch mode...'));
+    console.log(`  Server: ${serverUrl}`);
+    console.log();
+    // Initial build
+    await buildAll(config, options);
+    // Initial push
+    console.log('\nPushing initial build...');
+    await doPush(projectDir, serverUrl, token, options);
+    // Debounce timer
+    let pushTimer = null;
+    function schedulePush() {
+        if (pushTimer)
+            clearTimeout(pushTimer);
+        pushTimer = setTimeout(async () => {
+            pushTimer = null;
+            console.log(chalk.gray('\nPushing changes...'));
+            await doPush(projectDir, serverUrl, token, options);
+        }, PUSH_DEBOUNCE_MS);
     }
-    return result;
+    // Watch script files
+    const patterns = config.include || ['scripts/**/*.ts'];
+    const libDirs = config.lib || ['scripts/lib'];
+    const scriptWatcher = chokidar.watch(patterns, {
+        cwd: projectDir,
+        ignoreInitial: true,
+        ignored: config.exclude
+    });
+    const rebuildAndPush = async (changedFile) => {
+        const isLibFile = libDirs.some(lib => changedFile.startsWith(lib + '/') || changedFile.startsWith(lib + '\\'));
+        if (isLibFile) {
+            console.log(`\nLib file changed: ${changedFile}`);
+            console.log('Rebuilding all scripts...');
+            await buildAll(config, options);
+        }
+        else {
+            console.log(`\nFile changed: ${changedFile}`);
+            try {
+                const outputPath = await buildFile(changedFile, config, options);
+                console.log(`  [OK] ${changedFile} -> ${path.relative(projectDir, outputPath)}`);
+            }
+            catch (error) {
+                console.error(`  [ERROR] ${changedFile}: ${error instanceof Error ? error.message : error}`);
+                return; // Don't push if build failed
+            }
+        }
+        schedulePush();
+    };
+    scriptWatcher.on('change', rebuildAndPush);
+    scriptWatcher.on('add', rebuildAndPush);
+    scriptWatcher.on('unlink', (file) => {
+        console.log(`\nFile deleted: ${file}`);
+        // Delete the compiled output
+        const outDir = config.outDir || 'dist';
+        const outputPath = path.resolve(projectDir, outDir, file.replace(/\.ts$/, '.js'));
+        if (fs.existsSync(outputPath)) {
+            fs.unlinkSync(outputPath);
+        }
+        schedulePush();
+    });
+    // Watch sounds folder for type regeneration + push
+    const soundsWatcher = chokidar.watch('sounds/**/*.ogg', {
+        cwd: projectDir,
+        ignoreInitial: true
+    });
+    soundsWatcher.on('add', async (file) => {
+        console.log(`\nSound added: ${file}`);
+        console.log('Regenerating types...');
+        await prepare(projectDir);
+        schedulePush();
+    });
+    soundsWatcher.on('change', () => {
+        schedulePush();
+    });
+    soundsWatcher.on('unlink', async (file) => {
+        console.log(`\nSound removed: ${file}`);
+        console.log('Regenerating types...');
+        await prepare(projectDir);
+        schedulePush();
+    });
+    // Watch asset folders (textures, models, gui, etc.) — push on change
+    const assetPatterns = [
+        'textures/**/*',
+        'models/**/*',
+        'gui/**/*',
+        'lang/**/*',
+        'definitions/**/*'
+    ];
+    const assetsWatcher = chokidar.watch(assetPatterns, {
+        cwd: projectDir,
+        ignoreInitial: true
+    });
+    assetsWatcher.on('add', (file) => {
+        console.log(`\nAsset added: ${file}`);
+        schedulePush();
+    });
+    assetsWatcher.on('change', (file) => {
+        console.log(`\nAsset changed: ${file}`);
+        schedulePush();
+    });
+    assetsWatcher.on('unlink', (file) => {
+        console.log(`\nAsset removed: ${file}`);
+        schedulePush();
+    });
+    console.log('\nWatching for changes... (Ctrl+C to stop)');
+    // Keep process alive
+    process.on('SIGINT', () => {
+        console.log('\nStopping push watch mode...');
+        if (pushTimer)
+            clearTimeout(pushTimer);
+        scriptWatcher.close();
+        soundsWatcher.close();
+        assetsWatcher.close();
+        process.exit(0);
+    });
 }
 /**
- * Push command - bundle and upload pack to server.
+ * Push command — build, bundle, and upload pack to server.
+ *
+ * This is the primary deployment command. It:
+ * 1. Builds all TypeScript files
+ * 2. Bundles compiled JS + assets into a zip
+ * 3. Uploads the zip to the server via HTTP
  *
  * Usage:
- *   npx kustom-mc push              # Push to configured server
- *   npx kustom-mc push --server <url>  # Push to specific server
+ *   kustom push                    # One-shot build + push
+ *   kustom push --watch            # Watch + auto-push on changes
+ *   kustom push --server <url>     # Push to specific server
+ *   kustom push --dry-run          # Build + bundle, don't upload
  */
 export const pushCommand = new Command('push')
-    .description('Bundle and upload pack to the connected server')
+    .description('Build, bundle, and upload pack to the server')
     .option('-s, --server <url>', 'Server URL (overrides config)')
-    .option('--dry-run', 'Create bundle but do not upload')
+    .option('-w, --watch', 'Watch for changes and auto-push')
+    .option('--dry-run', 'Build and bundle but do not upload')
     .option('-y, --yes', 'Skip confirmation prompt')
+    .option('-v, --verbose', 'Verbose output')
     .action(async (options) => {
     const projectDir = process.cwd();
     const config = loadConfig(projectDir);
@@ -135,22 +203,35 @@ export const pushCommand = new Command('push')
         process.exit(1);
     }
     const cred = getServerCredential(serverUrl);
-    console.log(chalk.blue('Preparing pack for upload...'));
+    // Watch mode
+    if (options?.watch) {
+        if (!token) {
+            console.error(chalk.red('Error: --watch requires authentication'));
+            process.exit(1);
+        }
+        await pushWatchMode(config, projectDir, serverUrl, token, { verbose: options.verbose });
+        return;
+    }
+    // One-shot mode: build → bundle → upload
+    console.log(chalk.blue('Building and pushing pack...'));
     console.log(`  Server: ${serverUrl}`);
     if (cred?.playerName) {
         console.log(`  As: ${cred.playerName}`);
     }
     console.log();
     try {
-        // Create bundle
+        // Build
+        await buildAll(config, { verbose: options?.verbose });
+        console.log();
+        // Bundle
         console.log('Creating bundle...');
-        const { buffer, packId, version } = await createBundle(projectDir);
+        const { buffer, packId, version, fileCount } = await bundleToBuffer(projectDir);
         const sizeKB = (buffer.length / 1024).toFixed(2);
         console.log(chalk.green(`  Pack: ${packId} v${version}`));
-        console.log(chalk.green(`  Size: ${sizeKB} KB`));
+        console.log(chalk.green(`  Size: ${sizeKB} KB (${fileCount} files)`));
+        // Dry run — save to disk instead of uploading
         if (options?.dryRun) {
             console.log(chalk.yellow('\n--dry-run: Bundle created but not uploaded.'));
-            // Optionally save the bundle locally
             const outputPath = path.join(projectDir, 'dist', `${packId}.zip`);
             const outputDir = path.dirname(outputPath);
             if (!fs.existsSync(outputDir)) {
@@ -164,7 +245,6 @@ export const pushCommand = new Command('push')
         if (!options?.yes) {
             console.log(chalk.yellow(`\nThis will upload ${packId} v${version} to ${serverUrl}`));
             console.log(chalk.yellow('If a pack with this ID exists, it will be replaced.'));
-            // Simple confirmation using readline
             const readline = await import('readline');
             const rl = readline.createInterface({
                 input: process.stdin,
@@ -183,15 +263,14 @@ export const pushCommand = new Command('push')
         console.log('\nUploading...');
         const result = await uploadPack(serverUrl, token, buffer, packId);
         if (result.success) {
-            console.log(chalk.green('\nUpload successful!'));
+            console.log(chalk.green('\nPush successful!'));
             if (result.message) {
                 console.log(`  ${result.message}`);
             }
-            console.log(`\nPack ${packId} v${version} is now available on the server.`);
-            console.log(chalk.gray('Run /kustom pack reload to apply changes in-game.'));
+            console.log(`\nPack ${packId} v${version} is now live on the server.`);
         }
         else {
-            console.error(chalk.red('\nUpload failed'));
+            console.error(chalk.red('\nPush failed'));
             if (result.error) {
                 console.error(chalk.red(`  ${result.error}`));
             }

package/dist/config.d.ts

@@ -37,10 +37,6 @@ export interface KustomConfig {
     dependencies?: string[];
     /** Server connection settings */
     server?: ServerConfig;
-    deploy?: {
-        target?: string;
-        reloadCommand?: string;
-    };
     bundle?: {
         output?: string;
         include?: string[];

package/dist/config.js

@@ -3,7 +3,7 @@ import * as path from 'path';
 const defaultConfig = {
     include: ['scripts/**/*.ts', 'blocks/**/*.ts', 'items/**/*.ts'],
     exclude: ['**/*.test.ts', '**/*.spec.ts'],
-    outDir: '.',
+    outDir: 'dist',
     lib: ['scripts/lib'],
     manifest: {
         id: 'my-pack',
@@ -15,10 +15,6 @@ const defaultConfig = {
     server: {
         url: 'http://localhost:8765'
     },
-    deploy: {
-        target: '../run/plugins/kustom-plugin/packs',
-        reloadCommand: '/kustom pack reload'
-    },
     bundle: {
         output: 'dist/kustompack.zip',
         include: ['**/*.js', 'textures/**/*', 'gui/**/*', 'models/**/*', 'sounds/**/*']
@@ -41,7 +37,6 @@ export function loadConfig(cwd) {
                     id: userConfig.manifest?.id || defaultConfig.manifest?.id || 'my-pack'
                 },
                 server: { ...defaultConfig.server, ...userConfig.server },
-                deploy: { ...defaultConfig.deploy, ...userConfig.deploy },
                 bundle: { ...defaultConfig.bundle, ...userConfig.bundle }
             };
             return merged;

package/dist/upload.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Response from the /packs/upload endpoint.
+ */
+export interface UploadResponse {
+    success: boolean;
+    packId?: string;
+    version?: string;
+    message?: string;
+    error?: string;
+}
+/**
+ * Upload a pack zip to the server via HTTP POST.
+ *
+ * Sends raw zip bytes with application/zip content type.
+ * The server saves the zip and hot-loads the pack.
+ *
+ * @param serverUrl - Server base URL (e.g. "http://localhost:8765")
+ * @param token - Authentication token (from `kustom login`)
+ * @param buffer - Raw zip bytes
+ * @param packId - Pack ID hint for the server
+ */
+export declare function uploadPack(serverUrl: string, token: string, buffer: Buffer, packId: string): Promise<UploadResponse>;

package/dist/upload.js

@@ -0,0 +1,35 @@
+import { normalizeServerUrl } from './credentials.js';
+/**
+ * Upload a pack zip to the server via HTTP POST.
+ *
+ * Sends raw zip bytes with application/zip content type.
+ * The server saves the zip and hot-loads the pack.
+ *
+ * @param serverUrl - Server base URL (e.g. "http://localhost:8765")
+ * @param token - Authentication token (from `kustom login`)
+ * @param buffer - Raw zip bytes
+ * @param packId - Pack ID hint for the server
+ */
+export async function uploadPack(serverUrl, token, buffer, packId) {
+    const url = `${normalizeServerUrl(serverUrl)}/packs/upload`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/zip',
+            'X-Pack-Id': packId
+        },
+        body: buffer
+    });
+    if (response.status === 401) {
+        throw new Error('Authentication failed. Token may be invalid or expired. Run: npx kustom-mc login');
+    }
+    if (response.status === 403) {
+        throw new Error('Permission denied. You may not have upload permissions.');
+    }
+    const result = await response.json();
+    if (!response.ok) {
+        throw new Error(result.error || result.message || `Server returned ${response.status}`);
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kustom-mc",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "CLI and type library for kustompack development",
   "type": "module",
   "main": "dist/runtime.js",