@mafly/bdev-cli 1.0.2 → 1.0.4

package/dist/commands/dev.js

@@ -96,59 +96,79 @@ export async function devCommand(dirArg, options = {}) {
     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 (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}`));
+                }
+            }
+            // 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.error(`Invalid manifest in ${rel}:`);
-                        res.errors.forEach((e) => console.error(`  - ${e}`));
-                    }
-                }
-                // 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)`);
-                        }
+                        logger.info(`Hot reload skipped (no Minecraft client connected; run /connect localhost:${wsPort} in game)`);
                     }
                 }
             }
-            catch (err) {
-                logger.error(`Error during rebuild: ${err.message}`);
-            }
-            finally {
-                isRebuilding = false;
+        }
+        catch (err) {
+            logger.error(`Error during rebuild: ${err.message}`);
+        }
+        finally {
+            isRebuilding = false;
+            if (rebuildPending) {
+                runRebuildCycle(triggerPath);
             }
-        }, 100);
+        }
+    };
+    const triggerRebuild = (filePath) => {
+        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

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { generateManifests } 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) {
@@ -16,13 +17,21 @@ export async function initCommand(targetDirArg, options) {
     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 +49,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 +84,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 +98,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.js

@@ -100,7 +100,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) {

package/dist/utils/mojang.js

@@ -28,19 +28,55 @@ export function findMojangPath(customPath, projectDir = process.cwd()) {
     }
     const platform = os.platform();
     if (platform === "win32") {
+        const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
         const localAppData = process.env.LOCALAPPDATA ||
             path.join(os.homedir(), "AppData", "Local");
+        // Modern Windows GDK Bedrock (Shared folder contains dev packs)
+        const gdkShared = path.join(appData, "Minecraft Bedrock", "Users", "Shared", "games", "com.mojang");
+        if (fs.existsSync(gdkShared)) {
+            return makeLocations(gdkShared, "retail");
+        }
+        const gdkPreviewShared = path.join(appData, "Minecraft Bedrock Preview", "Users", "Shared", "games", "com.mojang");
+        if (fs.existsSync(gdkPreviewShared)) {
+            return makeLocations(gdkPreviewShared, "preview");
+        }
+        // Classic UWP Retail
         const retail = path.join(localAppData, "Packages", "Microsoft.MinecraftUWP_8wekyb3d8bbwe", "LocalState", "games", "com.mojang");
         if (fs.existsSync(retail)) {
             return makeLocations(retail, "retail");
         }
+        // Classic UWP Preview
         const preview = path.join(localAppData, "Packages", "Microsoft.MinecraftWindowsBeta_8wekyb3d8bbwe", "LocalState", "games", "com.mojang");
         if (fs.existsSync(preview)) {
             return makeLocations(preview, "preview");
         }
     }
-    // Check WSL
+    // Check Linux / Bedrock-on-linux / Proton / WSL
     if (platform === "linux") {
+        // 1. Bedrock-on-Linux (Proton / Wine)
+        const bolBase = path.join(os.homedir(), ".local", "share", "bedrock-on-linux");
+        if (fs.existsSync(bolBase)) {
+            const profilesDir = path.join(bolBase, "profiles");
+            if (fs.existsSync(profilesDir)) {
+                try {
+                    const profiles = fs.readdirSync(profilesDir);
+                    for (const prof of profiles) {
+                        const sharedPfx = path.join(profilesDir, prof, "compatdata", "pfx", "drive_c", "users", "steamuser", "AppData", "Roaming", "Minecraft Bedrock", "Users", "Shared", "games", "com.mojang");
+                        if (fs.existsSync(sharedPfx)) {
+                            return makeLocations(sharedPfx, "linux");
+                        }
+                    }
+                }
+                catch {
+                    // ignore profile read errors
+                }
+            }
+            const defaultShared = path.join(bolBase, "compatdata", "pfx", "drive_c", "users", "steamuser", "AppData", "Roaming", "Minecraft Bedrock", "Users", "Shared", "games", "com.mojang");
+            if (fs.existsSync(defaultShared)) {
+                return makeLocations(defaultShared, "linux");
+            }
+        }
+        // 2. Check WSL
         try {
             const isWsl = Boolean(process.env.WSL_DISTRO_NAME) ||
                 fs.readFileSync("/proc/version", "utf-8").toLowerCase().includes("microsoft");
@@ -49,14 +85,14 @@ export function findMojangPath(customPath, projectDir = process.cwd()) {
                 if (fs.existsSync(mntCUsers)) {
                     const users = fs.readdirSync(mntCUsers);
                     for (const u of users) {
+                        const gdk = path.join(mntCUsers, u, "AppData", "Roaming", "Minecraft Bedrock", "Users", "Shared", "games", "com.mojang");
+                        if (fs.existsSync(gdk)) {
+                            return makeLocations(gdk, "wsl");
+                        }
                         const retail = path.join(mntCUsers, u, "AppData", "Local", "Packages", "Microsoft.MinecraftUWP_8wekyb3d8bbwe", "LocalState", "games", "com.mojang");
                         if (fs.existsSync(retail)) {
                             return makeLocations(retail, "wsl");
                         }
-                        const preview = path.join(mntCUsers, u, "AppData", "Local", "Packages", "Microsoft.MinecraftWindowsBeta_8wekyb3d8bbwe", "LocalState", "games", "com.mojang");
-                        if (fs.existsSync(preview)) {
-                            return makeLocations(preview, "wsl");
-                        }
                     }
                 }
             }
@@ -64,7 +100,7 @@ export function findMojangPath(customPath, projectDir = process.cwd()) {
         catch {
             // Ignore read errors
         }
-        // Native Linux launcher locations
+        // 3. Native Linux mcpelauncher locations
         const linuxMcpelauncherPaths = [
             path.join(os.homedir(), ".var", "app", "io.mrarm.mcpelauncher", "data", "mcpelauncher", "games", "com.mojang"),
             path.join(os.homedir(), ".local", "share", "mcpelauncher", "games", "com.mojang"),
@@ -78,10 +114,22 @@ export function findMojangPath(customPath, projectDir = process.cwd()) {
     return null;
 }
 function makeLocations(root, type) {
+    // If pointing to a specific user XUID directory in Bedrock GDK (e.g. Users/<XUID>/games/com.mojang),
+    // Bedrock GDK only scans packs from Users/Shared/games/com.mojang.
+    let packsRoot = root;
+    try {
+        const sharedCandidate = path.resolve(root, "..", "..", "..", "Shared", "games", "com.mojang");
+        if (fs.existsSync(sharedCandidate)) {
+            packsRoot = sharedCandidate;
+        }
+    }
+    catch {
+        // Ignore resolution errors
+    }
     return {
-        root,
-        devBehaviorPacks: path.join(root, "development_behavior_packs"),
-        devResourcePacks: path.join(root, "development_resource_packs"),
+        root: packsRoot,
+        devBehaviorPacks: path.join(packsRoot, "development_behavior_packs"),
+        devResourcePacks: path.join(packsRoot, "development_resource_packs"),
         type,
     };
 }

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

@@ -35,17 +35,29 @@ export class BedrockHotReloadServer {
         server.on("connection", (socket) => {
             this.clients.add(socket);
             logger.success(pc.green("Minecraft connected to WebSocket hot reload!"));
-            // Delay welcome message 500ms so Bedrock completes internal handshake
-            setTimeout(() => {
-                if (socket.readyState === WebSocket.OPEN) {
-                    this.sendCommandToSocket(socket, 'tellraw @a {"rawtext":[{"text":"§a[bdev] Connected to hot reload server!"}]}');
-                }
-            }, 500);
+            // Bedrock expects an event subscription to establish connection cleanly
+            const subscribePayload = {
+                header: {
+                    version: 1,
+                    requestId: uuidv4(),
+                    messageType: "commandRequest",
+                    messagePurpose: "subscribe",
+                },
+                body: {
+                    eventName: "PlayerMessage",
+                },
+            };
+            socket.send(JSON.stringify(subscribePayload));
             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 {
@@ -56,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);
             });
         });
@@ -69,7 +82,8 @@ export class BedrockHotReloadServer {
         }
     }
     sendCommandToSocket(socket, commandLine) {
-        const formatted = commandLine.startsWith("/") ? commandLine : `/${commandLine}`;
+        // Bedrock commandLine must NOT have a leading slash
+        const cleanCmd = commandLine.startsWith("/") ? commandLine.slice(1) : commandLine;
         const payload = {
             header: {
                 version: 1,
@@ -79,7 +93,7 @@ export class BedrockHotReloadServer {
             },
             body: {
                 version: 1,
-                commandLine: formatted,
+                commandLine: cleanCmd,
                 origin: {
                     type: "player",
                 },
@@ -91,9 +105,7 @@ export class BedrockHotReloadServer {
         if (this.clients.size === 0) {
             return;
         }
-        // Notify in game chat and execute reload command
-        this.sendCommand('tellraw @a {"rawtext":[{"text":"§e[bdev] Reloading scripts..."}]}');
-        this.sendCommand("/reload");
+        this.sendCommand("reload");
     }
     get clientCount() {
         return this.clients.size;

package/package.json

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