vortix 1.0.0 → 1.0.1

package/agent/agent.js

@@ -0,0 +1,210 @@
+const WebSocket = require("ws");
+const { exec } = require("child_process");
+const os = require("os");
+
+process.on("uncaughtException", (err) => {
+  console.error("Uncaught Exception:", err);
+});
+
+process.on("unhandledRejection", (err) => {
+  console.error("Unhandled Rejection:", err);
+});
+
+const command = process.argv[2];
+
+if (command === "login") {
+  console.log("Login is not required in this version.");
+  console.log("Just run: vortix start");
+  return;
+}
+
+if (command === "start") {
+  startAgent();
+  return;
+}
+
+console.log("Available commands:");
+console.log("  vortix start  - Start the agent");
+console.log("  vortix help   - Show help");
+
+function startAgent() {
+  const deviceName = os.hostname();
+  const token = `device-${deviceName.toLowerCase()}`;
+
+  console.log(`Connecting as device: ${deviceName}`);
+  console.log(`Using token: ${token}`);
+
+  // Production backend URL - Render deployment
+  const BACKEND_URL = process.env.BACKEND_URL || 'wss://vortix.onrender.com';
+
+  const ws = new WebSocket(`${BACKEND_URL}?token=${token}`);
+
+  ws.on("open", () => {
+    console.log("Authenticated and connected to backend");
+
+    setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        console.log("Sending heartbeat...");
+        ws.send(
+          JSON.stringify({
+            type: "HEARTBEAT"
+          })
+        );
+      }
+    }, 5000);
+  });
+
+  ws.on("close", () => {
+    console.log("Disconnected from backend");
+  });
+
+  ws.on("error", (err) => {
+    console.error("WebSocket error:", err.message);
+  });
+
+  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();
+      }
+
+    } catch (err) {
+      console.error("Invalid message received:", message.toString());
+    }
+  });
+
+  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 + "\\";
+      }
+      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;
+  }
+
+  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}` }));
+
+    // 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"
+    });
+
+    // 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();
+    });
+  }
+}

package/agent/auth.js

@@ -0,0 +1,32 @@
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+
+const CONFIG_PATH = path.join(__dirname, "config.json");
+
+function login() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.question("Enter device token: ", (token) => {
+    const config = { token: token.trim() };
+
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+
+    console.log("Token saved successfully.");
+    rl.close();
+  });
+}
+
+function getToken() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return null;
+  }
+
+  const config = JSON.parse(fs.readFileSync(CONFIG_PATH));
+  return config.token;
+}
+
+module.exports = { login, getToken };

package/agent/config.json

@@ -0,0 +1,3 @@
+{
+  "token": "device-test-device"
+}

package/agent/package-lock.json

@@ -0,0 +1,37 @@
+{
+  "name": "agent",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "agent",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "ws": "^8.19.0"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

package/agent/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "agent",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node agent.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "ws": "^8.19.0"
+  }
+}

package/backend/package-lock.json

@@ -0,0 +1,354 @@
+{
+  "name": "vortix-backend",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "vortix-backend",
+      "version": "1.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "axios": "^1.13.5",
+        "ws": "^8.19.0"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/axios": {
+      "version": "1.13.5",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.5.tgz",
+      "integrity": "sha512-cz4ur7Vb0xS4/KUN0tPWe44eqxrIu31me+fbang3ijiNscE129POzipJJA6zniq2C/Z6sJCjMimjS8Lc/GAs8Q==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.11",
+        "form-data": "^4.0.5",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.11",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+      "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/openai": {
+      "version": "6.18.0",
+      "resolved": "https://registry.npmjs.org/openai/-/openai-6.18.0.tgz",
+      "integrity": "sha512-odLRYyz9rlzz6g8gKn61RM2oP5UUm428sE2zOxZqS9MzVfD5/XW8UoEjpnRkzTuScXP7ZbP/m7fC+bl8jCOZZw==",
+      "license": "Apache-2.0",
+      "bin": {
+        "openai": "bin/cli"
+      },
+      "peerDependencies": {
+        "ws": "^8.18.0",
+        "zod": "^3.25 || ^4.0"
+      },
+      "peerDependenciesMeta": {
+        "ws": {
+          "optional": true
+        },
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/uuid": {
+      "version": "13.0.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-13.0.0.tgz",
+      "integrity": "sha512-XQegIaBTVUjSHliKqcnFqYypAd4S+WCYt5NIeRs6w/UAry7z8Y9j5ZwRRL4kzq9U3sD6v+85er9FvkEaBpji2w==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist-node/bin/uuid"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

package/backend/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "vortix-backend",
+  "version": "1.0.0",
+  "description": "Vortix WebSocket backend server",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node server.js"
+  },
+  "keywords": ["websocket", "remote-control", "ai"],
+  "author": "",
+  "license": "MIT",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.13.5",
+    "ws": "^8.19.0"
+  }
+}

package/backend/railway.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://railway.app/railway.schema.json",
+  "build": {
+    "builder": "NIXPACKS"
+  },
+  "deploy": {
+    "startCommand": "node server.js",
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 10
+  }
+}

package/backend/server.js

@@ -0,0 +1,500 @@
+const WebSocket = require("ws");
+const readline = require("readline");
+const axios = require("axios");
+const os = require("os");
+const path = require("path");
+
+// Use environment PORT for cloud deployment, fallback to 8080 for local
+const PORT = process.env.PORT || 8080;
+
+const dashboardClients = new Set();
+const devices = new Map();
+// pendingResults holds awaiting resolvers for EXECUTE_RESULT from agents
+const pendingResults = new Map(); // deviceName -> [{ command, resolve, reject, timer }]
+
+const wss = new WebSocket.Server({ port: PORT });
+
+console.log(`Backend running on port ${PORT}`);
+
+function waitForExecuteResult(deviceName, command, timeoutMs = 120000) {
+  return new Promise((resolve, reject) => {
+    const list = pendingResults.get(deviceName) || [];
+    const entry = { command, resolve, reject, timer: null };
+    // timeout
+    entry.timer = setTimeout(() => {
+      // remove entry
+      const arr = pendingResults.get(deviceName) || [];
+      const idx = arr.indexOf(entry);
+      if (idx !== -1) arr.splice(idx, 1);
+      pendingResults.set(deviceName, arr);
+      reject(new Error('Timed out waiting for EXECUTE_RESULT'));
+    }, timeoutMs);
+
+    list.push(entry);
+    pendingResults.set(deviceName, list);
+  });
+}
+
+// ---------- WebSocket Handling ----------
+wss.on("connection", (ws, req) => {
+  const url = new URL(req.url, "http://localhost");
+
+  const token = url.searchParams.get("token");
+  const clientType = url.searchParams.get("type");
+
+  // ===== DASHBOARD CONNECTION =====
+  if (clientType === "dashboard") {
+    dashboardClients.add(ws);
+    console.log("Dashboard connected");
+    // Send initial device list to newly connected dashboard
+    broadcastDevices();
+
+    ws.on("message", async (message) => {
+      const data = JSON.parse(message);
+      if (data.type === "FORCE_EXECUTE") {
+        const targetDevice = [...devices.values()].find(
+          (d) =>
+            d.deviceName === data.deviceName &&
+            d.status === "online"
+        );
+
+        if (!targetDevice) return;
+
+        targetDevice.ws.send(
+          JSON.stringify({
+            type: "EXECUTE",
+            command: data.command,
+          })
+        );
+
+        console.log("Force executed dangerous command");
+      }
+
+      // if (data.type === "COMMAND") {
+      //   const targetDevice = [...devices.values()].find(
+      //     (d) =>
+      //       d.deviceName === data.deviceName &&
+      //       d.status === "online"
+      //   );
+
+      //   if (!targetDevice) {
+      //     console.log("Target device not found or offline");
+      //     return;
+      //   }
+      //    if (isDangerousCommand(data.command)) {
+      // ws.send(
+      //     JSON.stringify({
+      //     type: "APPROVAL_REQUIRED",
+      //     deviceName: data.deviceName,
+      //     command: data.command
+      //     })
+      // );
+
+      // console.log("Dangerous command detected, approval required");
+      // return;
+      // }
+
+      //   targetDevice.ws.send(
+      //     JSON.stringify({
+      //       type: "EXECUTE",
+      //       command: data.command,
+      //     })
+      //   );
+
+      //   console.log(
+      //     `Dashboard sent command to ${data.deviceName}`
+      //   );
+      // }
+      if (data.type === "APPROVE_PLAN") {
+        const targetDevice = [...devices.values()].find(
+          (d) =>
+            d.deviceName === data.deviceName &&
+            d.status === "online"
+        );
+
+        if (!targetDevice) {
+          console.log("Target device not found or offline");
+          dashboardClients.forEach((client) => {
+            client.send(
+              JSON.stringify({
+                type: "EXECUTION_FINISHED",
+                deviceName: data.deviceName,
+                error: "Device not found or offline"
+              })
+            );
+          });
+          return;
+        }
+
+        console.log("APPROVE_PLAN received:", data.steps);
+
+        // Notify all dashboard clients execution started
+        dashboardClients.forEach((client) => {
+          client.send(
+            JSON.stringify({
+              type: "EXECUTION_STARTED",
+              deviceName: data.deviceName
+            })
+          );
+        });
+
+        // Execute steps sequentially: wait for agent to report EXECUTE_RESULT for each step
+        (async () => {
+          let aborted = false;
+          for (const step of data.steps) {
+            // Send command EXACTLY as provided - don't modify it
+            const commandToExecute = step.command || step;
+            console.log("Sending EXECUTE to agent for:", commandToExecute);
+
+            targetDevice.ws.send(
+              JSON.stringify({
+                type: "EXECUTE",
+                command: commandToExecute
+              })
+            );
+
+            try {
+              const result = await waitForExecuteResult(targetDevice.deviceName, commandToExecute);
+              console.log("Step result:", result);
+
+              // send step log to dashboards
+              dashboardClients.forEach((client) => {
+                client.send(
+                  JSON.stringify({
+                    type: "LOG",
+                    deviceName: targetDevice.deviceName,
+                    message: `✓ Step completed: ${commandToExecute} (exit code: ${result.code})`
+                  })
+                );
+              });
+
+              // Continue even if code is not 0 - let user see the output
+              // but notify about non-zero exit
+              if (typeof result.code === 'number' && result.code !== 0) {
+                console.log(`Step exited with code ${result.code}: ${commandToExecute}`);
+              }
+            } catch (err) {
+              console.error("Step execution error:", err.message);
+              dashboardClients.forEach((client) => {
+                client.send(
+                  JSON.stringify({
+                    type: "LOG",
+                    deviceName: targetDevice.deviceName,
+                    message: `✗ Step failed: ${commandToExecute} - ${err.message}`
+                  })
+                );
+              });
+              dashboardClients.forEach((client) => {
+                client.send(
+                  JSON.stringify({
+                    type: "EXECUTION_FINISHED",
+                    deviceName: data.deviceName,
+                    error: err.message
+                  })
+                );
+              });
+              aborted = true;
+              break;
+            }
+          }
+
+          if (!aborted) {
+            dashboardClients.forEach((client) => {
+              client.send(
+                JSON.stringify({
+                  type: "EXECUTION_FINISHED",
+                  deviceName: data.deviceName,
+                  success: true
+                })
+              );
+            });
+          }
+        })();
+      }
+
+      if (data.type === "PLAN") {
+
+        const targetDevice = [...devices.values()].find(
+          (d) =>
+            d.deviceName === data.deviceName &&
+            d.status === "online"
+        );
+
+        if (!targetDevice) {
+          console.log("Device not found or offline");
+          return;
+        }
+
+        try {
+          const plan = await generatePlan(
+            data.command,
+            targetDevice.platform || "win32"
+          );
+          console.log("Generated plan:", plan.steps);
+
+          // SEND PLAN PREVIEW TO DASHBOARD - wait for approval
+          ws.send(
+            JSON.stringify({
+              type: "PLAN_PREVIEW",
+              deviceName: data.deviceName,
+              steps: plan.steps
+            })
+          );
+
+          console.log("AI Plan sent for approval:", plan);
+        } catch (err) {
+          console.error("AI planning error:", err.message);
+          // Notify dashboard of error
+          dashboardClients.forEach((client) => {
+            client.send(
+              JSON.stringify({
+                type: "EXECUTION_FINISHED",
+                deviceName: data.deviceName,
+                error: err.message
+              })
+            );
+          });
+        }
+      }
+
+    });
+
+    ws.on("close", () => {
+      dashboardClients.delete(ws);
+      console.log("Dashboard disconnected");
+    });
+
+    return;
+  }
+
+
+  // ===== AGENT CONNECTION =====
+  if (!token || !devices.has(token)) {
+    console.log("Unauthorized connection attempt");
+    ws.close();
+    return;
+  }
+
+  const device = devices.get(token);
+
+  device.ws = ws;
+  device.status = "online";
+  device.lastSeen = Date.now();
+
+  console.log(`Authenticated device: ${device.deviceName}`);
+
+  broadcastDevices(); // 🔥 notify dashboard
+
+  ws.on("message", (message) => {
+    const data = JSON.parse(message);
+
+    if (data.type === "HEARTBEAT") {
+      device.lastSeen = Date.now();
+      console.log(`Heartbeat received from ${device.deviceName}`);
+    }
+
+    if (data.type === "LOG") {
+      console.log(`[${device.deviceName}] ${data.message}`);
+
+      // 🔥 send logs to dashboard
+      dashboardClients.forEach((client) => {
+        client.send(
+          JSON.stringify({
+            type: "LOG",
+            deviceName: device.deviceName,
+            message: data.message,
+          })
+        );
+      });
+    }
+
+    if (data.type === "EXECUTE_RESULT") {
+      console.log(`EXECUTE_RESULT received from ${device.deviceName}:`, data);
+      const list = pendingResults.get(device.deviceName) || [];
+      for (let i = 0; i < list.length; i++) {
+        const entry = list[i];
+        if (entry.command === data.command) {
+          clearTimeout(entry.timer);
+          try {
+            entry.resolve(data);
+          } catch (e) {
+            entry.reject(e);
+          }
+          list.splice(i, 1);
+          break;
+        }
+      }
+      pendingResults.set(device.deviceName, list);
+    }
+  });
+
+  ws.on("close", () => {
+    device.status = "offline";
+    console.log(`${device.deviceName} disconnected`);
+    broadcastDevices(); // 🔥 notify dashboard
+  });
+});
+
+// ---------- Device Registration ----------
+function registerDevice(deviceName, token) {
+  // If no token provided, use the hostname-based token for consistency
+  if (!token) {
+    token = `device-${deviceName.toLowerCase()}`;
+  }
+
+  devices.set(token, {
+    deviceName,
+    status: "offline",
+    ws: null,
+    lastSeen: null
+  });
+
+  console.log(`Registered device: ${deviceName}`);
+  console.log(`Token: ${token}`);
+
+  return token;
+}
+
+// Register one device manually for testing
+registerDevice("Test-Device");
+registerDevice("VAIBHAV-PC");
+
+// ---------- Heartbeat Monitor ----------
+setInterval(() => {
+  const now = Date.now();
+
+  devices.forEach((device) => {
+    if (
+      device.status === "online" &&
+      device.lastSeen &&
+      now - device.lastSeen > 15000
+    ) {
+      device.status = "offline";
+      console.log(`${device.deviceName} marked offline`);
+    }
+  });
+}, 5000);
+
+// ---------- Terminal Command Interface (only in local development) ----------
+if (process.env.NODE_ENV !== 'production' && !process.env.RAILWAY_ENVIRONMENT) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.log("Type: send <DeviceName> <command>");
+
+  rl.on("line", (input) => {
+    const [keyword, deviceName, ...cmdParts] = input.split(" ");
+    const command = cmdParts.join(" ");
+
+    if (keyword !== "send") {
+      console.log("Invalid command. Use: send <DeviceName> <command>");
+      return;
+    }
+
+    let targetDevice = null;
+
+    devices.forEach((device) => {
+      if (device.deviceName === deviceName && device.status === "online") {
+        targetDevice = device;
+      }
+    });
+
+    if (!targetDevice) {
+      console.log("Device not found or offline.");
+      return;
+    }
+
+    targetDevice.ws.send(
+      JSON.stringify({
+        type: "EXECUTE",
+        command
+      })
+    );
+
+    console.log(`Command sent to ${deviceName}`);
+  });
+} else {
+  console.log("Running in production mode - terminal interface disabled");
+}
+
+async function generatePlan(userInput, platform) {
+  const homeDir = os.homedir();
+  const desktopPath = path.join(homeDir, "Desktop");
+
+  const prompt = `
+You are an AI OS command planner. Generate EXACT Windows commands for the user's request.
+
+System Information:
+- Home Directory: ${homeDir}
+- Desktop Path: ${desktopPath}
+- Platform: ${platform}
+
+CRITICAL RULES:
+1. Return ONLY valid JSON in this format - nothing else
+2. Use ABSOLUTE paths, NOT relative paths
+3. Use echo command for file creation (NOT type, NOT powershell)
+4. One command per step
+5. Never create unnecessary directories before files
+6. Format: echo "content" > full_path_to_file.txt
+
+CORRECT Examples:
+- "create hello.txt with html on desktop"
+  Response: {"steps": [{"command": "echo <!DOCTYPE html><html><head><title>Hello</title></head><body><h1>Hello</h1></body></html> > ${desktopPath}\\hello.txt"}]}
+
+- "create test file with hello world"  
+  Response: {"steps": [{"command": "echo hello world > ${homeDir}\\Desktop\\test.txt"}]}
+
+- "list desktop files"
+  Response: {"steps": [{"command": "dir ${desktopPath}"}]}
+
+User Request: ${userInput}
+
+Return ONLY JSON:
+`;
+
+  const response = await axios.post(
+    "http://localhost:11434/api/generate",
+    {
+      model: "qwen2.5:7b",
+      prompt: prompt,
+      stream: false
+    }
+  );
+
+  const text = response.data.response.trim();
+
+  console.log("LLM raw output:", text);
+
+  // Extract JSON safely
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+
+  if (!jsonMatch) {
+    throw new Error("No valid JSON found in LLM output");
+  }
+
+  return JSON.parse(jsonMatch[0]);
+}
+
+
+
+function broadcastDevices() {
+  const deviceList = [];
+
+  devices.forEach((device) => {
+    deviceList.push({
+      deviceName: device.deviceName,
+      status: device.status,
+    });
+  });
+
+  dashboardClients.forEach((client) => {
+    client.send(
+      JSON.stringify({
+        type: "DEVICES",
+        devices: deviceList,
+      })
+    );
+  });
+}

package/bin/vortix.js

@@ -1,15 +1,13 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
-const { spawn } = require('child_process');
 const path = require('path');
-const os = require('os');
 
 const command = process.argv[2];
-const args = process.argv.slice(3);
 
-// Paths to agent and backend
-const agentPath = path.join(__dirname, '../../agent/agent.js');
-const backendPath = path.join(__dirname, '../../backend/server.js');
+// When installed via npm, files are in the package directory
+const packageRoot = path.join(__dirname, '..');
+const agentPath = path.join(packageRoot, 'agent', 'agent.js');
+const backendPath = path.join(packageRoot, 'backend', 'server.js');
 
 function showHelp() {
     console.log(`
@@ -29,28 +27,34 @@ Examples:
 }
 
 function runAgent(cmd) {
-    const proc = spawn('node', [agentPath, cmd], {
-        stdio: 'inherit',
-        cwd: path.dirname(agentPath)
-    });
+    // Set the command argument for the agent
+    process.argv[2] = cmd;
 
-    proc.on('error', (err) => {
+    // Change to agent directory
+    process.chdir(path.dirname(agentPath));
+
+    // Require and run the agent
+    try {
+        require(agentPath);
+    } catch (err) {
         console.error('Failed to start agent:', err.message);
         process.exit(1);
-    });
+    }
 }
 
 function runBackend() {
     console.log('Starting Vortix backend server...');
-    const proc = spawn('node', [backendPath], {
-        stdio: 'inherit',
-        cwd: path.dirname(backendPath)
-    });
 
-    proc.on('error', (err) => {
+    // Change to backend directory
+    process.chdir(path.dirname(backendPath));
+
+    // Require and run the backend
+    try {
+        require(backendPath);
+    } catch (err) {
         console.error('Failed to start backend:', err.message);
         process.exit(1);
-    });
+    }
 }
 
 switch (command) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vortix",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "AI-powered OS control system with remote command execution",
   "main": "index.js",
   "bin": {
@@ -14,25 +14,23 @@
     "os-control",
     "agent"
   ],
-  "author": "Your Name <your.email@example.com>",
+  "author": "Vaibhav Rajpoot <vaibhavrajpoot2626@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/yourusername/vortix.git"
+    "url": "https://github.com/Vaibhav262610/vortix.git"
   },
   "engines": {
     "node": ">=14.0.0"
   },
   "files": [
     "bin/",
-    "../agent/",
-    "../backend/",
+    "agent/",
+    "backend/",
     "README.md"
   ],
   "dependencies": {
     "axios": "^1.6.0",
-    "ws": "^8.19.0",
-    "uuid": "^13.0.0",
-    "openai": "^6.18.0"
+    "ws": "^8.19.0"
   }
 }