mbler 0.2.2 → 0.2.3-alpha.r2

package/dist/index.js

@@ -8,6 +8,7 @@ var os = require('node:os');
 var readline = require('readline');
 var npmRegistryFetch = require('npm-registry-fetch');
 var node_child_process = require('node:child_process');
+var AdmZip = require('adm-zip');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -56,12 +57,13 @@ var types = /*#__PURE__*/Object.freeze({
     templateMblerConfig: templateMblerConfig
 });
 
-var MBLERVersion = { commit: `commit 81c6f8bb0b33367bd219c7c9168f18ae83e1f2e1
+var MBLERVersion = { commit: `commit fc1fee7f44a0ee08388276ad9288cbb5c0263414
+Merge: f36a4b5 c393c36
 Author: Ruanhor <3915264929@qq.com>
-Date:   Sun Apr 19 16:33:01 2026 +0800
+Date:   Sun Apr 26 17:05:29 2026 +0800
 
-    fix: init and add plan command
-`, version: "0.2.2" };
+    Merge branch 'master' of github.com:RuanhoR/mbler
+`, version: "0.2.3-alpha.r2" };
 
 var ZhLang = {
     description: `MBLER
@@ -118,6 +120,9 @@ git https://github.com/RuanhoR/mbler/`,
         enabled: "工作目录功能已启用",
         invalidParam: "参数错误，请使用 on 或 off",
     },
+    publish: {
+        askTip: "输入MCBE游戏绝对目录 (如 /sdcard/Android/data/com.mojang.minecraftpe/files/games)，以进行下一步:  "
+    }
 };
 
 var enLang = {
@@ -168,6 +173,9 @@ var enLang = {
         enabled: "Work dir enabled",
         invalidParam: "Invalid parameter, use on or off",
     },
+    publish: {
+        askTip: "Plase input the absolute path of your MCBE game directory (like /sdcard/Android/data/com.mojang.minecraftpe/files/games) for next step:  "
+    }
 };
 
 const configPath = path.join(require("node:os").homedir(), ".cache/mbler/lang.db");
@@ -383,6 +391,16 @@ async function FileExsit(file) {
     }
     return false;
 }
+async function ReadProjectMblerConfig(project) {
+    const fileExport = await import(path__namespace.join(project, BuildConfig.ConfigFile));
+    const file = fileExport.default || {};
+    for (const key in file) {
+        if (!(key in templateMblerConfig)) {
+            throw new Error(`[read config]: read config from '${project}' error: Unexpected '${key}'`);
+        }
+    }
+    return file;
+}
 async function readFileAsJson(filePath) {
     try {
         const content = await fs__namespace.readFile(filePath, 'utf-8');
@@ -468,7 +486,7 @@ const input = (function () {
                 curr(currstr);
                 curr = null;
                 currstr = '';
-                console.log('');
+                console.log('\n');
                 return;
             }
             if (raw === 'backspace') {
@@ -534,6 +552,15 @@ function runCommand(param, cwd, stdio) {
     });
     return promise;
 }
+async function fileExists(file) {
+    try {
+        await fs__namespace.stat(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 
 const logFile = path.join(os.homedir(), ".cache/mbler/latest.log");
 function _clean(promise) {
@@ -689,7 +716,8 @@ class WorkDirManage {
 const config = {
     tmpdir: path__namespace.join(os.tmpdir(), ".mbler"),
     mcxVersion: "0.0.2-beta.r7",
-    mcxCoreVersion: "0.0.6"
+    mcxCoreVersion: "0.0.6",
+    defaultPmnxBASE: "https://d.pmnx.qzz.io"
 };
 
 /**
@@ -1016,29 +1044,720 @@ function langCommand(cliParam, workdir) {
     return 0;
 }
 
-function unpublishCommand(cliParam, work) {
-    showText("unpublish is planing");
-    return 1;
+function createFullZip(dir) {
+    const zip = new AdmZip();
+    zip.addLocalFolder(dir);
+    return zip;
+}
+async function createZipWithMoreFolder(dir) {
+    const zip = new AdmZip();
+    for (const folder of dir) {
+        await zip.addLocalFolderPromise(folder[0], {
+            zipPath: folder[1]
+        });
+    }
+    return zip;
+}
+async function generateRelease(build) {
+    if (!build.outdirs)
+        throw new Error("invalid Build");
+    if (node_process.env.BUILD_MODULE !== "release")
+        return;
+    let zip;
+    if (build.module == "all") {
+        zip = await createZipWithMoreFolder([
+            [build.outdirs?.behavior, "behavior"],
+            [build.outdirs?.resources, "resources"]
+        ]);
+    }
+    else if (build.module == "behavior") {
+        zip = createFullZip(build.outdirs?.behavior);
+    }
+    else {
+        zip = createFullZip(build.outdirs?.resources);
+    }
+    await zip.writeZipPromise(build.outdirs?.dist);
+}
+
+class ConfigManger {
+    static defaultConfigPoint = path.join(os.homedir(), ".config", "_config.json");
+    static cacheValue = {};
+    static lockPromise = null;
+    static lockResolver = null;
+    static cacheTTL = 5000; // 5秒缓存
+    static lastAccess = 0;
+    static currentConfigPath = '';
+    static async acquireLock() {
+        while (this.lockPromise) {
+            await this.lockPromise;
+        }
+        this.lockPromise = new Promise((resolve) => {
+            this.lockResolver = resolve;
+        });
+    }
+    static releaseLock() {
+        if (this.lockResolver) {
+            this.lockResolver();
+            this.lockPromise = null;
+            this.lockResolver = null;
+        }
+    }
+    static isCacheValid(configPath) {
+        return this.currentConfigPath === configPath &&
+            Date.now() - this.lastAccess < this.cacheTTL &&
+            Object.keys(this.cacheValue).length > 0;
+    }
+    static async loadConfigToCache(configPath) {
+        try {
+            await this.acquireLock();
+            if (this.isCacheValid(configPath)) {
+                this.releaseLock();
+                return;
+            }
+            const configData = await readFileAsJson(configPath);
+            this.cacheValue = configData;
+            this.currentConfigPath = configPath;
+            this.lastAccess = Date.now();
+            this.releaseLock();
+        }
+        catch (error) {
+            this.releaseLock();
+            this.cacheValue = {};
+            throw error;
+        }
+    }
+    static async saveCacheToFile(configPath) {
+        try {
+            await this.acquireLock();
+            await writeJSON(configPath, this.cacheValue);
+            this.lastAccess = Date.now();
+            this.releaseLock();
+        }
+        catch (error) {
+            this.releaseLock();
+            throw error;
+        }
+    }
+    static async getConfigPoint() {
+        try {
+            const file = await fs$1.readFile(path.join(config.tmpdir, "_config_point.json"));
+            const configPoint = JSON.parse(file.toString());
+            return configPoint.point;
+        }
+        catch {
+            if (!await fileExists(this.defaultConfigPoint)) {
+                await writeJSON(this.defaultConfigPoint, {});
+            }
+            await writeJSON(path.join(config.tmpdir, "_config_point.json"), {
+                point: this.defaultConfigPoint,
+                update: new Date()
+            });
+            return this.defaultConfigPoint;
+        }
+    }
+    static async setConfigPoint(point) {
+        if (!await fileExists(point)) {
+            throw new Error("[mbler config]: can't bind config file: " + point);
+        }
+        await writeJSON(path.join(config.tmpdir, "_config_point.json"), {
+            point,
+            update: new Date()
+        });
+    }
+    static async getKey(key) {
+        try {
+            const configPath = await this.getConfigPoint();
+            // 使用缓存，避免频繁文件读取
+            if (!this.isCacheValid(configPath)) {
+                await this.loadConfigToCache(configPath);
+            }
+            return this.cacheValue[key];
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    static async setKey(key, value) {
+        try {
+            const configPath = await this.getConfigPoint();
+            // 确保缓存是最新的
+            if (!this.isCacheValid(configPath)) {
+                await this.loadConfigToCache(configPath);
+            }
+            this.cacheValue[key] = value;
+            this.saveCacheToFile(configPath).catch(error => {
+                Logger.e('ConfigManger', 'Failed to save config to file:' + error);
+            });
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static async init(defaultConfig = {}) {
+        const configPath = await this.getConfigPoint();
+        if (!await fileExists(configPath)) {
+            await writeJSON(configPath, defaultConfig);
+        }
+    }
+}
+
+class TokenManger {
+    static setToken(newToken) {
+        ConfigManger.setKey("token", newToken);
+        this.task = this.requestAPI();
+    }
+    static getToken() { return ConfigManger.getKey("token"); }
+    static isLogin = false;
+    static task;
+    static isLoading = true;
+    static user = null;
+    static async init() {
+        const token = await this.getToken();
+        if (token) {
+            this.task = this.requestAPI();
+            await this.task;
+        }
+        else {
+            this.isLoading = false;
+        }
+    }
+    static async waitVeirfy() {
+        if (!this.task)
+            await this.init();
+        console.debug(this.task);
+        return await this.task;
+    }
+    static async requestAPI() {
+        this.isLoading = true;
+        this.isLogin = false;
+        const token = await this.getToken();
+        const result = await fetch(`${config.defaultPmnxBASE}/token/${token}/verify`, {
+            method: "GET",
+            credentials: "omit",
+        });
+        this.isLoading = false;
+        const body = await result.json();
+        if (result.ok) {
+            this.isLogin = true;
+            this.user = body.data;
+        }
+        else {
+            this.isLogin = false;
+        }
+    }
+}
+
+class PublishManger {
+    static async publish(projectPath, options) {
+        if (TokenManger.isLoading)
+            await TokenManger.init();
+        if (!await fileExists(projectPath)) {
+            throw new Error("Project path does not exist");
+        }
+        const { onProgress = (p) => { }, onMessage = (m) => { }, build, tag } = options;
+        onProgress(1);
+        onMessage("Publishing...");
+        if (build == "enable") {
+            onMessage("Building project...");
+            await this.buildProject(projectPath);
+            onProgress(30);
+        }
+        const mblerConfig = await ReadProjectMblerConfig(projectPath);
+        const pkgData = await readFileAsJson(path.join(projectPath, "package.json"));
+        const outputPath = path.join(config.tmpdir, "mbler/0b09/release.zip");
+        const option = {
+            outdirs: {
+                behavior: mblerConfig.outdir?.behavior || path.join(projectPath, "dist", "behavior"),
+                resources: mblerConfig.outdir?.resources || path.join(projectPath, "dist", "resources"),
+                dist: outputPath
+            },
+            module: "all"
+        };
+        if (!option.outdirs.behavior || !option.outdirs.resources) {
+            throw new Error("Build output directories not found");
+        }
+        if (!await fileExists(option.outdirs.behavior) || !await fileExists(option.outdirs.resources)) {
+            throw new Error("Build output directories do not exist");
+        }
+        if (await fileExists(option.outdirs.behavior)) {
+            option.module = "behavior";
+        }
+        if (await fileExists(option.outdirs.resources)) {
+            if (option.module == "behavior") {
+                option.module = "all";
+            }
+            else {
+                option.module = "resources";
+            }
+        }
+        let readmePath = path.join(projectPath, "README.md");
+        if (await fileExists(path.join(projectPath, "README.md"))) {
+            readmePath = path.join(projectPath, "README.md");
+        }
+        if (await fileExists(path.join(projectPath, "readme.md"))) {
+            readmePath = path.join(projectPath, "readme.md");
+        }
+        if (await fileExists(path.join(projectPath, "Readme.md"))) {
+            readmePath = path.join(projectPath, "Readme.md");
+        }
+        if (await fileExists(path.join(projectPath, "README.MD"))) {
+            readmePath = path.join(projectPath, "README.MD");
+        }
+        if (await fileExists(path.join(projectPath, "readme.MD"))) {
+            readmePath = path.join(projectPath, "readme.MD");
+        }
+        if (await fileExists(path.join(projectPath, "Readme.MD"))) {
+            readmePath = path.join(projectPath, "Readme.MD");
+        }
+        if (await fileExists(path.join(projectPath, "README.markdown"))) {
+            readmePath = path.join(projectPath, "README.markdown");
+        }
+        if (await fileExists(path.join(projectPath, "readme.markdown"))) {
+            readmePath = path.join(projectPath, "readme.markdown");
+        }
+        if (await fileExists(path.join(projectPath, "Readme.markdown"))) {
+            readmePath = path.join(projectPath, "Readme.markdown");
+        }
+        if (await fileExists(path.join(projectPath, "README"))) {
+            readmePath = path.join(projectPath, "README");
+        }
+        if (!await fileExists(readmePath)) {
+            throw new Error("README file not found");
+        }
+        const metadata = {
+            readme: await fs$1.readFile(readmePath, "utf-8"),
+            scope: (mblerConfig.name.split("/").length > 1 ? mblerConfig.name.split("/")[0] : ""),
+            name: mblerConfig.name.split("/").length > 1 ? mblerConfig.name.split("/")[1] : pkgData.name,
+            version: mblerConfig.version,
+            version_tag: tag || "latest"
+        };
+        if (!metadata.name || !metadata.version || !metadata.readme || !metadata.scope) {
+            throw new Error("Invalid metadata");
+        }
+        if (!/^@\w+\/\w+$/.test(mblerConfig.name)) {
+            console.log(mblerConfig.name);
+            throw new Error("Package name must be in the format of @scope/name");
+        }
+        await generateRelease(option);
+        onProgress(70);
+        onMessage("Publishing to marketplace...");
+        const session = await PublishManger.createSession(metadata);
+        await PublishManger.publishToMarketplace(outputPath, session);
+        onProgress(100);
+        onMessage("Publish successful");
+        onMessage(`+ ${pkgData.name}@${metadata.version} (${metadata.version_tag})`);
+    }
+    static async unpublish(scope, name, version) {
+        if (TokenManger.isLoading)
+            await TokenManger.waitVeirfy();
+        if (!TokenManger.isLogin)
+            throw new Error("Not logged in");
+        const token = await TokenManger.getToken();
+        if (!token)
+            throw new Error("Failed to get token");
+        const response = await fetch(`${config.defaultPmnxBASE}/unpublish/${scope}/${name}/${version}`, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${token}`
+            }
+        });
+        if (!response.ok) {
+            throw new Error("Failed to unpublish package");
+        }
+        const result = await response.json();
+        if (result.code !== 200) {
+            throw new Error(`Failed to unpublish package: ${result.data}`);
+        }
+        return true;
+    }
+    static async createSession(metadata) {
+        if (TokenManger.isLoading)
+            await TokenManger.waitVeirfy();
+        if (!TokenManger.isLogin)
+            throw new Error("Not logged in");
+        const token = await TokenManger.getToken();
+        if (!token)
+            throw new Error("Failed to get token");
+        const response = await fetch(`${config.defaultPmnxBASE}/publish/session/${metadata.scope}/${metadata.name}/create`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${token}`
+            },
+            body: JSON.stringify(metadata)
+        });
+        const session = await response.json();
+        console.log(session);
+        if (!response.ok) {
+            throw new Error("Failed to create publish session");
+        }
+        if (typeof session.data !== "object" || typeof session.data.sessionKey !== "string") {
+            throw new Error(`${response.status} ${response.statusText}: ${session.data}`);
+        }
+        return session.data.sessionKey;
+    }
+    static async publishToMarketplace(zipPath, session) {
+        const formData = new FormData();
+        const fileBit = await fs$1.readFile(zipPath);
+        let fileName = path.basename(zipPath);
+        if (fileName.endsWith(".mcaddon")) {
+            fileName = fileName.slice(0, -".mcaddon".length) + ".zip";
+        }
+        formData.append("file", new File([fileBit], fileName, { type: "application/zip" }));
+        const token = await TokenManger.getToken();
+        if (!token)
+            throw new Error("Failed to get token");
+        const response = await fetch(`${config.defaultPmnxBASE}/publish/session/${session}/upload`, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${token}`
+            },
+            body: formData
+        });
+        if (!response.ok) {
+            throw new Error("Failed to upload zip file");
+        }
+        const result = await response.json();
+        if (result.code !== 200) {
+            throw new Error(`Failed to upload zip file: ${result.data}`);
+        }
+        return true;
+    }
+    static async buildProject(projectPath) {
+        const pkgData = await readFileAsJson(path.join(projectPath, "package.json"));
+        if (!pkgData) {
+            throw new Error("package.json not found");
+        }
+        if (!pkgData.scripts || !pkgData.scripts.build) {
+            throw new Error("No build script found in package.json");
+        }
+        const pkgManager = pkgData.packageManager || "npm";
+        await new Promise((resolve, reject) => {
+            const child = node_child_process.spawn(pkgManager, ["run", "build"], { cwd: projectPath });
+            child.on("close", (code) => {
+                if (code === 0) {
+                    resolve(void 0);
+                }
+                else {
+                    reject(new Error(`Build failed with code ${code}`));
+                }
+            });
+        });
+    }
+}
+
+function parsePackage$2(pkg) {
+    const result = /^(@[^/@\s]+)\/([^@\s]+)@(.+)$/.exec(pkg);
+    if (!result)
+        return null;
+    return {
+        scope: result[1],
+        name: result[2],
+        version: result[3],
+    };
+}
+async function unpublishCommand(cliParam, work) {
+    const pkg = cliParam.params[1];
+    if (!pkg) {
+        showText(i18n.help.unpublish);
+        return -1;
+    }
+    const parsed = parsePackage$2(pkg);
+    if (!parsed) {
+        showText(i18n.help.unpublish);
+        return -1;
+    }
+    try {
+        await PublishManger.unpublish(parsed.scope, parsed.name, parsed.version);
+        showText(`Package ${parsed.scope}/${parsed.name}@${parsed.version} unpublished successfully`);
+        return 0;
+    }
+    catch (error) {
+        showText(`Unpublish failed: ${error instanceof Error ? error.message : String(error)}`);
+        return -1;
+    }
+}
+
+async function publishCommand(cliParam, work) {
+    const tag = cliParam.params.find(p => p.startsWith("-tag="))?.split("=")[1] || "latest";
+    try {
+        await PublishManger.publish(work, {
+            build: "enable",
+            tag,
+            onProgress: (progress) => showText(`Progress: ${progress}%`),
+            onMessage: (message) => showText(message)
+        });
+        return 0;
+    }
+    catch (error) {
+        showText(`Publish failed: ${error instanceof Error ? error.message : String(error)}`);
+        return -1;
+    }
+}
+
+class GamePath {
+    static async askPath(autoset = true) {
+        const result = await input(i18n.publish.askTip);
+        if (!result) {
+            throw new Error("No path provided");
+        }
+        if (autoset) {
+            ConfigManger.setKey("gamePath", result);
+        }
+        return result;
+    }
+    static async getPath() {
+        const path = await ConfigManger.getKey("gamePath");
+        return path || null;
+    }
+    static async clearPath() {
+        await ConfigManger.setKey("gamePath", "");
+    }
+    static async getPathWithASK() {
+        let path = await this.getPath();
+        if (!path) {
+            path = await this.askPath();
+        }
+        return path;
+    }
 }
 
-function publishCommand(cliParam, work) {
-    showText("publish is planing");
-    return 1;
+function parsePackage$1(pkg) {
+    const result = /^(@[^/@\s]+)\/([^@\s]+)@(.+)$/.exec(pkg);
+    if (!result)
+        return null;
+    return {
+        scope: result[1],
+        name: result[2],
+        version: result[3],
+    };
+}
+async function uninstallCommand(cliParam, work) {
+    const pkg = cliParam.params[1];
+    if (!pkg) {
+        showText(i18n.help.uninstall);
+        return -1;
+    }
+    const parsed = parsePackage$1(pkg);
+    if (!parsed) {
+        showText(i18n.help.uninstall);
+        return -1;
+    }
+    const gamePoint = await GamePath.getPathWithASK();
+    if (!gamePoint) {
+        showText(i18n.help.uninstall);
+        return -1;
+    }
+    try {
+        const id = `${parsed.scope.slice(1)}-${parsed.name}-${parsed.version}`;
+        const behaviorDir = path.join(gamePoint, "behavior_packs", id);
+        const resourceDir = path.join(gamePoint, "resource_packs", id);
+        await fs$1.rm(behaviorDir, { recursive: true, force: true });
+        await fs$1.rm(resourceDir, { recursive: true, force: true });
+        // Remove from installed packages
+        const installed = (await ConfigManger.getKey("installedPackages")) || [];
+        const filtered = installed.filter((pkg) => pkg.id !== id);
+        await ConfigManger.setKey("installedPackages", filtered);
+        showText(`Package ${parsed.scope}/${parsed.name}@${parsed.version} uninstalled successfully`);
+        return 0;
+    }
+    catch (error) {
+        showText(`Uninstall failed: ${error instanceof Error ? error.message : String(error)}`);
+        return -1;
+    }
 }
 
-function uninstallCommand(cliParam, work) {
-    showText("uninstall is planing");
-    return 1;
+class InstallManger {
+    static async download(scope, name, version, outputPath) {
+        const response = await fetch(`${config.defaultPmnxBASE}/package/${scope}/${name}/v/${version}/download`);
+        if (!response.ok) {
+            throw new Error(`Failed to download package: ${response.status} ${response.statusText}`);
+        }
+        const buffer = await response.arrayBuffer();
+        await fs$1.writeFile(outputPath, Buffer.from(buffer));
+    }
+    static async info(scope, name) {
+        const response = await fetch(`${config.defaultPmnxBASE}/package/${scope}/${name}/info`);
+        if (!response.ok) {
+            throw new Error(`Failed to get package info: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (data.code !== 200) {
+            throw new Error(`Failed to get package info: ${data.data}`);
+        }
+        return data.data;
+    }
+    static async versionInfo(scope, name, version) {
+        const response = await fetch(`${config.defaultPmnxBASE}/package/${scope}/${name}/v/${version}/info`);
+        if (!response.ok) {
+            throw new Error(`Failed to get package version info: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (data.code !== 200) {
+            throw new Error(`Failed to get package version info: ${data.data}`);
+        }
+        return data.data;
+    }
 }
 
-function installCommand(cliParam, work) {
-    showText("install is planing");
-    return 1;
+function parsePackage(pkg) {
+    const result = /^(@[^/@\s]+)\/([^@\s]+)(?:@(.+))?$/.exec(pkg);
+    if (!result)
+        return null;
+    const info = {
+        scope: result[1],
+        name: result[2],
+    };
+    if (result[3]) {
+        info.version = result[3];
+    }
+    return info;
+}
+function pickLatestVersion(versions) {
+    const validVersions = versions.filter(isVaildVersion);
+    if (validVersions.length > 0) {
+        return validVersions.sort(compareVersion).reverse()[0] || "";
+    }
+    return versions[0] || "";
+}
+async function installCommand(cliParam, work) {
+    const pkg = cliParam.params[1];
+    if (!pkg) {
+        showText(i18n.help.install);
+        return -1;
+    }
+    const parsed = parsePackage(pkg);
+    if (!parsed) {
+        showText(i18n.help.install);
+        return -1;
+    }
+    const { scope, name } = parsed;
+    let version = parsed.version || "";
+    const gamePoint = await GamePath.getPathWithASK();
+    if (!gamePoint) {
+        showText(i18n.help.install);
+        return -1;
+    }
+    const packageJsonPath = path.join(work, "package.json");
+    if (!await fs$1.stat(packageJsonPath).catch(() => null)) {
+        showText("Install failed: work directory must contain package.json");
+        return -1;
+    }
+    const packageJson = JSON.parse(await fs$1.readFile(packageJsonPath, "utf-8"));
+    if (!packageJson.scripts?.build) {
+        showText("Install failed: package.json must contain a build script");
+        return -1;
+    }
+    showText(`Installing package ${pkg}...`);
+    try {
+        if (!version) {
+            const pkgInfo = await InstallManger.info(scope, name);
+            if (!pkgInfo.versions || pkgInfo.versions.length === 0) {
+                showText(`Package ${scope}/${name} not found`);
+                return -1;
+            }
+            const versionCandidates = pkgInfo.versions
+                .map((item) => item.name)
+                .filter((name) => typeof name === "string" && name.length > 0);
+            version = pickLatestVersion(versionCandidates);
+            if (!version) {
+                showText(`Package ${scope}/${name} has no available version`);
+                return -1;
+            }
+            showText(`Using latest version ${version}`);
+        }
+        const tmpDir = path.join(config.tmpdir, "tmp_mbler_install", `${Date.now()}`);
+        await fs$1.mkdir(tmpDir, { recursive: true });
+        await InstallManger.download(scope, name, version, path.join(tmpDir, "package.zip"));
+        const zip = new AdmZip(path.join(tmpDir, "package.zip"));
+        zip.extractAllTo(tmpDir, true);
+        async function findAddonRoots(dir) {
+            const results = [];
+            async function walk(p) {
+                const entries = await fs$1.readdir(p, { withFileTypes: true });
+                for (const entry of entries) {
+                    const entryPath = path.join(p, entry.name);
+                    if (entry.isFile() && entry.name === "manifest.json") {
+                        try {
+                            const manifest = JSON.parse(await fs$1.readFile(entryPath, "utf-8"));
+                            const type = manifest?.modules?.[0]?.type;
+                            if (type === "data") {
+                                results.push({ root: path.dirname(entryPath), type: "behavior" });
+                            }
+                            else if (type === "resources") {
+                                results.push({ root: path.dirname(entryPath), type: "resource" });
+                            }
+                        }
+                        catch {
+                            // ignore invalid manifest
+                        }
+                    }
+                    if (entry.isDirectory()) {
+                        await walk(entryPath);
+                    }
+                }
+            }
+            await walk(dir);
+            return results;
+        }
+        const addons = await findAddonRoots(tmpDir);
+        if (addons.length === 0) {
+            throw new Error("No valid addon found in package");
+        }
+        const id = `${scope.slice(1)}-${name}-${version}`;
+        const installed = (await ConfigManger.getKey("installedPackages")) || [];
+        for (const addon of addons) {
+            const packDir = addon.type === "behavior" ? "behavior_packs" : "resource_packs";
+            const dest = path.join(gamePoint, packDir, id);
+            await fs$1.mkdir(dest, { recursive: true });
+            await fs$1.cp(addon.root, dest, { recursive: true });
+            installed.push({ id, scope, name, version, type: addon.type });
+        }
+        await ConfigManger.setKey("installedPackages", installed);
+        await fs$1.rm(tmpDir, { recursive: true, force: true });
+        await new Promise((resolve, reject) => {
+            const child = node_child_process.spawn("pnpm", ["build"], { cwd: work });
+            child.on("close", (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`Build failed with code ${code}`));
+            });
+        });
+        showText(`Package ${scope}/${name}@${version} installed successfully as ${id}`);
+        return 0;
+    }
+    catch (error) {
+        showText(`Install failed: ${error instanceof Error ? error.message : String(error)}`);
+        return -1;
+    }
 }
 
-function loginCommand(cliParam, work) {
-    showText("login is planing");
-    return 1;
+async function loginCommand(cliParam, work) {
+    let token = cliParam.params[1];
+    if (!token) {
+        showText(i18n.help.login);
+        token = await input("Token: ", true);
+    }
+    if (!token) {
+        showText("Token is required");
+        return -1;
+    }
+    try {
+        TokenManger.setToken(token.trim());
+        await TokenManger.waitVeirfy();
+        if (!TokenManger.isLogin) {
+            showText("Login failed: invalid token");
+            return -1;
+        }
+        showText(`Login successful: ${TokenManger.user?.name || "unknown user"}`);
+        return 0;
+    }
+    catch (error) {
+        showText(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
+        return -1;
+    }
 }
 
 // `showText` moved to `utils` to avoid circular dependency with `build`.