vortix 1.0.4 → 1.1.0

package/agent/agent.js

@@ -4,6 +4,7 @@ const os = require("os");
 const readline = require("readline");
 const fs = require("fs");
 const path = require("path");
+const screenshot = require("screenshot-desktop");
 
 process.on("uncaughtException", (err) => {
   console.error("Uncaught Exception:", err);
@@ -15,6 +16,12 @@ process.on("unhandledRejection", (err) => {
 
 const CONFIG_FILE = path.join(os.homedir(), '.vortix-config.json');
 
+// Detect platform
+const PLATFORM = os.platform(); // 'win32', 'darwin', 'linux'
+const IS_WINDOWS = PLATFORM === 'win32';
+const IS_MAC = PLATFORM === 'darwin';
+const IS_LINUX = PLATFORM === 'linux';
+
 // Load or create config
 function loadConfig() {
   try {
@@ -75,9 +82,27 @@ if (command === "start") {
   return;
 }
 
+if (command === "enable-autostart") {
+  enableAutoStart();
+  return;
+}
+
+if (command === "disable-autostart") {
+  disableAutoStart();
+  return;
+}
+
+if (command === "status") {
+  checkAutoStartStatus();
+  return;
+}
+
 console.log("Available commands:");
-console.log("  vortix login  - Set device password");
-console.log("  vortix start  - Start the agent");
+console.log("  vortix login             - Set device password");
+console.log("  vortix start             - Start the agent");
+console.log("  vortix enable-autostart  - Enable auto-start on system boot");
+console.log("  vortix disable-autostart - Disable auto-start");
+console.log("  vortix status            - Check auto-start status");
 
 function startAgent() {
   const config = loadConfig();
@@ -92,179 +117,840 @@ function startAgent() {
   const token = `${deviceToken}:${config.password}`;
 
   console.log(`Device: ${deviceName}`);
+  console.log(`Platform: ${PLATFORM} (${IS_WINDOWS ? 'Windows' : IS_MAC ? 'macOS' : IS_LINUX ? 'Linux' : 'Unknown'})`);
   console.log("Connecting to backend...");
 
-  // Production backend URL - Render deployment
+  // Backend URL - supports both local and production
+  // For production: set BACKEND_URL environment variable
+  // For local: defaults to ws://localhost:8080
   const BACKEND_URL = process.env.BACKEND_URL || 'wss://vortix.onrender.com';
+  console.log(`Backend URL: ${BACKEND_URL}`);
 
-  const ws = new WebSocket(`${BACKEND_URL}?token=${encodeURIComponent(token)}`);
+  let ws = null;
+  let screenCaptureInterval = null;
+  let reconnectTimeout = null;
+  let isIntentionalClose = false;
 
-  ws.on("open", () => {
-    console.log("Authenticated and connected to backend");
+  function connect() {
+    console.log(`Attempting connection to: ${BACKEND_URL}`);
+    ws = new WebSocket(`${BACKEND_URL}?token=${encodeURIComponent(token)}`);
 
-    setInterval(() => {
-      if (ws.readyState === WebSocket.OPEN) {
-        console.log("Sending heartbeat...");
-        ws.send(
-          JSON.stringify({
-            type: "HEARTBEAT"
-          })
-        );
-      }
-    }, 5000);
-  });
+    ws.on("open", () => {
+      console.log("✅ Authenticated and connected to backend successfully!");
+      console.log(`Connected to: ${BACKEND_URL}`);
 
-  ws.on("close", () => {
-    console.log("Disconnected from backend");
-  });
+      // Clear any reconnect timeout
+      if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = null;
+      }
 
-  ws.on("error", (err) => {
-    console.error("WebSocket error:", err.message);
-  });
+      // Send platform info immediately on connection
+      ws.send(
+        JSON.stringify({
+          type: "HEARTBEAT",
+          platform: PLATFORM
+        })
+      );
+
+      // Then send heartbeat every 5 seconds
+      setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          console.log("Sending heartbeat...");
+          ws.send(
+            JSON.stringify({
+              type: "HEARTBEAT",
+              platform: PLATFORM
+            })
+          );
+        }
+      }, 5000);
+    });
 
-  let commandQueue = [];
-  let isRunning = false;
-  let currentCwd = require("os").homedir(); // Track current working directory
+    ws.on("close", (code, reason) => {
+      console.log("Disconnected from backend");
+      console.log(`Close code: ${code}, Reason: ${reason || 'No reason provided'}`);
 
-  ws.on("message", (message) => {
-    try {
-      const data = JSON.parse(message.toString());
+      // Clean up screen capture
+      if (screenCaptureInterval) {
+        clearInterval(screenCaptureInterval);
+        screenCaptureInterval = null;
+      }
 
-      if (data.type === "EXECUTE") {
-        console.log("Agent received EXECUTE:", data.command);
-        commandQueue.push(data.command);
-        processQueue();
+      // Auto-reconnect unless it was intentional
+      if (!isIntentionalClose) {
+        console.log("Attempting to reconnect in 5 seconds...");
+        reconnectTimeout = setTimeout(() => {
+          console.log("Reconnecting...");
+          connect();
+        }, 5000);
       }
+    });
 
-    } catch (err) {
-      console.error("Invalid message received:", message.toString());
-    }
-  });
+    ws.on("error", (err) => {
+      console.error("=".repeat(50));
+      console.error("❌ WebSocket Connection Error!");
+      console.error("Error:", err.message);
+      console.error("Trying to connect to:", BACKEND_URL);
+      console.error("=".repeat(50));
+      console.error("Troubleshooting:");
+      console.error("1. Make sure backend is running: cd backend && npm start");
+      console.error("2. Backend should show: 'Backend running on port 8080'");
+      console.error("3. Check if port 8080 is open: netstat -an | findstr :8080");
+      console.error("4. Verify BACKEND_URL environment variable (if set)");
+      console.error("=".repeat(50));
+    });
+
+    let commandQueue = [];
+    let isRunning = false;
+    let currentCwd = require("os").homedir(); // Track current working directory
+
+    ws.on("message", (message) => {
+      try {
+        const data = JSON.parse(message.toString());
+
+        if (data.type === "EXECUTE") {
+          console.log("Agent received EXECUTE:", data.command);
+          commandQueue.push(data.command);
+          processQueue();
+        }
+
+        if (data.type === "START_SCREEN_CAPTURE") {
+          console.log("🎥 Starting screen capture...");
+          if (!screenCaptureInterval) {
+            screenCaptureInterval = setInterval(async () => {
+              try {
+                console.log("📸 Capturing frame...");
+                const img = await screenshot({ format: 'jpg' });
+                const base64 = img.toString('base64');
+                console.log(`✅ Frame captured: ${img.length} bytes, base64: ${base64.length} chars`);
+
+                if (ws.readyState === WebSocket.OPEN) {
+                  ws.send(JSON.stringify({
+                    type: "SCREEN_FRAME",
+                    frame: base64
+                  }));
+                  console.log("📤 Frame sent to backend");
+                } else {
+                  console.log("⚠️ WebSocket not open, skipping frame");
+                }
+              } catch (err) {
+                console.error("❌ Screen capture error:", err.message);
+                console.error(err.stack);
+              }
+            }, 1000); // Capture every 1 second
+            console.log("✅ Screen capture interval started");
+          } else {
+            console.log("⚠️ Screen capture already running");
+          }
+        }
+
+        if (data.type === "STOP_SCREEN_CAPTURE") {
+          console.log("Stopping screen capture...");
+          if (screenCaptureInterval) {
+            clearInterval(screenCaptureInterval);
+            screenCaptureInterval = null;
+          }
+        }
+
+        if (data.type === "ENABLE_AUTOSTART") {
+          console.log("Received request to enable auto-start...");
+          try {
+            enableAutoStart();
+            ws.send(JSON.stringify({
+              type: "AUTOSTART_STATUS",
+              enabled: true,
+              message: "Auto-start enabled successfully"
+            }));
+          } catch (err) {
+            ws.send(JSON.stringify({
+              type: "AUTOSTART_ERROR",
+              message: err.message
+            }));
+          }
+        }
+
+        if (data.type === "DISABLE_AUTOSTART") {
+          console.log("Received request to disable auto-start...");
+          try {
+            disableAutoStart();
+            ws.send(JSON.stringify({
+              type: "AUTOSTART_STATUS",
+              enabled: false,
+              message: "Auto-start disabled successfully"
+            }));
+          } catch (err) {
+            ws.send(JSON.stringify({
+              type: "AUTOSTART_ERROR",
+              message: err.message
+            }));
+          }
+        }
+
+        if (data.type === "GET_AUTOSTART_STATUS") {
+          const config = loadConfig();
+          ws.send(JSON.stringify({
+            type: "AUTOSTART_STATUS",
+            enabled: config.autoStart || false
+          }));
+        }
 
-  function extractDirectoryFromCommand(command) {
-    // Check for cd commands and extract the target directory
-    // Handle: cd /d D:, cd /D D:\, cd D:\folder, etc.
-
-    // Match: cd /d D: or cd /D D: or similar
-    let match = command.match(/^\s*cd\s+\/[dD]\s+([^\s]+)\s*$/i);
-    if (match) {
-      let path = match[1].trim();
-      path = expandPath(path);
-      // Ensure it ends with backslash if it's just a drive letter
-      if (/^[A-Za-z]:$/.test(path)) {
-        path = path + "\\";
+        // System stats
+        if (data.type === "GET_SYSTEM_STATS") {
+          const os = require('os');
+          const { exec } = require('child_process');
+
+          // Get accurate CPU usage (measure over 500ms for faster response)
+          const getCPUUsage = () => {
+            return new Promise((resolve) => {
+              if (IS_WINDOWS) {
+                // Windows: Use wmic for more accurate CPU reading
+                exec('wmic cpu get loadpercentage', (err, stdout) => {
+                  if (err) {
+                    console.error("Error getting CPU usage:", err);
+                    // Fallback to Node.js method
+                    fallbackCPUMeasure(resolve);
+                    return;
+                  }
+
+                  const lines = stdout.trim().split('\n');
+                  if (lines.length >= 2) {
+                    const cpuLoad = parseInt(lines[1].trim());
+                    if (!isNaN(cpuLoad)) {
+                      resolve(cpuLoad);
+                      return;
+                    }
+                  }
+                  fallbackCPUMeasure(resolve);
+                });
+              } else {
+                // Mac/Linux: Use Node.js method
+                fallbackCPUMeasure(resolve);
+              }
+            });
+          };
+
+          const fallbackCPUMeasure = (resolve) => {
+            const startMeasure = os.cpus();
+
+            setTimeout(() => {
+              const endMeasure = os.cpus();
+
+              let totalIdle = 0;
+              let totalTick = 0;
+
+              for (let i = 0; i < startMeasure.length; i++) {
+                const start = startMeasure[i].times;
+                const end = endMeasure[i].times;
+
+                const idleDiff = end.idle - start.idle;
+                const totalDiff =
+                  (end.user - start.user) +
+                  (end.nice - start.nice) +
+                  (end.sys - start.sys) +
+                  (end.idle - start.idle) +
+                  (end.irq - start.irq);
+
+                totalIdle += idleDiff;
+                totalTick += totalDiff;
+              }
+
+              const cpuUsage = 100 - (100 * totalIdle / totalTick);
+              resolve(Math.round(cpuUsage));
+            }, 500);
+          };
+
+          // Get accurate disk usage
+          const getDiskUsage = () => {
+            return new Promise((resolve) => {
+              if (IS_WINDOWS) {
+                // Windows: Get C: drive usage
+                exec('wmic logicaldisk where "DeviceID=\'C:\'" get Size,FreeSpace', (err, stdout) => {
+                  if (err) {
+                    console.error("Error getting disk usage:", err);
+                    resolve(0);
+                    return;
+                  }
+
+                  const lines = stdout.trim().split('\n');
+                  if (lines.length >= 2) {
+                    const values = lines[1].trim().split(/\s+/);
+                    if (values.length >= 2) {
+                      const freeSpace = parseInt(values[0]);
+                      const totalSpace = parseInt(values[1]);
+                      const usedSpace = totalSpace - freeSpace;
+                      const diskUsage = (usedSpace / totalSpace) * 100;
+                      resolve(Math.round(diskUsage));
+                      return;
+                    }
+                  }
+                  resolve(0);
+                });
+              } else if (IS_MAC || IS_LINUX) {
+                // Mac/Linux: Get root partition usage
+                exec('df -h / | tail -1', (err, stdout) => {
+                  if (err) {
+                    console.error("Error getting disk usage:", err);
+                    resolve(0);
+                    return;
+                  }
+
+                  const parts = stdout.trim().split(/\s+/);
+                  if (parts.length >= 5) {
+                    const usagePercent = parts[4].replace('%', '');
+                    resolve(parseInt(usagePercent));
+                    return;
+                  }
+                  resolve(0);
+                });
+              } else {
+                resolve(0);
+              }
+            });
+          };
+
+          // Get all stats
+          Promise.all([
+            getCPUUsage(),
+            getDiskUsage()
+          ]).then(([cpuUsage, diskUsage]) => {
+            const totalMem = os.totalmem();
+            const freeMem = os.freemem();
+            const memoryUsage = ((totalMem - freeMem) / totalMem) * 100;
+
+            const statsData = {
+              cpu: cpuUsage,
+              memory: Math.round(memoryUsage),
+              disk: diskUsage
+            };
+
+            ws.send(JSON.stringify({
+              type: "SYSTEM_STATS",
+              stats: statsData
+            }));
+          }).catch(err => {
+            console.error("Error collecting stats:", err);
+            // Send fallback data
+            const totalMem = os.totalmem();
+            const freeMem = os.freemem();
+            const memoryUsage = ((totalMem - freeMem) / totalMem) * 100;
+
+            ws.send(JSON.stringify({
+              type: "SYSTEM_STATS",
+              stats: {
+                cpu: 0,
+                memory: Math.round(memoryUsage),
+                disk: 0
+              }
+            }));
+          });
+        }
+
+        // File browsing
+        if (data.type === "BROWSE_FILES") {
+          const fs = require('fs');
+          const path = require('path');
+
+          let targetPath = data.path || os.homedir();
+
+          // Handle special paths
+          if (targetPath === "Desktop") {
+            targetPath = path.join(os.homedir(), "Desktop");
+          } else if (targetPath === "Downloads") {
+            targetPath = path.join(os.homedir(), "Downloads");
+          } else if (targetPath === "Documents") {
+            targetPath = path.join(os.homedir(), "Documents");
+          }
+
+          try {
+            const items = fs.readdirSync(targetPath);
+            const files = items.map(item => {
+              const fullPath = path.join(targetPath, item);
+              const stats = fs.statSync(fullPath);
+              return {
+                name: item,
+                type: stats.isDirectory() ? "directory" : "file",
+                size: stats.isFile() ? stats.size : undefined,
+                path: fullPath
+              };
+            });
+
+            console.log(`Agent: Sending FILE_LIST for ${targetPath} with ${files.length} items`);
+            ws.send(JSON.stringify({
+              type: "FILE_LIST",
+              files,
+              path: targetPath
+            }));
+          } catch (err) {
+            console.error("Error browsing files:", err.message);
+            ws.send(JSON.stringify({
+              type: "FILE_LIST",
+              files: [],
+              path: targetPath,
+              error: err.message
+            }));
+          }
+        }
+
+        // File upload
+        if (data.type === "UPLOAD_FILE") {
+          const fs = require('fs');
+          const path = require('path');
+
+          let targetPath = data.targetPath || os.homedir();
+          if (targetPath === "Desktop") {
+            targetPath = path.join(os.homedir(), "Desktop");
+          } else if (targetPath === "Downloads") {
+            targetPath = path.join(os.homedir(), "Downloads");
+          } else if (targetPath === "Documents") {
+            targetPath = path.join(os.homedir(), "Documents");
+          }
+
+          const filePath = path.join(targetPath, data.fileName);
+          const fileBuffer = Buffer.from(data.fileData, 'base64');
+
+          try {
+            fs.writeFileSync(filePath, fileBuffer);
+            console.log(`Agent: File uploaded successfully: ${filePath}`);
+            ws.send(JSON.stringify({
+              type: "LOG",
+              deviceName,
+              message: `✓ File uploaded: ${data.fileName} to ${targetPath}`
+            }));
+          } catch (err) {
+            console.error("Agent: Error uploading file:", err.message);
+            ws.send(JSON.stringify({
+              type: "LOG",
+              deviceName,
+              message: `✗ Upload failed: ${err.message}`
+            }));
+          }
+        }
+
+        // File download
+        if (data.type === "DOWNLOAD_FILE") {
+          const fs = require('fs');
+
+          try {
+            const fileBuffer = fs.readFileSync(data.filePath);
+            const base64 = fileBuffer.toString('base64');
+            const fileName = require('path').basename(data.filePath);
+
+            ws.send(JSON.stringify({
+              type: "FILE_DATA",
+              fileName,
+              fileData: base64
+            }));
+
+            console.log(`File downloaded: ${data.filePath}`);
+          } catch (err) {
+            console.error("Error downloading file:", err.message);
+            ws.send(JSON.stringify({
+              type: "LOG",
+              deviceName,
+              message: `✗ Download failed: ${err.message}`
+            }));
+          }
+        }
+
+      } catch (err) {
+        console.error("Invalid message received:", message.toString());
       }
-      console.log("CD detected, new path:", path);
-      return path;
-    }
+    });
+
+    function extractDirectoryFromCommand(command) {
+      // Check for cd commands and extract the target directory
+      // Handle: cd /d D:, cd /D D:\, cd D:\folder, etc.
 
-    // Match: cd D:\folder or cd folder
-    match = command.match(/^\s*cd\s+([^\s][^\s]*)\s*$/i);
-    if (match) {
-      let path = match[1].trim();
-      path = expandPath(path);
-      // Only treat as cd if it looks like a path (has : or starts with \)
-      if (/[:\\]/.test(path)) {
+      // Match: cd /d D: or cd /D D: or similar
+      let match = command.match(/^\s*cd\s+\/[dD]\s+([^\s]+)\s*$/i);
+      if (match) {
+        let path = match[1].trim();
+        path = expandPath(path);
+        // Ensure it ends with backslash if it's just a drive letter
         if (/^[A-Za-z]:$/.test(path)) {
           path = path + "\\";
         }
         console.log("CD detected, new path:", path);
         return path;
       }
+
+      // Match: cd D:\folder or cd folder
+      match = command.match(/^\s*cd\s+([^\s][^\s]*)\s*$/i);
+      if (match) {
+        let path = match[1].trim();
+        path = expandPath(path);
+        // Only treat as cd if it looks like a path (has : or starts with \)
+        if (/[:\\]/.test(path)) {
+          if (/^[A-Za-z]:$/.test(path)) {
+            path = path + "\\";
+          }
+          console.log("CD detected, new path:", path);
+          return path;
+        }
+      }
+
+      return null;
+    }
+
+    function expandPath(path) {
+      // Expand environment variables
+      if (path.includes("%USERPROFILE%")) {
+        path = path.replace(/%USERPROFILE%/gi, os.homedir());
+      }
+      if (path.includes("%HOMEPATH%")) {
+        path = path.replace(/%HOMEPATH%/gi, os.homedir());
+      }
+      if (path.includes("%HOMEDRIVE%")) {
+        const homedir = os.homedir();
+        const drive = homedir.split("\\")[0];
+        path = path.replace(/%HOMEDRIVE%/gi, drive);
+      }
+      return path;
     }
 
-    return null;
+    function processQueue() {
+      if (isRunning || commandQueue.length === 0) return;
+
+      isRunning = true;
+      let command = commandQueue.shift();
+
+      console.log("Executing command:", command);
+
+      // Update current working directory if this is a cd command
+      const newCwd = extractDirectoryFromCommand(command);
+      if (newCwd) {
+        currentCwd = newCwd;
+        ws.send(JSON.stringify({ type: "LOG", deviceName, message: `Directory changed to: ${currentCwd}` }));
+        console.log("Directory state updated to:", currentCwd);
+      }
+
+      // report current cwd for diagnostics
+      ws.send(JSON.stringify({ type: "LOG", deviceName, message: `Working from: ${currentCwd}` }));
+      ws.send(JSON.stringify({ type: "LOG", deviceName, message: `Executing: ${command}` }));
+
+      // Platform-specific shell
+      const shell = IS_WINDOWS ? "cmd.exe" : IS_MAC || IS_LINUX ? "/bin/bash" : "sh";
+      const shellFlag = IS_WINDOWS ? "/c" : "-c";
+
+      // Use platform-appropriate shell
+      const process = exec(command, {
+        cwd: currentCwd,
+        shell: shell,
+        maxBuffer: 10 * 1024 * 1024,  // 10MB buffer for large outputs
+        encoding: "utf8"
+      });
+
+      // Track if we've received any output
+      let hasOutput = false;
+
+      process.stdout.on("data", (data) => {
+        hasOutput = true;
+        ws.send(JSON.stringify({
+          type: "LOG",
+          deviceName,
+          message: data.toString()
+        }));
+      });
+
+      process.stderr.on("data", (data) => {
+        hasOutput = true;
+        ws.send(JSON.stringify({
+          type: "LOG",
+          deviceName,
+          message: `[ERROR] ${data.toString()}`
+        }));
+      });
+
+      process.on("error", (err) => {
+        ws.send(JSON.stringify({
+          type: "LOG",
+          deviceName,
+          message: `[EXEC ERROR] ${err.message}`
+        }));
+      });
+
+      process.on("close", (code) => {
+        ws.send(JSON.stringify({
+          type: "LOG",
+          deviceName,
+          message: `Command execution finished with code: ${code}`
+        }));
+
+        // Send structured result so server can orchestrate sequential steps
+        ws.send(JSON.stringify({
+          type: "EXECUTE_RESULT",
+          command,
+          code: typeof code === 'number' ? code : 0
+        }));
+
+        isRunning = false;
+        processQueue();
+      });
+    }
   }
 
-  function expandPath(path) {
-    // Expand environment variables
-    if (path.includes("%USERPROFILE%")) {
-      path = path.replace(/%USERPROFILE%/gi, os.homedir());
+  // Start the connection
+  connect();
+
+  // Handle Ctrl+C gracefully
+  process.on('SIGINT', () => {
+    console.log('\n\nShutting down gracefully...');
+    isIntentionalClose = true;
+
+    if (screenCaptureInterval) {
+      clearInterval(screenCaptureInterval);
     }
-    if (path.includes("%HOMEPATH%")) {
-      path = path.replace(/%HOMEPATH%/gi, os.homedir());
+
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+    }
+
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.close();
+    }
+
+    console.log('Agent stopped.');
+    process.exit(0);
+  });
+}
+
+
+// ========== AUTO-START FUNCTIONALITY ==========
+
+function enableAutoStart() {
+  console.log("Enabling auto-start on system boot...");
+
+  const config = loadConfig();
+  if (!config.password) {
+    console.log("❌ Error: Please set a password first using 'vortix login'");
+    return;
+  }
+
+  try {
+    if (IS_WINDOWS) {
+      enableAutoStartWindows();
+    } else if (IS_MAC) {
+      enableAutoStartMac();
+    } else if (IS_LINUX) {
+      enableAutoStartLinux();
+    } else {
+      console.log("❌ Unsupported platform");
+      return;
     }
-    if (path.includes("%HOMEDRIVE%")) {
-      const homedir = os.homedir();
-      const drive = homedir.split("\\")[0];
-      path = path.replace(/%HOMEDRIVE%/gi, drive);
+
+    config.autoStart = true;
+    saveConfig(config);
+    console.log("✅ Auto-start enabled successfully!");
+    console.log("   The agent will start automatically on system boot.");
+  } catch (err) {
+    console.error("❌ Failed to enable auto-start:", err.message);
+  }
+}
+
+function disableAutoStart() {
+  console.log("Disabling auto-start...");
+
+  try {
+    if (IS_WINDOWS) {
+      disableAutoStartWindows();
+    } else if (IS_MAC) {
+      disableAutoStartMac();
+    } else if (IS_LINUX) {
+      disableAutoStartLinux();
+    } else {
+      console.log("❌ Unsupported platform");
+      return;
     }
-    return path;
+
+    const config = loadConfig();
+    config.autoStart = false;
+    saveConfig(config);
+    console.log("✅ Auto-start disabled successfully!");
+  } catch (err) {
+    console.error("❌ Failed to disable auto-start:", err.message);
   }
+}
+
+function checkAutoStartStatus() {
+  const config = loadConfig();
+  console.log("\n=== Vortix Agent Status ===");
+  console.log(`Platform: ${PLATFORM} (${IS_WINDOWS ? 'Windows' : IS_MAC ? 'macOS' : IS_LINUX ? 'Linux' : 'Unknown'})`);
+  console.log(`Device: ${os.hostname()}`);
+  console.log(`Password Set: ${config.password ? '✅ Yes' : '❌ No'}`);
+  console.log(`Auto-start: ${config.autoStart ? '✅ Enabled' : '❌ Disabled'}`);
+  console.log("===========================\n");
+}
+
+// ========== WINDOWS AUTO-START ==========
+
+function enableAutoStartWindows() {
+  const { execSync } = require('child_process');
 
-  function processQueue() {
-    if (isRunning || commandQueue.length === 0) return;
+  // Get the path to node and the agent script
+  const nodePath = process.execPath;
+  const agentPath = __filename;
 
-    isRunning = true;
-    let command = commandQueue.shift();
+  // Create a VBScript to run the agent silently (no console window)
+  const vbsPath = path.join(os.homedir(), 'vortix-agent.vbs');
+  const vbsContent = `Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run """${nodePath}"" ""${agentPath}"" start", 0, False`;
 
-    console.log("Executing command:", command);
+  fs.writeFileSync(vbsPath, vbsContent);
 
-    // Update current working directory if this is a cd command
-    const newCwd = extractDirectoryFromCommand(command);
-    if (newCwd) {
-      currentCwd = newCwd;
-      ws.send(JSON.stringify({ type: "LOG", deviceName, message: `Directory changed to: ${currentCwd}` }));
-      console.log("Directory state updated to:", currentCwd);
+  // Add to Windows Task Scheduler
+  const taskName = "VortixAgent";
+  const command = `schtasks /create /tn "${taskName}" /tr "${vbsPath}" /sc onlogon /rl highest /f`;
+
+  try {
+    execSync(command, { stdio: 'ignore' });
+    console.log("   Created Windows Task Scheduler entry");
+  } catch (err) {
+    throw new Error("Failed to create scheduled task. Try running as administrator.");
+  }
+}
+
+function disableAutoStartWindows() {
+  const { execSync } = require('child_process');
+
+  const taskName = "VortixAgent";
+  const command = `schtasks /delete /tn "${taskName}" /f`;
+
+  try {
+    execSync(command, { stdio: 'ignore' });
+    console.log("   Removed Windows Task Scheduler entry");
+  } catch (err) {
+    // Task might not exist, that's okay
+  }
+
+  // Remove VBScript file
+  const vbsPath = path.join(os.homedir(), 'vortix-agent.vbs');
+  if (fs.existsSync(vbsPath)) {
+    fs.unlinkSync(vbsPath);
+  }
+}
+
+// ========== macOS AUTO-START ==========
+
+function enableAutoStartMac() {
+  const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.vortix.agent.plist');
+
+  // Get the path to node and the agent script
+  const nodePath = process.execPath;
+  const agentPath = __filename;
+
+  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.vortix.agent</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${agentPath}</string>
+        <string>start</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${os.homedir()}/Library/Logs/vortix-agent.log</string>
+    <key>StandardErrorPath</key>
+    <string>${os.homedir()}/Library/Logs/vortix-agent-error.log</string>
+</dict>
+</plist>`;
+
+  // Create LaunchAgents directory if it doesn't exist
+  const launchAgentsDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+  if (!fs.existsSync(launchAgentsDir)) {
+    fs.mkdirSync(launchAgentsDir, { recursive: true });
+  }
+
+  fs.writeFileSync(plistPath, plistContent);
+
+  // Load the launch agent
+  const { execSync } = require('child_process');
+  try {
+    execSync(`launchctl load ${plistPath}`, { stdio: 'ignore' });
+    console.log("   Created macOS LaunchAgent");
+  } catch (err) {
+    console.log("   Created LaunchAgent (will load on next login)");
+  }
+}
+
+function disableAutoStartMac() {
+  const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.vortix.agent.plist');
+
+  if (fs.existsSync(plistPath)) {
+    const { execSync } = require('child_process');
+    try {
+      execSync(`launchctl unload ${plistPath}`, { stdio: 'ignore' });
+    } catch (err) {
+      // Might not be loaded, that's okay
     }
 
-    // report current cwd for diagnostics
-    ws.send(JSON.stringify({ type: "LOG", deviceName, message: `Working from: ${currentCwd}` }));
-    ws.send(JSON.stringify({ type: "LOG", deviceName, message: `Executing: ${command}` }));
+    fs.unlinkSync(plistPath);
+    console.log("   Removed macOS LaunchAgent");
+  }
+}
+
+// ========== LINUX AUTO-START ==========
 
-    // Use cmd.exe with /c flag to properly execute Windows commands
-    const process = exec(command, {
-      cwd: currentCwd,
-      shell: "cmd.exe",
-      maxBuffer: 10 * 1024 * 1024,  // 10MB buffer for large outputs
-      encoding: "utf8"
-    });
+function enableAutoStartLinux() {
+  const servicePath = path.join(os.homedir(), '.config', 'systemd', 'user', 'vortix-agent.service');
 
-    // Track if we've received any output
-    let hasOutput = false;
+  // Get the path to node and the agent script
+  const nodePath = process.execPath;
+  const agentPath = __filename;
 
-    process.stdout.on("data", (data) => {
-      hasOutput = true;
-      ws.send(JSON.stringify({
-        type: "LOG",
-        deviceName,
-        message: data.toString()
-      }));
-    });
+  const serviceContent = `[Unit]
+Description=Vortix Agent - Remote OS Control
+After=network.target
 
-    process.stderr.on("data", (data) => {
-      hasOutput = true;
-      ws.send(JSON.stringify({
-        type: "LOG",
-        deviceName,
-        message: `[ERROR] ${data.toString()}`
-      }));
-    });
+[Service]
+Type=simple
+ExecStart=${nodePath} ${agentPath} start
+Restart=always
+RestartSec=10
 
-    process.on("error", (err) => {
-      ws.send(JSON.stringify({
-        type: "LOG",
-        deviceName,
-        message: `[EXEC ERROR] ${err.message}`
-      }));
-    });
+[Install]
+WantedBy=default.target`;
 
-    process.on("close", (code) => {
-      ws.send(JSON.stringify({
-        type: "LOG",
-        deviceName,
-        message: `Command execution finished with code: ${code}`
-      }));
-
-      // Send structured result so server can orchestrate sequential steps
-      ws.send(JSON.stringify({
-        type: "EXECUTE_RESULT",
-        command,
-        code: typeof code === 'number' ? code : 0
-      }));
-
-      isRunning = false;
-      processQueue();
-    });
+  // Create systemd user directory if it doesn't exist
+  const systemdDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+  if (!fs.existsSync(systemdDir)) {
+    fs.mkdirSync(systemdDir, { recursive: true });
+  }
+
+  fs.writeFileSync(servicePath, serviceContent);
+
+  // Enable and start the service
+  const { execSync } = require('child_process');
+  try {
+    execSync('systemctl --user daemon-reload', { stdio: 'ignore' });
+    execSync('systemctl --user enable vortix-agent.service', { stdio: 'ignore' });
+    execSync('systemctl --user start vortix-agent.service', { stdio: 'ignore' });
+    console.log("   Created systemd user service");
+  } catch (err) {
+    console.log("   Created service file (enable with: systemctl --user enable vortix-agent.service)");
+  }
+}
+
+function disableAutoStartLinux() {
+  const servicePath = path.join(os.homedir(), '.config', 'systemd', 'user', 'vortix-agent.service');
+
+  if (fs.existsSync(servicePath)) {
+    const { execSync } = require('child_process');
+    try {
+      execSync('systemctl --user stop vortix-agent.service', { stdio: 'ignore' });
+      execSync('systemctl --user disable vortix-agent.service', { stdio: 'ignore' });
+    } catch (err) {
+      // Might not be running, that's okay
+    }
+
+    fs.unlinkSync(servicePath);
+    console.log("   Removed systemd user service");
   }
 }

package/agent/package.json

@@ -12,6 +12,7 @@
   "license": "ISC",
   "type": "commonjs",
   "dependencies": {
-    "ws": "^8.19.0"
+    "ws": "^8.19.0",
+    "screenshot-desktop": "^1.15.0"
   }
 }

package/bin/vortix.js

@@ -1,6 +1,8 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const path = require('path');
+const fs = require('fs');
+const os = require('os');
 
 const command = process.argv[2];
 
@@ -9,21 +11,73 @@ const packageRoot = path.join(__dirname, '..');
 const agentPath = path.join(packageRoot, 'agent', 'agent.js');
 const backendPath = path.join(packageRoot, 'backend', 'server.js');
 
+// Check if this is first run
+const configPath = path.join(os.homedir(), '.vortix-config.json');
+const firstRunFlagPath = path.join(os.homedir(), '.vortix-first-run');
+
+function showWelcome() {
+    const colors = {
+        reset: '\x1b[0m',
+        bright: '\x1b[1m',
+        green: '\x1b[32m',
+        cyan: '\x1b[36m',
+        yellow: '\x1b[33m',
+        magenta: '\x1b[35m',
+    };
+
+    console.log('\n');
+    console.log(colors.bright + colors.green + '  ╦  ╦┌─┐┬─┐┌┬┐┬─┐ ┬' + colors.reset);
+    console.log(colors.bright + colors.green + '  ╚╗╔╝│ │├┬┘ │ │┌┴┬┘' + colors.reset);
+    console.log(colors.bright + colors.green + '   ╚╝ └─┘┴└─ ┴ ┴┴ └─' + colors.reset);
+    console.log('\n');
+    console.log(colors.bright + colors.cyan + '  🚀 Welcome to Vortix!' + colors.reset);
+    console.log(colors.yellow + '  AI-Powered Remote OS Control' + colors.reset);
+    console.log('\n');
+    console.log(colors.bright + '  📖 Quick Start:' + colors.reset);
+    console.log('');
+    console.log('     ' + colors.cyan + '1.' + colors.reset + ' Set device password:');
+    console.log('        ' + colors.green + 'vortix login' + colors.reset);
+    console.log('');
+    console.log('     ' + colors.cyan + '2.' + colors.reset + ' Start the agent:');
+    console.log('        ' + colors.green + 'vortix start' + colors.reset);
+    console.log('');
+    console.log('     ' + colors.cyan + '3.' + colors.reset + ' Open dashboard:');
+    console.log('        ' + colors.magenta + colors.bright + 'https://vortixai.vercel.app' + colors.reset);
+    console.log('');
+    console.log(colors.yellow + '  ⚡ Pro Tip: ' + colors.reset + 'Use AI commands in the dashboard for natural language control!');
+    console.log('');
+}
+
 function showHelp() {
-    console.log(`
-Vortix - AI OS Control CLI
-
-Usage:
-  vortix login              Login and authenticate device
-  vortix start              Start the agent
-  vortix backend            Start the backend server
-  vortix help               Show this help message
-
-Examples:
-  vortix login              # Authenticate your device
-  vortix start              # Start agent on this machine
-  vortix backend            # Start backend server
-  `);
+    showWelcome();
+    console.log('  📚 Available Commands:\n');
+    console.log('     vortix login              Set device password');
+    console.log('     vortix start              Start the agent');
+    console.log('     vortix enable-autostart   Enable auto-start on system boot');
+    console.log('     vortix disable-autostart  Disable auto-start');
+    console.log('     vortix status             Check agent and auto-start status');
+    console.log('     vortix backend            Start backend server (dev only)');
+    console.log('     vortix help               Show this help message');
+    console.log('');
+    console.log('  📖 Documentation:');
+    console.log('     https://github.com/Vaibhav262610/vortix');
+    console.log('');
+}
+
+// Show welcome message on first run or if no command provided
+if (!command || command === 'help' || command === '--help' || command === '-h') {
+    if (!fs.existsSync(firstRunFlagPath) && !command) {
+        // First run without command
+        showWelcome();
+        fs.writeFileSync(firstRunFlagPath, Date.now().toString());
+        process.exit(0);
+    } else if (command === 'help' || command === '--help' || command === '-h') {
+        showHelp();
+        process.exit(0);
+    } else if (!command) {
+        showHelp();
+        process.exit(0);
+    }
 }
 
 function runAgent(cmd) {
@@ -66,14 +120,20 @@ switch (command) {
         runAgent('start');
         break;
 
-    case 'backend':
-        runBackend();
+    case 'enable-autostart':
+        runAgent('enable-autostart');
         break;
 
-    case 'help':
-    case '--help':
-    case '-h':
-        showHelp();
+    case 'disable-autostart':
+        runAgent('disable-autostart');
+        break;
+
+    case 'status':
+        runAgent('status');
+        break;
+
+    case 'backend':
+        runBackend();
         break;
 
     default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vortix",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "AI-powered OS control system with remote command execution",
   "main": "index.js",
   "bin": {
@@ -15,7 +15,17 @@
     "remote-control",
     "cli",
     "os-control",
-    "agent"
+    "agent",
+    "nodejs",
+    "websocket",
+    "command-execution",
+    "screen-sharing",
+    "multi-platform",
+    "windows",
+    "macos",
+    "linux",
+    "typescript",
+    "nextjs"
   ],
   "author": "Vaibhav Rajpoot <vaibhavrajpoot2626@gmail.com>",
   "license": "MIT",
@@ -23,6 +33,11 @@
     "type": "git",
     "url": "https://github.com/Vaibhav262610/vortix.git"
   },
+  "homepage": "https://vortixai.vercel.app",
+  "bugs": {
+    "url": "https://github.com/Vaibhav262610/vortix/issues",
+    "email": "vaibhavrajpoot2626@gmail.com"
+  },
   "engines": {
     "node": ">=14.0.0"
   },
@@ -35,6 +50,7 @@
   ],
   "dependencies": {
     "axios": "^1.6.0",
-    "ws": "^8.19.0"
+    "ws": "^8.19.0",
+    "screenshot-desktop": "^1.15.0"
   }
 }