@mcbepack/cli 1.0.0

package/README.md

@@ -0,0 +1,193 @@
+# @mcbepack/cli
+
+Development and build tooling for MCBEPACK projects
+
+[![npm version](https://badge.fury.io/js/create-mcbepack.svg)](https://www.npmjs.com/package/@mcbepack/cli)
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+
+## Overview
+
+`@mcbepack/cli` provides command-line tools for developing and building Minecraft Bedrock Edition addons. It includes a development server with hot-reload capabilities and multiple build format options.
+
+## Features
+
+- **Development Server** - Watch mode with automatic file synchronization
+- **Multiple Build Formats** - Export as `.zip`, `.mcpack`, or `.mcaddon`
+- **Script API Compilation** - Webpack-based bundling for Script API projects
+- **Smart File Sync** - Automatic synchronization to Minecraft development folders
+- **Dependency Updates** - Update Script API packages to latest versions
+- **Environment Configuration** - `.env.local` support for custom paths
+
+## Installation
+
+This package is automatically installed as a peer dependency when creating a project with `create-mcbepack`.
+
+```bash
+bun add -D @mcbepack/cli
+```
+
+## Commands
+
+### `mcbepack dev`
+
+Start the development server with file watching and automatic synchronization.
+
+```bash
+bun run dev
+# or
+mcbepack dev
+```
+
+**Features:**
+
+- Watches `scripts/` directory for changes
+- Compiles TypeScript/JavaScript with Webpack
+- Syncs compiled files to Minecraft development folder
+- Provides real-time feedback on file changes
+
+### `mcbepack build`
+
+Build the addon as a .zip, .mcpack, or .mcaddon file.
+
+```bash
+# Build the addon as a .zip archive.
+mcbepack build -o zip
+
+# Build the addon as a .mcpack file.
+mcbepack build -o mcpack
+
+# Build the addon as a .mcaddon file.
+mcbepack build -o addon
+```
+
+### `mcbepack update`
+
+Update Script API dependencies to the latest release.
+
+```bash
+# Update Script API dependencies to the latest stable release.
+mcbepack update -t stable
+
+# Update Script API dependencies to the latest beta release.
+mcbepack update -t beta
+
+# Update Script API dependencies to the latest preview release.
+mcbepack update -t preview
+```
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env.local` file in your project root:
+
+```env
+BASE_PATH="C:\Users\YourName\AppData\Roaming\Minecraft Bedrock\Users\Shared\games\com.mojang"
+RESOURCE_PATH="development_resource_packs"
+BEHAVIOR_PATH="development_behavior_packs"
+```
+
+**Variables:**
+
+- `BASE_PATH` - Path to Minecraft's `com.mojang` directory
+- `RESOURCE_PATH` - Relative path to resource packs folder
+- `BEHAVIOR_PATH` - Relative path to behavior packs folder
+
+### Project Structure
+
+The CLI expects the following project structure:
+
+```
+your-project/
+├── scripts/              # Source files (TypeScript/JavaScript)
+│   └── index.ts
+├── behavior/             # Auto-generated behavior pack (if applicable)
+├── resource/             # Auto-generated resource pack (if applicable)
+├── .env.local           # Environment configuration
+└── package.json
+```
+
+## Development Workflow
+
+1. **Start Development Server**
+
+   ```bash
+   bun run dev
+   ```
+
+2. **Edit Source Files**
+   - Modify files in `scripts/` directory
+   - Changes are automatically detected and compiled
+
+3. **Test in Minecraft**
+   - Files are synced to Minecraft's development folder
+   - Reload the world or restart Minecraft to see changes
+
+4. **Build for Distribution**
+   ```bash
+   bun run build:mcaddon
+   ```
+
+## Technical Details
+
+### File Watching
+
+The development server uses `chokidar` for efficient file watching:
+
+- Monitors `scripts/` directory for changes
+- Triggers recompilation on file add/change/delete
+- Syncs compiled output to Minecraft folders
+
+### Webpack Configuration
+
+For Script API projects, the CLI uses Webpack with:
+
+- TypeScript support via `ts-loader`
+- ESNext target
+- Bundler module resolution
+- Source map generation (development only)
+
+### Build Process
+
+The build commands:
+
+1. Compile source files (if Script API enabled)
+2. Copy pack files to temporary directory
+3. Create archive using `archiver`
+4. Output to project root
+
+## Related Packages
+
+- [`create-mcbepack`](../create-mcbepack) - Project scaffolding tool
+- [`@mcbepack/api`](../api) - Utility APIs for Script API
+- [`@mcbepack/common`](../common) - Shared utilities
+
+## Troubleshooting
+
+### Files Not Syncing
+
+1. Check `.env.local` paths are correct
+2. Ensure Minecraft development folders exist
+3. Verify file permissions
+
+### Compilation Errors
+
+1. Check TypeScript configuration in `tsconfig.json`
+2. Ensure all dependencies are installed
+3. Verify source file syntax
+
+### Build Failures
+
+1. Check for file permission issues
+2. Ensure sufficient disk space
+3. Verify pack manifest files are valid
+
+## License
+
+GPL-3.0 - see [LICENSE](./LICENSE) for details
+
+## Resources
+
+- [GitHub Repository](https://github.com/bugphxne/create-mcbepack)
+- [Documentation](https://docs.mbext.online/mcbepack)
+- [Issue Tracker](https://github.com/bugphxne/create-mcbepack/issues)

package/out/commands/build.js

@@ -0,0 +1,58 @@
+import pc from "picocolors";
+import { createCompiler } from "../utils/webpack";
+import { PackArchiver } from "../utils/archiver";
+import { getProjectPaths } from "../utils/paths";
+import fs from "fs";
+export const buildCommand = {
+    command: "build",
+    describe: "Build the project",
+    builder: (yargs) => {
+        return yargs.option("output", {
+            alias: "o",
+            type: "string",
+            description: "Output format",
+            demandOption: true,
+            choices: ["mcpack", "mcaddon", "zip"]
+        });
+    },
+    handler: async (argv) => {
+        try {
+            const paths = getProjectPaths();
+            const { output } = argv;
+            console.log(pc.cyan("Building project...\n"));
+            if (fs.existsSync(paths.scriptsDir)) {
+                const compiler = createCompiler();
+                await new Promise((resolve, reject) => {
+                    compiler.run((err, stats) => {
+                        if (err) {
+                            reject(err);
+                            return;
+                        }
+                        if (stats?.hasErrors()) {
+                            console.error(pc.red("Compilation errors:"));
+                            console.error(stats.toString({ errors: true }));
+                            reject(new Error("Compilation failed"));
+                            return;
+                        }
+                        console.log(stats?.toString({
+                            colors: true,
+                            modules: false,
+                            children: false,
+                            chunks: false,
+                            chunkModules: false,
+                        }));
+                        console.log(pc.green("\nWebpack compilation completed\n"));
+                        resolve();
+                    });
+                });
+            }
+            const archiver = new PackArchiver(paths);
+            await archiver.archive(output);
+            console.log(pc.green("\nBuild completed successfully!\n"));
+        }
+        catch (error) {
+            console.error(pc.red("Build failed:"), error);
+            process.exit(1);
+        }
+    }
+};

package/out/commands/dev.js

@@ -0,0 +1,44 @@
+import pc from "picocolors";
+import { createCompiler } from "../utils/webpack";
+import { FileSync } from "../utils/file-sync";
+import { getProjectPaths, validateEnv } from "../utils/paths";
+export const devCommand = {
+    command: "dev",
+    describe: "Run the development server",
+    handler: async () => {
+        try {
+            validateEnv();
+            const paths = getProjectPaths();
+            console.log(pc.cyan("Starting development server...\n"));
+            const compiler = createCompiler();
+            compiler.watch({
+                aggregateTimeout: 300,
+                poll: 1000
+            }, (err, stats) => {
+                if (stats?.hasWarnings()) {
+                    console.error(pc.yellow("Compilation warnings:"));
+                    console.error(stats.toString({ warnings: true }));
+                    return;
+                }
+                if (err) {
+                    console.error(pc.red("Webpack error:"), err);
+                    return;
+                }
+                if (stats?.hasErrors()) {
+                    console.error(pc.red("Compilation errors:"));
+                    console.error(stats.toString({ errors: true }));
+                    return;
+                }
+                console.log(pc.green(`Rebuilt at ${new Date().toLocaleTimeString()}`));
+            });
+            const fileSync = new FileSync(paths);
+            fileSync.watchBehaviorPack();
+            fileSync.watchResourcePack();
+            console.log(pc.dim("Watching for file changes...\n"));
+        }
+        catch (error) {
+            console.error(pc.red("Failed to start dev server:"), error);
+            process.exit(1);
+        }
+    }
+};

package/out/commands/update.js

@@ -0,0 +1,98 @@
+import pc from "picocolors";
+import { constants, getDependency } from "@mcbepack/common";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { getProjectPaths } from "../utils/paths";
+export const updateCommand = {
+    command: "update",
+    describe: "Update the project dependencies",
+    builder: (yargs) => {
+        return yargs.option("type", {
+            alias: "t",
+            type: "string",
+            description: "Update type",
+            choices: ['stable', 'beta', 'preview'],
+            default: 'stable'
+        });
+    },
+    handler: async (argv) => {
+        const { type = 'stable' } = argv;
+        console.log(pc.cyan(`Updating dependencies to ${pc.bold(type)} version...\n`));
+        try {
+            const packageJsonPath = join(process.cwd(), "package.json");
+            const manifestJsonPath = join(getProjectPaths().behaviorRootPath, "manifest.json");
+            if (!existsSync(packageJsonPath)) {
+                console.error(pc.red("package.json not found in current directory"));
+                process.exit(1);
+            }
+            if (!existsSync(manifestJsonPath)) {
+                console.error(pc.red("manifest.json not found in current directory"));
+                process.exit(1);
+            }
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            const manifestJson = JSON.parse(readFileSync(manifestJsonPath, "utf-8"));
+            if (!packageJson.dependencies) {
+                console.log(pc.yellow("No dependencies found in package.json"));
+                process.exit(0);
+            }
+            const minecraftPackages = [
+                ...constants.packages.modules,
+                ...constants.packages.plugins,
+            ];
+            let updated = false;
+            let updatedCount = 0;
+            for (const packageName of minecraftPackages) {
+                if (packageJson.dependencies[packageName]) {
+                    try {
+                        const dependency = await getDependency(packageName, type);
+                        const currentVersion = packageJson.dependencies[packageName];
+                        if (currentVersion !== dependency.fullVersion) {
+                            packageJson.dependencies[packageName] = dependency.fullVersion;
+                            console.log(pc.green(`  ✓ ${pc.bold(packageName)}`));
+                            console.log(pc.dim(`    ${currentVersion} → ${pc.white(dependency.fullVersion)}`));
+                            updated = true;
+                            updatedCount++;
+                        }
+                        else {
+                            console.log(pc.dim(`  ${packageName} is already up to date (${currentVersion})`));
+                        }
+                    }
+                    catch (error) {
+                        console.error(pc.red(`  Failed to update ${packageName}: ${error instanceof Error ? error.message : String(error)}`));
+                    }
+                }
+                const manifestDep = manifestJson.dependencies.find((dep) => "module_name" in dep && dep.module_name === packageName);
+                if (manifestDep) {
+                    try {
+                        const dependency = await getDependency(packageName, type);
+                        const currentVersion = "version" in manifestDep ? manifestDep.version : undefined;
+                        if (currentVersion !== dependency.version) {
+                            manifestJson.dependencies = manifestJson.dependencies.map((dep) => {
+                                if ("module_name" in dep && dep.module_name === packageName) {
+                                    return { ...dep, version: dependency.version };
+                                }
+                                return dep;
+                            });
+                        }
+                    }
+                    catch (error) {
+                        console.error(pc.red(`  Failed to update manifest for ${packageName}: ${error instanceof Error ? error.message : String(error)}`));
+                    }
+                }
+            }
+            if (updated) {
+                writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+                writeFileSync(manifestJsonPath, JSON.stringify(manifestJson, null, 2) + "\n", "utf-8");
+                console.log(pc.green(`\n✓ Updated ${updatedCount} package${updatedCount > 1 ? 's' : ''} successfully!`));
+                console.log(pc.dim(`Run ${pc.bold("bun install")} to install the new versions`));
+            }
+            else {
+                console.log(pc.green(`\n✓ All dependencies are up to date!`));
+            }
+        }
+        catch (error) {
+            console.error(pc.red(`\n✗ Error updating dependencies: ${error instanceof Error ? error.message : String(error)}`));
+            process.exit(1);
+        }
+    }
+};

package/out/index.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import "@mcbepack/common";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import dotenv from "dotenv";
+import { devCommand } from "./commands/dev";
+import { buildCommand } from "./commands/build";
+import { updateCommand } from "./commands/update";
+dotenv.config({
+    path: process.cwd() + "/.env.local"
+});
+process.env.NODE_NO_WARNINGS = "1";
+yargs(hideBin(process.argv))
+    .command(devCommand)
+    .command(buildCommand)
+    .command(updateCommand)
+    .demandCommand(1, "You need to specify a command")
+    .help()
+    .alias("h", "help")
+    .version()
+    .alias("v", "version")
+    .parse();

package/out/utils/archiver.js

@@ -0,0 +1,84 @@
+import fs from "fs";
+import path from "path";
+import archiver from "archiver";
+import pc from "picocolors";
+export class PackArchiver {
+    paths;
+    constructor(paths) {
+        this.paths = paths;
+        if (!fs.existsSync(this.paths.binPath)) {
+            fs.mkdirSync(this.paths.binPath, { recursive: true });
+        }
+    }
+    createArchive(outputPath, callback) {
+        return new Promise((resolve, reject) => {
+            const output = fs.createWriteStream(outputPath);
+            const archive = archiver("zip", { zlib: { level: 9 } });
+            output.on("close", () => {
+                console.log(pc.green(`Created: ${path.basename(outputPath)} (${archive.pointer()} bytes)`));
+                resolve();
+            });
+            archive.on("error", (err) => reject(err));
+            archive.pipe(output);
+            callback(archive);
+            archive.finalize();
+        });
+    }
+    async createMcpack() {
+        const promises = [];
+        if (fs.existsSync(this.paths.behaviorRootPath)) {
+            const outputPath = path.join(this.paths.binPath, `${this.paths.projectName}_behavior.mcpack`);
+            promises.push(this.createArchive(outputPath, (archive) => {
+                archive.directory(this.paths.behaviorRootPath, this.paths.projectName);
+            }));
+        }
+        if (fs.existsSync(this.paths.resourceRootPath)) {
+            const outputPath = path.join(this.paths.binPath, `${this.paths.projectName}_resource.mcpack`);
+            promises.push(this.createArchive(outputPath, (archive) => {
+                archive.directory(this.paths.resourceRootPath, this.paths.projectName);
+            }));
+        }
+        await Promise.all(promises);
+    }
+    async createMcaddon() {
+        const outputPath = path.join(this.paths.binPath, `${this.paths.projectName}.mcaddon`);
+        await this.createArchive(outputPath, (archive) => {
+            if (fs.existsSync(this.paths.behaviorRootPath)) {
+                archive.directory(this.paths.behaviorRootPath, "behavior_pack");
+            }
+            if (fs.existsSync(this.paths.resourceRootPath)) {
+                archive.directory(this.paths.resourceRootPath, "resource_pack");
+            }
+        });
+    }
+    async createZip() {
+        const promises = [];
+        if (fs.existsSync(this.paths.behaviorRootPath)) {
+            const outputPath = path.join(this.paths.binPath, `${this.paths.projectName}_behavior.zip`);
+            promises.push(this.createArchive(outputPath, (archive) => {
+                archive.directory(this.paths.behaviorRootPath, this.paths.projectName);
+            }));
+        }
+        if (fs.existsSync(this.paths.resourceRootPath)) {
+            const outputPath = path.join(this.paths.binPath, `${this.paths.projectName}_resource.zip`);
+            promises.push(this.createArchive(outputPath, (archive) => {
+                archive.directory(this.paths.resourceRootPath, this.paths.projectName);
+            }));
+        }
+        await Promise.all(promises);
+    }
+    async archive(format) {
+        console.log(pc.cyan(`\nCreating ${format} archive...`));
+        switch (format) {
+            case "mcpack":
+                await this.createMcpack();
+                break;
+            case "mcaddon":
+                await this.createMcaddon();
+                break;
+            case "zip":
+                await this.createZip();
+                break;
+        }
+    }
+}

package/out/utils/file-sync.js

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import chokidar from "chokidar";
+import pc from "picocolors";
+export class FileSync {
+    paths;
+    constructor(paths) {
+        this.paths = paths;
+    }
+    syncFile(filePath, action) {
+        const destPath = this.getDestPath(filePath);
+        if (!destPath)
+            return;
+        try {
+            if (action === "copy") {
+                fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                fs.copyFileSync(filePath, destPath);
+                console.log(pc.green(`Synced: ${path.basename(filePath)}`));
+            }
+            else if (action === "unlink") {
+                if (fs.existsSync(destPath)) {
+                    fs.unlinkSync(destPath);
+                    console.log(pc.red(`Unlinked: ${path.basename(filePath)}`));
+                }
+            }
+            else if (action === "unlinkDir") {
+                if (fs.existsSync(destPath)) {
+                    fs.rmSync(destPath, { recursive: true, force: true });
+                    console.log(pc.red(`Unlinked Dir: ${path.basename(filePath)}`));
+                }
+            }
+        }
+        catch (error) {
+            console.error(pc.red(`Error syncing ${filePath}:`), error);
+        }
+    }
+    setupInitialSync(rootPath, destPath) {
+        const targetPath = path.join(destPath, this.paths.projectName);
+        if (fs.existsSync(targetPath)) {
+            fs.rmSync(targetPath, { recursive: true, force: true });
+        }
+        fs.mkdirSync(targetPath, { recursive: true });
+        fs.cpSync(rootPath, targetPath, { recursive: true });
+    }
+    getDestPath(filePath) {
+        const outputPath = path.relative(this.paths.behaviorRootPath, filePath);
+        if (filePath.startsWith(this.paths.behaviorRootPath)) {
+            return path.join(this.paths.behaviorPath, path.relative(path.dirname(process.cwd()), outputPath));
+        }
+        else if (filePath.startsWith(this.paths.resourceRootPath)) {
+            return path.join(this.paths.resourcePath, path.relative(path.dirname(process.cwd()), outputPath));
+        }
+        return undefined;
+    }
+    watchBehaviorPack() {
+        if (!fs.existsSync(this.paths.behaviorRootPath))
+            return;
+        this.setupInitialSync(this.paths.behaviorRootPath, this.paths.behaviorPath);
+        chokidar.watch(this.paths.behaviorRootPath, { ignoreInitial: true })
+            .on("add", (filePath) => this.syncFile(filePath, "copy"))
+            .on("change", (filePath) => this.syncFile(filePath, "copy"))
+            .on("unlink", (filePath) => this.syncFile(filePath, "unlink"))
+            .on("unlinkDir", (filePath) => this.syncFile(filePath, "unlinkDir"));
+    }
+    watchResourcePack() {
+        if (!fs.existsSync(this.paths.resourceRootPath))
+            return;
+        this.setupInitialSync(this.paths.resourceRootPath, this.paths.resourcePath);
+        chokidar.watch(this.paths.resourceRootPath, { ignoreInitial: true })
+            .on("add", (filePath) => this.syncFile(filePath, "copy"))
+            .on("change", (filePath) => this.syncFile(filePath, "copy"))
+            .on("unlink", (filePath) => this.syncFile(filePath, "unlink"))
+            .on("unlinkDir", (filePath) => this.syncFile(filePath, "unlinkDir"));
+    }
+}

package/out/utils/paths.js

@@ -0,0 +1,20 @@
+import path from "path";
+export function validateEnv() {
+    const required = ['BASE_PATH', 'BEHAVIOR_PATH', 'RESOURCE_PATH'];
+    const missing = required.filter(key => !process.env[key]);
+    if (missing.length > 0) {
+        throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
+    }
+}
+export function getProjectPaths() {
+    const projectName = path.basename(process.cwd());
+    return {
+        scriptsDir: path.join(process.cwd(), "scripts"),
+        behaviorPath: path.join(process.env.BASE_PATH, process.env.BEHAVIOR_PATH),
+        resourcePath: path.join(process.env.BASE_PATH, process.env.RESOURCE_PATH),
+        behaviorRootPath: path.join(process.cwd(), "src", "behavior_pack"),
+        resourceRootPath: path.join(process.cwd(), "src", "resource_pack"),
+        binPath: path.join(process.cwd(), "bin"),
+        projectName
+    };
+}

package/out/utils/webpack.js

@@ -0,0 +1,77 @@
+import path from "path";
+import { webpack } from "webpack";
+import { constants } from "@mcbepack/common";
+import fs from "node:fs";
+export function createWebpackConfig() {
+    if (fs.existsSync(path.join(process.cwd(), 'scripts', 'index.ts'))) {
+        return {
+            mode: 'development',
+            entry: './scripts/index',
+            target: 'node',
+            infrastructureLogging: {
+                level: 'warn'
+            },
+            output: {
+                path: path.resolve(process.cwd(), 'src', 'behavior_pack', 'scripts'),
+                filename: 'index.js',
+                module: true,
+                library: {
+                    type: 'module'
+                }
+            },
+            resolve: {
+                extensions: ['.js', '.ts'],
+            },
+            resolveLoader: {
+                modules: [
+                    path.join(__dirname, '..', '..', 'node_modules'),
+                    'node_modules'
+                ]
+            },
+            externals: constants.packages.modules.map(module => ({
+                [module]: module
+            })),
+            module: {
+                rules: [
+                    {
+                        test: /\.ts$/,
+                        use: 'ts-loader',
+                        exclude: /node_modules/
+                    },
+                ],
+            },
+            experiments: {
+                outputModule: true
+            }
+        };
+    }
+    else if (fs.existsSync(path.join(process.cwd(), 'scripts', 'index.js'))) {
+        return {
+            mode: 'development',
+            entry: './scripts/index',
+            target: 'node',
+            infrastructureLogging: {
+                level: 'warn'
+            },
+            output: {
+                path: path.resolve(process.cwd(), 'src', 'behavior_pack', 'scripts'),
+                filename: 'index.js'
+            },
+            externals: constants.packages.modules.map(module => ({
+                [module]: module
+            })),
+            resolve: {
+                extensions: ['.js'],
+            },
+            experiments: {
+                outputModule: true
+            }
+        };
+    }
+    else {
+        throw new Error('This project does not use script api.');
+    }
+}
+export function createCompiler() {
+    return webpack(createWebpackConfig());
+}