magonai 1.0.7

package/index.js

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+
+const fs      = require("fs");
+const path    = require("path");
+const https   = require("https");
+const os      = require("os");
+const AdmZip  = require("adm-zip");
+const { execSync } = require("child_process");
+
+// -----------------------------
+// Config
+// -----------------------------
+const SERVER_HOST = "cli.magonai.com";
+const SERVER_PATH = "/scan";
+const AUTH_HOST   = "auth.magonai.com";
+const CONFIG_DIR  = path.join(os.homedir(), ".magonai");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+const EXCLUDE = new Set(["node_modules", ".git", ".env", ".env.local", ".env.production"]);
+
+// -----------------------------
+// Config helpers
+// -----------------------------
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function saveConfig(data) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+
+// -----------------------------
+// HTTPS helpers
+// -----------------------------
+function httpsGet(host, urlPath, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      { hostname: host, path: urlPath, method: "GET", headers },
+      (res) => {
+        let data = "";
+        res.on("data", c => data += c);
+        res.on("end", () => {
+          try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+          catch { resolve({ status: res.statusCode, body: data }); }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.setTimeout(10000, () => { req.destroy(); reject(new Error("Request timed out")); });
+    req.end();
+  });
+}
+
+function httpsPost(host, urlPath, payload, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify(payload);
+    const req = https.request(
+      {
+        hostname: host, path: urlPath, method: "POST",
+        headers: {
+          "Content-Type":   "application/json",
+          "Content-Length": Buffer.byteLength(body),
+          ...headers,
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", c => data += c);
+        res.on("end", () => {
+          try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+          catch { resolve({ status: res.statusCode, body: data }); }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.setTimeout(10000, () => { req.destroy(); reject(new Error("Request timed out")); });
+    req.write(body);
+    req.end();
+  });
+}
+
+// -----------------------------
+// Open URL in default browser
+// -----------------------------
+function openBrowser(url) {
+  try {
+    if (process.platform === "win32") {
+      execSync(`start "" "${url}"`, { stdio: "ignore" });
+    } else if (process.platform === "darwin") {
+      execSync(`open "${url}"`, { stdio: "ignore" });
+    } else {
+      try { execSync(`xdg-open "${url}"`, { stdio: "ignore" }); }
+      catch {
+        try { execSync(`gnome-open "${url}"`, { stdio: "ignore" }); }
+        catch { try { execSync(`firefox "${url}"`, { stdio: "ignore" }); } catch {} }
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// -----------------------------
+// Spinner
+// -----------------------------
+function startSpinner(msg) {
+  const frames = ["⠋","⠙","⠹","⠸","⠼","⠴","⠦","⠧","⠇","⠏"];
+  let i = 0;
+  return setInterval(() => {
+    process.stdout.write(`\r${frames[i++ % frames.length]} ${msg}`);
+  }, 100);
+}
+
+function stopSpinner(id) {
+  clearInterval(id);
+  process.stdout.write("\r\x1b[K");
+}
+
+// =============================================================
+// COMMANDS
+// =============================================================
+const command = process.argv[2];
+
+// -----------------------------
+// magonai login
+// -----------------------------
+if (command === "login") {
+  (async () => {
+    console.log("🔐 Authenticating with MagonAI...\n");
+
+    // Step 1: Request a one-time token from auth server
+    let token;
+    try {
+      const res = await httpsPost(AUTH_HOST, "/cli/auth/request", {});
+      if (res.status !== 200 || !res.body?.token) {
+        console.error("❌ Could not reach authentication server.");
+        console.error("   Make sure you have internet access and try again.");
+        process.exit(1);
+      }
+      token = res.body.token;
+    } catch (err) {
+      console.error("❌ Could not connect to authentication server:", err.message);
+      process.exit(1);
+    }
+
+    // Step 2: Open browser with token embedded in the login URL
+    const loginUrl = `https://magonai.com/login?cli_token=${token}`;
+    console.log("   Opening your browser to log in...");
+    console.log(`   ${loginUrl}\n`);
+
+    const opened = openBrowser(loginUrl);
+    if (!opened) {
+      console.log("⚠️  Could not open browser automatically.");
+      console.log(`   Please visit this URL manually:\n   ${loginUrl}\n`);
+    }
+
+    // Step 3: Poll auth server until login confirmed (max 5 minutes)
+    const spin = startSpinner("Waiting for authentication...");
+
+    const MAX_WAIT_MS = 5 * 60 * 1000;
+    const POLL_MS     = 2000;
+    const started     = Date.now();
+    let apiKey        = null;
+    let userEmail     = null;
+    let userName      = null;
+
+    while (Date.now() - started < MAX_WAIT_MS) {
+      await new Promise(r => setTimeout(r, POLL_MS));
+      try {
+        const res = await httpsGet(AUTH_HOST, `/cli/auth/status?token=${token}`);
+        if (res.status === 200 && res.body?.authenticated) {
+          apiKey    = res.body.apiKey;
+          userEmail = res.body.email || "";
+          userName  = res.body.name  || "";
+          break;
+        }
+      } catch {
+        // Network hiccup — keep polling
+      }
+    }
+
+    stopSpinner(spin);
+
+    if (!apiKey) {
+      console.error("❌ Authentication timed out. Please run `magonai login` again.");
+      process.exit(1);
+    }
+
+    // Step 4: Save credentials locally
+    saveConfig({
+      apiKey,
+      email:           userEmail,
+      name:            userName,
+      authenticatedAt: new Date().toISOString(),
+    });
+
+    console.log(`✅ Authenticated successfully${userEmail ? " as " + userEmail : ""}!`);
+    console.log(`   Credentials saved to ${CONFIG_FILE}`);
+    process.exit(0);
+  })();
+
+// -----------------------------
+// magonai logout
+// -----------------------------
+} else if (command === "logout") {
+  (async () => {
+    const cfg = loadConfig();
+    if (!cfg.apiKey) {
+      console.log("⚠️  You are not logged in.");
+      process.exit(0);
+    }
+
+    // Tell auth server to revoke the key in Redis + MongoDB
+    try {
+      const res = await httpsPost(
+        AUTH_HOST,
+        "/cli/auth/revoke",
+        {},
+        { "Authorization": `Bearer ${cfg.apiKey}` }
+      );
+      if (res.status === 200) {
+        console.log("   API key revoked on server.");
+      } else {
+        console.warn("   Server revoke failed — clearing locally anyway.");
+      }
+    } catch {
+      console.warn("   Could not reach server — clearing locally only.");
+    }
+
+    saveConfig({});
+    console.log("✅ Logged out. Credentials cleared.");
+    process.exit(0);
+  })();
+
+// -----------------------------
+// magonai whoami
+// -----------------------------
+} else if (command === "whoami") {
+  (async () => {
+    const cfg = loadConfig();
+    if (!cfg.apiKey) {
+      console.log("❌ Not logged in. Run `magonai login` first.");
+      process.exit(1);
+    }
+
+    // Verify key is still valid against auth server (MongoDB-backed)
+    try {
+      const res = await httpsGet(
+        AUTH_HOST,
+        "/cli/auth/whoami",
+        { "Authorization": `Bearer ${cfg.apiKey}` }
+      );
+
+      if (res.status === 200 && res.body?.valid) {
+        const { email, name, issuedAt } = res.body;
+        console.log(`👤 Logged in${email ? " as " + email : ""}${name ? " (" + name + ")" : ""}`);
+        console.log(`   API key : ${cfg.apiKey.slice(0, 12)}${"*".repeat(20)}`);
+        console.log(`   Since   : ${issuedAt ? new Date(issuedAt).toLocaleString() : cfg.authenticatedAt || "unknown"}`);
+      } else {
+        console.log("❌ Your session has expired. Run `magonai login` again.");
+        saveConfig({});
+        process.exit(1);
+      }
+    } catch {
+      // Offline fallback — show local info
+      console.log(`👤 Logged in${cfg.email ? " as " + cfg.email : ""} (offline)`);
+      console.log(`   API key : ${cfg.apiKey.slice(0, 12)}${"*".repeat(20)}`);
+      console.log(`   Since   : ${cfg.authenticatedAt || "unknown"}`);
+    }
+
+    process.exit(0);
+  })();
+
+// -----------------------------
+// magonai help
+// -----------------------------
+} else if (command === "help" || command === "--help" || command === "-h") {
+  console.log(`
+  MagonAI Security Scanner
+
+  Usage:
+    magonai              Scan current project for vulnerabilities
+    magonai login        Authenticate with your MagonAI account
+    magonai logout       Clear saved credentials (revokes key on server)
+    magonai whoami       Show currently logged-in account
+    magonai help         Show this help message
+  `);
+  process.exit(0);
+
+// -----------------------------
+// magonai (default: scan)
+// -----------------------------
+} else {
+  (async () => {
+    const cfg = loadConfig();
+    if (!cfg.apiKey) {
+      console.log("❌ Not logged in. Please authenticate first:\n");
+      console.log("   magonai login\n");
+      process.exit(1);
+    }
+
+    const projectPath = process.cwd();
+
+    const hasJS = fs.existsSync(path.join(projectPath, "package.json"));
+    const hasPython =
+      fs.existsSync(path.join(projectPath, "requirements.txt")) ||
+      fs.existsSync(path.join(projectPath, "Pipfile.lock"))     ||
+      fs.existsSync(path.join(projectPath, "poetry.lock"))      ||
+      fs.existsSync(path.join(projectPath, "pyproject.toml"));
+
+    if (!hasJS && !hasPython) {
+      console.log("❌ No package.json or Python dependency file found");
+      console.log("   Supported: package.json / requirements.txt / Pipfile.lock / poetry.lock / pyproject.toml");
+      process.exit(1);
+    }
+
+    const spin = startSpinner("Scanning for vulnerabilities...");
+
+    // Build zip of project — excluding noise directories
+    const zip = new AdmZip();
+
+    function addDir(dirPath, zipBase) {
+      let entries;
+      try { entries = fs.readdirSync(dirPath, { withFileTypes: true }); }
+      catch { return; }
+      for (const entry of entries) {
+        if (EXCLUDE.has(entry.name)) continue;
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+          addDir(fullPath, zipBase ? `${zipBase}/${entry.name}` : entry.name);
+        } else {
+          zip.addLocalFile(fullPath, zipBase || "");
+        }
+      }
+    }
+
+    addDir(projectPath, "");
+    const zipBuffer = zip.toBuffer();
+
+    const chunks = [];
+    try {
+      await new Promise((resolve, reject) => {
+        const options = {
+          hostname: SERVER_HOST,
+          path:     SERVER_PATH,
+          method:   "POST",
+          headers: {
+            "Content-Type":   "application/zip",
+            "Content-Length": zipBuffer.length,
+            "Authorization":  `Bearer ${cfg.apiKey}`,
+          },
+        };
+
+        const req = https.request(options, (res) => {
+          if (res.statusCode === 401) {
+            stopSpinner(spin);
+            console.error("❌ Invalid or expired credentials. Please run `magonai login` again.");
+            process.exit(1);
+          }
+          res.on("data",  chunk => chunks.push(chunk));
+          res.on("end",   resolve);
+          res.on("error", reject);
+        });
+
+        req.on("error", reject);
+        req.write(zipBuffer);
+        req.end();
+      });
+    } catch (err) {
+      stopSpinner(spin);
+      console.error("❌ Could not connect to server:", err.message);
+      process.exit(1);
+    }
+
+    stopSpinner(spin);
+    console.log(Buffer.concat(chunks).toString("utf-8"));
+    process.exit(0);
+  })();
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "magonai",
+  "version": "1.0.7",
+  "description": "MagonAI vulnerability scanner CLI",
+  "bin": {
+    "magonai": "index.js"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.17",
+    "archiver": "^7.0.1",
+    "form-data": "^4.0.0",
+    "node-fetch": "^2.7.0"
+  },
+  "main": "index.js",
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}