@mafly/bdev-cli 1.0.3 → 1.0.5

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,62 +93,107 @@ 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 rebuildTimeout = null;
+    const ignoredPatterns = [
+        /(^|[/\\])\../, // dotfiles
+        /node_modules/,
+        /dist/,
+    ];
+    if (fs.existsSync(srcDir)) {
+        // Ignore entire scripts directory in behavior pack when compiling from src
+        ignoredPatterns.push(/(^|[/\\])behavior_pack[/\\]scripts([/\\].*)?$/);
+    }
+    else {
+        ignoredPatterns.push(/\.map$/);
+    }
     const watcher = chokidar.watch(watchPaths, {
-        ignored: [
-            /(^|[/\\])\../, // dotfiles
-            /node_modules/,
-            /dist/,
-            /behavior_pack[/\\]scripts[/\\]main\.js(\.map)?$/, // ignore build output
-        ],
+        ignored: ignoredPatterns,
         persistent: true,
         ignoreInitial: true,
     });
-    const triggerRebuild = (filePath) => {
-        const rel = path.relative(rootDir, filePath);
-        logger.info(`Change detected in ${rel}`);
-        if (rebuildTimeout) {
-            clearTimeout(rebuildTimeout);
-        }
-        rebuildTimeout = setTimeout(async () => {
-            if (isRebuilding)
-                return;
-            isRebuilding = true;
-            try {
-                if (filePath.endsWith("manifest.json")) {
-                    const res = validateManifest(filePath);
-                    if (res.valid) {
-                        logger.success(`Validated ${rel}`);
+    const runRebuildCycle = async (triggerPath) => {
+        isRebuilding = true;
+        rebuildPending = false;
+        const rel = path.relative(rootDir, triggerPath);
+        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}`);
                     }
-                    else {
-                        logger.error(`Invalid manifest in ${rel}:`);
-                        res.errors.forEach((e) => console.error(`  - ${e}`));
+                    catch (err) {
+                        logger.error(`Failed to link Resource Pack: ${err.message}`);
                     }
                 }
-                // Run build if src changed or if script output needed
-                if (fs.existsSync(srcDir)) {
-                    const buildOk = await buildCommand(rootDir);
-                    if (buildOk && hotReloadServer) {
-                        if (hotReloadServer.clientCount > 0) {
-                            hotReloadServer.reload();
-                            logger.success("Sent /reload to Minecraft via WebSocket");
-                        }
-                        else {
-                            logger.info(`Hot reload skipped (no Minecraft client connected; run /connect localhost:${wsPort} in game)`);
-                        }
-                    }
+            }
+            if (triggerPath.endsWith("manifest.json")) {
+                const res = validateManifest(triggerPath);
+                if (res.valid) {
+                    logger.success(`Validated ${rel}`);
+                }
+                else {
+                    logger.error(`Invalid manifest in ${rel}:`);
+                    res.errors.forEach((e) => console.error(`  - ${e}`));
                 }
             }
-            catch (err) {
-                logger.error(`Error during rebuild: ${err.message}`);
+            // Run build if src changed or if script output needed
+            if (fs.existsSync(srcDir)) {
+                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));
+                        hotReloadServer.reload();
+                        logger.success("Sent /reload to Minecraft via WebSocket");
+                    }
+                    else {
+                        logger.info(`Hot reload skipped (no Minecraft client connected; run /connect localhost:${wsPort} in game)`);
+                    }
+                }
             }
-            finally {
-                isRebuilding = false;
+        }
+        catch (err) {
+            logger.error(`Error during rebuild: ${err.message}`);
+        }
+        finally {
+            isRebuilding = false;
+            if (rebuildPending) {
+                runRebuildCycle(triggerPath);
             }
-        }, 100);
+        }
+    };
+    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;
+            return;
+        }
+        if (rebuildTimeout) {
+            clearTimeout(rebuildTimeout);
+        }
+        rebuildTimeout = setTimeout(() => {
+            runRebuildCycle(filePath);
+        }, 300);
     };
     watcher.on("change", triggerRebuild);
     watcher.on("add", triggerRebuild);

package/dist/commands/init.js

@@ -1,28 +1,55 @@
 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"}`);
     if (!fs.existsSync(targetDir)) {
         fs.mkdirSync(targetDir, { recursive: true });
     }
+    const spinner = logger.spinner("Fetching latest @minecraft/* versions from npm...");
+    const mcVersions = await resolveMinecraftDependencies([
+        "@minecraft/server",
+        "@minecraft/server-ui",
+    ]);
+    const serverVersion = mcVersions["@minecraft/server"] || "2.11.0";
+    const serverUiVersion = mcVersions["@minecraft/server-ui"] || "2.3.0";
+    spinner.succeed(`Resolved dependencies: @minecraft/server@${serverVersion}, @minecraft/server-ui@${serverUiVersion}`);
     const { bpManifest, rpManifest } = generateManifests({
         name: projectName,
         description: projectDesc,
         hasScript: true,
         hasRp,
         minEngineVersion: [1, 21, 0],
-        serverVersion: "1.16.0",
+        serverVersion,
     });
     // 1. Behavior Pack
     const bpDir = path.join(targetDir, "behavior_pack");
@@ -40,24 +67,24 @@ export async function initCommand(targetDirArg, options) {
         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";
+    const starterCodeTs = `import { world, type Player } from "@minecraft/server";
 
-world.afterEvents.worldInitialize.subscribe(() => {
-  world.sendMessage("Hello from ${projectName}!");
+world.afterEvents.playerSpawn.subscribe((e) => {
+  const player: Player = e.player;
+  player.sendMessage("Welcome!");
 });
+`;
+    const starterCodeJs = `import { world } from "@minecraft/server";
 
-let ticks = 0;
-system.runInterval(() => {
-  ticks++;
-  if (ticks % 100 === 0) {
-    // Periodic tick logic
-  }
-}, 20);
+world.afterEvents.playerSpawn.subscribe((e) => {
+  const player = e.player;
+  player.sendMessage("Welcome!");
+});
 `;
     if (isTs) {
         const srcDir = path.join(targetDir, "src");
         fs.mkdirSync(srcDir, { recursive: true });
-        fs.writeFileSync(path.join(srcDir, "main.ts"), starterCode);
+        fs.writeFileSync(path.join(srcDir, "main.ts"), starterCodeTs);
         // tsconfig.json
         const tsconfig = {
             compilerOptions: {
@@ -75,7 +102,7 @@ system.runInterval(() => {
     else {
         const scriptsDir = path.join(bpDir, "scripts");
         fs.mkdirSync(scriptsDir, { recursive: true });
-        fs.writeFileSync(path.join(scriptsDir, "main.js"), starterCode);
+        fs.writeFileSync(path.join(scriptsDir, "main.js"), starterCodeJs);
     }
     // 4. package.json
     const pkgJson = {
@@ -89,8 +116,8 @@ system.runInterval(() => {
             package: "bdev package",
         },
         dependencies: {
-            "@minecraft/server": "1.16.0",
-            "@minecraft/server-ui": "1.7.0",
+            "@minecraft/server": serverVersion,
+            "@minecraft/server-ui": serverUiVersion,
         },
     };
     if (isTs) {

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)) {
@@ -100,7 +103,7 @@ export function generateManifests(opts) {
     if (opts.hasScript) {
         bpDependencies.push({
             module_name: "@minecraft/server",
-            version: opts.serverVersion || "1.16.0",
+            version: opts.serverVersion || "2.11.0",
         });
     }
     if (opts.hasRp) {
@@ -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/dist/utils/npm.d.ts

@@ -0,0 +1,2 @@
+export declare function fetchLatestNpmVersion(pkgName: string, fallback?: string): Promise<string>;
+export declare function resolveMinecraftDependencies(packages: string[]): Promise<Record<string, string>>;

package/dist/utils/npm.js

@@ -0,0 +1,35 @@
+const DEFAULT_FALLBACKS = {
+    "@minecraft/server": "2.11.0",
+    "@minecraft/server-ui": "2.3.0",
+    "@minecraft/server-admin": "1.0.0-beta",
+    "@minecraft/server-gametest": "1.0.0-beta",
+    "@minecraft/server-net": "1.0.0-beta",
+};
+export async function fetchLatestNpmVersion(pkgName, fallback) {
+    const defaultFallback = fallback || DEFAULT_FALLBACKS[pkgName] || "latest";
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${pkgName}/latest`, {
+            headers: {
+                Accept: "application/json",
+            },
+            signal: AbortSignal.timeout(4000),
+        });
+        if (res.ok) {
+            const data = (await res.json());
+            if (data?.version) {
+                return data.version;
+            }
+        }
+    }
+    catch {
+        // Offline or network timeout, return fallback
+    }
+    return defaultFallback;
+}
+export async function resolveMinecraftDependencies(packages) {
+    const entries = await Promise.all(packages.map(async (pkg) => {
+        const ver = await fetchLatestNpmVersion(pkg);
+        return [pkg, ver];
+    }));
+    return Object.fromEntries(entries);
+}

package/dist/utils/wsserver.js

@@ -51,8 +51,13 @@ export class BedrockHotReloadServer {
             socket.on("message", (data) => {
                 try {
                     const res = JSON.parse(data.toString());
-                    if (res?.body?.statusCode && res.body.statusCode !== 0) {
-                        logger.warn(`Minecraft command response: ${res.body.statusMessage || "Error"}`);
+                    if (res?.header?.messagePurpose === "commandResponse") {
+                        if (res.body?.statusCode && res.body.statusCode !== 0) {
+                            logger.warn(`Minecraft command error (${res.body.statusCode}): ${res.body.statusMessage || "Error"}`);
+                        }
+                        else if (res.body?.statusMessage) {
+                            logger.info(`Minecraft: ${res.body.statusMessage}`);
+                        }
                     }
                 }
                 catch {
@@ -63,7 +68,8 @@ export class BedrockHotReloadServer {
                 this.clients.delete(socket);
                 logger.info("Minecraft disconnected from WebSocket.");
             });
-            socket.on("error", () => {
+            socket.on("error", (err) => {
+                logger.warn(`WebSocket client error: ${err.message}`);
                 this.clients.delete(socket);
             });
         });

package/package.json

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