@mafly/bdev-cli 1.0.4 → 1.0.6

package/dist/commands/build.js

@@ -1,12 +1,14 @@
 import fs from "node:fs";
 import path from "node:path";
 import { runBuild } from "../utils/bundler.js";
-import { validateManifest } from "../utils/manifest.js";
+import { validateManifest, syncManifestDependencies, addResourcePack, } from "../utils/manifest.js";
 import { logger } from "../utils/logger.js";
 export async function buildCommand(dirArg, options = {}) {
     const rootDir = path.resolve(dirArg || ".");
     const bpDir = path.join(rootDir, "behavior_pack");
     const bpManifestPath = path.join(bpDir, "manifest.json");
+    // Sync @minecraft/* dependencies from package.json into manifest.json
+    syncManifestDependencies(rootDir);
     // 1. Validate Behavior Pack Manifest
     if (!fs.existsSync(bpManifestPath)) {
         logger.error(`Behavior pack manifest not found: ${bpManifestPath}`);
@@ -25,6 +27,10 @@ export async function buildCommand(dirArg, options = {}) {
     // Validate Resource Pack Manifest if exists
     const rpDir = path.join(rootDir, "resource_pack");
     const rpManifestPath = path.join(rpDir, "manifest.json");
+    if (fs.existsSync(rpDir) && !fs.existsSync(rpManifestPath)) {
+        logger.info("Found resource_pack folder without manifest. Initializing Resource Pack...");
+        addResourcePack(rootDir);
+    }
     if (fs.existsSync(rpManifestPath)) {
         const rpValidation = validateManifest(rpManifestPath);
         if (!rpValidation.valid) {

package/dist/commands/dev.js

@@ -7,13 +7,13 @@ import { findMojangPath, linkPack } from "../utils/mojang.js";
 import { saveConfig } from "../utils/config.js";
 import { BedrockHotReloadServer } from "../utils/wsserver.js";
 import { logger } from "../utils/logger.js";
-import { validateManifest } from "../utils/manifest.js";
+import { validateManifest, getLastManifestSyncTime } from "../utils/manifest.js";
 export async function devCommand(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);
+    let hasRp = fs.existsSync(rpDir);
     if (!hasBp && !hasRp) {
         logger.error(`No behavior_pack or resource_pack found in ${rootDir}. Run 'bdev init' first.`);
         process.exit(1);
@@ -33,8 +33,8 @@ export async function devCommand(dirArg, options = {}) {
     }
     // 2. Setup symlinks to com.mojang
     const shouldLink = options.link !== false;
+    const mojang = shouldLink ? findMojangPath(options.path, rootDir) : null;
     if (shouldLink) {
-        const mojang = findMojangPath(options.path, rootDir);
         if (!mojang) {
             logger.warn("Minecraft com.mojang directory not found.");
             logger.warn("Tip: Set with 'bdev set-path <path>' or pass '-p <path>' or 'BEDROCK_MOJANG_PATH'.");
@@ -93,11 +93,18 @@ export async function devCommand(dirArg, options = {}) {
     if (hasRp) {
         watchPaths.push(rpDir);
     }
+    const pkgJsonPath = path.join(rootDir, "package.json");
+    if (fs.existsSync(pkgJsonPath)) {
+        watchPaths.push(pkgJsonPath);
+    }
     logger.info(`Starting file watcher on: ${watchPaths.map((p) => path.relative(rootDir, p)).join(", ")}`);
     logger.info("Press Ctrl+C to stop.");
     let isRebuilding = false;
-    let rebuildPending = false;
+    let queuedFilePath = null;
     let rebuildTimeout = null;
+    let lastReloadTime = 0;
+    const RELOAD_COOLDOWN_MS = 1200;
+    const DEBOUNCE_MS = 350;
     const ignoredPatterns = [
         /(^|[/\\])\../, // dotfiles
         /node_modules/,
@@ -115,11 +122,41 @@ export async function devCommand(dirArg, options = {}) {
         persistent: true,
         ignoreInitial: true,
     });
+    const scheduleRebuild = (filePath) => {
+        queuedFilePath = filePath;
+        if (rebuildTimeout) {
+            clearTimeout(rebuildTimeout);
+        }
+        rebuildTimeout = setTimeout(() => {
+            rebuildTimeout = null;
+            if (!isRebuilding && queuedFilePath) {
+                const target = queuedFilePath;
+                queuedFilePath = null;
+                runRebuildCycle(target);
+            }
+        }, DEBOUNCE_MS);
+    };
     const runRebuildCycle = async (triggerPath) => {
         isRebuilding = true;
-        rebuildPending = false;
         const rel = path.relative(rootDir, triggerPath);
+        const isManifestRelated = triggerPath.endsWith("manifest.json") || triggerPath.endsWith("package.json");
         try {
+            // If resource_pack was added while dev server is running
+            if (!hasRp && fs.existsSync(rpDir)) {
+                hasRp = true;
+                watcher.add(rpDir);
+                logger.info("Detected new Resource Pack. Watching resource_pack...");
+                if (shouldLink && mojang) {
+                    const destRp = path.join(mojang.devResourcePacks, `${folderName}_RP`);
+                    try {
+                        linkPack(rpDir, destRp);
+                        logger.success(`Linked Resource Pack -> ${destRp}`);
+                    }
+                    catch (err) {
+                        logger.error(`Failed to link Resource Pack: ${err.message}`);
+                    }
+                }
+            }
             if (triggerPath.endsWith("manifest.json")) {
                 const res = validateManifest(triggerPath);
                 if (res.valid) {
@@ -135,9 +172,15 @@ export async function devCommand(dirArg, options = {}) {
                 const buildOk = await buildCommand(rootDir);
                 if (buildOk && hotReloadServer) {
                     if (hotReloadServer.clientCount > 0) {
-                        // Buffer 150ms before reload command so Proton/Wine file cache flushes
-                        await new Promise((resolve) => setTimeout(resolve, 150));
+                        // Buffer 200ms before reload command so Proton/Wine file cache flushes
+                        await new Promise((resolve) => setTimeout(resolve, 200));
+                        // Enforce reload cooldown so rapid saves cannot crash Minecraft scripting engine
+                        const elapsed = Date.now() - lastReloadTime;
+                        if (elapsed < RELOAD_COOLDOWN_MS) {
+                            await new Promise((resolve) => setTimeout(resolve, RELOAD_COOLDOWN_MS - elapsed));
+                        }
                         hotReloadServer.reload();
+                        lastReloadTime = Date.now();
                         logger.success("Sent /reload to Minecraft via WebSocket");
                     }
                     else {
@@ -145,30 +188,35 @@ export async function devCommand(dirArg, options = {}) {
                     }
                 }
             }
+            if (isManifestRelated) {
+                logger.warn("Note: Minecraft /reload only reloads scripts. Re-enter world to apply manifest/package.json changes.");
+            }
         }
         catch (err) {
             logger.error(`Error during rebuild: ${err.message}`);
         }
         finally {
             isRebuilding = false;
-            if (rebuildPending) {
-                runRebuildCycle(triggerPath);
+            if (queuedFilePath) {
+                const nextTarget = queuedFilePath;
+                queuedFilePath = null;
+                scheduleRebuild(nextTarget);
             }
         }
     };
     const triggerRebuild = (filePath) => {
+        // Ignore internal writes to manifest.json caused by syncManifestDependencies
+        if (filePath.endsWith("manifest.json") &&
+            Date.now() - getLastManifestSyncTime() < 600) {
+            return;
+        }
         const rel = path.relative(rootDir, filePath);
         logger.info(`Change detected in ${rel}`);
         if (isRebuilding) {
-            rebuildPending = true;
+            queuedFilePath = filePath;
             return;
         }
-        if (rebuildTimeout) {
-            clearTimeout(rebuildTimeout);
-        }
-        rebuildTimeout = setTimeout(() => {
-            runRebuildCycle(filePath);
-        }, 300);
+        scheduleRebuild(filePath);
     };
     watcher.on("change", triggerRebuild);
     watcher.on("add", triggerRebuild);

package/dist/commands/init.js

@@ -1,16 +1,34 @@
 import fs from "node:fs";
 import path from "node:path";
-import { generateManifests } from "../utils/manifest.js";
+import { generateManifests, addResourcePack, DEFAULT_ICON_BASE64, } from "../utils/manifest.js";
 import { saveConfig } from "../utils/config.js";
 import { resolveMinecraftDependencies } from "../utils/npm.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;
+    const existingBpManifest = path.join(targetDir, "behavior_pack", "manifest.json");
+    if (fs.existsSync(existingBpManifest)) {
+        if (hasRp) {
+            const existingRpManifest = path.join(targetDir, "resource_pack", "manifest.json");
+            if (!fs.existsSync(existingRpManifest)) {
+                logger.info("Existing Behavior Pack project detected without Resource Pack.");
+                addResourcePack(targetDir, { name: projectName, description: projectDesc });
+                return;
+            }
+            else {
+                logger.warn("Project already initialized with Behavior Pack and Resource Pack.");
+                return;
+            }
+        }
+        else {
+            logger.warn("Project is already initialized.");
+            return;
+        }
+    }
     logger.info(`Scaffolding Bedrock Addon project: ${projectName}`);
     logger.info(`Directory: ${targetDir}`);
     logger.info(`Language: ${isTs ? "TypeScript" : "JavaScript"} | Resource Pack: ${hasRp ? "Yes" : "No"}`);

package/dist/utils/manifest.d.ts

@@ -1,3 +1,4 @@
+export declare const DEFAULT_ICON_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
 export interface ManifestHeader {
     name: string;
     description: string;
@@ -40,3 +41,10 @@ export declare function generateManifests(opts: {
     bpManifest: BedrockManifest;
     rpManifest?: BedrockManifest;
 };
+export interface AddResourcePackOptions {
+    name?: string;
+    description?: string;
+}
+export declare function addResourcePack(rootDir: string, options?: AddResourcePackOptions): boolean;
+export declare function getLastManifestSyncTime(): number;
+export declare function syncManifestDependencies(rootDir: string): boolean;

package/dist/utils/manifest.js

@@ -1,5 +1,8 @@
 import fs from "node:fs";
+import path from "node:path";
 import { v4 as uuidv4, validate as validateUuid } from "uuid";
+import { logger } from "./logger.js";
+export const DEFAULT_ICON_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
 export function validateManifest(manifestPath) {
     const errors = [];
     if (!fs.existsSync(manifestPath)) {
@@ -144,3 +147,234 @@ export function generateManifests(opts) {
     }
     return { bpManifest, rpManifest };
 }
+export function addResourcePack(rootDir, options = {}) {
+    const bpDir = path.join(rootDir, "behavior_pack");
+    const bpManifestPath = path.join(bpDir, "manifest.json");
+    if (!fs.existsSync(bpManifestPath)) {
+        logger.error(`Behavior pack manifest not found in ${rootDir}. Run 'bdev init' first.`);
+        return false;
+    }
+    const rpDir = path.join(rootDir, "resource_pack");
+    const rpManifestPath = path.join(rpDir, "manifest.json");
+    let bpManifest;
+    try {
+        bpManifest = JSON.parse(fs.readFileSync(bpManifestPath, "utf-8"));
+    }
+    catch (err) {
+        logger.error(`Failed to parse ${bpManifestPath}: ${err.message}`);
+        return false;
+    }
+    if (fs.existsSync(rpManifestPath)) {
+        try {
+            const rpManifest = JSON.parse(fs.readFileSync(rpManifestPath, "utf-8"));
+            const rpUuid = rpManifest?.header?.uuid;
+            if (rpUuid) {
+                if (!Array.isArray(bpManifest.dependencies)) {
+                    bpManifest.dependencies = [];
+                }
+                const hasDep = bpManifest.dependencies.some((d) => d.uuid?.toLowerCase() === rpUuid.toLowerCase());
+                if (!hasDep) {
+                    bpManifest.dependencies.push({
+                        uuid: rpUuid,
+                        version: rpManifest.header?.version || [1, 0, 0],
+                    });
+                    fs.writeFileSync(bpManifestPath, JSON.stringify(bpManifest, null, 2) + "\n");
+                    logger.success("Linked existing Resource Pack to Behavior Pack manifest.");
+                    return true;
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        logger.warn("Resource pack already exists in this project.");
+        return false;
+    }
+    let projectName = options.name;
+    let projectDesc = options.description;
+    const pkgJsonPath = path.join(rootDir, "package.json");
+    if ((!projectName || !projectDesc) && fs.existsSync(pkgJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+            if (!projectName && pkg.name)
+                projectName = pkg.name;
+            if (!projectDesc && pkg.description)
+                projectDesc = pkg.description;
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!projectName) {
+        projectName = (bpManifest.header?.name || path.basename(rootDir)).replace(/\s*\(BP\)$/i, "");
+    }
+    if (!projectDesc) {
+        projectDesc = bpManifest.header?.description || `${projectName} Resource Pack`;
+    }
+    const minEngineVersion = bpManifest.header?.min_engine_version || [1, 21, 0];
+    const rpHeaderUuid = uuidv4();
+    const rpModuleUuid = uuidv4();
+    const rpManifest = {
+        format_version: 2,
+        header: {
+            name: `${projectName} (RP)`,
+            description: projectDesc,
+            uuid: rpHeaderUuid,
+            version: [1, 0, 0],
+            min_engine_version: minEngineVersion,
+        },
+        modules: [
+            {
+                description: "Resource Pack Modules",
+                type: "resources",
+                uuid: rpModuleUuid,
+                version: [1, 0, 0],
+            },
+        ],
+    };
+    fs.mkdirSync(rpDir, { recursive: true });
+    fs.writeFileSync(rpManifestPath, JSON.stringify(rpManifest, null, 2) + "\n");
+    const bpIconPath = path.join(bpDir, "pack_icon.png");
+    const rpIconPath = path.join(rpDir, "pack_icon.png");
+    if (fs.existsSync(bpIconPath)) {
+        fs.copyFileSync(bpIconPath, rpIconPath);
+    }
+    else {
+        fs.writeFileSync(rpIconPath, 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`);
+    if (!Array.isArray(bpManifest.dependencies)) {
+        bpManifest.dependencies = [];
+    }
+    const existingRpIndex = bpManifest.dependencies.findIndex((d) => d.uuid && !d.module_name);
+    if (existingRpIndex !== -1) {
+        bpManifest.dependencies[existingRpIndex] = {
+            uuid: rpHeaderUuid,
+            version: [1, 0, 0],
+        };
+    }
+    else {
+        bpManifest.dependencies.push({
+            uuid: rpHeaderUuid,
+            version: [1, 0, 0],
+        });
+    }
+    fs.writeFileSync(bpManifestPath, JSON.stringify(bpManifest, null, 2) + "\n");
+    logger.success(`Resource Pack created and linked to Behavior Pack at ${rpDir}`);
+    return true;
+}
+let lastManifestSyncTime = 0;
+export function getLastManifestSyncTime() {
+    return lastManifestSyncTime;
+}
+export function syncManifestDependencies(rootDir) {
+    const pkgPath = path.join(rootDir, "package.json");
+    const bpManifestPath = path.join(rootDir, "behavior_pack", "manifest.json");
+    if (!fs.existsSync(pkgPath) || !fs.existsSync(bpManifestPath)) {
+        return false;
+    }
+    let pkg;
+    let bpManifest;
+    try {
+        pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        bpManifest = JSON.parse(fs.readFileSync(bpManifestPath, "utf-8"));
+    }
+    catch {
+        return false;
+    }
+    const targetDeps = new Map();
+    if (pkg.devDependencies && typeof pkg.devDependencies === "object") {
+        for (const [name, ver] of Object.entries(pkg.devDependencies)) {
+            if (name.startsWith("@minecraft/") && typeof ver === "string") {
+                targetDeps.set(name, ver.replace(/^[~^>=v\s]+/, ""));
+            }
+        }
+    }
+    if (pkg.dependencies && typeof pkg.dependencies === "object") {
+        for (const [name, ver] of Object.entries(pkg.dependencies)) {
+            if (name.startsWith("@minecraft/") && typeof ver === "string") {
+                targetDeps.set(name, ver.replace(/^[~^>=v\s]+/, ""));
+            }
+        }
+    }
+    if (!Array.isArray(bpManifest.dependencies)) {
+        bpManifest.dependencies = [];
+    }
+    let modified = false;
+    const updatedModules = [];
+    // 1. Update existing @minecraft/* entries or prune removed ones
+    const toRemoveIndices = [];
+    bpManifest.dependencies.forEach((dep, idx) => {
+        if (dep.module_name && dep.module_name.startsWith("@minecraft/")) {
+            const targetVer = targetDeps.get(dep.module_name);
+            if (targetVer) {
+                if (dep.version !== targetVer) {
+                    dep.version = targetVer;
+                    modified = true;
+                    updatedModules.push(`${dep.module_name}@${targetVer}`);
+                }
+            }
+            else if (dep.module_name !== "@minecraft/server") {
+                // Removed from package.json
+                toRemoveIndices.push(idx);
+                modified = true;
+                updatedModules.push(`-${dep.module_name}`);
+            }
+        }
+    });
+    if (toRemoveIndices.length > 0) {
+        bpManifest.dependencies = bpManifest.dependencies.filter((_, idx) => !toRemoveIndices.includes(idx));
+    }
+    // 2. Add new @minecraft/* dependencies from package.json that are missing in manifest
+    for (const [name, ver] of targetDeps.entries()) {
+        const exists = bpManifest.dependencies.some((d) => d.module_name === name);
+        if (!exists) {
+            bpManifest.dependencies.push({
+                module_name: name,
+                version: ver,
+            });
+            modified = true;
+            updatedModules.push(`+${name}@${ver}`);
+        }
+    }
+    // 3. Link resource pack if exists and not linked
+    const rpManifestPath = path.join(rootDir, "resource_pack", "manifest.json");
+    if (fs.existsSync(rpManifestPath)) {
+        try {
+            const rpManifest = JSON.parse(fs.readFileSync(rpManifestPath, "utf-8"));
+            const rpUuid = rpManifest?.header?.uuid;
+            if (rpUuid) {
+                const hasRpDep = bpManifest.dependencies.some((d) => d.uuid && d.uuid.toLowerCase() === rpUuid.toLowerCase());
+                if (!hasRpDep) {
+                    const staleRpIndex = bpManifest.dependencies.findIndex((d) => d.uuid && !d.module_name);
+                    if (staleRpIndex !== -1) {
+                        bpManifest.dependencies[staleRpIndex] = {
+                            uuid: rpUuid,
+                            version: rpManifest.header?.version || [1, 0, 0],
+                        };
+                    }
+                    else {
+                        bpManifest.dependencies.push({
+                            uuid: rpUuid,
+                            version: rpManifest.header?.version || [1, 0, 0],
+                        });
+                    }
+                    modified = true;
+                    updatedModules.push(`linked RP (${rpUuid.slice(0, 8)}...)`);
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (modified) {
+        lastManifestSyncTime = Date.now();
+        fs.writeFileSync(bpManifestPath, JSON.stringify(bpManifest, null, 2) + "\n");
+        logger.success(`Synchronized manifest.json dependencies: ${updatedModules.join(", ")}`);
+        return true;
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mafly/bdev-cli",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Modern CLI tool for Minecraft Bedrock Edition Addon development",
   "author": "Mafly",
   "license": "MIT",