browser-commander 0.32.1 → 0.33.1

package/src/browser/launcher.js

@@ -1,4 +1,3 @@
-import { access } from 'node:fs/promises';
 import { launchFailure } from './launch-diagnostics.js';
 import {
   installSessionPersistence,
@@ -20,9 +19,13 @@ import {
   configureUserDataDir,
   removeUserDataDir,
 } from './profile-directory.js';
+import {
+  ENGINE_BROWSERS,
+  defaultRestrictionsFor,
+  resolveLaunchExecutable,
+} from './launch-executable.js';
 import { launchRealBrowser } from './real-browser.js';
 import { resolveRestrictions } from './restrictions.js';
-import { resolveSystemBrowserExecutable } from './system-browser.js';
 import { applyFingerprint } from '../fingerprint/apply.js';
 import { attachDownloads } from '../downloads/attach.js';
 import { launchWebDriver } from './webdriver.js';
@@ -36,14 +39,11 @@ import {
 } from './storage-state.js';
 import { interruptionMode } from '../utilities/subprocess.js';
 
+export { resolveLaunchExecutable };
+
 /** How `launchBrowser` starts the browser (issue #103). */
 export const LAUNCH_MODES = Object.freeze(['real', 'engine']);
 
-const loadEngine = {
-  playwright: async () => (await import('playwright')).chromium,
-  puppeteer: async () => (await import('puppeteer')).default,
-};
-
 function validateLaunchMode({ engine, launch, attach }) {
   assertSupportedEngine(engine);
   if (!LAUNCH_MODES.includes(launch)) {
@@ -58,48 +58,6 @@ function validateLaunchMode({ engine, launch, attach }) {
   }
 }
 
-async function isExecutable(file) {
-  try {
-    await access(file);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Pick the browser binary for a real launch.
- *
- * An explicit `executablePath` or `channel` is honoured as given. Without
- * either, the installed Google Chrome is preferred - it is the browser a
- * person would start - and the engine's own downloaded Chromium is the
- * fallback, so a machine with only `npx playwright install` still works. The
- * binary is spawned by Browser Commander either way, with the same clean
- * command line.
- */
-export async function resolveLaunchExecutable(
-  { engine, channel, executablePath },
-  { resolveSystem = resolveSystemBrowserExecutable, loadEngineModule } = {}
-) {
-  if (executablePath !== undefined || channel !== undefined) {
-    return await resolveSystem({
-      channel: channel ?? 'chrome',
-      executablePath,
-    });
-  }
-  try {
-    return await resolveSystem({ channel: 'chrome' });
-  } catch (error) {
-    const bundled = await (loadEngineModule ?? loadEngine[engine])()
-      .then((module) => module.executablePath())
-      .catch(() => undefined);
-    if (bundled && (await isExecutable(bundled))) {
-      return bundled;
-    }
-    throw error;
-  }
-}
-
 async function launchReal(options, dependencies) {
   const {
     engine,
@@ -144,14 +102,47 @@ async function launchReal(options, dependencies) {
   return { browser, page, close, connectedBrowser, ...meta };
 }
 
+// The Chrome for Testing an engine launch starts on its own, or the one a
+// Selenium launch is pointed at; undefined for any installed browser.
+async function engineExecutable(
+  { engine, browser = 'chrome', channel, executablePath },
+  engineModule,
+  dependencies
+) {
+  if (executablePath !== undefined || channel !== undefined) {
+    return executablePath;
+  }
+  if (engine === 'selenium') {
+    // Without Chrome for Testing this fails rather than let the driver pick
+    // the installed Google Chrome (issue #179).
+    return browser === 'chrome'
+      ? await resolveLaunchExecutable({ engine }, dependencies)
+      : undefined;
+  }
+  return await Promise.resolve()
+    .then(() => engineModule.executablePath?.())
+    .catch(() => undefined);
+}
+
 async function launchWithEngine(options, dependencies) {
   if (options.engine === 'selenium') {
+    // launchWebDriver adds the defaults of the browser it resolves.
+    const executablePath = await engineExecutable(options, null, dependencies);
     const launched = await (dependencies.launchWebDriver ?? launchWebDriver)({
       ...options,
+      ...(executablePath ? { executablePath } : {}),
       args: [...options.args, ...options.extraArgs],
     });
     return { ...launched, browser: launched.driver };
   }
+  const engineModule = await (
+    dependencies.loadEngineModule ?? ENGINE_BROWSERS[options.engine]
+  )();
+  const defaultRestrictions = defaultRestrictionsFor(
+    await engineExecutable(options, engineModule, dependencies),
+    options.defaultRestrictions
+  );
+  const restrictions = [...defaultRestrictions, ...options.restrictions];
   const {
     engine,
     userDataDir: requestedUserDataDir,
@@ -160,7 +151,6 @@ async function launchWithEngine(options, dependencies) {
     args,
     extraArgs,
     ignoreDefaultArgs,
-    restrictions,
     env,
     colorScheme,
     channel,
@@ -195,9 +185,6 @@ async function launchWithEngine(options, dependencies) {
     },
     localState: options.localState,
   });
-  const engineModule = await (
-    dependencies.loadEngineModule ?? loadEngine[engine]
-  )();
   const selection = { channel, executablePath };
 
   let browser;
@@ -263,6 +250,7 @@ async function launchWithEngine(options, dependencies) {
     userDataDir,
     temporaryProfile,
     args: chrome.args,
+    defaultRestrictions,
   };
 }
 
@@ -285,13 +273,20 @@ async function unfocusAddressBar(page, verbose, settleMs = 500) {
 /**
  * Launch a browser.
  *
- * By default (`launch: 'real'`) Browser Commander starts the installed Chrome
- * itself, exactly like a person who wants to attach a debugger would:
+ * By default (`launch: 'real'`) Browser Commander starts Chrome itself,
+ * exactly like a person who wants to attach a debugger would:
  * `--user-data-dir=<fresh temporary profile> --remote-debugging-port=<reserved
  * port>` and nothing else, then attaches the engine over CDP (issues #101 and
  * #103). The profile is deleted on close. Every restriction the library used
  * to add silently is an explicit opt-in through `restrictions`.
  *
+ * The browser is the engine's Chrome for Testing, an application of its own,
+ * so the user's Google Chrome is never taken over; `channel: 'chrome'` asks
+ * for the installed Google Chrome. Chrome for Testing gets the
+ * `chrome-for-testing` restrictions (`--test-type=gpu`, the only switch that
+ * hides its "only for automated testing" bar, and `--use-mock-keychain`)
+ * unless `defaultRestrictions` says otherwise (issue #179).
+ *
  * `launch: 'engine'` keeps the Playwright/Puppeteer-launched browser for CI
  * and headless use; the switches those engines add are listed in
  * limitations.json (`engine-launch-switches`).
@@ -304,12 +299,13 @@ async function unfocusAddressBar(page, verbose, settleMs = 500) {
  * @param {number} [options.slowMo=0] - Slow down operations by ms
  * @param {boolean} [options.verbose=false] - Enable verbose logging
  * @param {string[]} [options.restrictions] - Opt-in restrictions from launch-restrictions.json, such as 'no-extensions' or the 'legacy-defaults' preset
+ * @param {string[]} [options.defaultRestrictions] - Restrictions that replace the executable's defaults (the 'chrome-for-testing' preset for Chrome for Testing, none otherwise); [] turns them off
  * @param {string[]} [options.args] - Additional Chrome arguments
  * @param {string[]} [options.extraArgs] - Additional Chrome arguments appended after args
  * @param {boolean|string[]} [options.ignoreDefaultArgs] - Engine default switches to omit, or true for all ('engine' launch only)
  * @param {Object<string,string>} [options.env] - Extra environment for the browser process only
  * @param {string|null} [options.colorScheme] - Emulate color scheme: 'light', 'dark', 'no-preference', or null to reset
- * @param {string} [options.channel] - Installed browser channel, such as 'chrome', 'chrome-beta', 'msedge', 'brave' or 'chromium'
+ * @param {string} [options.channel] - Installed browser channel, such as 'chrome', 'chrome-beta', 'msedge', 'brave' or 'chromium'; without it (and without executablePath) the engine's Chrome for Testing is started
  * @param {string} [options.executablePath] - Explicit path to a Chrome or Chromium executable
  * @param {number} [options.remoteDebuggingPort] - Fixed CDP port for the real launch; a free one is reserved when omitted
  * @param {string|Object} [options.storageState] - Playwright-compatible storage state path or object
@@ -317,7 +313,7 @@ async function unfocusAddressBar(page, verbose, settleMs = 500) {
  * @param {boolean} [options.automationParity=true] - Keep navigator.webdriver false where a launch switch would turn it on (headless or engine launches)
  * @param {boolean|Object} [options.downloads] - Manage downloads: true for defaults, or {directory, persist, conflict}. The directory may be an absolute path, 'user-downloads' or 'temporary'.
  * @param {boolean|Object} [options.debug=false] - Opt-in recording: true, {output}, or {directory, retain, maxDurationMs, limits} for managed storage
- * @returns {Promise<{browser: Object, page: Object, downloads: (Object|null), close: function(): Promise<void>, launch: string, userDataDir: string, temporaryProfile: boolean, args: Array<string>}>} Browser (a BrowserContext for Playwright), page, download manager and launch metadata
+ * @returns {Promise<{browser: Object, page: Object, downloads: (Object|null), close: function(): Promise<void>, launch: string, userDataDir: string, temporaryProfile: boolean, args: Array<string>, defaultRestrictions: Array<string>}>} Browser (a BrowserContext for Playwright), page, download manager and launch metadata
  */
 export async function launchBrowser(options = {}) {
   return await launchBrowserWithDependencies(options);
@@ -368,6 +364,23 @@ export async function launchBrowserWithDependencies(
   }
 }
 
+function validateSeleniumLaunch({
+  launch,
+  browser,
+  colorScheme,
+  fingerprint,
+  downloads,
+}) {
+  if (colorScheme !== undefined || fingerprint !== undefined || downloads) {
+    throw new Error(
+      'selenium does not support CDP emulation, fingerprint overrides or managed downloads (webdriver-no-cdp-emulation)'
+    );
+  }
+  if (launch === 'real' && browser === 'firefox') {
+    throw new Error("selenium Firefox requires launch: 'engine'");
+  }
+}
+
 async function launchNonSafariBrowser(options, dependencies) {
   const {
     engine = 'playwright',
@@ -388,16 +401,16 @@ async function launchNonSafariBrowser(options, dependencies) {
   } = options;
   validateLaunchMode({ engine, launch, attach: rest.attach });
   if (engine === 'selenium') {
-    if (colorScheme !== undefined || fingerprint !== undefined || downloads) {
-      throw new Error(
-        'selenium does not support CDP emulation, fingerprint overrides or managed downloads (webdriver-no-cdp-emulation)'
-      );
-    }
-    if (launch === 'real' && rest.browser === 'firefox') {
-      throw new Error("selenium Firefox requires launch: 'engine'");
-    }
+    validateSeleniumLaunch({
+      launch,
+      colorScheme,
+      fingerprint,
+      downloads,
+      ...rest,
+    });
   }
   // Validate arguments before anything is started or written to disk.
+  resolveRestrictions(rest.defaultRestrictions ?? []);
   resolveChromeArgs({
     args,
     extraArgs,

package/src/browser/migration/firefox.js

@@ -218,7 +218,7 @@ export async function migrateFirefoxPasswords({
   targetProfileDir,
   platform,
   targetKey,
-  targetPrefix = platform === 'win32' ? 'v10' : 'v11',
+  targetPrefix = platform === 'linux' ? 'v11' : 'v10',
   primaryPassword = Buffer.alloc(0),
   domains,
 }) {

package/src/browser/migration/index.js

@@ -122,6 +122,7 @@ async function resolvePasswordKeys({
   keys,
   browser,
   targetBrowser,
+  targetKeystore,
   platform,
   sourceProfileDir,
   environment,
@@ -135,6 +136,7 @@ async function resolvePasswordKeys({
   const { key: targetKey, prefix: targetPrefix } = await resolveTargetKey({
     browser: targetBrowser,
     platform,
+    keystore: targetKeystore,
     environment,
   });
   const resolveSourceKey = isChromiumBrowser(browser)
@@ -159,6 +161,7 @@ async function resolvePasswordKeys({
  * @param {boolean} [options.includePaymentCards=false] - Separate explicit payment-card consent
  * @param {string} [options.platform=process.platform]
  * @param {string} [options.targetBrowser] - Launching browser channel (key derivation)
+ * @param {'mock'|'os'} [options.targetKeystore='os'] - 'mock' when the launch bypasses the OS keystore (`targetKeystoreFor`)
  * @param {Object} [options.keys] - Injected password keys {resolveSourceKey, targetKey, targetPrefix, primaryPassword}
  * @param {string} [options.homeDir]
  * @param {Object} [options.environment]
@@ -171,6 +174,7 @@ export async function migrateProfile({
   domains,
   platform = process.platform,
   targetBrowser,
+  targetKeystore,
   keys,
   homeDir = os.homedir(),
   environment = process.env,
@@ -272,6 +276,7 @@ export async function migrateProfile({
       keys,
       browser,
       targetBrowser,
+      targetKeystore,
       platform,
       sourceProfileDir,
       environment,
@@ -352,6 +357,7 @@ export async function migrateProfile({
       keys,
       browser,
       targetBrowser,
+      targetKeystore,
       platform,
       sourceProfileDir,
       environment,
@@ -377,6 +383,7 @@ async function migrateSafariProfile({
   selected,
   sourceProfileDir,
   targetBrowser,
+  targetKeystore,
   to,
 }) {
   const passwordKeys =
@@ -385,6 +392,7 @@ async function migrateSafariProfile({
           keys,
           browser,
           targetBrowser: targetBrowser ?? 'chrome',
+          targetKeystore,
           platform,
           sourceProfileDir,
           environment,
@@ -442,6 +450,7 @@ async function migratePasswordClass(
     platform,
     sourceProfileDir,
     targetBrowser,
+    targetKeystore,
     to,
   }
 ) {
@@ -464,6 +473,7 @@ async function migratePasswordClass(
     keys,
     browser,
     targetBrowser: targetBrowser ?? (isFirefox ? 'chrome' : browser),
+    targetKeystore,
     platform,
     sourceProfileDir,
     environment,

package/src/browser/migration/os-crypt-keys.js

@@ -73,12 +73,34 @@ export function createSourceKeyResolver({
   };
 }
 
+/**
+ * Which keystore a launch encrypts its new profile with: `'mock'` when the
+ * launch switches bypass the OS keystore (`--use-mock-keychain` on macOS, as
+ * Chrome for Testing gets by default, or `--password-store=basic` on Linux),
+ * `'os'` otherwise.
+ *
+ * @param {string[]} args - The browser command-line switches
+ * @param {string} platform
+ * @returns {'mock'|'os'}
+ */
+export function targetKeystoreFor(args, platform) {
+  const bypass =
+    platform === 'darwin' ? '--use-mock-keychain' : '--password-store=basic';
+  return platform !== 'win32' && args.includes(bypass) ? 'mock' : 'os';
+}
+
 /**
  * Resolve the target (launching) profile's encryption key on macOS/Linux.
  *
+ * macOS Chromium only knows the `v10` tag; Linux tags keyring keys `v11` and
+ * its fixed basic-store key `v10`. A `'mock'` keystore uses Chromium's fixed
+ * mock passwords: `mock_password` for the mock keychain, `peanuts` for the
+ * basic store.
+ *
  * @param {Object} options
  * @param {string} options.browser - Launching browser channel
  * @param {string} options.platform
+ * @param {'mock'|'os'} [options.keystore='os'] - See `targetKeystoreFor`
  * @param {Object} [options.environment]
  * @param {Function} [options.readSafeStoragePassword]
  * @returns {Promise<{key: Buffer, prefix: string}>}
@@ -86,16 +108,24 @@ export function createSourceKeyResolver({
 export async function resolveTargetKey({
   browser,
   platform,
+  keystore = 'os',
   environment = process.env,
   readSafeStoragePassword: readSafeStorage = readSafeStoragePassword,
 }) {
-  if (platform === 'darwin' || platform === 'linux') {
-    const password = await readSafeStorage({ browser, platform, environment });
-    return { key: deriveChromiumCookieKey(password, platform), prefix: 'v11' };
+  if (platform !== 'darwin' && platform !== 'linux') {
+    throw new Error(
+      `resolveTargetKey does not derive a Windows key; use createWindowsProfileKey`
+    );
   }
-  throw new Error(
-    `resolveTargetKey does not derive a Windows key; use createWindowsProfileKey`
-  );
+  if (keystore === 'mock') {
+    const password = platform === 'darwin' ? 'mock_password' : 'peanuts';
+    return { key: deriveChromiumCookieKey(password, platform), prefix: 'v10' };
+  }
+  const password = await readSafeStorage({ browser, platform, environment });
+  return {
+    key: deriveChromiumCookieKey(password, platform),
+    prefix: platform === 'darwin' ? 'v10' : 'v11',
+  };
 }
 
 /** Convenience: the Local State path next to a profile directory. */

package/src/browser/migration/passwords.js

@@ -108,7 +108,7 @@ export async function migratePasswords({
   platform = process.platform,
   resolveSourceKey,
   targetKey,
-  targetPrefix = platform === 'win32' ? 'v10' : 'v11',
+  targetPrefix = platform === 'linux' ? 'v11' : 'v10',
   domains,
 }) {
   const sourcePath = path.join(sourceProfileDir, 'Login Data');

package/src/browser/parity.js

@@ -317,7 +317,12 @@ function normalizeWhitespace(text) {
 function requestedArgsFor(session, options) {
   const requested = [...(options.args ?? []), ...(options.extraArgs ?? [])];
   const launchedArgs = session.args ?? [];
-  if ((options.restrictions ?? []).length > 0) {
+  // Chrome for Testing's default restrictions are requested too (issue #179).
+  const restrictions = [
+    ...(session.defaultRestrictions ?? []),
+    ...(options.restrictions ?? []),
+  ];
+  if (restrictions.length > 0) {
     requested.push(
       ...launchedArgs.filter(
         (arg) =>

package/src/browser/real-browser.js

@@ -23,6 +23,7 @@ import {
 } from './attach/snapshot-launch.js';
 import { connectBrowser } from './connector.js';
 import { migrateProfile } from './migration/index.js';
+import { targetKeystoreFor } from './migration/os-crypt-keys.js';
 import {
   assertFixedDebuggingPort,
   classifyDevToolsOwnership,
@@ -48,6 +49,11 @@ import {
   knownDefaultUserDataDirs,
   resolveSystemBrowserExecutable,
 } from './system-browser.js';
+import {
+  defaultRestrictionsFor,
+  isChromeForTesting,
+  resolveLaunchExecutable,
+} from './launch-executable.js';
 
 /**
  * Switches the launcher owns. Letting a caller pass them would break the
@@ -368,29 +374,34 @@ function createCloser({
 
 /**
  * Selenium attaches through a chromedriver the launch starts; the driver
- * follows the browser's interruption ownership (issue #174).
+ * follows the browser's interruption ownership (issue #174) and must match
+ * the browser just started, not the installed Chrome Selenium Manager would
+ * otherwise pick (issue #179).
  */
-function driverInterruption(engine, interruption) {
-  return engine === 'selenium' ? { interruption } : {};
+function driverOptions(engine, { interruption, executablePath }) {
+  return engine === 'selenium' ? { interruption, executablePath } : {};
 }
 
 /**
- * Spawn a genuine installed Chrome-family browser with a dedicated profile,
- * wait for its loopback CDP endpoint, and attach through {@link connectBrowser}.
+ * Spawn a Chrome-family browser with a dedicated profile, wait for its
+ * loopback CDP endpoint, and attach through {@link connectBrowser}.
  *
  * The command line is `--user-data-dir=<dir> --remote-debugging-port=<port>`
  * and nothing else unless asked for, so the session is as close to a
  * hand-started browser as CDP allows and `navigator.webdriver` is false.
+ * Without `channel`, `executablePath` or `attach` the engine's Chrome for
+ * Testing is started, with the `chrome-for-testing` restrictions (issue #179).
  *
  * @param {Object} options - Launch and connection options
  * @param {'playwright'|'puppeteer'} [options.engine='playwright'] - Automation engine
- * @param {string} [options.channel='chrome'] - Installed Chrome-family channel
+ * @param {string} [options.channel] - Installed Chrome-family channel, such as 'chrome' for the installed Google Chrome; it also names the browser a snapshot or migration belongs to (default 'chrome')
  * @param {string} [options.executablePath] - Explicit installed browser executable
  * @param {string} [options.userDataDir] - Persistent dedicated profile. When omitted a fresh temporary profile is created and deleted on close.
  * @param {number} [options.remoteDebuggingPort] - Fixed loopback CDP port. When omitted a free port is reserved (and re-reserved on a port race). Zero is refused because it sets navigator.webdriver.
  * @param {number} [options.portAttempts=3] - Launch attempts when a reserved port is lost to a race
  * @param {boolean} [options.headless=false] - Run the installed browser headlessly
  * @param {string[]} [options.restrictions] - Opt-in restrictions from launch-restrictions.json, such as 'no-extensions'
+ * @param {string[]} [options.defaultRestrictions] - Restrictions that replace the executable's defaults: the 'chrome-for-testing' preset for Chrome for Testing, none for any other browser. Pass [] to start Chrome for Testing without them.
  * @param {string[]} [options.args] - Additional browser arguments
  * @param {string[]} [options.extraArgs] - Additional browser arguments appended after args
  * @param {boolean} [options.defaultBrowserCheck=false] - Allow the disposable browser to ask to become the default
@@ -404,7 +415,7 @@ function driverInterruption(engine, interruption) {
  * @param {{browser: string, profile: (string|undefined), userDataDir: (string|undefined), include: (Array<string>|undefined), domains: (Array<string>|undefined)}} [options.migrateFrom] - Migrate a real browser profile into the dedicated profile before launch; on-disk data is written before the browser starts and cookies are seeded over CDP after connecting
  * @param {{mode: 'snapshot', browser: (string|undefined), profile: (string|undefined), userDataDir: (string|undefined)}} [options.attach] - Launch on a read-only snapshot of a real profile (issue #102, addendum): `snapshotUserDataDir()` copies it into a temporary user data directory, which is deleted on close. `browser` defaults to the channel's browser and `profile` to Default. Mutually exclusive with `migrateFrom` and `userDataDir`.
  * @param {boolean} [options.verbose=false] - Show browser and connection logs
- * @returns {Promise<{browser: Object, page: Object, downloads: (Object|null), close: function(): Promise<void>, browserProcess: Object, cdpEndpoint: string, remoteDebuggingPort: number, executablePath: string, userDataDir: string, temporaryProfile: boolean, args: Array<string>, migration: (Object|undefined), attach: ({mode: 'snapshot', snapshot: Object, differences: Array<{aspect: string, description: string}>}|undefined)}>} Connected handles and process metadata (with a `migration` report when `migrateFrom` was given and an `attach` entry when `attach` was given)
+ * @returns {Promise<{browser: Object, page: Object, downloads: (Object|null), close: function(): Promise<void>, browserProcess: Object, cdpEndpoint: string, remoteDebuggingPort: number, executablePath: string, userDataDir: string, temporaryProfile: boolean, args: Array<string>, defaultRestrictions: Array<string>, migration: (Object|undefined), attach: ({mode: 'snapshot', snapshot: Object, differences: Array<{aspect: string, description: string}>}|undefined)}>} Connected handles and process metadata (with a `migration` report when `migrateFrom` was given and an `attach` entry when `attach` was given)
  */
 export async function launchAndConnectRealBrowser(options = {}) {
   return await launchAndConnectRealBrowserWithDependencies(options);
@@ -595,6 +606,9 @@ async function runPreLaunchMigration({
   migrateFrom,
   userDataDir,
   channel,
+  executablePath,
+  argOptions,
+  platform,
   temporaryProfile,
   migrate,
 }) {
@@ -603,6 +617,14 @@ async function runPreLaunchMigration({
   }
   const { include, domains, passwordCsv, includePaymentCards, ...from } =
     migrateFrom;
+  // Passwords are re-encrypted with the key of the browser that starts:
+  // Chrome for Testing keeps "Chromium Safe Storage", and its default mock
+  // keychain uses Chromium's fixed mock password (issue #179).
+  const launchArgs = [
+    ...resolveRestrictions(argOptions.restrictions).args,
+    ...argOptions.args,
+    ...argOptions.extraArgs,
+  ];
   try {
     const report = await migrate({
       from,
@@ -611,7 +633,8 @@ async function runPreLaunchMigration({
       domains,
       passwordCsv,
       includePaymentCards,
-      targetBrowser: channel,
+      targetBrowser: isChromeForTesting(executablePath) ? 'chromium' : channel,
+      targetKeystore: targetKeystoreFor(launchArgs, platform),
     });
     const { cookies, ...migration } = report;
     return { migration, migratedCookies: cookies ?? [] };
@@ -662,6 +685,7 @@ export async function launchAndConnectRealBrowserWithDependencies(
     portAttempts = 3,
     headless = false,
     restrictions = [],
+    defaultRestrictions: requestedDefaultRestrictions,
     args = [],
     extraArgs = [],
     ignoreDefaultArgs: _ignoredLegacyDefaults,
@@ -699,14 +723,17 @@ export async function launchAndConnectRealBrowserWithDependencies(
     attach,
     migrateFrom,
   });
+  resolveRestrictions(requestedDefaultRestrictions ?? []);
 
+  // Without a channel, executablePath or attach the engine's Chrome for
+  // Testing is started, never the user's Google Chrome (issue #179).
   const resolveExecutable =
-    dependencies.resolveExecutable ?? resolveSystemBrowserExecutable;
-  const launchChannel = attach?.browser ?? channel;
+    dependencies.resolveExecutable ??
+    ((request) => resolveLaunchExecutable({ engine, ...request }));
   const executablePath = await Promise.resolve()
     .then(() =>
       resolveExecutable({
-        channel: launchChannel,
+        channel: attach?.browser ?? options.channel,
         executablePath: requestedExecutablePath,
       })
     )
@@ -718,6 +745,14 @@ export async function launchAndConnectRealBrowserWithDependencies(
         executablePath: requestedExecutablePath,
       });
     });
+  // Chrome for Testing gets its infobar hidden and a mock keychain unless the
+  // caller sets defaultRestrictions; the snapshot keystore warning, the
+  // environment and the profile preferences all see them.
+  const defaultRestrictions = defaultRestrictionsFor(
+    executablePath,
+    requestedDefaultRestrictions
+  );
+  argOptions.restrictions = [...defaultRestrictions, ...restrictions];
 
   const temporaryProfile = !requestedUserDataDir;
   const { userDataDir, snapshotLaunch } = await prepareProfile({
@@ -728,12 +763,15 @@ export async function launchAndConnectRealBrowserWithDependencies(
     snapshot: dependencies.snapshotUserDataDir,
     firstRun,
   });
-  const childEnv = browserEnvironment(restrictions, env);
+  const childEnv = browserEnvironment(argOptions.restrictions, env);
 
   const { migration, migratedCookies } = await runPreLaunchMigration({
     migrateFrom,
     userDataDir,
     channel,
+    executablePath,
+    argOptions,
+    platform: dependencies.platform ?? process.platform,
     temporaryProfile,
     migrate: dependencies.migrateProfile ?? migrateProfile,
   });
@@ -745,7 +783,7 @@ export async function launchAndConnectRealBrowserWithDependencies(
     configureUserDataDir(userDataDir, {
       defaultBrowserCheck,
       preferences: {
-        ...resolveRestrictions(restrictions).preferences,
+        ...resolveRestrictions(argOptions.restrictions).preferences,
         ...preferences,
       },
       localState,
@@ -787,7 +825,7 @@ export async function launchAndConnectRealBrowserWithDependencies(
       engine,
       cdpEndpoint: resolvedCdpEndpoint,
       ...connectionOptions,
-      ...driverInterruption(engine, interruption),
+      ...driverOptions(engine, { interruption, executablePath }),
       seedCookies,
       verbose,
     });
@@ -814,6 +852,7 @@ export async function launchAndConnectRealBrowserWithDependencies(
         userDataDir,
         temporaryProfile,
         args: launched.browserArgs,
+        defaultRestrictions,
         ...(migration ? { migration } : {}),
         ...(snapshotLaunch ? { attach: snapshotLaunch.attach } : {}),
       },