@mafly/bdev-cli 0.0.0-stage → 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,164 @@
+import fs from "node:fs";
+import path from "node:path";
+import { generateManifests } from "../utils/manifest.js";
+import { saveConfig } from "../utils/config.js";
+import { logger } from "../utils/logger.js";
+const DEFAULT_ICON_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+export async function initCommand(targetDirArg, options) {
+    const targetDir = path.resolve(targetDirArg || ".");
+    const projectName = options.name || path.basename(targetDir) || "my-bedrock-addon";
+    const projectDesc = options.desc || `${projectName} - Bedrock Addon created with bdev`;
+    const isTs = options.lang !== "js";
+    const hasRp = options.rp !== false;
+    logger.info(`Scaffolding Bedrock Addon project: ${projectName}`);
+    logger.info(`Directory: ${targetDir}`);
+    logger.info(`Language: ${isTs ? "TypeScript" : "JavaScript"} | Resource Pack: ${hasRp ? "Yes" : "No"}`);
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    const { bpManifest, rpManifest } = generateManifests({
+        name: projectName,
+        description: projectDesc,
+        hasScript: true,
+        hasRp,
+        minEngineVersion: [1, 21, 0],
+        serverVersion: "1.16.0",
+    });
+    // 1. Behavior Pack
+    const bpDir = path.join(targetDir, "behavior_pack");
+    fs.mkdirSync(bpDir, { recursive: true });
+    fs.writeFileSync(path.join(bpDir, "manifest.json"), JSON.stringify(bpManifest, null, 2) + "\n");
+    fs.writeFileSync(path.join(bpDir, "pack_icon.png"), Buffer.from(DEFAULT_ICON_BASE64, "base64"));
+    // 2. Resource Pack (if enabled)
+    if (hasRp && rpManifest) {
+        const rpDir = path.join(targetDir, "resource_pack");
+        fs.mkdirSync(rpDir, { recursive: true });
+        fs.writeFileSync(path.join(rpDir, "manifest.json"), JSON.stringify(rpManifest, null, 2) + "\n");
+        fs.writeFileSync(path.join(rpDir, "pack_icon.png"), Buffer.from(DEFAULT_ICON_BASE64, "base64"));
+        const textsDir = path.join(rpDir, "texts");
+        fs.mkdirSync(textsDir, { recursive: true });
+        fs.writeFileSync(path.join(textsDir, "en_US.lang"), `pack.name=${projectName}\npack.description=${projectDesc}\n`);
+    }
+    // 3. Scripts / Source code
+    const starterCode = `import { world, system } from "@minecraft/server";
+
+world.afterEvents.worldInitialize.subscribe(() => {
+  world.sendMessage("Hello from ${projectName}!");
+});
+
+let ticks = 0;
+system.runInterval(() => {
+  ticks++;
+  if (ticks % 100 === 0) {
+    // Periodic tick logic
+  }
+}, 20);
+`;
+    if (isTs) {
+        const srcDir = path.join(targetDir, "src");
+        fs.mkdirSync(srcDir, { recursive: true });
+        fs.writeFileSync(path.join(srcDir, "main.ts"), starterCode);
+        // tsconfig.json
+        const tsconfig = {
+            compilerOptions: {
+                target: "ES2020",
+                module: "ESNext",
+                moduleResolution: "Bundler",
+                strict: true,
+                skipLibCheck: true,
+                noEmit: true,
+            },
+            include: ["src/**/*"],
+        };
+        fs.writeFileSync(path.join(targetDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
+    }
+    else {
+        const scriptsDir = path.join(bpDir, "scripts");
+        fs.mkdirSync(scriptsDir, { recursive: true });
+        fs.writeFileSync(path.join(scriptsDir, "main.js"), starterCode);
+    }
+    // 4. package.json
+    const pkgJson = {
+        name: projectName.toLowerCase().replace(/[^a-z0-9-_]/g, "-"),
+        version: "1.0.0",
+        description: projectDesc,
+        type: "module",
+        scripts: {
+            build: "bdev build",
+            dev: "bdev dev",
+            package: "bdev package",
+        },
+        dependencies: {
+            "@minecraft/server": "1.16.0",
+            "@minecraft/server-ui": "1.7.0",
+        },
+    };
+    if (isTs) {
+        pkgJson.devDependencies = {
+            "@types/node": "^22.0.0",
+            typescript: "^5.0.0",
+        };
+    }
+    fs.writeFileSync(path.join(targetDir, "package.json"), JSON.stringify(pkgJson, null, 2) + "\n");
+    // 5. bdev.json config
+    saveConfig({
+        name: projectName,
+        mojangPath: options.path ? path.resolve(options.path) : undefined,
+    }, { dir: targetDir });
+    // 6. Comprehensive .gitignore
+    const gitignoreLines = [
+        "# Dependencies",
+        "node_modules/",
+        "",
+        "# Build outputs",
+        "dist/",
+    ];
+    if (isTs) {
+        gitignoreLines.push("behavior_pack/scripts/");
+    }
+    gitignoreLines.push("", "# bdev cache & local configs", ".bdev/", "*.local.json", "", "# Logs", "*.log", "npm-debug.log*", "yarn-debug.log*", "yarn-error.log*", "", "# OS files", ".DS_Store", ".DS_Store?", "._*", ".Spotlight-V100", ".Trashes", "ehthumbs.db", "Thumbs.db", "", "# Editor files", ".vscode/", ".idea/");
+    fs.writeFileSync(path.join(targetDir, ".gitignore"), gitignoreLines.join("\n") + "\n");
+    // 7. README.md
+    const readmeContent = `# ${projectName}
+
+${projectDesc}
+
+## Development
+
+Run development watcher (auto builds, symlinks, and starts WebSocket hot reload):
+\`\`\`bash
+bdev dev
+\`\`\`
+
+In your Minecraft world (cheats enabled), connect the game to bdev hot reload:
+\`\`\`
+/connect localhost:8000
+\`\`\`
+Whenever you save script files, bdev will automatically execute \`/reload\` in game.
+
+To configure your \`com.mojang\` Bedrock directory:
+\`\`\`bash
+bdev set-path "C:\\path\\to\\com.mojang"
+# or
+bdev dev -p "C:\\path\\to\\com.mojang"
+\`\`\`
+
+## Build & Package
+
+Compile scripts and validate manifest:
+\`\`\`bash
+bdev build
+\`\`\`
+
+Bundle into \`.mcaddon\` and \`.mcpack\` for distribution:
+\`\`\`bash
+bdev package
+\`\`\`
+`;
+    fs.writeFileSync(path.join(targetDir, "README.md"), readmeContent);
+    logger.success(`Project initialized successfully at ${targetDir}`);
+    if (options.path) {
+        logger.success(`Configured com.mojang path: ${path.resolve(options.path)}`);
+    }
+    logger.info("Run: cd " + (targetDirArg || ".") + " && bdev dev");
+}

package/dist/commands/package.d.ts

@@ -0,0 +1,5 @@
+export interface PackageOptions {
+    output?: string;
+    name?: string;
+}
+export declare function packageCommand(dirArg?: string, options?: PackageOptions): Promise<void>;

package/dist/commands/package.js

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import path from "node:path";
+import archiver from "archiver";
+import { buildCommand } from "./build.js";
+import { logger } from "../utils/logger.js";
+function archiveDirectory(sourceDir, destZipPath, prefix = "") {
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(destZipPath);
+        const archive = archiver("zip", { zlib: { level: 9 } });
+        output.on("close", () => {
+            resolve(archive.pointer());
+        });
+        archive.on("error", (err) => {
+            reject(err);
+        });
+        archive.pipe(output);
+        archive.directory(sourceDir, prefix || false);
+        archive.finalize();
+    });
+}
+function archiveMultiple(entries, destZipPath) {
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(destZipPath);
+        const archive = archiver("zip", { zlib: { level: 9 } });
+        output.on("close", () => {
+            resolve(archive.pointer());
+        });
+        archive.on("error", (err) => {
+            reject(err);
+        });
+        archive.pipe(output);
+        for (const entry of entries) {
+            archive.directory(entry.dir, entry.prefix);
+        }
+        archive.finalize();
+    });
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+export async function packageCommand(dirArg, options = {}) {
+    const rootDir = path.resolve(dirArg || ".");
+    const bpDir = path.join(rootDir, "behavior_pack");
+    const rpDir = path.join(rootDir, "resource_pack");
+    const hasBp = fs.existsSync(bpDir);
+    const hasRp = fs.existsSync(rpDir);
+    if (!hasBp && !hasRp) {
+        logger.error(`No behavior_pack or resource_pack found in ${rootDir}.`);
+        process.exit(1);
+    }
+    logger.info("Building project before packaging...");
+    const buildOk = await buildCommand(rootDir);
+    if (!buildOk) {
+        logger.error("Build failed. Aborting package.");
+        process.exit(1);
+    }
+    const outDir = options.output
+        ? path.resolve(rootDir, options.output)
+        : path.join(rootDir, "dist");
+    if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+    }
+    const baseName = options.name || path.basename(rootDir);
+    const spinner = logger.spinner("Packaging Bedrock Addon...");
+    try {
+        const generatedFiles = [];
+        // Package BP if present
+        if (hasBp) {
+            const bpZipPath = path.join(outDir, `${baseName}_BP.mcpack`);
+            const size = await archiveDirectory(bpDir, bpZipPath);
+            generatedFiles.push({ path: bpZipPath, size });
+        }
+        // Package RP if present
+        if (hasRp) {
+            const rpZipPath = path.join(outDir, `${baseName}_RP.mcpack`);
+            const size = await archiveDirectory(rpDir, rpZipPath);
+            generatedFiles.push({ path: rpZipPath, size });
+        }
+        // If both exist, package into .mcaddon
+        if (hasBp && hasRp) {
+            const mcaddonPath = path.join(outDir, `${baseName}.mcaddon`);
+            const size = await archiveMultiple([
+                { dir: bpDir, prefix: `${baseName}_BP` },
+                { dir: rpDir, prefix: `${baseName}_RP` },
+            ], mcaddonPath);
+            generatedFiles.push({ path: mcaddonPath, size });
+        }
+        spinner.succeed("Packaging complete!");
+        logger.info("Generated distribution packages:");
+        for (const f of generatedFiles) {
+            logger.success(`  ${path.relative(rootDir, f.path)} (${formatBytes(f.size)})`);
+        }
+    }
+    catch (err) {
+        spinner.fail("Packaging failed");
+        logger.error(err.message);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { buildCommand } from "./commands/build.js";
+import { devCommand } from "./commands/dev.js";
+import { packageCommand } from "./commands/package.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { setConfigCommand, getConfigCommand, setPathCommand, } from "./commands/config.js";
+const program = new Command();
+program
+    .name("bdev")
+    .description("Modern CLI tool for Minecraft Bedrock Edition Addon development")
+    .version("0.1.0");
+program
+    .command("init [directory]")
+    .description("Scaffold a new Bedrock addon project")
+    .option("-n, --name <name>", "Project / pack name")
+    .option("-d, --desc <description>", "Pack description")
+    .option("-p, --path <path>", "Custom com.mojang path to save in bdev.json")
+    .option("--no-rp", "Scaffold Behavior Pack only (skip Resource Pack)")
+    .option("--lang <lang>", "Script language: ts or js", "ts")
+    .action(async (directory, options) => {
+    try {
+        await initCommand(directory, options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program
+    .command("build [directory]")
+    .description("Compile TypeScript scripts and validate manifests")
+    .option("-m, --minify", "Minify bundled JavaScript")
+    .option("--no-sourcemap", "Disable sourcemap generation")
+    .action(async (directory, options) => {
+    try {
+        const ok = await buildCommand(directory, options);
+        if (!ok)
+            process.exit(1);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program
+    .command("dev [directory]")
+    .description("Symlink packs to com.mojang, start hot-reload WebSocket, and watch for changes")
+    .option("-p, --path <path>", "Custom com.mojang directory path")
+    .option("-s, --save", "Save custom path to bdev.json for future use")
+    .option("-P, --port <port>", "WebSocket server port for Minecraft hot reload", "8000")
+    .option("--no-ws", "Disable WebSocket hot reload server")
+    .option("--no-link", "Skip creating symlinks to development directories")
+    .action(async (directory, options) => {
+    try {
+        await devCommand(directory, options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program
+    .command("package [directory]")
+    .alias("deploy")
+    .description("Build and compress packs into .mcaddon and .mcpack files")
+    .option("-o, --output <dir>", "Output directory for packages", "dist")
+    .option("-n, --name <name>", "Package file name prefix")
+    .action(async (directory, options) => {
+    try {
+        await packageCommand(directory, options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program
+    .command("set-path <path>")
+    .alias("path")
+    .description("Set com.mojang Bedrock path in configuration")
+    .option("-g, --global", "Save path globally in ~/.bdev/config.json")
+    .action(async (pathInput, options) => {
+    try {
+        await setPathCommand(pathInput, options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+const configCmd = program
+    .command("config")
+    .description("Manage bdev configuration");
+configCmd
+    .command("set <key> <value>")
+    .description("Set configuration key (e.g. mojangPath /path/to/com.mojang)")
+    .option("-g, --global", "Set globally in ~/.bdev/config.json")
+    .action(async (key, value, options) => {
+    try {
+        await setConfigCommand(key, value, options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+configCmd
+    .command("get [key]")
+    .description("Get configuration key or list all")
+    .option("-g, --global", "Get from ~/.bdev/config.json only")
+    .action(async (key, options) => {
+    try {
+        await getConfigCommand(key, options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+configCmd
+    .command("path <path>")
+    .description("Set com.mojang directory path")
+    .option("-g, --global", "Set globally in ~/.bdev/config.json")
+    .action(async (pathInput, options) => {
+    try {
+        await setPathCommand(pathInput, options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program
+    .command("doctor")
+    .description("Verify environment requirements and Bedrock paths")
+    .option("-p, --path <path>", "Custom com.mojang path to check")
+    .action(async (options) => {
+    try {
+        await doctorCommand(options.path);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/utils/bundler.d.ts

@@ -0,0 +1,2 @@
+import * as esbuildNative from "esbuild";
+export declare function runBuild(options: esbuildNative.BuildOptions): Promise<esbuildNative.BuildResult>;

package/dist/utils/bundler.js

@@ -0,0 +1,29 @@
+import * as esbuildNative from "esbuild";
+import * as esbuildWasm from "esbuild-wasm";
+let wasmInitialized = false;
+export async function runBuild(options) {
+    try {
+        return await esbuildNative.build(options);
+    }
+    catch (err) {
+        const errorObj = err;
+        const message = typeof errorObj?.message === "string" ? errorObj.message : "";
+        // If it's a code/syntax error from esbuild itself, rethrow directly
+        if (Array.isArray(errorObj?.errors) && errorObj.errors.length > 0) {
+            throw err;
+        }
+        // If missing native executable or module resolution in compiled binary, fallback to wasm
+        const isBinaryResolutionError = message.includes("Cannot find module 'esbuild'") ||
+            message.includes("could not be found") ||
+            message.includes("cannot be bundled") ||
+            message.includes("Failed to resolve entry for package");
+        if (isBinaryResolutionError) {
+            if (!wasmInitialized) {
+                await esbuildWasm.initialize({});
+                wasmInitialized = true;
+            }
+            return (await esbuildWasm.build(options));
+        }
+        throw err;
+    }
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,14 @@
+export interface BDevConfig {
+    name?: string;
+    mojangPath?: string;
+    [key: string]: unknown;
+}
+export declare function getGlobalConfigPath(): string;
+export declare function getLocalConfigPath(targetDir?: string): string;
+export declare function loadGlobalConfig(): BDevConfig;
+export declare function loadLocalConfig(targetDir?: string): BDevConfig;
+export declare function loadMergedConfig(targetDir?: string): BDevConfig;
+export declare function saveConfig(updates: Partial<BDevConfig>, opts?: {
+    global?: boolean;
+    dir?: string;
+}): string;

package/dist/utils/config.js

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const GLOBAL_CONFIG_DIR = path.join(os.homedir(), ".bdev");
+const GLOBAL_CONFIG_PATH = path.join(GLOBAL_CONFIG_DIR, "config.json");
+export function getGlobalConfigPath() {
+    return GLOBAL_CONFIG_PATH;
+}
+export function getLocalConfigPath(targetDir = process.cwd()) {
+    return path.join(path.resolve(targetDir), "bdev.json");
+}
+export function loadGlobalConfig() {
+    try {
+        if (fs.existsSync(GLOBAL_CONFIG_PATH)) {
+            const raw = fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8");
+            return JSON.parse(raw);
+        }
+    }
+    catch {
+        // Ignore read errors
+    }
+    return {};
+}
+export function loadLocalConfig(targetDir = process.cwd()) {
+    try {
+        const localPath = getLocalConfigPath(targetDir);
+        if (fs.existsSync(localPath)) {
+            const raw = fs.readFileSync(localPath, "utf-8");
+            return JSON.parse(raw);
+        }
+    }
+    catch {
+        // Ignore read errors
+    }
+    return {};
+}
+export function loadMergedConfig(targetDir = process.cwd()) {
+    const globalConf = loadGlobalConfig();
+    const localConf = loadLocalConfig(targetDir);
+    return { ...globalConf, ...localConf };
+}
+export function saveConfig(updates, opts = {}) {
+    if (opts.global) {
+        if (!fs.existsSync(GLOBAL_CONFIG_DIR)) {
+            fs.mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+        }
+        const current = loadGlobalConfig();
+        const merged = { ...current, ...updates };
+        fs.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(merged, null, 2) + "\n");
+        return GLOBAL_CONFIG_PATH;
+    }
+    const targetDir = opts.dir ? path.resolve(opts.dir) : process.cwd();
+    const localPath = getLocalConfigPath(targetDir);
+    const current = loadLocalConfig(targetDir);
+    const merged = { ...current, ...updates };
+    fs.writeFileSync(localPath, JSON.stringify(merged, null, 2) + "\n");
+    return localPath;
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,8 @@
+import { Ora } from "ora";
+export declare const logger: {
+    info(msg: string): void;
+    success(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    spinner(text: string): Ora;
+};

package/dist/utils/logger.js

@@ -0,0 +1,19 @@
+import pc from "picocolors";
+import ora from "ora";
+export const logger = {
+    info(msg) {
+        console.log(`${pc.cyan("ℹ")} ${msg}`);
+    },
+    success(msg) {
+        console.log(`${pc.green("✔")} ${msg}`);
+    },
+    warn(msg) {
+        console.log(`${pc.yellow("⚠")} ${msg}`);
+    },
+    error(msg) {
+        console.error(`${pc.red("✖")} ${msg}`);
+    },
+    spinner(text) {
+        return ora({ text, color: "cyan" }).start();
+    },
+};

package/dist/utils/manifest.d.ts

@@ -0,0 +1,42 @@
+export interface ManifestHeader {
+    name: string;
+    description: string;
+    uuid: string;
+    version: [number, number, number];
+    min_engine_version?: [number, number, number];
+}
+export interface ManifestModule {
+    type: "data" | "script" | "resources" | "client_data" | string;
+    uuid: string;
+    version: [number, number, number];
+    language?: string;
+    entry?: string;
+    description?: string;
+}
+export interface ManifestDependency {
+    uuid?: string;
+    version?: [number, number, number] | string;
+    module_name?: string;
+}
+export interface BedrockManifest {
+    format_version: number;
+    header: ManifestHeader;
+    modules: ManifestModule[];
+    dependencies?: ManifestDependency[];
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export declare function validateManifest(manifestPath: string): ValidationResult;
+export declare function generateManifests(opts: {
+    name: string;
+    description: string;
+    hasScript: boolean;
+    hasRp: boolean;
+    minEngineVersion?: [number, number, number];
+    serverVersion?: string;
+}): {
+    bpManifest: BedrockManifest;
+    rpManifest?: BedrockManifest;
+};