halo-agent 1.1.0 → 1.2.2

package/browser.js

@@ -55,9 +55,22 @@ function launchChrome() {
       console.error('[halo-agent] Chrome not found. Install Google Chrome from https://www.google.com/chrome/');
       return;
     }
-    // Use shell:true so the path with spaces is handled correctly by the shell
-    spawn(`"${chromePath}" ${flags}`, [], {
-      shell: true,
+    // CRITICAL: on macOS, spawning the Chrome executable directly while
+    // LaunchServices still has a Chrome instance registered (recent quit,
+    // dock icon still showing, etc.) causes the new launch to REACTIVATE
+    // the existing instance and silently DROP all --flags. Symptom: Chrome
+    // opens but without --remote-debugging-port, so the agent can never
+    // see it. `open -na` forces a fresh app instance and `--args` passes
+    // flags through reliably — this is the only correct way to launch
+    // Chrome with custom flags on macOS.
+    const splitFlags = [
+      `--remote-debugging-port=${CDP_PORT}`,
+      '--profile-directory=Default',
+      '--no-first-run',
+      '--no-default-browser-check',
+      '--restore-last-session',  // bring back the windows the user just had
+    ];
+    spawn('open', ['-na', chromePath, '--args', ...splitFlags], {
       detached: true,
       stdio: 'ignore',
     }).unref();
@@ -81,7 +94,12 @@ function launchChrome() {
  * Returns { browser, context, newPage }.
  * All requests use the user's real session — cookies, IP, fingerprint, extensions.
  */
-async function connectToChrome(retries = 10) {
+async function connectToChrome(retries = 10, opts = {}) {
+  // skipLaunch: caller has ALREADY launched Chrome (e.g. via the index.js
+  // restart-with-debug-flag flow) and we should JUST wait for CDP to come
+  // up. Without this, every retry path also tries to launch Chrome again,
+  // which on macOS spawns extra windows via the LaunchServices race.
+  const skipLaunch = !!opts.skipLaunch;
   for (let i = 0; i < retries; i++) {
     const debuggable = await isChromeDebuggable();
     if (debuggable) {
@@ -135,7 +153,7 @@ async function connectToChrome(retries = 10) {
       }
     }
 
-    if (i === 0) {
+    if (i === 0 && !skipLaunch) {
       console.log('[halo-agent] Chrome not found on port 9222. Launching...');
       launchChrome();
       console.log('[halo-agent] Waiting for Chrome to start...');
@@ -149,8 +167,10 @@ async function connectToChrome(retries = 10) {
   console.log(''); // newline after dots
   throw new Error(
     `Could not connect to Chrome after ${retries} attempts.\n` +
-    `Run this manually in a separate terminal, then try again:\n\n` +
-    `  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --remote-debugging-port=9222 --user-data-dir=/tmp/halo-chrome\n`
+    `Chrome may have launched without the --remote-debugging-port=9222 flag\n` +
+    `(macOS reactivates an existing Chrome instance and drops flags).\n` +
+    `Try: fully quit Chrome (Cmd+Q in every window + check the dock), then run:\n\n` +
+    `  halo-agent start\n`
   );
 }
 

package/index.js

@@ -291,6 +291,158 @@ async function runInit() {
   console.log('Run "halo-agent start" to begin.\n');
 }
 
+// Is Chrome running without the --remote-debugging-port=9222 flag?
+// Returns true ONLY when we're certain a restart is needed.
+async function detectChromeRunningWithoutDebug() {
+  const { execSync } = require('child_process');
+  try {
+    if (process.platform === 'darwin') {
+      execSync('pgrep -x "Google Chrome"', { stdio: 'ignore' });
+      const psOut = execSync('ps aux', { encoding: 'utf8' });
+      return !psOut.includes('--remote-debugging-port=9222');
+    }
+    if (process.platform === 'win32') {
+      const out = execSync('tasklist /FI "IMAGENAME eq chrome.exe"', { encoding: 'utf8' });
+      if (!/chrome\.exe/i.test(out)) return false;
+      // Windows tasklist doesn't show full cmdline; use wmic as a fallback.
+      try {
+        const wmic = execSync('wmic process where "name=\'chrome.exe\'" get CommandLine', { encoding: 'utf8' });
+        return !wmic.includes('--remote-debugging-port=9222');
+      } catch { return true; } // can't introspect — safer to offer restart
+    }
+    // Linux
+    try { execSync('pgrep -x chrome', { stdio: 'ignore' }); } catch { return false; }
+    try {
+      const ps = execSync('ps -eo args', { encoding: 'utf8' });
+      return !ps.includes('--remote-debugging-port=9222');
+    } catch { return true; }
+  } catch {
+    return false; // pgrep failed → Chrome not running
+  }
+}
+
+// Terminal Y/n prompt for the consent before we touch Chrome.
+function offerChromeRestart() {
+  return new Promise((resolve) => {
+    console.log('');
+    console.log('Chrome is running, but without the debug flag the agent needs.');
+    console.log('I can restart Chrome for you — your tabs will reopen automatically');
+    console.log('(if your "On startup" setting is "Continue where you left off").');
+    console.log('');
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question('Restart Chrome now? [Y/n] ', (ans) => {
+      rl.close();
+      const a = (ans || '').trim().toLowerCase();
+      resolve(a === '' || a === 'y' || a === 'yes');
+    });
+  });
+}
+
+// Graceful quit (preserves tabs), wait until the process is actually gone,
+// then relaunch with the debug flag. Cross-platform.
+async function restartChromeWithDebugFlag() {
+  const { execSync, spawnSync } = require('child_process');
+  const { launchChrome, isChromeDebuggable } = require('./browser');
+
+  console.log('Restarting Chrome…');
+
+  // Escalation ladder: try the friendliest quit first, escalate if needed.
+  // On macOS the "warn before quitting" dialog can intercept AppleScript
+  // quit, so we follow up with SIGTERM (still graceful — Chrome handles it
+  // and saves session state). SIGKILL is last resort and very rarely needed.
+  const tryGraceful = () => {
+    if (process.platform === 'darwin') {
+      try { spawnSync('osascript', ['-e', 'tell application "Google Chrome" to quit'], { stdio: 'ignore' }); } catch {}
+    } else if (process.platform === 'win32') {
+      try { spawnSync('taskkill', ['/IM', 'chrome.exe'], { stdio: 'ignore' }); } catch {}
+    } else {
+      try { spawnSync('pkill', ['-x', 'chrome'], { stdio: 'ignore' }); } catch {}
+    }
+  };
+  const trySigterm = () => {
+    if (process.platform === 'darwin') {
+      try { spawnSync('pkill', ['-TERM', '-x', 'Google Chrome'], { stdio: 'ignore' }); } catch {}
+    } else if (process.platform === 'win32') {
+      // Already taskkill above; no escalation step worth running before /F
+    } else {
+      try { spawnSync('pkill', ['-TERM', '-x', 'chrome'], { stdio: 'ignore' }); } catch {}
+    }
+  };
+  const tryForce = () => {
+    if (process.platform === 'darwin') {
+      try { spawnSync('pkill', ['-9', '-x', 'Google Chrome'], { stdio: 'ignore' }); } catch {}
+    } else if (process.platform === 'win32') {
+      try { spawnSync('taskkill', ['/F', '/IM', 'chrome.exe'], { stdio: 'ignore' }); } catch {}
+    } else {
+      try { spawnSync('pkill', ['-9', '-x', 'chrome'], { stdio: 'ignore' }); } catch {}
+    }
+  };
+
+  tryGraceful();
+  let gone = await waitForChromeGone(4_000);
+  if (!gone) {
+    // AppleScript blocked (likely by "warn before quitting" dialog). SIGTERM
+    // bypasses the dialog but still lets Chrome shut down cleanly.
+    console.log('Sending SIGTERM (Chrome had a quit prompt) …');
+    trySigterm();
+    gone = await waitForChromeGone(4_000);
+  }
+  if (!gone) {
+    // Last resort.
+    console.log('Force-quitting Chrome …');
+    tryForce();
+    gone = await waitForChromeGone(3_000);
+  }
+  if (!gone) {
+    console.error('Could not stop Chrome. Quit it manually (Cmd+Q in every window) and run `halo-agent start` again.');
+    process.exit(1);
+  }
+
+  // Relaunch with the debug flag + Default profile. Uses the existing
+  // browser.js logic so the path-finding stays in one place.
+  await new Promise(r => setTimeout(r, 800)); // brief breath
+  launchChrome();
+
+  // Wait for the new Chrome to expose CDP. Up to ~25s — with
+  // --restore-last-session Chrome has to re-open every tab from before,
+  // which on a heavy session can take 10-15s before the CDP server binds.
+  process.stdout.write('Waiting for Chrome to expose CDP');
+  for (let i = 0; i < 50; i++) {
+    if (await isChromeDebuggable()) {
+      console.log('\nChrome is back, debugging enabled.');
+      return;
+    }
+    process.stdout.write('.');
+    await new Promise(r => setTimeout(r, 500));
+  }
+  console.error('\nChrome relaunched but CDP didn’t come up in time.');
+  console.error('Try running `halo-agent start` again — Chrome may have just been slow.');
+  process.exit(1);
+}
+
+async function waitForChromeGone(timeoutMs) {
+  const { execSync } = require('child_process');
+  const probe = () => {
+    try {
+      if (process.platform === 'darwin') execSync('pgrep -x "Google Chrome"', { stdio: 'ignore' });
+      else if (process.platform === 'win32') {
+        const out = execSync('tasklist /FI "IMAGENAME eq chrome.exe"', { encoding: 'utf8' });
+        if (!/chrome\.exe/i.test(out)) return false;
+      } else execSync('pgrep -x chrome', { stdio: 'ignore' });
+      return true; // pgrep succeeded → still running
+    } catch {
+      return false; // pgrep failed → process gone
+    }
+  };
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!probe()) return true;
+    await new Promise(r => setTimeout(r, 300));
+  }
+  return false;
+}
+
 async function runStart() {
   const config = loadConfig();
   if (!config || !config.token) {
@@ -301,39 +453,33 @@ async function runStart() {
   console.log('\nHALO Agent starting...');
   console.log('Connecting to your Chrome browser...\n');
 
-  // Pre-check: if Chrome is running WITHOUT debug port, warn immediately
+  // Pre-check: Chrome must be running with --remote-debugging-port=9222 for
+  // CDP to work. If it's running WITHOUT that flag, Chrome can't have it
+  // added retroactively — it's a Chrome architecture limit. We offer to
+  // restart Chrome gracefully (preserves tabs via Chrome's "Continue where
+  // you left off" setting) and relaunch with the flag.
   const { isChromeDebuggable } = require('./browser');
+  // weRestartedIt: tracks whether THIS process launched/restarted Chrome.
+  // When true, connectToChrome must NOT launch again — that's the double-
+  // launch bug that was spawning extra Chrome windows.
+  let weRestartedIt = false;
   const alreadyDebuggable = await isChromeDebuggable();
   if (!alreadyDebuggable) {
-    const { execSync } = require('child_process');
-    let chromeRunning = false;
-    let chromeHasDebugFlag = false;
-    try {
-      execSync('pgrep -x "Google Chrome"', { stdio: 'ignore' });
-      chromeRunning = true;
-    } catch {}
-    if (chromeRunning) {
-      try {
-        const psOut = execSync('ps aux', { encoding: 'utf8' });
-        chromeHasDebugFlag = psOut.includes('--remote-debugging-port=9222');
-      } catch {}
-    }
-    if (chromeRunning && !chromeHasDebugFlag) {
-      console.error('Chrome is already running WITHOUT remote debugging enabled.\n');
-      console.error('You need to fully quit Chrome first, then relaunch it with the debug flag.\n');
-      console.error('Run these commands:\n');
-      console.error('  pkill -a -i "Google Chrome"');
-      console.error('  sleep 2');
-      console.error('  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --remote-debugging-port=9222 --profile-directory=Default &');
-      console.error('  sleep 4');
-      console.error('  node index.js start\n');
-      process.exit(1);
+    const needsRestart = await detectChromeRunningWithoutDebug();
+    if (needsRestart) {
+      const ok = await offerChromeRestart();
+      if (!ok) {
+        console.error('\nOK — leaving Chrome alone. Run `halo-agent start` again after you’ve quit Chrome.');
+        process.exit(1);
+      }
+      await restartChromeWithDebugFlag();
+      weRestartedIt = true;
     }
   }
 
   let chromeConn;
   try {
-    chromeConn = await connectToChrome();
+    chromeConn = await connectToChrome(10, { skipLaunch: weRestartedIt });
     console.log('\nConnected to Chrome. Polling for queued jobs...');
     console.log('Go to your HALO dashboard and click "Auto-Apply" on any job.\n');
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "1.1.0",
+  "version": "1.2.2",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {