adhdev 0.1.6 → 0.1.8

package/dist/index.js

@@ -162,18 +162,18 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs() {
-  const os = (0, import_os.platform)();
+  const os2 = (0, import_os.platform)();
   const results = [];
   for (const def of IDE_DEFINITIONS) {
     const cliPath = findCliCommand(def.cli);
-    const appPath = checkPathExists(def.paths[os] || []);
+    const appPath = checkPathExists(def.paths[os2] || []);
     const installed = !!(cliPath || appPath);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os === "darwin") {
+    if (!resolvedCli && appPath && os2 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os === "win32") {
+    if (!resolvedCli && appPath && os2 === "win32") {
       const { dirname } = await import("path");
       const appDir = dirname(appPath);
       const candidates = [
@@ -772,15 +772,15 @@ async function loginFlow() {
 async function injectTokenToIDE(ide, connectionToken) {
   if (!ide.cliCommand) return;
   try {
-    const os = await import("os");
+    const os2 = await import("os");
     const fs = await import("fs");
     const path = await import("path");
-    const platform2 = os.platform();
-    const home = os.homedir();
+    const platform3 = os2.platform();
+    const home = os2.homedir();
     const getSettingsPath = (appName2) => {
-      if (platform2 === "darwin") {
+      if (platform3 === "darwin") {
         return path.join(home, "Library", "Application Support", appName2, "User", "settings.json");
-      } else if (platform2 === "win32") {
+      } else if (platform3 === "win32") {
         return path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), appName2, "User", "settings.json");
       } else {
         return path.join(home, ".config", appName2, "User", "settings.json");
@@ -853,12 +853,366 @@ async function addExtensionsFlow() {
   console.log(import_chalk.default.green("\n\u2713 Extensions added!"));
 }
 
+// src/launch.ts
+var import_child_process3 = require("child_process");
+var net = __toESM(require("net"));
+var os = __toESM(require("os"));
+var CDP_PORTS = {
+  cursor: [9333, 9334],
+  antigravity: [9335, 9336],
+  vscode: [9229, 9230],
+  windsurf: [9337, 9338],
+  "vscode-insiders": [9231, 9232],
+  vscodium: [9233, 9234]
+};
+var MAC_APP_IDENTIFIERS = {
+  cursor: "Cursor",
+  antigravity: "Antigravity",
+  vscode: "Visual Studio Code",
+  windsurf: "Windsurf",
+  "vscode-insiders": "Visual Studio Code - Insiders",
+  vscodium: "VSCodium"
+};
+var WIN_PROCESS_NAMES = {
+  cursor: "Cursor.exe",
+  antigravity: "Antigravity.exe",
+  vscode: "Code.exe",
+  windsurf: "Windsurf.exe",
+  "vscode-insiders": "Code - Insiders.exe",
+  vscodium: "VSCodium.exe"
+};
+async function findFreePort(ports) {
+  for (const port2 of ports) {
+    const free = await checkPortFree(port2);
+    if (free) return port2;
+  }
+  let port = ports[1] + 1;
+  while (port < ports[1] + 10) {
+    if (await checkPortFree(port)) return port;
+    port++;
+  }
+  throw new Error("No free port found");
+}
+function checkPortFree(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", () => resolve(false));
+    server.listen(port, "127.0.0.1", () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+async function isCdpActive(port) {
+  return new Promise((resolve) => {
+    const req = require("http").get(`http://127.0.0.1:${port}/json/version`, {
+      timeout: 2e3
+    }, (res) => {
+      let data = "";
+      res.on("data", (c) => data += c);
+      res.on("end", () => {
+        try {
+          const info = JSON.parse(data);
+          resolve(!!info["WebKit-Version"] || !!info["Browser"]);
+        } catch {
+          resolve(false);
+        }
+      });
+    });
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+async function killIdeProcess(ideId) {
+  const platform3 = os.platform();
+  const appName = MAC_APP_IDENTIFIERS[ideId];
+  const winProcess = WIN_PROCESS_NAMES[ideId];
+  try {
+    if (platform3 === "darwin" && appName) {
+      try {
+        (0, import_child_process3.execSync)(`osascript -e 'tell application "${appName}" to quit' 2>/dev/null`, {
+          timeout: 5e3
+        });
+      } catch {
+        try {
+          (0, import_child_process3.execSync)(`pkill -f "${appName}" 2>/dev/null`);
+        } catch {
+        }
+      }
+    } else if (platform3 === "win32" && winProcess) {
+      try {
+        (0, import_child_process3.execSync)(`taskkill /IM "${winProcess}" /F 2>nul`, { timeout: 5e3 });
+      } catch {
+      }
+    } else {
+      try {
+        (0, import_child_process3.execSync)(`pkill -f "${ideId}" 2>/dev/null`);
+      } catch {
+      }
+    }
+    for (let i = 0; i < 30; i++) {
+      await new Promise((r) => setTimeout(r, 500));
+      if (!isIdeRunning(ideId)) return true;
+    }
+    if (platform3 === "darwin" && appName) {
+      try {
+        (0, import_child_process3.execSync)(`pkill -9 -f "${appName}" 2>/dev/null`);
+      } catch {
+      }
+    } else if (platform3 === "win32" && winProcess) {
+      try {
+        (0, import_child_process3.execSync)(`taskkill /IM "${winProcess}" /F 2>nul`);
+      } catch {
+      }
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+    return !isIdeRunning(ideId);
+  } catch {
+    return false;
+  }
+}
+function isIdeRunning(ideId) {
+  const platform3 = os.platform();
+  try {
+    if (platform3 === "darwin") {
+      const appName = MAC_APP_IDENTIFIERS[ideId];
+      if (!appName) return false;
+      const result = (0, import_child_process3.execSync)(`pgrep -f "${appName}" 2>/dev/null`, { encoding: "utf-8" });
+      return result.trim().length > 0;
+    } else if (platform3 === "win32") {
+      const winProc = WIN_PROCESS_NAMES[ideId];
+      if (!winProc) return false;
+      const result = (0, import_child_process3.execSync)(`tasklist /FI "IMAGENAME eq ${winProc}" /NH 2>nul`, { encoding: "utf-8" });
+      return result.includes(winProc);
+    } else {
+      const result = (0, import_child_process3.execSync)(`pgrep -f "${ideId}" 2>/dev/null`, { encoding: "utf-8" });
+      return result.trim().length > 0;
+    }
+  } catch {
+    return false;
+  }
+}
+function detectCurrentWorkspace(ideId) {
+  const platform3 = os.platform();
+  if (platform3 !== "darwin") return void 0;
+  try {
+    const appName = MAC_APP_IDENTIFIERS[ideId];
+    if (!appName) return void 0;
+    const result = (0, import_child_process3.execSync)(
+      `lsof -c "${appName}" 2>/dev/null | grep cwd | head -1 | awk '{print $NF}'`,
+      { encoding: "utf-8", timeout: 3e3 }
+    );
+    const dir = result.trim();
+    if (dir && dir !== "/") return dir;
+  } catch {
+  }
+  return void 0;
+}
+async function launchWithCdp(options = {}) {
+  const platform3 = os.platform();
+  let targetIde;
+  const ides = await detectIDEs();
+  if (options.ideId) {
+    targetIde = ides.find((i) => i.id === options.ideId && i.installed);
+    if (!targetIde) {
+      return {
+        success: false,
+        ideId: options.ideId,
+        ideName: options.ideId,
+        port: 0,
+        action: "failed",
+        message: "",
+        error: `IDE '${options.ideId}' not found or not installed`
+      };
+    }
+  } else {
+    const config = loadConfig();
+    if (config.selectedIde) {
+      targetIde = ides.find((i) => i.id === config.selectedIde && i.installed);
+    }
+    if (!targetIde) {
+      targetIde = ides.find((i) => i.installed);
+    }
+    if (!targetIde) {
+      return {
+        success: false,
+        ideId: "unknown",
+        ideName: "Unknown",
+        port: 0,
+        action: "failed",
+        message: "",
+        error: "No IDE found. Install VS Code, Cursor, or Antigravity first."
+      };
+    }
+  }
+  const portPair = CDP_PORTS[targetIde.id] || [9333, 9334];
+  for (const port2 of portPair) {
+    if (await isCdpActive(port2)) {
+      return {
+        success: true,
+        ideId: targetIde.id,
+        ideName: targetIde.displayName,
+        port: port2,
+        action: "reused",
+        message: `CDP already active on port ${port2}`
+      };
+    }
+  }
+  const alreadyRunning = isIdeRunning(targetIde.id);
+  const workspace = options.workspace || (alreadyRunning ? detectCurrentWorkspace(targetIde.id) : void 0);
+  if (alreadyRunning) {
+    const killed = await killIdeProcess(targetIde.id);
+    if (!killed) {
+      return {
+        success: false,
+        ideId: targetIde.id,
+        ideName: targetIde.displayName,
+        port: 0,
+        action: "failed",
+        message: "",
+        error: `Could not stop ${targetIde.displayName}. Close it manually and try again.`
+      };
+    }
+    await new Promise((r) => setTimeout(r, 3e3));
+  }
+  const port = await findFreePort(portPair);
+  try {
+    if (platform3 === "darwin") {
+      await launchMacOS(targetIde, port, workspace, options.newWindow);
+    } else if (platform3 === "win32") {
+      await launchWindows(targetIde, port, workspace, options.newWindow);
+    } else {
+      await launchLinux(targetIde, port, workspace, options.newWindow);
+    }
+    let cdpReady = false;
+    for (let i = 0; i < 30; i++) {
+      await new Promise((r) => setTimeout(r, 500));
+      if (await isCdpActive(port)) {
+        cdpReady = true;
+        break;
+      }
+    }
+    return {
+      success: true,
+      ideId: targetIde.id,
+      ideName: targetIde.displayName,
+      port,
+      action: alreadyRunning ? "restarted" : "started",
+      message: cdpReady ? `${targetIde.displayName} launched with CDP on port ${port}` : `${targetIde.displayName} launched (CDP may take a moment to initialize)`
+    };
+  } catch (e) {
+    return {
+      success: false,
+      ideId: targetIde.id,
+      ideName: targetIde.displayName,
+      port,
+      action: "failed",
+      message: "",
+      error: e?.message || String(e)
+    };
+  }
+}
+async function launchMacOS(ide, port, workspace, newWindow) {
+  const appName = MAC_APP_IDENTIFIERS[ide.id];
+  const args = ["--remote-debugging-port=" + port];
+  if (newWindow) args.push("--new-window");
+  if (workspace) args.push(workspace);
+  if (appName) {
+    const openArgs = ["-a", appName, "--args", ...args];
+    (0, import_child_process3.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
+  } else if (ide.cliCommand) {
+    (0, import_child_process3.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore" }).unref();
+  } else {
+    throw new Error(`No app identifier or CLI for ${ide.displayName}`);
+  }
+}
+async function launchWindows(ide, port, workspace, newWindow) {
+  const cli = ide.cliCommand;
+  if (!cli) {
+    throw new Error(`No CLI command for ${ide.displayName}. Please add it to PATH.`);
+  }
+  const args = ["--remote-debugging-port=" + port];
+  if (newWindow) args.push("--new-window");
+  if (workspace) args.push(workspace);
+  (0, import_child_process3.spawn)(cli, args, {
+    detached: true,
+    stdio: "ignore",
+    shell: true
+  }).unref();
+}
+async function launchLinux(ide, port, workspace, newWindow) {
+  const cli = ide.cliCommand;
+  if (!cli) {
+    throw new Error(`No CLI command for ${ide.displayName}. Make sure it's in PATH.`);
+  }
+  const args = ["--remote-debugging-port=" + port];
+  if (newWindow) args.push("--new-window");
+  if (workspace) args.push(workspace);
+  (0, import_child_process3.spawn)(cli, args, { detached: true, stdio: "ignore" }).unref();
+}
+
 // src/index.ts
 var program = new import_commander.Command();
-program.name("adhdev").description("\u{1F309} ADHDev \u2014 Agent Dashboard Hub for your IDE").version("0.1.0");
+program.name("adhdev").description("\u{1F309} ADHDev \u2014 Agent Dashboard Hub for your IDE").version("0.1.6");
 program.command("setup", { isDefault: true }).description("Run the interactive setup wizard").option("-f, --force", "Force re-run setup even if already configured").action(async (options) => {
   await runWizard({ force: options.force });
 });
+program.command("launch [ide]").description("Launch or relaunch IDE with CDP debugging port (kills existing process first)").option("-w, --workspace <path>", "Workspace/folder to open").option("-n, --new-window", "Open in a new window").action(async (ideArg, options) => {
+  const ora2 = await import("ora");
+  const spinner = ora2.default("Detecting IDE...").start();
+  try {
+    const result = await launchWithCdp({
+      ideId: ideArg,
+      workspace: options.workspace,
+      newWindow: options.newWindow
+    });
+    spinner.stop();
+    if (!result.success) {
+      console.log(import_chalk2.default.red(`
+\u2717 ${result.error}
+`));
+      console.log(import_chalk2.default.gray("  Available IDEs:"));
+      const ides = await detectIDEs();
+      ides.forEach((ide) => {
+        if (ide.installed) {
+          console.log(`    ${import_chalk2.default.green("\u2713")} ${ide.icon} ${import_chalk2.default.bold(ide.id)} \u2014 ${ide.displayName}`);
+        }
+      });
+      console.log(import_chalk2.default.gray(`
+  Usage: adhdev launch <ide-id>
+`));
+      process.exit(1);
+    }
+    console.log();
+    console.log(import_chalk2.default.bold("  \u{1F680} IDE Launched with CDP\n"));
+    console.log(`  ${import_chalk2.default.bold("IDE:")}     ${result.ideName}`);
+    console.log(`  ${import_chalk2.default.bold("CDP:")}     ${import_chalk2.default.cyan(`ws://127.0.0.1:${result.port}`)}`);
+    switch (result.action) {
+      case "reused":
+        console.log(`  ${import_chalk2.default.bold("Action:")}  ${import_chalk2.default.yellow("CDP already active \u2014 reusing existing session")}`);
+        break;
+      case "restarted":
+        console.log(`  ${import_chalk2.default.bold("Action:")}  ${import_chalk2.default.green("\u2713 Killed existing process \u2192 Restarted with CDP")}`);
+        break;
+      case "started":
+        console.log(`  ${import_chalk2.default.bold("Action:")}  ${import_chalk2.default.green("\u2713 Started fresh with CDP")}`);
+        break;
+    }
+    console.log();
+    console.log(import_chalk2.default.gray("  Bridge extension will auto-connect to CDP."));
+    console.log(import_chalk2.default.gray(`  Test: curl http://127.0.0.1:${result.port}/json/version
+`));
+  } catch (e) {
+    spinner.stop();
+    console.log(import_chalk2.default.red(`
+\u2717 Launch failed: ${e?.message || e}
+`));
+    process.exit(1);
+  }
+});
 program.command("status").description("Show current ADHDev setup status").action(() => {
   const config = loadConfig();
   console.log(import_chalk2.default.bold("\n\u{1F309} ADHDev Status\n"));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "adhdev",
-    "version": "0.1.6",
+    "version": "0.1.8",
     "description": "ADHDev CLI — Detect, install and configure your IDE + AI agent extensions",
     "main": "dist/index.js",
     "bin": {