antigravity-usage 0.2.7 → 0.2.8

package/dist/index.js

@@ -1852,12 +1852,21 @@ async function detectOnUnix() {
     const { stdout } = await execAsync("ps aux");
     const lines = stdout.split("\n");
     for (const line of lines) {
-      if (line.toLowerCase().includes("antigravity") && (line.includes("language-server") || line.includes("lsp") || line.includes("server"))) {
-        debug("process-detector", `Found potential Antigravity process: ${line}`);
-        const processInfo = parseUnixProcessLine(line);
-        if (processInfo) {
-          return processInfo;
-        }
+      const lower = line.toLowerCase();
+      if (!lower.includes("antigravity")) {
+        continue;
+      }
+      if (lower.includes("server installation script")) {
+        continue;
+      }
+      const hasServerSignal = line.includes("language-server") || line.includes("lsp") || line.includes("--csrf_token") || line.includes("--extension_server_port") || line.includes("exa.language_server_pb");
+      if (!hasServerSignal) {
+        continue;
+      }
+      debug("process-detector", `Found potential Antigravity process: ${line}`);
+      const processInfo = parseUnixProcessLine(line);
+      if (processInfo) {
+        return processInfo;
       }
     }
     debug("process-detector", "No Antigravity process found");
@@ -1894,24 +1903,27 @@ async function detectOnWindows() {
       // 10MB buffer for long command lines
     );
     const lines = stdout.split("\n").filter((line) => line.trim() && !line.includes("Node,CommandLine,ProcessId"));
+    const candidates = [];
     for (const line of lines) {
       const parts = line.split(",");
       if (parts.length >= 3) {
         const commandLine = parts.slice(1, -1).join(",");
         const pid = parseInt(parts[parts.length - 1].trim(), 10);
         if (!isNaN(pid) && commandLine.toLowerCase().includes("antigravity")) {
-          debug("process-detector", `Found Antigravity process on Windows: PID ${pid}`);
-          const csrfToken = extractArgument(commandLine, "--csrf_token");
-          const extensionServerPort = extractArgument(commandLine, "--extension_server_port");
-          return {
+          candidates.push({
             pid,
-            csrfToken: csrfToken || void 0,
-            extensionServerPort: extensionServerPort ? parseInt(extensionServerPort, 10) : void 0,
+            csrfToken: extractArgument(commandLine, "--csrf_token") || void 0,
+            extensionServerPort: parsePortValue(extractArgument(commandLine, "--extension_server_port")),
             commandLine
-          };
+          });
         }
       }
     }
+    const selected = selectBestWindowsCandidate(candidates);
+    if (selected) {
+      debug("process-detector", `Selected Antigravity process on Windows: PID ${selected.pid}`);
+      return selected;
+    }
     return await detectOnWindowsPowerShell();
   } catch (err) {
     debug("process-detector", "Error detecting process on Windows with WMIC, trying PowerShell", err);
@@ -1928,28 +1940,73 @@ async function detectOnWindowsPowerShell() {
     }
     const processes = JSON.parse(stdout);
     const processList = Array.isArray(processes) ? processes : [processes];
+    const candidates = [];
     for (const proc of processList) {
       if (proc.Id) {
         const { stdout: cmdLine } = await execAsync(
           `powershell -Command "(Get-CimInstance Win32_Process -Filter 'ProcessId = ${proc.Id}').CommandLine"`
         );
         const commandLine = cmdLine.trim();
-        const csrfToken = extractArgument(commandLine, "--csrf_token");
-        const extensionServerPort = extractArgument(commandLine, "--extension_server_port");
-        return {
+        if (!commandLine.toLowerCase().includes("antigravity")) {
+          continue;
+        }
+        candidates.push({
           pid: proc.Id,
-          csrfToken: csrfToken || void 0,
-          extensionServerPort: extensionServerPort ? parseInt(extensionServerPort, 10) : void 0,
+          csrfToken: extractArgument(commandLine, "--csrf_token") || void 0,
+          extensionServerPort: parsePortValue(extractArgument(commandLine, "--extension_server_port")),
           commandLine
-        };
+        });
       }
     }
+    const selected = selectBestWindowsCandidate(candidates);
+    if (selected) {
+      debug("process-detector", `Selected Antigravity process on Windows (PowerShell): PID ${selected.pid}`);
+      return selected;
+    }
     return null;
   } catch (err) {
     debug("process-detector", "Error detecting process on Windows with PowerShell", err);
     return null;
   }
 }
+function parsePortValue(rawPort) {
+  if (!rawPort) {
+    return void 0;
+  }
+  const parsed = parseInt(rawPort, 10);
+  return isNaN(parsed) ? void 0 : parsed;
+}
+function scoreWindowsCandidate(candidate) {
+  const lower = candidate.commandLine.toLowerCase();
+  let score = 0;
+  if (lower.includes("antigravity")) score += 1;
+  if (lower.includes("lsp")) score += 5;
+  if (candidate.extensionServerPort) score += 10;
+  if (candidate.csrfToken) score += 20;
+  if (lower.includes("language_server") || lower.includes("language-server") || lower.includes("exa.language_server_pb")) {
+    score += 50;
+  }
+  return score;
+}
+function selectBestWindowsCandidate(candidates) {
+  if (candidates.length === 0) {
+    return null;
+  }
+  debug("process-detector", `Found ${candidates.length} Antigravity candidate process(es) on Windows`);
+  let best = null;
+  let bestScore = -1;
+  for (const candidate of candidates) {
+    const score = scoreWindowsCandidate(candidate);
+    if (score > bestScore) {
+      best = candidate;
+      bestScore = score;
+    }
+  }
+  if (best) {
+    debug("process-detector", `Selected PID ${best.pid} with score ${bestScore}`);
+  }
+  return best;
+}
 function extractArgument(commandLine, argName) {
   const eqRegex = new RegExp(`${argName}=([^\\s"']+|"[^"]*"|'[^']*')`, "i");
   const eqMatch = commandLine.match(eqRegex);
@@ -2076,6 +2133,8 @@ async function discoverPortsOnWindows(pid) {
 // src/local/port-prober.ts
 import https from "https";
 import http from "http";
+var CONNECT_RPC_PATH = "/exa.language_server_pb.LanguageServerService/GetUnleashData";
+var VALID_CONNECT_STATUSES = /* @__PURE__ */ new Set([200, 401]);
 async function probeForConnectAPI(ports, csrfToken, timeout = 500) {
   debug("port-prober", `Probing ${ports.length} ports: ${ports.join(", ")}`);
   const probePromises = ports.map((port) => probePort(port, csrfToken, timeout));
@@ -2095,7 +2154,7 @@ async function probePort(port, csrfToken, timeout = 500) {
   if (httpsResult) {
     return httpsResult;
   }
-  const httpResult = await probeHttp(port, timeout);
+  const httpResult = await probeHttp(port, timeout, csrfToken);
   if (httpResult) {
     return httpResult;
   }
@@ -2106,7 +2165,7 @@ function probeHttps(port, timeout, csrfToken) {
     const options = {
       hostname: "127.0.0.1",
       port,
-      path: "/exa.language_server_pb.LanguageServerService/GetUnleashData",
+      path: CONNECT_RPC_PATH,
       method: "POST",
       timeout,
       rejectUnauthorized: false,
@@ -2118,7 +2177,7 @@ function probeHttps(port, timeout, csrfToken) {
       }
     };
     const req = https.request(options, (res) => {
-      if (res.statusCode === 200) {
+      if (res.statusCode && VALID_CONNECT_STATUSES.has(res.statusCode)) {
         debug("port-prober", `HTTPS Connect RPC probe on port ${port}: status ${res.statusCode} - valid connect port`);
         resolve({
           baseUrl: `https://127.0.0.1:${port}`,
@@ -2144,23 +2203,43 @@ function probeHttps(port, timeout, csrfToken) {
     req.end();
   });
 }
-function probeHttp(port, timeout) {
+function probeHttp(port, timeout, csrfToken) {
   return new Promise((resolve) => {
     const options = {
-      hostname: "localhost",
+      hostname: "127.0.0.1",
       port,
-      path: "/",
-      method: "GET",
-      timeout
+      path: CONNECT_RPC_PATH,
+      method: "POST",
+      timeout,
+      headers: {
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1",
+        ...csrfToken ? { "X-Codeium-Csrf-Token": csrfToken } : {}
+      }
     };
     const req = http.request(options, (res) => {
-      debug("port-prober", `HTTP probe on port ${port}: status ${res.statusCode}`);
-      resolve({
-        baseUrl: `http://localhost:${port}`,
-        protocol: "http",
-        port
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      res.on("end", () => {
+        if (data.toLowerCase().includes("client sent an http request to an https server")) {
+          debug("port-prober", `HTTP probe on port ${port}: protocol mismatch response, rejecting`);
+          resolve(null);
+          return;
+        }
+        if (res.statusCode && VALID_CONNECT_STATUSES.has(res.statusCode)) {
+          debug("port-prober", `HTTP Connect RPC probe on port ${port}: status ${res.statusCode} - valid connect port`);
+          resolve({
+            baseUrl: `http://127.0.0.1:${port}`,
+            protocol: "http",
+            port
+          });
+          return;
+        }
+        debug("port-prober", `HTTP probe on port ${port}: status ${res.statusCode} - not connect port`);
+        resolve(null);
       });
-      res.resume();
     });
     req.on("error", (err) => {
       debug("port-prober", `HTTP probe on port ${port} failed: ${err.message}`);
@@ -2171,6 +2250,7 @@ function probeHttp(port, timeout) {
       req.destroy();
       resolve(null);
     });
+    req.write(JSON.stringify({ wrapper_data: {} }));
     req.end();
   });
 }
@@ -2468,7 +2548,11 @@ async function fetchQuotaLocal() {
     throw new AntigravityNotRunningError();
   }
   debug("service", `Found Antigravity process: PID ${processInfo.pid}`);
-  const ports = await discoverPorts(processInfo.pid);
+  let ports = await discoverPorts(processInfo.pid);
+  if (ports.length === 0 && processInfo.extensionServerPort) {
+    debug("service", `Falling back to extension_server_port: ${processInfo.extensionServerPort}`);
+    ports = [processInfo.extensionServerPort];
+  }
   if (ports.length === 0) {
     throw new PortDetectionError();
   }