halo-agent 1.2.0 → 1.3.0

package/browser.js

@@ -3,10 +3,19 @@
 const { chromium } = require('playwright');
 const { execSync, spawnSync, spawn } = require('child_process');
 const fs = require('fs');
+const path = require('path');
+const os = require('os');
 
 const CDP_PORT = 9222;
 const CDP_URL = `http://localhost:${CDP_PORT}`;
 
+// Dedicated user-data-dir for the agent's Chrome. Fully isolated from the
+// user's real Chrome so it can run side-by-side without profile-lock
+// collisions (which silently disable --remote-debugging-port). The
+// user logs into Workday / LinkedIn here ONCE on first run and the
+// session persists across runs because this dir is on disk, not /tmp.
+const AGENT_PROFILE_DIR = path.join(os.homedir(), '.halo-agent', 'chrome-profile');
+
 /**
  * Check if Chrome is already running with remote debugging on CDP_PORT.
  */
@@ -42,12 +51,22 @@ function findChromeMac() {
  */
 function launchChrome() {
   const platform = process.platform;
-  const flags = [
+
+  // Ensure the dedicated profile dir exists. Chrome will populate it on
+  // first launch (and persist cookies/logins there across runs).
+  try { fs.mkdirSync(AGENT_PROFILE_DIR, { recursive: true }); } catch {}
+
+  // Note: we use --user-data-dir (a full isolated dir), NOT --profile-directory
+  // (which is a sub-profile name inside the default user-data-dir and would
+  // still collide with the user's running Chrome and silently drop the
+  // --remote-debugging-port flag).
+  const baseFlags = [
     `--remote-debugging-port=${CDP_PORT}`,
-    '--profile-directory=Default',
+    `--user-data-dir=${AGENT_PROFILE_DIR}`,
     '--no-first-run',
     '--no-default-browser-check',
-  ].join(' ');
+    '--no-default-browser-check',
+  ];
 
   if (platform === 'darwin') {
     const chromePath = findChromeMac();
@@ -55,9 +74,11 @@ 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,
+    // `open -na` forces a fresh app instance (LaunchServices would otherwise
+    // reactivate the existing Chrome and drop our flags). Because we point
+    // at a dedicated --user-data-dir, this instance does NOT collide with
+    // the user's everyday Chrome — they can run side-by-side cleanly.
+    spawn('open', ['-na', chromePath, '--args', ...baseFlags], {
       detached: true,
       stdio: 'ignore',
     }).unref();
@@ -69,10 +90,12 @@ function launchChrome() {
     ];
     const chromePath = chromePaths.find(p => { try { fs.accessSync(p); return true; } catch { return false; } });
     if (!chromePath) { console.error('[halo-agent] Chrome not found on Windows.'); return; }
-    spawn(`"${chromePath}" ${flags}`, [], { shell: true, detached: true, stdio: 'ignore' }).unref();
+    const winFlags = baseFlags.map(f => f.includes(' ') ? `"${f}"` : f).join(' ');
+    spawn(`"${chromePath}" ${winFlags}`, [], { shell: true, detached: true, stdio: 'ignore' }).unref();
   } else {
     // Linux
-    spawn(`google-chrome ${flags}`, [], { shell: true, detached: true, stdio: 'ignore' }).unref();
+    const linuxFlags = baseFlags.map(f => f.includes(' ') ? `"${f}"` : f).join(' ');
+    spawn(`google-chrome ${linuxFlags}`, [], { shell: true, detached: true, stdio: 'ignore' }).unref();
   }
 }
 
@@ -81,7 +104,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 +163,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...');
@@ -148,9 +176,11 @@ 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`
+    `Could not connect to the agent's Chrome on port ${CDP_PORT} after ${retries} attempts.\n` +
+    `The agent uses an isolated Chrome profile at ${AGENT_PROFILE_DIR}.\n` +
+    `If a previous run is still alive, kill it:\n\n` +
+    `  pkill -f "user-data-dir=${AGENT_PROFILE_DIR}"\n\n` +
+    `Then run \`halo-agent start\` again.\n`
   );
 }
 

package/index.js

@@ -346,24 +346,56 @@ async function restartChromeWithDebugFlag() {
   const { launchChrome, isChromeDebuggable } = require('./browser');
 
   console.log('Restarting Chrome…');
-  if (process.platform === 'darwin') {
-    // AppleScript graceful quit — respects Chrome's restore-tabs behavior.
-    try {
-      spawnSync('osascript', ['-e', 'tell application "Google Chrome" to quit'], { stdio: 'ignore' });
-    } catch { /* fall through to pkill if osascript missing */ }
-  } else if (process.platform === 'win32') {
-    // Windows: send WM_CLOSE via taskkill (no /F so it's graceful).
-    try { spawnSync('taskkill', ['/IM', 'chrome.exe'], { stdio: 'ignore' }); } catch {}
-  } else {
-    try { spawnSync('pkill', ['-x', 'chrome'], { stdio: 'ignore' }); } catch {}
-  }
 
-  // Poll until Chrome is gone (up to 10s). If it lingers, the user has a
-  // "leave site?" prompt or modal — we surface that rather than force-killing.
-  const gone = await waitForChromeGone(10_000);
+  // 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) {
-    console.error('Chrome didn’t quit (you may have an unsaved-changes prompt).');
-    console.error('Click through any prompts in Chrome, then run `halo-agent start` again.');
+    // 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);
   }
 
@@ -372,15 +404,19 @@ async function restartChromeWithDebugFlag() {
   await new Promise(r => setTimeout(r, 800)); // brief breath
   launchChrome();
 
-  // Wait for the new Chrome to expose CDP. Up to ~15s.
-  for (let i = 0; i < 30; i++) {
+  // 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('Chrome is back, debugging enabled.');
+      console.log('\nChrome is back, debugging enabled.');
       return;
     }
+    process.stdout.write('.');
     await new Promise(r => setTimeout(r, 500));
   }
-  console.error('Chrome relaunched but CDP didn’t come up in time.');
+  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);
 }
@@ -417,29 +453,16 @@ async function runStart() {
   console.log('\nHALO Agent starting...');
   console.log('Connecting to your Chrome browser...\n');
 
-  // 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');
-  const alreadyDebuggable = await isChromeDebuggable();
-  if (!alreadyDebuggable) {
-    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();
-    }
-  }
-
+  // The agent runs its own isolated Chrome instance (separate --user-data-dir
+  // at ~/.halo-agent/chrome-profile) so it never collides with the user's
+  // everyday Chrome. First launch will be a blank profile — the user logs
+  // into Workday / LinkedIn ONCE in the agent's Chrome and those sessions
+  // persist across runs. No need to detect or restart the user's Chrome.
   let chromeConn;
   try {
-    chromeConn = await connectToChrome();
+    chromeConn = await connectToChrome(10);
     console.log('\nConnected to Chrome. Polling for queued jobs...');
+    console.log('First time? Log into Workday/LinkedIn in this Chrome window — sessions persist.');
     console.log('Go to your HALO dashboard and click "Auto-Apply" on any job.\n');
   } catch (err) {
     console.error('\nCould not connect to Chrome:', err.message);

package/package.json

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