neoagent 2.3.1-beta.0 → 2.3.1-beta.100

package/server/services/bootstrap_helpers.js

@@ -1,7 +1,3 @@
-'use strict';
-
-const HEADLESS_BROWSER_SETTING_KEY = 'headless_browser';
-
 function getErrorMessage(error) {
   if (error instanceof Error && error.message) {
     return error.message;
@@ -10,34 +6,6 @@ function getErrorMessage(error) {
   return String(error);
 }
 
-function isEnabledSetting(value) {
-  return value !== 'false' && value !== false && value !== '0';
-}
-
-function restoreBrowserHeadlessPreference(browserController, database) {
-  const userCount =
-    database.prepare('SELECT COUNT(*) AS count FROM users').get()?.count || 0;
-  const headlessSetting =
-    userCount === 1
-      ? database
-          .prepare(
-            'SELECT value FROM user_settings WHERE user_id = (SELECT id FROM users LIMIT 1) AND key = ?',
-          )
-          .get(HEADLESS_BROWSER_SETTING_KEY)
-      : null;
-
-  if (!headlessSetting) {
-    return { restored: false, userCount };
-  }
-
-  browserController.headless = isEnabledSetting(headlessSetting.value);
-  return {
-    restored: true,
-    userCount,
-    headless: browserController.headless,
-  };
-}
-
 function runBackgroundTask(errorPrefix, task, logger = console.error) {
   return Promise.resolve()
     .then(task)
@@ -48,7 +16,5 @@ function runBackgroundTask(errorPrefix, task, logger = console.error) {
 
 module.exports = {
   getErrorMessage,
-  isEnabledSetting,
-  restoreBrowserHeadlessPreference,
   runBackgroundTask,
 };

package/server/services/browser/controller.js

@@ -1,16 +1,20 @@
 const path = require('path');
 const fs = require('fs');
+const { spawn } = require('child_process');
 const { DATA_DIR } = require('../../../runtime/paths');
 
 const SCREENSHOTS_DIR = path.join(DATA_DIR, 'screenshots');
 if (!fs.existsSync(SCREENSHOTS_DIR)) fs.mkdirSync(SCREENSHOTS_DIR, { recursive: true });
+const BROWSER_PROFILE_ROOT = path.join(DATA_DIR, 'browser-profiles');
+if (!fs.existsSync(BROWSER_PROFILE_ROOT)) fs.mkdirSync(BROWSER_PROFILE_ROOT, { recursive: true });
+const BROWSER_READY_MARKER = '/var/lib/neoagent/browser-runtime-ready';
 
 const USER_AGENTS = [
-  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36',
   'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
   'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
-  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36',
 ];
 
 const VIEWPORTS = [
@@ -22,12 +26,31 @@ const VIEWPORTS = [
 
 function resolveBrowserExecutablePath() {
   const explicitPath =
+    process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH ||
     process.env.PUPPETEER_EXECUTABLE_PATH ||
     process.env.CHROME_BIN ||
     process.env.CHROMIUM_BIN;
 
   if (explicitPath && fs.existsSync(explicitPath)) return explicitPath;
 
+  const bundledCandidates = [
+    () => require('playwright-chromium').chromium.executablePath(),
+  ];
+  for (const resolveBundled of bundledCandidates) {
+    try {
+      const bundledPath = resolveBundled();
+      if (bundledPath && fs.existsSync(bundledPath)) {
+        if (process.platform === 'linux') {
+          const wrappedPath = path.join(path.dirname(bundledPath), 'chrome-wrapper');
+          if (fs.existsSync(wrappedPath)) {
+            return wrappedPath;
+          }
+        }
+        return bundledPath;
+      }
+    } catch {}
+  }
+
   const platformCandidates = process.platform === 'darwin'
     ? [
         '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
@@ -53,6 +76,38 @@ function resolveBrowserExecutablePath() {
   return platformCandidates.find((candidate) => fs.existsSync(candidate)) || null;
 }
 
+function installPlaywrightBrowserBinary(browserName) {
+  const packageRoot = path.dirname(require.resolve('playwright-chromium/package.json'));
+  const cliPath = path.join(packageRoot, 'cli.js');
+  return new Promise((resolve, reject) => {
+    const args = [cliPath, 'install', '--no-shell', browserName];
+    const child = spawn(process.execPath, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+    child.on('error', (error) => {
+      const detail = String(error?.message || `playwright install ${browserName} failed`).trim();
+      reject(new Error(detail));
+    });
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      const detail = String(stderr || stdout || `playwright install ${browserName} exited with code ${code ?? 'unknown'}`).trim();
+      reject(new Error(detail));
+    });
+  });
+}
+
 function rand(min, max) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 }
@@ -61,6 +116,22 @@ function sleep(ms) {
   return new Promise(r => setTimeout(r, ms));
 }
 
+async function waitForFile(filePath, options = {}) {
+  const timeoutMs = Math.max(0, Number(options.timeoutMs || 0));
+  const intervalMs = Math.max(100, Number(options.intervalMs || 500));
+  if (!filePath || timeoutMs <= 0 || fs.existsSync(filePath)) {
+    return fs.existsSync(filePath);
+  }
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    await sleep(intervalMs);
+    if (fs.existsSync(filePath)) {
+      return true;
+    }
+  }
+  return fs.existsSync(filePath);
+}
+
 function buildIsolatedEvaluationExpression(script) {
   const source = String(script || 'undefined');
   // Evaluate each snippet inside a fresh function scope so repeated calls do not
@@ -68,26 +139,59 @@ function buildIsolatedEvaluationExpression(script) {
   return `(() => eval(${JSON.stringify(source)}))()`;
 }
 
+function normalizeWaitUntil(waitUntil) {
+  const value = String(waitUntil || '').trim().toLowerCase();
+  if (value === 'networkidle0' || value === 'networkidle2') {
+    return 'networkidle';
+  }
+  if (value === 'load' || value === 'domcontentloaded' || value === 'networkidle' || value === 'commit') {
+    return value;
+  }
+  return 'domcontentloaded';
+}
+
+function clearChromiumSingletonLocks(profileDir) {
+  const lockEntries = [
+    'SingletonLock',
+    'SingletonSocket',
+    'SingletonCookie',
+    'SingletonStartupLock',
+    'DevToolsActivePort',
+  ];
+  for (const entry of lockEntries) {
+    const targetPath = path.join(profileDir, entry);
+    try {
+      fs.rmSync(targetPath, { force: true, recursive: true });
+    } catch {}
+  }
+}
+
 class BrowserController {
   constructor(options = {}) {
     this.io = options.io || null;
     this.userId = options.userId != null ? String(options.userId) : null;
     this.artifactStore = options.artifactStore || null;
     this.runtimeBackend = options.runtimeBackend || 'host';
+    this.engine = 'chromium';
     this.browser = null;
+    this.context = null;
     this.page = null;
+    this.displayProcess = null;
+    this.displayValue = process.env.DISPLAY || null;
     this.launching = false;
-    this.headless = true;
+    this.launchPromise = null;
+    this.browserBinaryInstallPromise = null;
+    this.headless = false;
     this._viewport = VIEWPORTS[0];
     this._userAgent = USER_AGENTS[0];
+    this.profileDir = path.join(BROWSER_PROFILE_ROOT, this.userId || 'default');
+    if (!fs.existsSync(this.profileDir)) fs.mkdirSync(this.profileDir, { recursive: true });
   }
 
   async setHeadless(val) {
-    const wasHeadless = this.headless;
-    this.headless = val !== false && val !== 'false';
-    if (wasHeadless !== this.headless) {
-      await this.close().catch(() => { });
-    }
+    void val;
+    // Browser sessions inside the VM always run headed.
+    this.headless = false;
   }
 
   async closeBrowser() {
@@ -98,14 +202,20 @@ class BrowserController {
     const ua = this._userAgent;
     const vp = this._viewport;
 
-    await page.setUserAgent(ua);
-    await page.setViewport(vp);
-    await page.setExtraHTTPHeaders({
-      'Accept-Language': 'en-US,en;q=0.9',
-    });
+    if (typeof page.setUserAgent === 'function') {
+      await page.setUserAgent(ua);
+    }
+    if (typeof page.setViewport === 'function') {
+      await page.setViewport(vp);
+    }
+    if (typeof page.setExtraHTTPHeaders === 'function') {
+      await page.setExtraHTTPHeaders({
+        'Accept-Language': 'en-US,en;q=0.9',
+      });
+    }
 
     // Inject fingerprint overrides before any page script runs
-    await page.evaluateOnNewDocument(`
+    const script = `
       (() => {
         // Remove webdriver flag
         Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
@@ -148,47 +258,138 @@ class BrowserController {
             return arr;
           }
         });
+
+        // WebGL Spoofing
+        const getParameterProxyHandler = {
+          apply: function(target, ctx, args) {
+            const param = args[0];
+            // UNMASKED_VENDOR_WEBGL
+            if (param === 37445) return 'Google Inc. (Apple)';
+            // UNMASKED_RENDERER_WEBGL
+            if (param === 37446) return 'ANGLE (Apple, Apple M2, OpenGL 4.1)';
+            return Reflect.apply(target, ctx, args);
+          }
+        };
+        const getParam = WebGLRenderingContext.prototype.getParameter;
+        WebGLRenderingContext.prototype.getParameter = new Proxy(getParam, getParameterProxyHandler);
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+          const getParam2 = WebGL2RenderingContext.prototype.getParameter;
+          WebGL2RenderingContext.prototype.getParameter = new Proxy(getParam2, getParameterProxyHandler);
+        }
+
+        // Canvas Spoofing (slight noise)
+        const originalFillText = CanvasRenderingContext2D.prototype.fillText;
+        CanvasRenderingContext2D.prototype.fillText = function(...args) {
+            if (!this._spoofing_applied) {
+                this._spoofing_applied = true;
+                const r = Math.random() * 0.0001;
+                const g = Math.random() * 0.0001;
+                const b = Math.random() * 0.0001;
+                this.fillStyle = \`rgba(\${Math.floor(r * 255)}, \${Math.floor(g * 255)}, \${Math.floor(b * 255)}, 0.01)\`;
+                originalFillText.call(this, "spoof", 0, 0);
+            }
+            return originalFillText.apply(this, args);
+        };
+
+        // Media Devices Spoofing
+        if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+            const originalEnumerateDevices = navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices);
+            navigator.mediaDevices.enumerateDevices = async () => {
+                return [
+                    { kind: 'audioinput', deviceId: 'default', groupId: 'a', label: 'MacBook Pro Microphone' },
+                    { kind: 'audiooutput', deviceId: 'default', groupId: 'b', label: 'MacBook Pro Speakers' },
+                    { kind: 'videoinput', deviceId: 'default', groupId: 'c', label: 'FaceTime HD Camera' }
+                ];
+            };
+        }
       })();
-    `);
+    `;
+    if (typeof page.evaluateOnNewDocument === 'function') {
+      await page.evaluateOnNewDocument(script);
+    } else if (typeof page.addInitScript === 'function') {
+      await page.addInitScript(script);
+    }
   }
 
   async ensureBrowser() {
     if (this.browser && this.browser.isConnected()) return;
-    if (this.launching) {
-      await sleep(2000);
+    if (this.launchPromise) {
+      await this.launchPromise;
       return;
     }
 
     this.launching = true;
-    try {
-      const puppeteer = require('puppeteer-extra');
-      const StealthPlugin = require('puppeteer-extra-plugin-stealth');
-      puppeteer.use(StealthPlugin());
+    this.launchPromise = (async () => {
+      const runtimeReady = await waitForFile(BROWSER_READY_MARKER, {
+        timeoutMs: 10 * 60 * 1000,
+        intervalMs: 1000,
+      });
+      if (!runtimeReady) {
+        throw new Error('Browser runtime provisioning is still in progress inside the VM. Retry shortly.');
+      }
+      await this.ensureVirtualDisplay();
 
       this._userAgent = USER_AGENTS[rand(0, USER_AGENTS.length - 1)];
       this._viewport = VIEWPORTS[rand(0, VIEWPORTS.length - 1)];
 
-      this.browser = await puppeteer.launch({
-        headless: this.headless ? 'new' : false,
-        executablePath: resolveBrowserExecutablePath() || undefined,
-        args: [
-          '--no-sandbox',
-          '--disable-setuid-sandbox',
-          '--disable-dev-shm-usage',
-          '--disable-blink-features=AutomationControlled',
-          '--disable-infobars',
-          '--no-first-run',
-          '--no-default-browser-check',
-          '--lang=en-US,en',
-          `--window-size=${this._viewport.width},${this._viewport.height}`,
-        ],
-        defaultViewport: this._viewport,
-        ignoreDefaultArgs: ['--enable-automation'],
-      });
+      let executablePath = resolveBrowserExecutablePath();
+      if (!executablePath) {
+        if (!this.browserBinaryInstallPromise) {
+          this.browserBinaryInstallPromise = installPlaywrightBrowserBinary(this.engine);
+        }
+        try {
+          await this.browserBinaryInstallPromise;
+        } finally {
+          this.browserBinaryInstallPromise = null;
+        }
+        executablePath = resolveBrowserExecutablePath();
+      }
+
+      if (!executablePath) {
+        throw new Error(`No ${this.engine} executable found for the VM browser runtime.`);
+      }
+
+      const launchEnv = {
+        ...process.env,
+        ...(this.displayValue ? { DISPLAY: this.displayValue } : {}),
+      };
 
-      this.page = await this.browser.newPage();
+      const launchArgs = [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--disable-dev-shm-usage',
+        '--disable-crash-reporter',
+        '--disable-background-networking',
+        '--disable-component-update',
+        '--disable-blink-features=AutomationControlled',
+        '--disable-infobars',
+        '--no-first-run',
+        '--no-default-browser-check',
+        '--disable-gpu',
+        '--lang=en-US,en',
+        `--window-size=${this._viewport.width},${this._viewport.height}`,
+      ];
+
+      const playwright = require('playwright-chromium');
+      clearChromiumSingletonLocks(this.profileDir);
+      this.context = await playwright.chromium.launchPersistentContext(this.profileDir, {
+        headless: false,
+        executablePath,
+        env: launchEnv,
+        args: launchArgs,
+        viewport: this._viewport,
+        ignoreHTTPSErrors: false,
+        timeout: 120000,
+      });
+      this.browser = typeof this.context.browser === 'function' ? this.context.browser() : null;
+      this.page = this.context.pages()[0] || await this.context.newPage();
       await this._applyStealthToPage(this.page);
+    })();
+
+    try {
+      await this.launchPromise;
     } finally {
+      this.launchPromise = null;
       this.launching = false;
     }
   }
@@ -196,7 +397,11 @@ class BrowserController {
   async ensurePage() {
     await this.ensureBrowser();
     if (!this.page || this.page.isClosed()) {
-      this.page = await this.browser.newPage();
+      if (this.context && typeof this.context.newPage === 'function') {
+        this.page = await this.context.newPage();
+      } else {
+        this.page = await this.browser.newPage();
+      }
       await this._applyStealthToPage(this.page);
     }
     return this.page;
@@ -253,7 +458,7 @@ class BrowserController {
 
     try {
       const response = await page.goto(url, {
-        waitUntil: 'networkidle2',
+        waitUntil: normalizeWaitUntil(options.waitUntil),
         timeout: 30000
       });
 
@@ -285,7 +490,9 @@ class BrowserController {
         url: currentUrl,
         status: response?.status() || 0,
         bodyText,
-        screenshotPath: screenshot?.screenshotPath || null
+        screenshotPath: screenshot?.screenshotPath || null,
+        artifactId: screenshot?.artifactId || null,
+        fullPath: screenshot?.fullPath || null
       };
     } catch (err) {
       let screenshot = null;
@@ -293,7 +500,9 @@ class BrowserController {
       return {
         error: err.message,
         url,
-        screenshotPath: screenshot?.screenshotPath || null
+        screenshotPath: screenshot?.screenshotPath || null,
+        artifactId: screenshot?.artifactId || null,
+        fullPath: screenshot?.fullPath || null
       };
     }
   }
@@ -335,7 +544,9 @@ class BrowserController {
         success: true,
         url: page.url(),
         title: await page.title(),
-        screenshotPath: screenshotResult?.screenshotPath || null
+        screenshotPath: screenshotResult?.screenshotPath || null,
+        artifactId: screenshotResult?.artifactId || null,
+        fullPath: screenshotResult?.fullPath || null
       };
     } catch (err) {
       return { error: err.message };
@@ -364,7 +575,9 @@ class BrowserController {
         y: py,
         url: page.url(),
         title: await page.title(),
-        screenshotPath: screenshotResult?.screenshotPath || null
+        screenshotPath: screenshotResult?.screenshotPath || null,
+        artifactId: screenshotResult?.artifactId || null,
+        fullPath: screenshotResult?.fullPath || null
       };
     } catch (err) {
       return { error: err.message };
@@ -388,7 +601,9 @@ class BrowserController {
         success: true,
         url: page.url(),
         title: await page.title(),
-        screenshotPath: screenshotResult?.screenshotPath || null
+        screenshotPath: screenshotResult?.screenshotPath || null,
+        artifactId: screenshotResult?.artifactId || null,
+        fullPath: screenshotResult?.fullPath || null
       };
     } catch (err) {
       return { error: err.message };
@@ -419,7 +634,9 @@ class BrowserController {
       return {
         success: true,
         typed: text,
-        screenshotPath: screenshotResult?.screenshotPath || null
+        screenshotPath: screenshotResult?.screenshotPath || null,
+        artifactId: screenshotResult?.artifactId || null,
+        fullPath: screenshotResult?.fullPath || null
       };
     } catch (err) {
       return { error: err.message };
@@ -445,7 +662,9 @@ class BrowserController {
       return {
         success: true,
         typed: String(text || ''),
-        screenshotPath: screenshotResult?.screenshotPath || null
+        screenshotPath: screenshotResult?.screenshotPath || null,
+        artifactId: screenshotResult?.artifactId || null,
+        fullPath: screenshotResult?.fullPath || null
       };
     } catch (err) {
       return { error: err.message };
@@ -469,7 +688,9 @@ class BrowserController {
       return {
         success: true,
         key: normalized,
-        screenshotPath: screenshotResult?.screenshotPath || null
+        screenshotPath: screenshotResult?.screenshotPath || null,
+        artifactId: screenshotResult?.artifactId || null,
+        fullPath: screenshotResult?.fullPath || null
       };
     } catch (err) {
       return { error: err.message };
@@ -520,15 +741,20 @@ class BrowserController {
   }
 
   async launch(options = {}) {
+    void options;
     await this.ensureBrowser();
     return { success: true };
   }
 
   isLaunched() {
-    return !!(this.browser && this.browser.isConnected());
+    if (this.context) return true;
+    return !!(this.browser && typeof this.browser.isConnected === 'function' && this.browser.isConnected());
   }
 
   getPageCount() {
+    if (this.context && typeof this.context.pages === 'function') {
+      try { return this.context.pages().length; } catch { return 0; }
+    }
     if (!this.browser) return 0;
     try { return this.browser.pages ? 1 : 0; } catch { return 0; }
   }
@@ -553,16 +779,64 @@ class BrowserController {
     };
   }
 
+  async getCookies() {
+    await this.ensureBrowser();
+    if (!this.context || typeof this.context.cookies !== 'function') {
+      return { cookies: [] };
+    }
+    const cookies = await this.context.cookies().catch(() => []);
+    return {
+      cookies: Array.isArray(cookies) ? cookies : [],
+    };
+  }
+
   async close() {
     if (this.page && !this.page.isClosed()) {
       await this.page.close().catch(() => { });
     }
+    if (this.context) {
+      await this.context.close().catch(() => { });
+      this.context = null;
+      this.browser = null;
+      this.page = null;
+      return;
+    }
     if (this.browser) {
       await this.browser.close().catch(() => { });
       this.browser = null;
       this.page = null;
     }
   }
+
+  async ensureVirtualDisplay() {
+    if (process.platform !== 'linux') {
+      return;
+    }
+    if (this.displayProcess && !this.displayProcess.killed) {
+      return;
+    }
+    if (this.displayValue && String(this.displayValue).trim()) {
+      return;
+    }
+
+    const display = ':99';
+    const child = spawn('Xvfb', [display, '-screen', '0', '1440x900x24', '-ac', '-nolisten', 'tcp'], {
+      stdio: ['ignore', 'ignore', 'pipe'],
+    });
+
+    let launchError = '';
+    child.stderr.on('data', (chunk) => {
+      launchError += chunk.toString();
+    });
+
+    await sleep(1000);
+    if (child.exitCode != null) {
+      throw new Error(`Failed to start Xvfb: ${String(launchError || `exit code ${child.exitCode}`).trim()}`);
+    }
+
+    this.displayProcess = child;
+    this.displayValue = display;
+  }
 }
 
-module.exports = { BrowserController, resolveBrowserExecutablePath, buildIsolatedEvaluationExpression };
+module.exports = { BrowserController, resolveBrowserExecutablePath, buildIsolatedEvaluationExpression, normalizeWaitUntil };

package/server/services/cli/executor.js

@@ -7,6 +7,38 @@ const FORCE_KILL_GRACE_MS = 5000;
 const MAX_STDOUT_CHARS = 50000;
 const MAX_STDERR_CHARS = 10000;
 
+function resolveDefaultShell() {
+  const candidates = [
+    process.env.SHELL,
+    '/bin/zsh',
+    '/bin/bash',
+    '/bin/sh',
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    try {
+      execFileSync(candidate, ['-lc', 'printf ok'], {
+        timeout: 3000,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      return candidate;
+    } catch {}
+  }
+
+  try {
+    execFileSync('/bin/sh', ['-lc', 'printf ok'], {
+      timeout: 3000,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return '/bin/sh';
+  } catch (error) {
+    console.warn('[CLI] No usable shell found for executor:', error?.message || error);
+    return null;
+  }
+}
+
 function clampTimeout(value, fallback) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
@@ -46,7 +78,10 @@ function wrapCommandForShell(command, shellPath) {
 class CLIExecutor {
   constructor() {
     this.activeProcesses = new Map();
-    this.defaultShell = process.env.SHELL || '/bin/zsh';
+    this.defaultShell = resolveDefaultShell();
+    if (!this.defaultShell) {
+      throw new Error('No usable shell found for CLI execution.');
+    }
   }
 
   _getLoginPath() {
@@ -258,6 +293,10 @@ class CLIExecutor {
     return false;
   }
 
+  isManaged(pid) {
+    return this.activeProcesses.has(pid);
+  }
+
   killAll(reason = 'aborted') {
     for (const [pid, proc] of this.activeProcesses) {
       proc.__neoagentKilled = true;