@hapico/cli 0.0.16 → 0.0.18

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 inquirer from "inquirer";
+import { exec } from "child_process";
+import { promisify } from "util";
+import chalk from "chalk";
+
+// 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,23 +304,25 @@ class RoomState {
     }
 
     this.ws = new WebSocket(
-      `https://base.myworkbeast.com/ws?room=${this.roomId}`
+      `https://ws2.myworkbeast.com/ws?room=${this.roomId}`
     );
 
     this.ws.onopen = () => {
-      console.log(`Connected to room: ${this.roomId}`);
+      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}`);
+      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),
@@ -360,12 +377,12 @@ 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();
     });
   }
@@ -400,7 +417,7 @@ class RoomState {
   }
 }
 
-program.version("0.0.16").description("Hapico CLI for project management");
+program.version("0.0.18").description("Hapico CLI for project management");
 
 program
   .command("clone <id>")
@@ -408,43 +425,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 +477,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 +492,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 +509,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 +573,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 +610,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 +627,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;
       }
 
@@ -601,7 +640,9 @@ program
           `https://zalo.me/s/3218692650896662017/player/${projectId}`,
           { 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,7 +650,9 @@ 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);
       }
@@ -623,27 +666,47 @@ program
     const data = getStoredToken();
     const { accessToken } = data || {};
     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 saveSpinner: Ora = ora("Saving project source code...").start();
+    const saveSpinner: Ora = ora(
+      chalk.blue("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."
+        chalk.red(
+          "✗ 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."
+        chalk.red(
+          "✗ Source directory 'src' does not exist. Please clone a project first."
+        )
       );
       return;
     }
     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}`;
     axios
       .put(
@@ -661,10 +724,12 @@ program
         }
       )
       .then(() => {
-        saveSpinner.succeed("Project source code saved successfully!");
+        saveSpinner.succeed(
+          chalk.green("Project source code saved successfully!")
+        );
       })
       .catch((error) => {
-        saveSpinner.fail(`Error saving project: ${error.message}`);
+        saveSpinner.fail(chalk.red(`✗ Error saving project: ${error.message}`));
       });
   });
 
@@ -672,8 +737,8 @@ 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 +747,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 +780,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 +802,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 +815,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 +846,371 @@ 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}`)
       );
     }
   });
 
+// 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}`));
+            });
+          }
+        );
+      }
+    }
+  );
+
 program.parse(process.argv);