@hapico/cli 0.0.17 → 0.0.19

package/index.ts

@@ -12,6 +12,13 @@ import * as Babel from "@babel/standalone";
 import QRCode from "qrcode-terminal";
 import open from "open";
 import { randomUUID } from "crypto";
+import { exec } from "child_process";
+import { promisify } from "util";
+import chalk from "chalk";
+import pako from 'pako';
+
+// Promisify exec for async usage
+const execPromise = promisify(exec);
 
 // Directory to store the token and project config
 const CONFIG_DIR = path.join(
@@ -20,7 +27,7 @@ const CONFIG_DIR = path.join(
 );
 const TOKEN_FILE = path.join(CONFIG_DIR, "auth_token.json");
 
-const connected = ora("Connected to WebSocket server");
+const connected = ora(chalk.cyan("Connected to WebSocket server"));
 
 // Ensure config directory exists
 if (!fs.existsSync(CONFIG_DIR)) {
@@ -89,6 +96,9 @@ interface FileContent {
 interface ApiResponse {
   data: {
     files?: FileContent[];
+    type: "view" | "zalominiapp" | string;
+    dbCode: string;
+    db_code: string;
   };
 }
 
@@ -188,7 +198,9 @@ class FileManager {
           hasChanged = existingContent !== file.content;
         } catch (readError) {
           console.warn(
-            `Warning: Could not read existing file ${fullPath}, treating as changed:`,
+            chalk.yellow(
+              `Warning: Could not read existing file ${fullPath}, treating as changed:`
+            ),
             readError
           );
           hasChanged = true;
@@ -199,7 +211,7 @@ class FileManager {
         fs.writeFileSync(fullPath, file.content, { encoding: "utf8" });
       }
     } catch (error) {
-      console.error(`Error processing file ${file.path}:`, error);
+      console.error(chalk.red(`Error processing file ${file.path}:`), error);
       throw error;
     }
   }
@@ -223,7 +235,10 @@ class FileManager {
                 this.onFileChange!(fullPath, content);
               }
             } catch (error) {
-              console.warn(`Error reading changed file ${fullPath}:`, error);
+              console.warn(
+                chalk.yellow(`Error reading changed file ${fullPath}:`),
+                error
+              );
             }
           }
         }
@@ -289,33 +304,47 @@ class RoomState {
     }
 
     this.ws = new WebSocket(
-      `https://ws2.myworkbeast.com/ws?room=${this.roomId}`
+      `wss://ws3.myworkbeast.com/ws?room=${this.roomId}`
     );
 
-    this.ws.onopen = () => {
-      console.log(`Connected to room: ${this.roomId}`);
+    // Set binaryType to 'arraybuffer' to handle binary data
+    this.ws.binaryType = 'arraybuffer';
+
+    this.ws.on("open", () => {
+      console.log(chalk.green(`Connected to room: ${this.roomId}`));
       this.isConnected = true;
       this.reconnectAttempts = 0;
       onConnected?.(); // Call the onConnected callback if provided
-    };
+    });
 
-    this.ws.onclose = () => {
-      console.log(`Disconnected from room: ${this.roomId}`);
+    this.ws.on("close", () => {
+      console.log(chalk.yellow(`⚠ Disconnected from room: ${this.roomId}`));
       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...`);
+      console.log(
+        chalk.yellow(`Attempting to reconnect in ${delay / 1000}s...`)
+      );
 
       this.reconnectTimeout = setTimeout(
         () => this.connect(onConnected),
         delay
       );
-    };
+    });
 
-    this.ws.on("message", (data: Buffer | string) => {
+    this.ws.on("message", (data: any) => {
       try {
-        const jsonStr = typeof data === "string" ? data : data.toString();
+        let jsonStr: string;
+        if (data instanceof ArrayBuffer) {
+          jsonStr = pako.inflate(data, { to: 'string' });
+        } else if (typeof data === "string") {
+          jsonStr = data;
+        } else if (Buffer.isBuffer(data)) {
+          jsonStr = pako.inflate(data, { to: 'string' });
+        } else {
+          jsonStr = data.toString(); // Fallback nếu không nén
+        }
         const parsedData = JSON.parse(jsonStr);
         const includes = [
           "view",
@@ -360,24 +389,24 @@ class RoomState {
           this.state = newState;
         }
       } catch (e) {
-        console.error("Error processing message:", e);
+        console.error(chalk.red("Error processing message:"), e);
       }
     });
 
     this.ws.on("error", (err) => {
-      console.error("WebSocket error:", err);
+      console.error(chalk.red("WebSocket error:"), err);
       this.ws?.close();
     });
   }
 
   updateState(key: string, value: any): void {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(
-        JSON.stringify({
-          type: "update",
-          state: { [key]: value },
-        })
-      );
+      const message = JSON.stringify({
+        type: "update",
+        state: { [key]: value },
+      });
+      const compressed = pako.deflate(message); // Nén dữ liệu
+      this.ws.send(compressed); // Gửi binary
     }
   }
 
@@ -386,7 +415,7 @@ class RoomState {
       clearTimeout(this.reconnectTimeout);
     }
     if (this.ws) {
-      this.ws.onclose = null; // Prevent reconnect on intentional close
+      this.ws.removeAllListeners("close"); // Prevent reconnect on intentional close
       this.ws.close();
     }
   }
@@ -400,7 +429,7 @@ class RoomState {
   }
 }
 
-program.version("0.0.16").description("Hapico CLI for project management");
+program.version("0.0.19").description("Hapico CLI for project management");
 
 program
   .command("clone <id>")
@@ -408,43 +437,49 @@ program
   .action(async (id: string) => {
     const { accessToken } = getStoredToken();
     if (!accessToken) {
-      console.error("You need to login first. Use 'hapico login' command.");
+      console.error(
+        chalk.red("✗ You need to login first. Use 'hapico login' command.")
+      );
       return;
     }
     const projectDir: string = path.resolve(process.cwd(), id);
     if (fs.existsSync(projectDir)) {
-      console.error(`Project directory "${id}" already exists.`);
+      console.error(chalk.red(`✗ Project directory "${id}" already exists.`));
       return;
     }
 
     let files: FileContent[] = [];
-    const apiSpinner: Ora = ora("Fetching project data...").start();
+    const apiSpinner: Ora = ora(chalk.blue("Fetching project data...")).start();
 
     try {
       const response: ApiResponse = await axios.get(
         `https://base.myworkbeast.com/api/views/${id}`
       );
       files = response.data.files || [];
-      apiSpinner.succeed("Project data fetched successfully!");
+      apiSpinner.succeed(chalk.green("Project data fetched successfully!"));
 
-      const templateSpinner: Ora = ora("Downloading template...").start();
+      const templateSpinner: Ora = ora(
+        chalk.blue("Downloading template...")
+      ).start();
       const TEMPLATE_URL: string =
         "https://files.hcm04.vstorage.vngcloud.vn/assets/template_zalominiapp_devmode.zip";
       const templateResponse = await axios.get(TEMPLATE_URL, {
         responseType: "arraybuffer",
       });
-      templateSpinner.succeed("Template downloaded successfully!");
+      templateSpinner.succeed(chalk.green("Template downloaded successfully!"));
 
       const outputDir: string = path.resolve(process.cwd(), id);
       if (!fs.existsSync(outputDir)) {
         fs.mkdirSync(outputDir);
       }
 
-      const unzipSpinner: Ora = ora("Extracting template...").start();
+      const unzipSpinner: Ora = ora(
+        chalk.blue("Extracting template...")
+      ).start();
       await unzipper.Open.buffer(templateResponse.data).then((directory) =>
         directory.extract({ path: outputDir })
       );
-      unzipSpinner.succeed("Template extracted successfully!");
+      unzipSpinner.succeed(chalk.green("Template extracted successfully!"));
 
       const macosxDir: string = path.join(process.cwd(), id, "__MACOSX");
       if (fs.existsSync(macosxDir)) {
@@ -454,9 +489,11 @@ program
       // Save project ID to hapico.config.json
       saveProjectId(outputDir, id);
 
-      console.log("Project cloned successfully!");
+      console.log(chalk.green("Project cloned successfully!"));
 
-      const saveSpinner: Ora = ora("Saving project files...").start();
+      const saveSpinner: Ora = ora(
+        chalk.blue("Saving project files...")
+      ).start();
       files.forEach((file: FileContent) => {
         const filePath: string = path.join(process.cwd(), id, "src", file.path);
         const dir: string = path.dirname(filePath);
@@ -467,12 +504,14 @@ program
 
         fs.writeFileSync(filePath, file.content);
       });
-      saveSpinner.succeed("Project files saved successfully!");
+      saveSpinner.succeed(chalk.green("Project files saved successfully!"));
       console.log(
-        `Run 'cd ${id} && npm install && hapico dev' to start the project.`
+        chalk.cyan(
+          `💡 Run ${chalk.bold("cd ${id} && npm install && hapico dev")} to start the project.`
+        )
       );
     } catch (error: any) {
-      apiSpinner.fail(`Error cloning project: ${error.message}`);
+      apiSpinner.fail(chalk.red(`Error cloning project: ${error.message}`));
     }
   });
 
@@ -482,17 +521,21 @@ program
   .action(() => {
     const { accessToken } = getStoredToken();
     if (!accessToken) {
-      console.error("You need to login first. Use 'hapico login' command.");
+      console.error(
+        chalk.red("✗ You need to login first. Use 'hapico login' command.")
+      );
       return;
     }
     const devSpinner = ora(
-      "Starting the project in development mode..."
+      chalk.blue("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."
+        chalk.red(
+          "✗ Source directory 'src' does not exist. Please clone a project first."
+        )
       );
       return;
     }
@@ -542,25 +585,29 @@ program
     const projectId = Buffer.from(info).toString("base64");
     if (!projectId) {
       devSpinner.fail(
-        "Project ID not found. Please ensure hapico.config.json exists in the project directory."
+        chalk.red(
+          "✗ Project ID not found. Please ensure hapico.config.json exists in the project directory."
+        )
       );
       return;
     }
 
-    console.log(`Connecting to WebSocket server`);
+    console.log(chalk.cyan("🔗 Connecting to WebSocket server"));
     const room = new RoomState(`view_${projectId}`, []);
     const fileManager = new FileManager(srcDir);
     const initialFiles = fileManager.listFiles();
     room.files = initialFiles;
 
     room.connect(async () => {
-      devSpinner.succeed("Project started in development mode!");
+      devSpinner.succeed(chalk.green("Project started in development mode!"));
 
       room.updateState("view", initialFiles);
 
       fileManager.setOnFileChange((filePath, content) => {
         const es5 = compileES5(content, filePath) ?? "";
-        console.log(`File changed: ${filePath?.replace(srcDir, ".")}`);
+        console.log(
+          chalk.yellow(`📝 File changed: ${filePath?.replace(srcDir, ".")}`)
+        );
         const updatedFiles = room.files.map((file) => {
           if (path.join(srcDir, file.path) === filePath) {
             return { ...file, content, es5 };
@@ -575,7 +622,9 @@ program
       const projectInfo = getStoredProjectId(pwd);
       if (!projectInfo) {
         console.error(
-          "Project ID not found. Please ensure hapico.config.json exists in the project directory."
+          chalk.red(
+            "✗ Project ID not found. Please ensure hapico.config.json exists in the project directory."
+          )
         );
         return;
       }
@@ -590,7 +639,9 @@ program
       );
 
       if (project.status !== 200) {
-        console.error(`Error fetching project info: ${project.statusText}`);
+        console.error(
+          chalk.red(`✗ Error fetching project info: ${project.statusText}`)
+        );
         return;
       }
 
@@ -598,10 +649,12 @@ program
 
       if (projectType === "zalominiapp") {
         QRCode.generate(
-          `https://zalo.me/s/3218692650896662017/player/${projectId}`,
+          `https://zalo.me/s/3218692650896662017/player/${projectId}?env=TESTING&version=75`,
           { small: true },
           (qrcode) => {
-            console.log("Scan this QR code to connect to the project:");
+            console.log(
+              chalk.cyan("📱 Scan this QR code to connect to the project:")
+            );
             console.log(qrcode);
           }
         );
@@ -609,71 +662,100 @@ program
       } else {
         const previewUrl = `https://com.ai.vn/dev_preview/${projectId}`;
         console.log(
-          `Open this URL in your browser to preview the project: \n${previewUrl}`
+          chalk.cyan(
+            `🌐 Open this URL in your browser to preview the project:\n${previewUrl}`
+          )
         );
         await open(previewUrl);
       }
     });
   });
 
+// Hàm tái sử dụng để push mã nguồn lên server
+async function pushProject(spinner: Ora): Promise<boolean> {
+  const data = getStoredToken();
+  const { accessToken } = data || {};
+  if (!accessToken) {
+    spinner.fail(chalk.red("✗ You need to login first. Use 'hapico login' command."));
+    return false;
+  }
+  const pwd = process.cwd();
+  const projectId = getStoredProjectId(pwd);
+  if (!projectId) {
+    spinner.fail(
+      chalk.red(
+        "✗ Project ID not found. Please ensure hapico.config.json exists in the project directory."
+      )
+    );
+    return false;
+  }
+  const srcDir: string = path.join(pwd, "src");
+  if (!fs.existsSync(srcDir)) {
+    spinner.fail(
+      chalk.red(
+        "✗ Source directory 'src' does not exist. Please clone a project first."
+      )
+    );
+    return false;
+  }
+  const fileManager = new FileManager(srcDir);
+  const files = fileManager.listFiles();
+
+  // Nếu có file .env
+  const envFile = path.join(pwd, ".env");
+  console.log(chalk.cyan(`🔍 Checking for .env file at ${envFile}`));
+  if (fs.existsSync(envFile)) {
+    console.log(chalk.green(".env file found, including in push."));
+    const content = fs.readFileSync(envFile, { encoding: "utf8" });
+    files.push({
+      path: "./.env",
+      content,
+    });
+  }
+  const apiUrl = `https://base.myworkbeast.com/api/views/${projectId}`;
+  try {
+    await axios.put(
+      apiUrl,
+      {
+        code: JSON.stringify({
+          files,
+        }),
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    return true;
+  } catch (error) {
+    spinner.fail(chalk.red(`✗ Error saving project: ${(error as Error).message}`));
+    return false;
+  }
+}
+
 program
   .command("push")
   .description("Push the project source code to the server")
-  .action(() => {
-    const data = getStoredToken();
-    const { accessToken } = data || {};
-    if (!accessToken) {
-      console.error("You need to login first. Use 'hapico login' command.");
-      return;
-    }
-    const saveSpinner: Ora = ora("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: string = path.join(pwd, "src");
-    if (!fs.existsSync(srcDir)) {
-      saveSpinner.fail(
-        "Source directory 'src' does not exist. Please clone a project first."
+  .action(async () => {
+    const saveSpinner: Ora = ora(
+      chalk.blue("Saving project source code...")
+    ).start();
+    const success = await pushProject(saveSpinner);
+    if (success) {
+      saveSpinner.succeed(
+        chalk.green("Project source code saved successfully!")
       );
-      return;
     }
-    const fileManager = new FileManager(srcDir);
-    const files = fileManager.listFiles();
-    const apiUrl = `https://base.myworkbeast.com/api/views/${projectId}`;
-    axios
-      .put(
-        apiUrl,
-        {
-          code: JSON.stringify({
-            files,
-          }),
-        },
-        {
-          headers: {
-            Authorization: `Bearer ${accessToken}`,
-            "Content-Type": "application/json",
-          },
-        }
-      )
-      .then(() => {
-        saveSpinner.succeed("Project source code saved successfully!");
-      })
-      .catch((error) => {
-        saveSpinner.fail(`Error saving project: ${error.message}`);
-      });
   });
 
 program
   .command("login")
   .description("Login to the system")
   .action(async () => {
-    console.log("Logging in to the system...");
-    const loginSpinner: Ora = ora("Initiating login...").start();
+    console.log(chalk.cyan("🔐 Logging in to the system..."));
+    const loginSpinner: Ora = ora(chalk.blue("Initiating login...")).start();
 
     try {
       const response = await axios.post(
@@ -682,14 +764,20 @@ program
       const { device_code, user_code, verification_url, expires_in, interval } =
         response.data;
 
-      loginSpinner.succeed("Login initiated!");
-      console.log(`Please open this URL in your browser: ${verification_url}`);
-      console.log(`And enter this code: ${user_code}`);
-      console.log("Waiting for authentication...");
+      loginSpinner.succeed(chalk.green("Login initiated!"));
+      console.log(
+        chalk.cyan(
+          `🌐 Please open this URL in your browser: ${verification_url}`
+        )
+      );
+      console.log(chalk.yellow(`🔑 And enter this code: ${user_code}`));
+      console.log(chalk.blue("⏳ Waiting for authentication..."));
 
       await open(verification_url);
 
-      const pollSpinner: Ora = ora("Waiting for authentication...").start();
+      const pollSpinner: Ora = ora(
+        chalk.blue("Waiting for authentication...")
+      ).start();
       let tokens = null;
       const startTime = Date.now();
       while (Date.now() - startTime < expires_in * 1000) {
@@ -709,15 +797,19 @@ program
       }
 
       if (tokens) {
-        pollSpinner.succeed("Login successful!");
+        pollSpinner.succeed(chalk.green("Login successful!"));
         saveToken(tokens);
       } else {
         pollSpinner.fail(
-          "Login failed: Timeout or user did not complete authentication."
+          chalk.red(
+            "✗ Login failed: Timeout or user did not complete authentication."
+          )
         );
       }
     } catch (error) {
-      loginSpinner.fail(`Login error: ${(error as Error).message}`);
+      loginSpinner.fail(
+        chalk.red(`✗ Login error: ${(error as Error).message}`)
+      );
     }
   });
 
@@ -727,11 +819,11 @@ program
   .action(() => {
     const accessToken = getStoredToken();
     if (!accessToken) {
-      console.log("You are not logged in.");
+      console.log(chalk.yellow("ℹ You are not logged in."));
       return;
     }
     fs.unlinkSync(TOKEN_FILE);
-    console.log("Logout successful!");
+    console.log(chalk.green("Logout successful!"));
   });
 // Pull command to fetch the latest project files from the server
 program
@@ -740,18 +832,24 @@ program
   .action(async () => {
     const token = getStoredToken();
     if (!token) {
-      console.error("You need to login first. Use 'hapico login' command.");
+      console.error(
+        chalk.red("✗ You need to login first. Use 'hapico login' command.")
+      );
       return;
     }
     const pwd: string = process.cwd();
     const projectId = getStoredProjectId(pwd);
     if (!projectId) {
       console.error(
-        "Project ID not found. Please ensure hapico.config.json exists in the project directory."
+        chalk.red(
+          "✗ Project ID not found. Please ensure hapico.config.json exists in the project directory."
+        )
       );
       return;
     }
-    const apiSpinner: Ora = ora("Fetching latest project files...").start();
+    const apiSpinner: Ora = ora(
+      chalk.blue("Fetching latest project files...")
+    ).start();
     try {
       const response: ApiResponse = await axios.get(
         `https://base.myworkbeast.com/api/views/${projectId}`,
@@ -765,12 +863,411 @@ program
       const files: FileContent[] = response.data.files || [];
       const fileManager = new FileManager(path.join(pwd, "src"));
       fileManager.syncFiles(files);
-      apiSpinner.succeed("Project files updated successfully!");
+      apiSpinner.succeed(chalk.green("Project files updated successfully!"));
     } catch (error) {
       apiSpinner.fail(
-        `Error fetching project files: ${(error as Error).message}`
+        chalk.red(`✗ Error fetching project files: ${(error as Error).message}`)
       );
     }
   });
 
-program.parse(process.argv);
+// be {{id}} --be --port {{port}}
+program
+  .command("fetch <id>")
+  .option("--port <port>", "Port to run the backend", "3000")
+  .option("--serve", "Flag to indicate serving the backend")
+  .option(
+    "--libs <libs>",
+    "Additional libraries to install (comma-separated)",
+    ""
+  )
+  .option("--be", "Flag to indicate backend")
+  .description("Open backend for the project")
+  .action(
+    async (
+      id: string,
+      options: { port: string; serve?: boolean; libs?: string; be?: boolean }
+    ) => {
+      const { accessToken } = getStoredToken();
+      if (!accessToken) {
+        console.error(
+          chalk.red("✗ You need to login first. Use 'hapico login' command.")
+        );
+        return;
+      }
+
+      console.log(chalk.cyan(`🌐 PORT = ${options.port}`));
+
+      // Chọn hỏi user port để vận hành
+      let port = 3000;
+      const response: ApiResponse = await axios.get(
+        `https://base.myworkbeast.com/api/views/${id}`
+      );
+      const portInput = options.port;
+      if (portInput) {
+        const parsedPort = parseInt(portInput, 10);
+        if (!isNaN(parsedPort)) {
+          port = parsedPort;
+        }
+      }
+
+      const projectDir: string = path.resolve(process.cwd(), id);
+      if (!fs.existsSync(projectDir)) {
+        // create folder
+        fs.mkdirSync(projectDir);
+      }
+
+      // download template https://main.hcm04.vstorage.vngcloud.vn/templates/hapico/hapico-basic.zip
+      const TEMPLATE_URL: string = `https://main.hcm04.vstorage.vngcloud.vn/templates/hapico/be.zip?t=${Date.now()}`;
+      let templateResponse = undefined;
+      try {
+        templateResponse = await axios.get(TEMPLATE_URL, {
+          responseType: "arraybuffer",
+        });
+      } catch (error) {
+        console.error(
+          chalk.red("✗ Error downloading template:"),
+          (error as Error).message
+        );
+        return;
+      }
+
+      const outputDir: string = path.resolve(process.cwd(), id);
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir);
+      }
+
+      await unzipper.Open.buffer(templateResponse.data).then((directory) =>
+        directory.extract({ path: outputDir })
+      );
+
+      const macosxDir: string = path.join(process.cwd(), id, "__MACOSX");
+      if (fs.existsSync(macosxDir)) {
+        fs.rmSync(macosxDir, { recursive: true, force: true });
+      }
+
+      // outputPath/src/server.ts có dòng (3006) thay thành port
+      const serverFile = path.join(process.cwd(), id, "src", "index.ts");
+      if (fs.existsSync(serverFile)) {
+        let serverContent = fs.readFileSync(serverFile, { encoding: "utf8" });
+        serverContent = serverContent.split("(3006)").join(`(${port})`);
+        fs.writeFileSync(serverFile, serverContent, { encoding: "utf8" });
+      }
+
+      // lấy danh sách migrations
+      const MIGRATIONS_URL = `https://base.myworkbeast.com/api/client/query?dbCode=${
+        response.data.dbCode || response.data.db_code
+      }&table=migration_logs&operation=select&columns=%5B%22*%22%5D`;
+
+      // Lấy danh sách các migration đã chạy
+      let migrations: Array<{
+        id: number;
+        created_at: string;
+        sql_statement: string;
+      }> = [];
+      const migrationsResponse = await axios.get(MIGRATIONS_URL, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+          "x-db-code": response.data.dbCode || response.data.db_code,
+        },
+      });
+      if (migrationsResponse.status === 200) {
+        migrations = (migrationsResponse.data.data?.rows || []).map(
+          (item: any) => ({
+            created_at: item.created_at,
+            sql: item.sql_statement,
+          })
+        );
+      }
+
+      console.log(chalk.cyan(`🔍 Found ${migrations.length} migrations.`));
+
+      // Tạo thư mục migrations nếu chưa tồn tại
+      const migrationsDir = path.join(process.cwd(), id, "migrations");
+      if (!fs.existsSync(migrationsDir)) {
+        fs.mkdirSync(migrationsDir);
+      }
+
+      // Lưu từng migration vào file
+      migrations.forEach((migration, index) => {
+        const timestamp = new Date(migration.created_at)
+          .toISOString()
+          .replace(/[-:]/g, "")
+          .replace(/\..+/, "");
+        const filename = path.join(
+          migrationsDir,
+          `${index + 1}_migration_${timestamp}.sql`
+        );
+        fs.writeFileSync(filename, (migration as any).sql, { encoding: "utf8" });
+      });
+
+      console.log(chalk.green("✓ Migrations saved successfully!"));
+
+      // Download project files and save to project
+      let files: FileContent[] = [];
+      const apiSpinner: Ora = ora(
+        chalk.blue("Fetching project data...")
+      ).start();
+
+      try {
+        files = response.data.files || [];
+        apiSpinner.succeed(chalk.green("Project data fetched successfully!"));
+
+        const saveSpinner: Ora = ora(
+          chalk.blue("Saving project files...")
+        ).start();
+        files.forEach((file: FileContent) => {
+          // skip ./app, ./components
+          if (
+            file.path.startsWith("./app") ||
+            file.path.startsWith("./components")
+          ) {
+            return;
+          }
+          // hoặc các file có đuôi là .tsx
+          if (file.path.endsWith(".tsx")) {
+            return;
+          }
+          try {
+            if (file.content.trim().length == 0) return;
+            const filePath: string = path.join(
+              process.cwd(),
+              id,
+              "src",
+              file.path
+            );
+            const dir: string = path.dirname(filePath);
+
+            if (!fs.existsSync(dir)) {
+              fs.mkdirSync(dir, { recursive: true });
+            }
+
+            fs.writeFileSync(filePath, file.content);
+          } catch (error) {
+            console.log(chalk.red("✗ Error writing file"), file.path, error);
+          }
+        });
+        saveSpinner.succeed(chalk.green("Project files saved successfully!"));
+      } catch (error: any) {
+        apiSpinner.fail(chalk.red(`✗ Error cloning project: ${error.message}`));
+      }
+
+      // Download project files and save to project
+      console.log(chalk.green("✓ Project cloned successfully!"));
+
+      // Save project ID to hapico.config.json
+      saveProjectId(outputDir, id);
+
+      console.log(chalk.green("✓ Project setup successfully!"));
+
+      let serveProcess: any = null;
+
+      if (options.serve) {
+        // Run bun install
+        const { exec } = require("child_process");
+        const installSpinner: Ora = ora(
+          chalk.blue("Installing dependencies...")
+        ).start();
+
+        // create a loop to check if there is new version of project
+        // https://main.hcm04.vstorage.vngcloud.vn/statics/{{id}}/version.json
+        let currentVersionStr = fs.existsSync(
+          path.join(outputDir, "version.json")
+        )
+          ? JSON.parse(
+              fs.readFileSync(path.join(outputDir, "version.json"), {
+                encoding: "utf8",
+              })
+            ).version
+          : "0.0.1";
+
+        const checkVersion = async () => {
+          try {
+            // check if file version.json exists
+            const flyCheck = await axios.head(
+              `https://statics.hcm04.vstorage.vngcloud.vn/${id}/version.json`
+            );
+            if (flyCheck.status !== 200) {
+              return;
+            }
+            // get file version.json
+            const versionResponse = await axios.get(
+              `https://statics.hcm04.vstorage.vngcloud.vn/${id}/version.json`
+            );
+            const latestVersionData = versionResponse.data;
+            const latestVersion = latestVersionData.version;
+            if (latestVersion !== currentVersionStr) {
+              console.log(
+                chalk.yellow(`📦 New version available: ${latestVersion}`)
+              );
+              // Save new version.json
+              fs.writeFileSync(
+                path.join(outputDir, "version.json"),
+                JSON.stringify(latestVersionData, null, 2),
+                { encoding: "utf8" }
+              );
+              // Install external libraries if any
+              if (
+                latestVersionData.external_libraries &&
+                latestVersionData.external_libraries.length > 0
+              ) {
+                console.log(chalk.blue("Installing new external libraries..."));
+                for (const lib of latestVersionData.external_libraries) {
+                  try {
+                    await execPromise(`bun add ${lib}`, { cwd: outputDir });
+                    console.log(chalk.green(`Added ${lib}`));
+                  } catch (addError) {
+                    console.error(
+                      chalk.red(`✗ Error adding ${lib}:`),
+                      (addError as Error).message
+                    );
+                  }
+                }
+              }
+              // Rerun bun install
+              try {
+                await execPromise("bun install", { cwd: outputDir });
+                console.log(
+                  chalk.green("Dependencies reinstalled successfully!")
+                );
+              } catch (installError) {
+                console.error(
+                  chalk.red("✗ Error reinstalling dependencies:"),
+                  (installError as Error).message
+                );
+              }
+              // Restart the process
+              if (serveProcess && !serveProcess.killed) {
+                console.log(chalk.blue("Restarting backend..."));
+                serveProcess.kill("SIGTERM");
+              }
+              // Start new process
+              const newServeProcess = exec("bun run start", { cwd: outputDir });
+              newServeProcess.stdout?.on("data", (data: any) => {
+                process.stdout.write(data);
+              });
+              newServeProcess.stderr?.on("data", (data: any) => {
+                process.stderr.write(data);
+              });
+              newServeProcess.on("close", (code: any) => {
+                console.log(
+                  chalk.yellow(`⚠ backend exited with code ${code}`)
+                );
+              });
+              serveProcess = newServeProcess;
+              currentVersionStr = latestVersion;
+            }
+          } catch (error) {
+            // If the remote version.json does not exist, do not update
+            console.error(
+              chalk.yellow("⚠ Error checking for updates (skipping update):"),
+              (error as Error).message
+            );
+          }
+        };
+
+        // check every 3 seconds
+        setInterval(async () => await checkVersion(), 10 * 1000);
+
+        exec(
+          "bun install",
+          { cwd: outputDir },
+          async (error: any, stdout: any, stderr: any) => {
+            if (error) {
+              installSpinner.fail(
+                chalk.red(`✗ Error installing dependencies: ${error.message}`)
+              );
+              return;
+            }
+            if (stderr) {
+              console.error(chalk.red(`stderr: ${stderr}`));
+            }
+            installSpinner.succeed(
+              chalk.green("Dependencies installed successfully!")
+            );
+
+            // Install additional libraries if --libs is provided
+            if (options.libs && options.libs.trim()) {
+              const libsSpinner: Ora = ora(
+                chalk.blue("Installing additional libraries...")
+              ).start();
+              const additionalLibs = options.libs
+                .split(",")
+                .map((lib) => lib.trim())
+                .filter((lib) => lib);
+              for (const lib of additionalLibs) {
+                try {
+                  await execPromise(`bun add ${lib}`, { cwd: outputDir });
+                  console.log(chalk.green(`Added ${lib}`));
+                } catch (addError) {
+                  console.error(
+                    chalk.red(`✗ Error adding ${lib}:`),
+                    (addError as Error).message
+                  );
+                }
+              }
+              libsSpinner.succeed(
+                chalk.green("Additional libraries installed successfully!")
+              );
+            }
+
+            // Run cd ${id} && bun run serve-be
+            console.log(chalk.blue("🚀 Starting backend"));
+            serveProcess = exec("bun run start", { cwd: outputDir });
+            serveProcess.stdout.on("data", (data: any) => {
+              process.stdout.write(data);
+            });
+            serveProcess.stderr.on("data", (data: any) => {
+              process.stderr.write(data);
+            });
+            serveProcess.on("close", (code: any) => {
+              console.log(chalk.yellow(`⚠ backend exited with code ${code}`));
+            });
+          }
+        );
+      }
+    }
+  );
+
+// hapico publish
+program.command("publish").action(async () => {
+  const publishSpinner: Ora = ora(chalk.blue("Publishing to Hapico...")).start();
+  // Bước 1: Push mã nguồn lên server (tái sử dụng hàm pushProject)
+  const pushSuccess = await pushProject(publishSpinner);
+  if (!pushSuccess) {
+    return; // Dừng nếu push thất bại
+  }
+
+  // Bước 2: Gọi API để publish
+  const { accessToken } = getStoredToken();
+  const pwd = process.cwd();
+  const projectId = getStoredProjectId(pwd);
+  if (!projectId) {
+    publishSpinner.fail(
+      chalk.red(
+        "✗ Project ID not found. Please ensure hapico.config.json exists in the project directory."
+      )
+    );
+    return;
+  }
+  const apiUrl = "https://base.myworkbeast.com/api/views/publish";
+  try {
+    await axios.post(
+      apiUrl,
+      { view_id: parseInt(projectId, 10) }, // Đảm bảo viewId là number
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    publishSpinner.succeed(chalk.green("Project published successfully!"));
+  } catch (error) {
+    console.log(error);
+    publishSpinner.fail(chalk.red(`✗ Error publishing project: ${(error as Error).message}`));
+  }
+});
+
+program.parse(process.argv);