nexforge-cli 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexforge-cli",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Custom Deployment CLI for NexForge",
   "main": "index.js",
   "bin": {
@@ -9,7 +9,11 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": ["cli", "deployment", "nexforge"],
+  "keywords": [
+    "cli",
+    "deployment",
+    "nexforge"
+  ],
   "author": "Manav Sharma",
   "license": "ISC",
   "type": "commonjs",
@@ -21,6 +25,7 @@
     "dotenv": "^17.4.2",
     "form-data": "^4.0.6",
     "ignore": "^7.0.5",
+    "inquirer": "^8.2.6",
     "ora": "^5.4.1",
     "socket.io-client": "^4.8.3"
   }

package/src/commands/create.js

@@ -0,0 +1,261 @@
+const fs = require("fs")
+const path = require("path")
+const chalk = require("chalk")
+const ora = require("ora")
+const inquirer = require("inquirer")
+const { execSync } = require("child_process")
+
+const BACKEND_DEPS = {
+  "@aws-sdk/client-s3": "^3.1075.0",
+  "@aws-sdk/lib-storage": "^3.1075.0",
+  "@google/genai": "^2.10.0",
+  "axios": "^1.18.0",
+  "bullmq": "^5.79.1",
+  "cookie-parser": "^1.4.7",
+  "cors": "^2.8.6",
+  "dotenv": "^17.4.2",
+  "express": "^5.2.1",
+  "express-rate-limit": "^8.5.2",
+  "extract-zip": "^2.0.1",
+  "groq-sdk": "^1.3.0",
+  "http-proxy-middleware": "^4.1.1",
+  "ioredis": "^5.11.1",
+  "jsonwebtoken": "^9.0.3",
+  "mime-types": "^3.0.2",
+  "mongoose": "^9.7.1",
+  "multer": "^2.2.0",
+  "node-cron": "^4.5.0",
+  "openai": "^6.44.0",
+  "os-utils": "^0.0.14",
+  "pm2": "^7.0.1",
+  "portfinder": "^1.0.38",
+  "redis": "^6.0.0",
+  "socket.io": "^4.8.3"
+}
+
+const FRONTEND_DEPS = {
+  "@heroicons/react": "^2.2.0",
+  "axios": "^1.18.0",
+  "clsx": "^2.1.1",
+  "framer-motion": "^12.40.0",
+  "gsap": "^3.15.0",
+  "lenis": "^1.3.23",
+  "lucide-react": "^1.21.0",
+  "react-icons": "^5.6.0",
+  "react-toastify": "^11.1.0",
+  "recharts": "^3.8.1",
+  "socket.io-client": "^4.8.3",
+  "tailwind-merge": "^3.6.0"
+}
+
+const NEXTJS_DEPS = { ...FRONTEND_DEPS, ...BACKEND_DEPS }
+
+const createFolderStructure = (baseDir, folders) => {
+  folders.forEach((folder) => {
+    fs.mkdirSync(path.join(baseDir, folder), { recursive: true })
+  })
+}
+
+const runCommand = (command, cwd) => {
+  try {
+    execSync(command, { cwd, stdio: "inherit" })
+  } catch (error) {
+    console.error(chalk.red(`Failed to execute: ${command}`))
+  }
+}
+
+const setupBackend = (targetDir) => {
+  console.log(chalk.cyan("\n🚀 Scaffolding Backend (Express/Node)..."))
+  fs.mkdirSync(targetDir, { recursive: true })
+  createFolderStructure(path.join(targetDir, "src"), [
+    "controllers",
+    "models",
+    "routes",
+    "middlewares",
+    "services",
+    "utils",
+    "config",
+  ])
+
+  const pkgJson = {
+    name: "backend",
+    version: "1.0.0",
+    main: "src/server.js",
+    scripts: {
+      dev: "nodemon src/server.js",
+      start: "node src/server.js",
+    },
+    dependencies: BACKEND_DEPS,
+    devDependencies: {
+      nodemon: "^3.1.14",
+    },
+  }
+
+  fs.writeFileSync(path.join(targetDir, "package.json"), JSON.stringify(pkgJson, null, 2))
+  fs.writeFileSync(path.join(targetDir, ".env"), "PORT=8000\nMONGO_URI=")
+  fs.writeFileSync(path.join(targetDir, ".gitignore"), "node_modules\n.env\n")
+
+  const serverJs = `const express = require('express');
+const cors = require('cors');
+require('dotenv').config();
+
+const app = express();
+app.use(cors());
+app.use(express.json());
+
+app.get('/', (req, res) => res.send('NexForge Backend API is running!'));
+
+const PORT = process.env.PORT || 8000;
+app.listen(PORT, () => console.log(\`Server running on port \${PORT}\`));
+`
+  fs.writeFileSync(path.join(targetDir, "src", "server.js"), serverJs)
+  
+  console.log(chalk.yellow("📦 Installing backend dependencies (this may take a while)..."))
+  runCommand("npm install", targetDir)
+}
+
+const setupFrontend = (targetDir) => {
+  console.log(chalk.cyan("\n⚛️ Scaffolding Frontend (React + Vite)..."))
+  runCommand(`npx create-vite@latest ${path.basename(targetDir)} --template react`, path.dirname(targetDir))
+
+  createFolderStructure(path.join(targetDir, "src"), [
+    "assets",
+    "components",
+    "hooks",
+    "lib",
+    "pages",
+    "redux",
+    "services",
+    "utils",
+  ])
+
+  // Merge package.json
+  const pkgPath = path.join(targetDir, "package.json")
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"))
+    pkg.dependencies = { ...pkg.dependencies, ...FRONTEND_DEPS, "react-router-dom": "^7.18.0" }
+    pkg.devDependencies = { ...pkg.devDependencies, tailwindcss: "^3.4.19", postcss: "^8.5.15", autoprefixer: "^10.5.0" }
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2))
+  }
+
+  // Tailwind config
+  const twConfig = `/** @type {import('tailwindcss').Config} */
+export default {
+  content: ["./index.html", "./src/**/*.{js,ts,jsx,tsx}"],
+  theme: { extend: {} },
+  plugins: [],
+}`
+  fs.writeFileSync(path.join(targetDir, "tailwind.config.js"), twConfig)
+  fs.writeFileSync(path.join(targetDir, "postcss.config.js"), `export default { plugins: { tailwindcss: {}, autoprefixer: {} } }`)
+  
+  const css = `@tailwind base;\n@tailwind components;\n@tailwind utilities;\n`
+  fs.writeFileSync(path.join(targetDir, "src", "index.css"), css)
+  
+  // Utils
+  const utilsJs = `import { clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs) {
+  return twMerge(clsx(inputs))
+}
+`
+  fs.writeFileSync(path.join(targetDir, "src", "lib", "utils.js"), utilsJs)
+
+  console.log(chalk.yellow("📦 Installing frontend dependencies..."))
+  runCommand("npm install", targetDir)
+}
+
+const setupNextJs = (targetDir) => {
+  console.log(chalk.cyan("\n🚀 Scaffolding Next.js App Router Project..."))
+  // We use npx create-next-app
+  const command = `npx create-next-app@latest ${path.basename(targetDir)} --js --tailwind --eslint --app --src-dir --import-alias "@/*"`
+  runCommand(command, path.dirname(targetDir))
+
+  // Create custom folders
+  createFolderStructure(path.join(targetDir, "src"), [
+    "app/api",
+    "components",
+    "hooks",
+    "lib",
+    "store",
+    "services",
+    "utils",
+  ])
+
+  // Merge package.json
+  const pkgPath = path.join(targetDir, "package.json")
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"))
+    pkg.dependencies = { ...pkg.dependencies, ...NEXTJS_DEPS }
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2))
+  }
+
+  const utilsJs = `import { clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs) {
+  return twMerge(clsx(inputs))
+}
+`
+  fs.writeFileSync(path.join(targetDir, "src", "lib", "utils.js"), utilsJs)
+
+  console.log(chalk.yellow("📦 Installing Next.js additional dependencies..."))
+  runCommand("npm install", targetDir)
+}
+
+module.exports = (program) => {
+  program
+    .command("create")
+    .description("Generate a standardized project with industry folders and NexForge libraries")
+    .action(async () => {
+      console.log(chalk.cyan("✨ Welcome to NexForge Project Generator!\n"))
+      
+      const answers = await inquirer.prompt([
+        {
+          type: "input",
+          name: "projectName",
+          message: "What is your project name?",
+          validate: (input) => (input ? true : "Project name cannot be empty!"),
+        },
+        {
+          type: "list",
+          name: "template",
+          message: "Which stack would you like to use?",
+          choices: [
+            "MERN Stack (Fullstack with /frontend and /backend)",
+            "Next.js (App Router)",
+            "Frontend Only (React + Vite)",
+            "Backend Only (Node + Express)",
+          ],
+        },
+      ])
+
+      const { projectName, template } = answers
+      const targetDir = path.join(process.cwd(), projectName)
+
+      if (fs.existsSync(targetDir)) {
+        console.log(chalk.red(`\n❌ Directory ${projectName} already exists. Please choose a different name.`))
+        return
+      }
+
+      fs.mkdirSync(targetDir, { recursive: true })
+
+      if (template.includes("Backend Only")) {
+        setupBackend(targetDir)
+      } else if (template.includes("Frontend Only")) {
+        setupFrontend(targetDir)
+      } else if (template.includes("Next.js")) {
+        setupNextJs(targetDir)
+      } else if (template.includes("MERN Stack")) {
+        console.log(chalk.magenta("\n🔥 Generating MERN Stack..."))
+        setupBackend(path.join(targetDir, "backend"))
+        setupFrontend(path.join(targetDir, "frontend"))
+      }
+
+      console.log(chalk.green(`\n🎉 Project ${projectName} created successfully!`))
+      console.log(chalk.white(`\n👉 Next steps:`))
+      console.log(chalk.cyan(`   cd ${projectName}`))
+      console.log(chalk.cyan(`   nexforge init (to link with NexForge Platform)`))
+      console.log(chalk.cyan(`   nexforge deploy\n`))
+    })
+}

package/src/commands/deploy.js

@@ -0,0 +1,124 @@
+const fs = require("fs")
+const path = require("path")
+const chalk = require("chalk")
+const ora = require("ora")
+const archiver = require("archiver")
+const FormData = require("form-data")
+const { axios, API_BASE_URL, CONFIG_FILE } = require("../config")
+
+module.exports = (program) => {
+  program
+    .command("deploy")
+    .description("Deploy the current directory to NexForge")
+    .action(async () => {
+      // First we check if they are logged in by reading the config file
+      if (!fs.existsSync(CONFIG_FILE)) {
+        console.log(
+          chalk.red(
+            "❌ You are not logged in. Please run `nexforge login` first.",
+          ),
+        )
+        return
+      }
+
+      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"))
+      const projectId = config.projectId
+
+      const spinner = ora("Packaging your project...").start()
+      const zipPath = path.join(process.cwd(), "nexforge-build.zip")
+
+      try {
+        // We create a write stream to zip the contents of the current folder
+        const output = fs.createWriteStream(zipPath)
+        const archive = archiver("zip", { zlib: { level: 9 } }) // Maximum compression
+
+        // We need to wait for the archive to finish writing
+        const archivePromise = new Promise((resolve, reject) => {
+          output.on("close", resolve)
+          archive.on("error", reject)
+        })
+
+        archive.pipe(output)
+
+        // We grab everything in the current directory EXCEPT node_modules and hidden files
+        // Skipping node_modules is super important otherwise the upload would take forever
+        archive.glob("**/*", {
+          cwd: process.cwd(),
+          ignore: ["node_modules/**", ".git/**", "nexforge-build.zip", ".env"],
+        })
+
+        await archive.finalize()
+        await archivePromise
+
+        spinner.text = "Uploading to NexForge servers..."
+
+        // Now we prepare the multipart form-data request to send the zip file
+        const formData = new FormData()
+        formData.append("projectZip", fs.createReadStream(zipPath))
+
+        const response = await axios.post(
+          `${API_BASE_URL}/cli/deploy/${projectId}`,
+          formData,
+          {
+            headers: {
+              ...formData.getHeaders(),
+            },
+          },
+        )
+
+        spinner.succeed(chalk.green("🎉 Deployment queued successfully!"))
+        console.log(chalk.cyan(`Live URL: ${response.data.liveUrl}`))
+        console.log(chalk.gray(`Streaming live build logs...\n`))
+
+        // Automatically stream logs after deployment
+        const io = require("socket.io-client")
+        const socket = io(API_BASE_URL.replace("/api", ""), {
+          transports: ["websocket", "polling"],
+        })
+
+        socket.emit("joinProject", projectId)
+
+        socket.on("new-log", (entry) => {
+          const color =
+            entry.level === "ERROR"
+              ? chalk.red
+              : entry.level === "WARN"
+                ? chalk.yellow
+                : chalk.white
+          console.log(
+            color(
+              `[${new Date(entry.timestamp).toLocaleTimeString()}] ${entry.message}`,
+            ),
+          )
+        })
+
+        socket.on("status-change", (data) => {
+          if (data.status === "LIVE") {
+            console.log(chalk.green(`\n✅ Deployment successful and Live!`))
+            socket.disconnect()
+            process.exit(0)
+          } else if (data.status === "FAILED") {
+            console.log(chalk.red(`\n❌ Deployment failed!`))
+            socket.disconnect()
+            process.exit(1)
+          }
+        })
+      } catch (error) {
+        spinner.fail(chalk.red("Deployment failed!"))
+
+        // If our API returned a specific error message we want to show that to the user
+        if (error.response && error.response.data) {
+          console.log(
+            chalk.red(`Server Error: ${JSON.stringify(error.response.data)}`),
+          )
+        } else {
+          console.error(error.message)
+        }
+      } finally {
+        // Clean up the temporary zip file so we don't leave trash on the user's PC
+        if (fs.existsSync(zipPath)) {
+          fs.unlinkSync(zipPath)
+        }
+      }
+    })
+}

package/src/commands/env.js

@@ -0,0 +1,102 @@
+const fs = require("fs")
+const path = require("path")
+const chalk = require("chalk")
+const ora = require("ora")
+const { axios, API_BASE_URL, CONFIG_FILE } = require("../config")
+
+module.exports = (program) => {
+  const envCommand = program
+    .command("env")
+    .description("Manage your environment variables")
+
+  envCommand
+    .command("push")
+    .description("Push local .env file to NexForge")
+    .action(async () => {
+      if (!fs.existsSync(CONFIG_FILE)) {
+        console.log(
+          chalk.red(
+            "❌ You are not logged in. Please run `nexforge login` first.",
+          ),
+        )
+        return
+      }
+
+      const envPath = path.join(process.cwd(), ".env")
+      if (!fs.existsSync(envPath)) {
+        console.log(chalk.red("❌ No .env file found in the current directory."))
+        return
+      }
+
+      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"))
+      const projectId = config.projectId
+
+      const spinner = ora("Pushing environment variables...").start()
+      try {
+        const dotenv = require("dotenv")
+        const envConfig = dotenv.parse(fs.readFileSync(envPath))
+
+        const envs = Object.keys(envConfig).map((key) => ({
+          key,
+          value: envConfig[key],
+        }))
+
+        await axios.post(`${API_BASE_URL}/cli/env/push/${projectId}`, { envs })
+
+        spinner.succeed(
+          chalk.green("🎉 Environment variables pushed successfully!"),
+        )
+      } catch (error) {
+        spinner.fail(chalk.red("Failed to push environment variables!"))
+        console.error(error.message)
+      }
+    })
+
+  envCommand
+    .command("pull")
+    .description("Pull environment variables from NexForge to local .env")
+    .action(async () => {
+      if (!fs.existsSync(CONFIG_FILE)) {
+        console.log(
+          chalk.red(
+            "❌ You are not logged in. Please run `nexforge login` first.",
+          ),
+        )
+        return
+      }
+
+      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"))
+      const projectId = config.projectId
+
+      const spinner = ora("Pulling environment variables...").start()
+      try {
+        const response = await axios.get(
+          `${API_BASE_URL}/cli/env/pull/${projectId}`,
+        )
+        const envs = response.data.envs
+
+        if (!envs || envs.length === 0) {
+          spinner.info(
+            chalk.yellow("No environment variables found on the server."),
+          )
+          return
+        }
+
+        let envContent = ""
+        envs.forEach((e) => {
+          envContent += `${e.key}=${e.value}\n`
+        })
+
+        const envPath = path.join(process.cwd(), ".env")
+        fs.writeFileSync(envPath, envContent)
+
+        spinner.succeed(
+          chalk.green("🎉 Environment variables pulled successfully!"),
+        )
+        console.log(chalk.cyan(`Saved to ${envPath}`))
+      } catch (error) {
+        spinner.fail(chalk.red("Failed to pull environment variables!"))
+        console.error(error.message)
+      }
+    })
+}

package/src/commands/init.js

@@ -0,0 +1,97 @@
+const fs = require("fs")
+const chalk = require("chalk")
+const ora = require("ora")
+const { axios, API_BASE_URL, CONFIG_DIR, CONFIG_FILE } = require("../config")
+
+module.exports = (program) => {
+  program
+    .command("init")
+    .description("Initialize a new NexForge project in the current directory")
+    .action(async () => {
+      const readline = require("readline").createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      })
+
+      console.log(chalk.cyan("✨ Let's set up a new NexForge project!"))
+
+      readline.question(
+        "What is your project name? (e.g. my-app): ",
+        async (projectName) => {
+          if (!projectName) {
+            console.log(chalk.red("Project name cannot be empty!"))
+            readline.close()
+            return
+          }
+
+          readline.question(
+            "What framework are you using? (React, Vue, Express, Node, Next.js): ",
+            async (framework) => {
+              if (!framework) {
+                console.log(chalk.red("Framework cannot be empty!"))
+                readline.close()
+                return
+              }
+
+              const spinner = ora(
+                "Creating project on NexForge servers...",
+              ).start()
+
+              try {
+                const response = await axios.post(`${API_BASE_URL}/cli/init`, {
+                  projectName,
+                  framework,
+                  projectType: ["express", "node"].includes(
+                    framework.toLowerCase(),
+                  )
+                    ? "NODE"
+                    : "STATIC",
+                })
+
+                const { projectId } = response.data
+
+                // Ensure the config directory exists before saving
+                if (!fs.existsSync(CONFIG_DIR)) {
+                  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+                }
+
+                // We preserve the existing CLI Token if it exists, and just update the projectId
+                let currentConfig = {}
+                if (fs.existsSync(CONFIG_FILE)) {
+                  currentConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"))
+                }
+
+                fs.writeFileSync(
+                  CONFIG_FILE,
+                  JSON.stringify({ ...currentConfig, projectId }),
+                )
+
+                spinner.succeed(chalk.green("🎉 Project created successfully!"))
+                console.log(
+                  chalk.cyan(`Project ID: ${projectId} has been saved locally.`),
+                )
+                console.log(
+                  chalk.yellow(
+                    `You can now run \`nexforge deploy\` to push your code.`,
+                  ),
+                )
+              } catch (error) {
+                spinner.fail(chalk.red("Failed to create project!"))
+                if (error.response && error.response.data) {
+                  console.log(
+                    chalk.red(
+                      `Server Error: ${JSON.stringify(error.response.data)}`,
+                    ),
+                  )
+                } else {
+                  console.error(error.message)
+                }
+              } finally {
+                readline.close()
+              }
+            },
+          )
+        },
+      )
+    })
+}

package/src/commands/login.js

@@ -0,0 +1,50 @@
+const fs = require("fs")
+const chalk = require("chalk")
+const { CONFIG_DIR, CONFIG_FILE } = require("../config")
+
+module.exports = (program) => {
+  program
+    .command("login")
+    .description("Log in to your NexForge account")
+    .action(async () => {
+      const readline = require("readline").createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      })
+
+      console.log(chalk.cyan("🚀 Welcome to NexForge CLI!"))
+
+      readline.question(
+        "Please enter your personal CLI Token (Generate this from Dashboard Settings): ",
+        (cliToken) => {
+          if (!cliToken) {
+            console.log(chalk.red("CLI Token cannot be empty!"))
+            readline.close()
+            return
+          }
+
+          readline.question("Please enter your Project ID: ", (projectId) => {
+            if (!projectId) {
+              console.log(chalk.red("Project ID cannot be empty!"))
+              readline.close()
+              return
+            }
+
+            if (!fs.existsSync(CONFIG_DIR)) {
+              fs.mkdirSync(CONFIG_DIR, { recursive: true })
+            }
+
+            // Save both Token and Project ID
+            fs.writeFileSync(CONFIG_FILE, JSON.stringify({ cliToken, projectId }))
+
+            console.log(
+              chalk.green(
+                "✅ Successfully logged in! You can now run `nexforge deploy`",
+              ),
+            )
+            readline.close()
+          })
+        },
+      )
+    })
+}