@mafly/bdev-cli 0.0.0-stage → 0.1.0

package/dist/utils/manifest.js

@@ -0,0 +1,146 @@
+import fs from "node:fs";
+import { v4 as uuidv4, validate as validateUuid } from "uuid";
+export function validateManifest(manifestPath) {
+    const errors = [];
+    if (!fs.existsSync(manifestPath)) {
+        return { valid: false, errors: [`File not found: ${manifestPath}`] };
+    }
+    let raw;
+    try {
+        const content = fs.readFileSync(manifestPath, "utf-8");
+        raw = JSON.parse(content);
+    }
+    catch (err) {
+        return {
+            valid: false,
+            errors: [`Invalid JSON in ${manifestPath}: ${err.message}`],
+        };
+    }
+    if (raw.format_version !== 2) {
+        errors.push(`'format_version' should be 2 (found ${raw.format_version})`);
+    }
+    if (!raw.header) {
+        errors.push("Missing 'header' object");
+        return { valid: false, errors };
+    }
+    if (!raw.header.name || typeof raw.header.name !== "string") {
+        errors.push("Missing or invalid 'header.name'");
+    }
+    if (!raw.header.uuid || !validateUuid(raw.header.uuid)) {
+        errors.push(`Invalid 'header.uuid': ${raw.header.uuid}`);
+    }
+    if (!Array.isArray(raw.header.version) || raw.header.version.length !== 3) {
+        errors.push("'header.version' must be [major, minor, patch] array");
+    }
+    const seenUuids = new Set();
+    if (raw.header.uuid) {
+        seenUuids.add(raw.header.uuid.toLowerCase());
+    }
+    if (!Array.isArray(raw.modules) || raw.modules.length === 0) {
+        errors.push("'modules' array must contain at least one module");
+    }
+    else {
+        raw.modules.forEach((mod, idx) => {
+            if (!mod.type) {
+                errors.push(`Module[${idx}]: missing 'type'`);
+            }
+            if (!mod.uuid || !validateUuid(mod.uuid)) {
+                errors.push(`Module[${idx}]: invalid 'uuid': ${mod.uuid}`);
+            }
+            else {
+                const lowerUuid = mod.uuid.toLowerCase();
+                if (seenUuids.has(lowerUuid)) {
+                    errors.push(`Duplicate UUID in manifest: ${mod.uuid}`);
+                }
+                seenUuids.add(lowerUuid);
+            }
+            if (!Array.isArray(mod.version) || mod.version.length !== 3) {
+                errors.push(`Module[${idx}]: 'version' must be [major, minor, patch]`);
+            }
+            if (mod.type === "script") {
+                if (!mod.entry) {
+                    errors.push(`Script module[${idx}]: missing 'entry' script path`);
+                }
+                if (mod.language && mod.language !== "javascript") {
+                    errors.push(`Script module[${idx}]: language should be 'javascript'`);
+                }
+            }
+        });
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+export function generateManifests(opts) {
+    const minEngineVersion = opts.minEngineVersion || [1, 21, 0];
+    const bpHeaderUuid = uuidv4();
+    const bpDataModuleUuid = uuidv4();
+    const bpScriptModuleUuid = uuidv4();
+    const rpHeaderUuid = uuidv4();
+    const rpModuleUuid = uuidv4();
+    const bpModules = [
+        {
+            type: "data",
+            uuid: bpDataModuleUuid,
+            version: [1, 0, 0],
+        },
+    ];
+    if (opts.hasScript) {
+        bpModules.push({
+            description: "Script Resources",
+            language: "javascript",
+            type: "script",
+            uuid: bpScriptModuleUuid,
+            version: [1, 0, 0],
+            entry: "scripts/main.js",
+        });
+    }
+    const bpDependencies = [];
+    if (opts.hasScript) {
+        bpDependencies.push({
+            module_name: "@minecraft/server",
+            version: opts.serverVersion || "1.16.0",
+        });
+    }
+    if (opts.hasRp) {
+        bpDependencies.push({
+            uuid: rpHeaderUuid,
+            version: [1, 0, 0],
+        });
+    }
+    const bpManifest = {
+        format_version: 2,
+        header: {
+            name: `${opts.name} (BP)`,
+            description: opts.description || `${opts.name} Behavior Pack`,
+            uuid: bpHeaderUuid,
+            version: [1, 0, 0],
+            min_engine_version: minEngineVersion,
+        },
+        modules: bpModules,
+        dependencies: bpDependencies,
+    };
+    let rpManifest;
+    if (opts.hasRp) {
+        rpManifest = {
+            format_version: 2,
+            header: {
+                name: `${opts.name} (RP)`,
+                description: opts.description || `${opts.name} Resource Pack`,
+                uuid: rpHeaderUuid,
+                version: [1, 0, 0],
+                min_engine_version: minEngineVersion,
+            },
+            modules: [
+                {
+                    description: "Resource Pack Modules",
+                    type: "resources",
+                    uuid: rpModuleUuid,
+                    version: [1, 0, 0],
+                },
+            ],
+        };
+    }
+    return { bpManifest, rpManifest };
+}

package/dist/utils/mojang.d.ts

@@ -0,0 +1,8 @@
+export interface MojangLocations {
+    root: string;
+    devBehaviorPacks: string;
+    devResourcePacks: string;
+    type: "retail" | "preview" | "custom" | "wsl" | "linux" | "config";
+}
+export declare function findMojangPath(customPath?: string, projectDir?: string): MojangLocations | null;
+export declare function linkPack(sourceDir: string, destDir: string): void;

package/dist/utils/mojang.js

@@ -0,0 +1,122 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { loadMergedConfig } from "./config.js";
+export function findMojangPath(customPath, projectDir = process.cwd()) {
+    // 1. Direct custom CLI path argument
+    if (customPath) {
+        const resolved = path.resolve(customPath);
+        if (fs.existsSync(resolved)) {
+            return makeLocations(resolved, "custom");
+        }
+        return null;
+    }
+    // 2. Config file (local bdev.json or global ~/.bdev/config.json)
+    const config = loadMergedConfig(projectDir);
+    if (config.mojangPath && typeof config.mojangPath === "string") {
+        const confPath = path.resolve(config.mojangPath);
+        if (fs.existsSync(confPath)) {
+            return makeLocations(confPath, "config");
+        }
+    }
+    // 3. Environment variable
+    if (process.env.BEDROCK_MOJANG_PATH) {
+        const envPath = path.resolve(process.env.BEDROCK_MOJANG_PATH);
+        if (fs.existsSync(envPath)) {
+            return makeLocations(envPath, "custom");
+        }
+    }
+    const platform = os.platform();
+    if (platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA ||
+            path.join(os.homedir(), "AppData", "Local");
+        const retail = path.join(localAppData, "Packages", "Microsoft.MinecraftUWP_8wekyb3d8bbwe", "LocalState", "games", "com.mojang");
+        if (fs.existsSync(retail)) {
+            return makeLocations(retail, "retail");
+        }
+        const preview = path.join(localAppData, "Packages", "Microsoft.MinecraftWindowsBeta_8wekyb3d8bbwe", "LocalState", "games", "com.mojang");
+        if (fs.existsSync(preview)) {
+            return makeLocations(preview, "preview");
+        }
+    }
+    // Check WSL
+    if (platform === "linux") {
+        try {
+            const isWsl = Boolean(process.env.WSL_DISTRO_NAME) ||
+                fs.readFileSync("/proc/version", "utf-8").toLowerCase().includes("microsoft");
+            if (isWsl) {
+                const mntCUsers = "/mnt/c/Users";
+                if (fs.existsSync(mntCUsers)) {
+                    const users = fs.readdirSync(mntCUsers);
+                    for (const u of users) {
+                        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");
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+        // Native Linux launcher 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"),
+        ];
+        for (const p of linuxMcpelauncherPaths) {
+            if (fs.existsSync(p)) {
+                return makeLocations(p, "linux");
+            }
+        }
+    }
+    return null;
+}
+function makeLocations(root, type) {
+    return {
+        root,
+        devBehaviorPacks: path.join(root, "development_behavior_packs"),
+        devResourcePacks: path.join(root, "development_resource_packs"),
+        type,
+    };
+}
+export function linkPack(sourceDir, destDir) {
+    const resolvedSource = path.resolve(sourceDir);
+    const resolvedDest = path.resolve(destDir);
+    if (!fs.existsSync(resolvedSource)) {
+        throw new Error(`Source pack directory not found: ${resolvedSource}`);
+    }
+    // Ensure parent directory exists
+    const parent = path.dirname(resolvedDest);
+    if (!fs.existsSync(parent)) {
+        fs.mkdirSync(parent, { recursive: true });
+    }
+    if (fs.existsSync(resolvedDest) || isSymlink(resolvedDest)) {
+        const stat = fs.lstatSync(resolvedDest);
+        if (stat.isSymbolicLink()) {
+            const currentTarget = path.resolve(path.dirname(resolvedDest), fs.readlinkSync(resolvedDest));
+            if (currentTarget === resolvedSource) {
+                return; // Already linked
+            }
+            fs.unlinkSync(resolvedDest);
+        }
+        else {
+            throw new Error(`Destination path exists and is not a symlink: ${resolvedDest}. Remove or rename it manually.`);
+        }
+    }
+    const symlinkType = os.platform() === "win32" ? "junction" : "dir";
+    fs.symlinkSync(resolvedSource, resolvedDest, symlinkType);
+}
+function isSymlink(filePath) {
+    try {
+        return fs.lstatSync(filePath).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/wsserver.d.ts

@@ -0,0 +1,25 @@
+export interface BedrockCommandRequest {
+    header: {
+        version: number;
+        requestId: string;
+        messagePurpose: "commandRequest";
+    };
+    body: {
+        commandLine: string;
+        version: number;
+    };
+}
+export declare class BedrockHotReloadServer {
+    private wss;
+    private clients;
+    private port;
+    constructor(port?: number);
+    start(): Promise<number>;
+    private setupHandlers;
+    sendCommand(commandLine: string): void;
+    private sendCommandToSocket;
+    reload(): void;
+    get clientCount(): number;
+    get currentPort(): number;
+    stop(): Promise<void>;
+}

package/dist/utils/wsserver.js

@@ -0,0 +1,109 @@
+import { WebSocketServer, WebSocket } from "ws";
+import { v4 as uuidv4 } from "uuid";
+import pc from "picocolors";
+import { logger } from "./logger.js";
+export class BedrockHotReloadServer {
+    wss = null;
+    clients = new Set();
+    port;
+    constructor(port = 8000) {
+        this.port = port;
+    }
+    start() {
+        return new Promise((resolve, reject) => {
+            const tryListen = (attemptPort) => {
+                const server = new WebSocketServer({ port: attemptPort }, () => {
+                    this.port = attemptPort;
+                    this.wss = server;
+                    this.setupHandlers(server);
+                    resolve(attemptPort);
+                });
+                server.on("error", (err) => {
+                    if (err.code === "EADDRINUSE") {
+                        logger.warn(`Port ${attemptPort} is in use, trying ${attemptPort + 1}...`);
+                        tryListen(attemptPort + 1);
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            };
+            tryListen(this.port);
+        });
+    }
+    setupHandlers(server) {
+        server.on("connection", (socket) => {
+            this.clients.add(socket);
+            logger.success(pc.green("Minecraft connected to WebSocket hot reload!"));
+            // Send welcome message in Minecraft chat
+            this.sendCommandToSocket(socket, 'tellraw @a {"rawtext":[{"text":"§a[bdev] Connected to hot reload server!"}]}');
+            socket.on("message", (data) => {
+                try {
+                    const res = JSON.parse(data.toString());
+                    if (res?.body?.statusCode && res.body.statusCode !== 0) {
+                        logger.warn(`Minecraft command warning: ${res.body.statusMessage || "Error"}`);
+                    }
+                }
+                catch {
+                    // Ignore non-json responses
+                }
+            });
+            socket.on("close", () => {
+                this.clients.delete(socket);
+                logger.info("Minecraft disconnected from WebSocket.");
+            });
+            socket.on("error", () => {
+                this.clients.delete(socket);
+            });
+        });
+    }
+    sendCommand(commandLine) {
+        for (const client of this.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                this.sendCommandToSocket(client, commandLine);
+            }
+        }
+    }
+    sendCommandToSocket(socket, commandLine) {
+        const payload = {
+            header: {
+                version: 1,
+                requestId: uuidv4(),
+                messagePurpose: "commandRequest",
+            },
+            body: {
+                commandLine,
+                version: 1,
+            },
+        };
+        socket.send(JSON.stringify(payload));
+    }
+    reload() {
+        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");
+    }
+    get clientCount() {
+        return this.clients.size;
+    }
+    get currentPort() {
+        return this.port;
+    }
+    stop() {
+        return new Promise((resolve) => {
+            if (this.wss) {
+                for (const client of this.clients) {
+                    client.terminate();
+                }
+                this.clients.clear();
+                this.wss.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@mafly/bdev-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Modern CLI tool for Minecraft Bedrock Edition Addon development",
+  "author": "Mafly",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "bdev": "./dist/index.js"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "minecraft",
+    "bedrock",
+    "addon",
+    "cli",
+    "esbuild",
+    "typescript",
+    "hot-reload"
+  ],
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun run build:binary",
+    "build:binary": "bun build ./src/index.ts --compile --outfile bdev",
+    "build:npm": "tsc --outDir dist",
+    "prepack": "npm run build:npm",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "chokidar": "^4.0.3",
+    "commander": "^13.1.0",
+    "esbuild": "^0.25.0",
+    "esbuild-wasm": "^0.28.2",
+    "ora": "^8.2.0",
+    "picocolors": "^1.1.1",
+    "uuid": "^11.1.0",
+    "ws": "^8.22.2"
+  },
+  "devDependencies": {
+    "@types/archiver": "^6.0.3",
+    "@types/node": "^22.13.8",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.18.2",
+    "typescript": "^5.7.3"
+  }
+}