@hapico/cli 0.0.2

package/dist/index.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileES5 = void 0;
+const commander_1 = require("commander");
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const unzipper_1 = __importDefault(require("unzipper"));
+const ora_1 = __importDefault(require("ora"));
+const ws_1 = require("ws");
+const Babel = __importStar(require("@babel/standalone"));
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+// Directory to store the token and project config
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || ".", ".hapico");
+const TOKEN_FILE = path.join(CONFIG_DIR, "auth_token.json");
+// Ensure config directory exists
+if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+// Function to save token
+const saveToken = (token) => {
+    fs.writeFileSync(TOKEN_FILE, JSON.stringify({ access_token: token }, null, 2), {
+        encoding: "utf8",
+    });
+};
+// Function to get stored token
+const getStoredToken = () => {
+    if (fs.existsSync(TOKEN_FILE)) {
+        const data = fs.readFileSync(TOKEN_FILE, { encoding: "utf8" });
+        const json = JSON.parse(data);
+        return json.access_token || null;
+    }
+    return null;
+};
+// Function to save project ID
+const saveProjectId = (projectDir, id) => {
+    const configFile = path.join(projectDir, "hapico.config.json");
+    fs.writeFileSync(configFile, JSON.stringify({ projectId: id }, null, 2), { encoding: "utf8" });
+};
+// Function to get stored project ID
+const getStoredProjectId = (projectDir) => {
+    const configFile = path.join(projectDir, "hapico.config.json");
+    if (fs.existsSync(configFile)) {
+        const data = fs.readFileSync(configFile, { encoding: "utf8" });
+        const json = JSON.parse(data);
+        return json.projectId || null;
+    }
+    return null;
+};
+// Khởi tạo cache bằng Map để lưu trữ kết quả compile
+const compileCache = new Map();
+const compileES5 = (code, filePath) => {
+    if (filePath && !filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) {
+        return code;
+    }
+    if (compileCache.has(code)) {
+        return compileCache.get(code);
+    }
+    try {
+        const result = Babel.transform(code, {
+            presets: [
+                ["env", { targets: { esmodules: false } }],
+                "typescript",
+                "react",
+            ],
+            filename: "file.tsx",
+        });
+        compileCache.set(code, result.code || "");
+        return result.code;
+    }
+    catch (error) {
+        return "";
+    }
+};
+exports.compileES5 = compileES5;
+class FileManager {
+    constructor(basePath, onFileChange) {
+        this.basePath = basePath;
+        this.onFileChange = onFileChange;
+    }
+    syncFiles(files) {
+        for (const file of files) {
+            this.writeFile(file);
+        }
+    }
+    listFiles() {
+        const files = [];
+        const traverseDirectory = (dir) => {
+            fs.readdirSync(dir, { withFileTypes: true }).forEach((entry) => {
+                var _a;
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    traverseDirectory(fullPath);
+                }
+                else if (entry.isFile()) {
+                    const content = fs.readFileSync(fullPath, { encoding: "utf8" });
+                    files.push({
+                        path: fullPath.replace(this.basePath + path.sep, "./"),
+                        content,
+                        es5: (_a = (0, exports.compileES5)(content, fullPath)) !== null && _a !== void 0 ? _a : "",
+                    });
+                }
+            });
+        };
+        traverseDirectory(this.basePath);
+        return files;
+    }
+    writeFile(file) {
+        try {
+            const fullPath = path.join(this.basePath, file.path);
+            const dir = path.dirname(fullPath);
+            fs.mkdirSync(dir, { recursive: true });
+            let hasChanged = true;
+            if (fs.existsSync(fullPath)) {
+                try {
+                    const existingContent = fs.readFileSync(fullPath, {
+                        encoding: "utf8",
+                    });
+                    hasChanged = existingContent !== file.content;
+                }
+                catch (readError) {
+                    console.warn(`Warning: Could not read existing file ${fullPath}, treating as changed:`, readError);
+                    hasChanged = true;
+                }
+            }
+            if (hasChanged) {
+                fs.writeFileSync(fullPath, file.content, { encoding: "utf8" });
+            }
+        }
+        catch (error) {
+            console.error(`Error processing file ${file.path}:`, error);
+            throw error;
+        }
+    }
+    startWatching() {
+        if (!this.onFileChange) {
+            return;
+        }
+        try {
+            this.watcher = fs.watch(this.basePath, { recursive: true }, (eventType, filename) => {
+                if (filename && eventType === "change") {
+                    const fullPath = path.join(this.basePath, filename);
+                    try {
+                        const stats = fs.statSync(fullPath);
+                        if (stats.isFile()) {
+                            const content = fs.readFileSync(fullPath, { encoding: "utf8" });
+                            this.onFileChange(fullPath, content);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Error reading changed file ${fullPath}:`, error);
+                    }
+                }
+            });
+        }
+        catch (error) {
+            // console.error(`Error setting up file watcher for ${this.basePath}:`, error);
+        }
+    }
+    setOnFileChange(callback) {
+        this.onFileChange = callback;
+        if (!this.watcher && callback) {
+            this.startWatching();
+        }
+    }
+    stopWatching() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = undefined;
+        }
+    }
+}
+class RoomState {
+    constructor(roomId) {
+        this.files = [];
+        this.roomId = roomId;
+        this.state = {};
+        this.isConnected = false;
+        this.ws = null;
+        this.reconnectTimeout = null;
+        this.reconnectAttempts = 0;
+    }
+    connect(onConnected) {
+        if (this.ws && this.ws.readyState === ws_1.WebSocket.OPEN)
+            return;
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+        }
+        this.ws = new ws_1.WebSocket(`https://base.myworkbeast.com/ws?room=${this.roomId}`);
+        this.ws.on("open", () => {
+            this.isConnected = true;
+            this.reconnectAttempts = 0;
+            onConnected === null || onConnected === void 0 ? void 0 : onConnected();
+        });
+        this.ws.on("close", () => {
+            this.isConnected = false;
+            this.reconnectAttempts++;
+            const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+            console.log(`Attempting to reconnect in ${delay / 1000}s...`);
+            this.reconnectTimeout = setTimeout(() => this.connect(), delay);
+        });
+        this.ws.on("message", (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                if (message.type === "state" && message.state) {
+                    this.state = message.state;
+                    const view = this.state.view;
+                    this.files = view;
+                }
+            }
+            catch (e) {
+                console.error("Error processing message:", e);
+            }
+        });
+        this.ws.on("error", (err) => {
+            var _a;
+            console.error("WebSocket error:", err);
+            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
+        });
+    }
+    updateState(key, value) {
+        if (this.ws && this.ws.readyState === ws_1.WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: "update",
+                state: { [key]: value },
+            }));
+        }
+        else {
+            console.log("Cannot update state: Not connected");
+        }
+    }
+    disconnect() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+        }
+        if (this.ws) {
+            this.ws.removeAllListeners("close");
+            this.ws.close();
+        }
+    }
+    getState() {
+        return this.state;
+    }
+    getIsConnected() {
+        return this.isConnected;
+    }
+}
+commander_1.program.version("1.0.0").description("Hapico CLI for project management");
+commander_1.program
+    .command("clone <id>")
+    .description("Clone a project by ID")
+    .action(async (id) => {
+    const token = getStoredToken();
+    if (!token) {
+        console.error("You need to login first. Use 'hapico login' command.");
+        return;
+    }
+    const projectDir = path.resolve(process.cwd(), id);
+    if (fs.existsSync(projectDir)) {
+        console.error(`Project directory "${id}" already exists.`);
+        return;
+    }
+    let files = [];
+    const apiSpinner = (0, ora_1.default)("Fetching project data...").start();
+    try {
+        const response = await axios_1.default.get(`https://base.myworkbeast.com/api/views/${id}`);
+        files = response.data.files || [];
+        apiSpinner.succeed("Project data fetched successfully!");
+        const templateSpinner = (0, ora_1.default)("Downloading template...").start();
+        const TEMPLATE_URL = "https://files.hcm04.vstorage.vngcloud.vn/assets/template_zalominiapp_devmode.zip";
+        const templateResponse = await axios_1.default.get(TEMPLATE_URL, {
+            responseType: "arraybuffer",
+        });
+        templateSpinner.succeed("Template downloaded successfully!");
+        const outputDir = path.resolve(process.cwd(), id);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir);
+        }
+        const unzipSpinner = (0, ora_1.default)("Extracting template...").start();
+        await unzipper_1.default.Open.buffer(templateResponse.data).then((directory) => directory.extract({ path: outputDir }));
+        unzipSpinner.succeed("Template extracted successfully!");
+        const macosxDir = path.join(process.cwd(), id, "__MACOSX");
+        if (fs.existsSync(macosxDir)) {
+            fs.rmSync(macosxDir, { recursive: true, force: true });
+        }
+        // Save project ID to hapico.config.json
+        saveProjectId(outputDir, id);
+        console.log("Project cloned successfully!");
+        const saveSpinner = (0, ora_1.default)("Saving project files...").start();
+        files.forEach((file) => {
+            const filePath = path.join(process.cwd(), id, "src", file.path);
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, file.content);
+        });
+        saveSpinner.succeed("Project files saved successfully!");
+        console.log(`Run 'cd ${id} && npm install && hapico dev' to start the project.`);
+    }
+    catch (error) {
+        apiSpinner.fail(`Error cloning project: ${error.message}`);
+    }
+});
+commander_1.program
+    .command("dev")
+    .description("Start the project in development mode")
+    .action(() => {
+    const token = getStoredToken();
+    if (!token) {
+        console.error("You need to login first. Use 'hapico login' command.");
+        return;
+    }
+    const devSpinner = (0, ora_1.default)("Starting the project in development mode...").start();
+    const pwd = process.cwd();
+    const srcDir = path.join(pwd, "src");
+    if (!fs.existsSync(srcDir)) {
+        devSpinner.fail("Source directory 'src' does not exist. Please clone a project first.");
+        return;
+    }
+    const projectId = getStoredProjectId(pwd);
+    if (!projectId) {
+        devSpinner.fail("Project ID not found. Please ensure hapico.config.json exists in the project directory.");
+        return;
+    }
+    console.log(`Connecting to WebSocket server for room: ${projectId}`);
+    const room = new RoomState(`view_${projectId}`);
+    room.connect(async () => {
+        devSpinner.succeed("Project started in development mode!");
+        const fileManager = new FileManager(srcDir);
+        const initialFiles = fileManager.listFiles();
+        room.updateState("view", initialFiles);
+        fileManager.setOnFileChange((filePath, content) => {
+            const es5 = (0, exports.compileES5)(content, filePath);
+            console.log(`File changed: ${filePath === null || filePath === void 0 ? void 0 : filePath.replace(srcDir, ".")}`);
+            const updatedView = room.files.map((file) => {
+                if (path.join(srcDir, file.path) === filePath) {
+                    return { ...file, content, es5 };
+                }
+                return file;
+            });
+            room.updateState("view", updatedView);
+        });
+        qrcode_terminal_1.default.generate(`https://zalo.me/s/3218692650896662017/player/${projectId}`, { small: true }, (qrcode) => {
+            console.log("Scan this QR code to connect to the project:");
+            console.log(qrcode);
+        });
+    });
+});
+commander_1.program
+    .command("publish")
+    .description("Publish the project source code to the server")
+    .action(() => {
+    const token = getStoredToken();
+    if (!token) {
+        console.error("You need to login first. Use 'hapico login' command.");
+        return;
+    }
+    const saveSpinner = (0, ora_1.default)("Saving project source code...").start();
+    const pwd = process.cwd();
+    const projectId = getStoredProjectId(pwd);
+    if (!projectId) {
+        saveSpinner.fail("Project ID not found. Please ensure hapico.config.json exists in the project directory.");
+        return;
+    }
+    const srcDir = path.join(pwd, "src");
+    if (!fs.existsSync(srcDir)) {
+        saveSpinner.fail("Source directory 'src' does not exist. Please clone a project first.");
+        return;
+    }
+    const fileManager = new FileManager(srcDir);
+    const files = fileManager.listFiles();
+    const apiUrl = `https://base.myworkbeast.com/api/views/${projectId}`;
+    axios_1.default
+        .put(apiUrl, {
+        code: JSON.stringify({
+            files,
+        }),
+    }, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+    })
+        .then(() => {
+        saveSpinner.succeed("Project source code saved successfully!");
+    })
+        .catch((error) => {
+        saveSpinner.fail(`Error saving project: ${error.message}`);
+    });
+});
+commander_1.program
+    .command("login")
+    .description("Login to the system")
+    .action(() => {
+    const token = getStoredToken();
+    if (token) {
+        console.log("You are already logged in.");
+        return;
+    }
+    const readline = require("readline").createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    readline.question("Please enter your token: ", (inputToken) => {
+        saveToken(inputToken);
+        console.log("Login successful!");
+        readline.close();
+    });
+});
+commander_1.program
+    .command("logout")
+    .description("Logout from the system")
+    .action(() => {
+    const token = getStoredToken();
+    if (!token) {
+        console.log("You are not logged in.");
+        return;
+    }
+    fs.unlinkSync(TOKEN_FILE);
+    console.log("Logout successful!");
+});
+commander_1.program.parse(process.argv);