@everydaydevopsio/pilot 0.6.2 → 0.7.0

package/src/browser/sessions.ts

@@ -0,0 +1,299 @@
+import { execFileSync } from 'child_process';
+import { existsSync, lstatSync, readdirSync, statSync } from 'fs';
+import { hostname } from 'os';
+import { basename, dirname, join } from 'path';
+import {
+  PROFILE_NAME_RE,
+  cleanupLockFiles,
+  isProcessAlive,
+  profileLockOwner,
+  resolveUserDataDir
+} from './chrome-launcher.js';
+
+export type ProfileLockState =
+  /** No lock files: the profile is free. */
+  | 'unlocked'
+  /** Locked by a live process on this host. */
+  | 'locked'
+  /** Locked by a process on this host that is no longer running. */
+  | 'stale'
+  /** Locked from another host; liveness cannot be checked here. */
+  | 'locked_other_host'
+  /** Lock files exist but name no owner Pilot can read. */
+  | 'locked_unknown';
+
+export interface ProfileStatus {
+  profile: string;
+  userDataDir: string;
+  state: ProfileLockState;
+  pid?: number;
+  host?: string;
+  /** True when the lock owner's command line shows Chrome using this Pilot profile. */
+  pilotChrome?: boolean;
+}
+
+export function pilotDataDir(): string {
+  // resolveUserDataDir validates the name; any valid name gives the parent.
+  return dirname(resolveUserDataDir('profile1'));
+}
+
+/**
+ * Report the lock state of every Pilot profile. Read-only: unlike
+ * isProfileLocked, it never removes stale locks.
+ */
+export function listProfiles(): ProfileStatus[] {
+  const dataDir = pilotDataDir();
+  let names: string[];
+  try {
+    names = readdirSync(dataDir);
+  } catch {
+    return [];
+  }
+
+  return names
+    .filter((name) => PROFILE_NAME_RE.test(name))
+    .filter((name) => {
+      try {
+        return statSync(join(dataDir, name)).isDirectory();
+      } catch {
+        return false;
+      }
+    })
+    .sort()
+    .map((profile) => profileStatus(profile, join(dataDir, profile)));
+}
+
+function profileStatus(profile: string, userDataDir: string): ProfileStatus {
+  const owner = profileLockOwner(userDataDir);
+  const base = { profile, userDataDir };
+
+  if (!owner) {
+    const hasLock =
+      lockPresent(join(userDataDir, 'SingletonLock')) ||
+      existsSync(join(userDataDir, 'lockfile'));
+    return { ...base, state: hasLock ? 'locked_unknown' : 'unlocked' };
+  }
+  if (owner.lockHost !== hostname()) {
+    return {
+      ...base,
+      state: 'locked_other_host',
+      pid: owner.pid,
+      host: owner.lockHost
+    };
+  }
+  if (!isProcessAlive(owner.pid)) {
+    return { ...base, state: 'stale', pid: owner.pid, host: owner.lockHost };
+  }
+  return {
+    ...base,
+    state: 'locked',
+    pid: owner.pid,
+    host: owner.lockHost,
+    pilotChrome: isPilotChrome(owner.pid, userDataDir)
+  };
+}
+
+function lockPresent(path: string): boolean {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ps(pid: number, field: 'args' | 'comm'): string | null {
+  if (process.platform === 'win32') return null;
+  try {
+    const out = execFileSync('ps', ['-o', `${field}=`, '-p', String(pid)], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+
+/** The full command line of a process, or null when it cannot be read. */
+export function readProcessCommand(pid: number): string | null {
+  return ps(pid, 'args');
+}
+
+// Chrome's main executable: "chrome" or "chromium-browser" on Linux (comm is
+// truncated to 15 characters), "Google Chrome" or "Chromium" on macOS.
+const CHROME_EXECUTABLE_RE = /chrom(e|ium)/i;
+
+/**
+ * Whether pid is a Chrome or Chromium browser started with exactly this Pilot
+ * profile directory. A pid read from a lock can be reused by an unrelated
+ * process, so stop-all only signals processes that pass this check.
+ */
+export function isPilotChrome(pid: number, userDataDir: string): boolean {
+  const executable = ps(pid, 'comm');
+  if (!executable || !CHROME_EXECUTABLE_RE.test(basename(executable))) {
+    return false;
+  }
+  const command = readProcessCommand(pid);
+  if (!command) return false;
+  const flag = ` --user-data-dir=${userDataDir}`;
+  let at = command.indexOf(flag);
+  while (at !== -1) {
+    const next = command.charAt(at + flag.length);
+    if (next === '' || next === ' ') return true;
+    at = command.indexOf(flag, at + 1);
+  }
+  return false;
+}
+
+export interface StopResult {
+  profile: string;
+  pid?: number;
+  outcome: 'stopped' | 'cleaned' | 'failed' | 'skipped';
+  detail: string;
+}
+
+async function waitForProcessExit(pid: number, ms: number): Promise<boolean> {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) return true;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return !isProcessAlive(pid);
+}
+
+type TerminateResult =
+  | { outcome: 'stopped' }
+  | { outcome: 'not_pilot' }
+  | { outcome: 'failed'; detail: string };
+
+/**
+ * SIGTERM, then SIGKILL. The pid's identity is re-checked right before each
+ * signal: a process seen earlier can exit and its pid be reused while
+ * other browsers are being stopped.
+ */
+async function terminate(
+  pid: number,
+  userDataDir: string
+): Promise<TerminateResult> {
+  const signal = (sig: NodeJS.Signals): 'sent' | 'gone' | { error: string } => {
+    if (!isPilotChrome(pid, userDataDir)) return 'gone';
+    try {
+      process.kill(pid, sig);
+      return 'sent';
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code === 'ESRCH') return 'gone';
+      return { error: `could not send ${sig} to pid ${pid} (${code})` };
+    }
+  };
+
+  const term = signal('SIGTERM');
+  if (term === 'gone') {
+    return isProcessAlive(pid)
+      ? { outcome: 'not_pilot' }
+      : { outcome: 'stopped' };
+  }
+  if (typeof term === 'object')
+    return { outcome: 'failed', detail: term.error };
+  if (await waitForProcessExit(pid, 5000)) return { outcome: 'stopped' };
+
+  const kill = signal('SIGKILL');
+  if (kill === 'gone') {
+    // Only a confirmed exit counts as stopped. A live pid that no longer
+    // verifies (ps failed, or the process changed) is left alone.
+    return isProcessAlive(pid)
+      ? {
+          outcome: 'failed',
+          detail: `pid ${pid} did not exit after SIGTERM and could no longer be verified as Chrome using ${userDataDir}; not killed, lock kept`
+        }
+      : { outcome: 'stopped' };
+  }
+  if (typeof kill === 'object')
+    return { outcome: 'failed', detail: kill.error };
+  return (await waitForProcessExit(pid, 2000))
+    ? { outcome: 'stopped' }
+    : { outcome: 'failed', detail: `pid ${pid} did not exit after SIGKILL` };
+}
+
+/**
+ * Stop every Chrome on this host that holds a Pilot profile lock. Processes
+ * are only signalled after their command line confirms they use that
+ * profile's directory; nothing else is touched.
+ */
+export async function stopPilotBrowsers(): Promise<StopResult[]> {
+  const results: StopResult[] = [];
+  for (const status of listProfiles()) {
+    const { profile, pid } = status;
+    switch (status.state) {
+      case 'unlocked':
+        continue;
+      case 'stale': {
+        const removed = cleanupLockFiles(status.userDataDir, pid!);
+        results.push(
+          removed
+            ? {
+                profile,
+                pid,
+                outcome: 'cleaned',
+                detail: `removed stale lock left by pid ${pid}, which is no longer running`
+              }
+            : {
+                profile,
+                pid,
+                outcome: 'failed',
+                detail: `stale lock left by pid ${pid} could not be removed (the lock changed owner or is not writable)`
+              }
+        );
+        continue;
+      }
+      case 'locked_other_host':
+        results.push({
+          profile,
+          pid,
+          outcome: 'skipped',
+          detail: `locked by pid ${pid} on host "${status.host}"; Pilot can only stop browsers on this host`
+        });
+        continue;
+      case 'locked_unknown':
+        results.push({
+          profile,
+          outcome: 'skipped',
+          detail: 'lock files name no owner; left in place'
+        });
+        continue;
+      case 'locked':
+        results.push(await stopLockedProfile(status));
+    }
+  }
+  return results;
+}
+
+/** Stop the Chrome holding a profile lock, if it is verifiably Pilot's. */
+export async function stopLockedProfile(
+  status: ProfileStatus
+): Promise<StopResult> {
+  const { profile, pid, userDataDir } = status;
+  const notPilot: StopResult = {
+    profile,
+    pid,
+    outcome: 'skipped',
+    detail: `pid ${pid} holds the lock but its command line does not show Chrome using ${userDataDir}; not stopped`
+  };
+  if (pid === undefined || !status.pilotChrome) return notPilot;
+
+  const result = await terminate(pid, userDataDir);
+  if (result.outcome === 'not_pilot') return notPilot;
+  if (result.outcome === 'failed') {
+    return { profile, pid, outcome: 'failed', detail: result.detail };
+  }
+  const removed = cleanupLockFiles(userDataDir, pid);
+  return {
+    profile,
+    pid,
+    outcome: 'stopped',
+    detail: removed
+      ? `stopped Chrome pid ${pid}`
+      : `stopped Chrome pid ${pid}, but its lock could not be removed`
+  };
+}

package/src/browser/types.ts

@@ -1,4 +1,5 @@
 import type { Client } from 'chrome-remote-interface';
+import type { BrowserKind } from './driver/types.js';
 
 export type BrowserEventCallback = (event: string, data: unknown) => void;
 
@@ -28,5 +29,18 @@ export interface LaunchOptions {
   startupTimeoutMs?: number;
 }
 
+export interface SessionInfo {
+  /** Browser the session drives; set by the driver. */
+  browser?: BrowserKind;
+  /** launched: Chrome started by this session; external: browser_connect. */
+  mode: 'launched' | 'external' | 'none';
+  connected: boolean;
+  profile?: string;
+  userDataDir?: string;
+  pid?: number;
+  host?: string;
+  cdpPort?: number;
+}
+
 export type SandboxDecision =
   { disable: false } | { disable: true; reason: 'env_override' | 'root_user' };

package/src/cli/skill-template.ts

@@ -1,4 +1,4 @@
 // Generated by scripts/build-skill.mjs from skills/pilot/SKILL.md.
 // Do not edit this file directly.
 export const SKILL_CONTENT =
-  '---\nname: pilot\ndescription: Control and debug web pages with the Pilot MCP browser tools. Use when the user asks to open, inspect, test, or troubleshoot a site in Chrome with Pilot.\n---\n\n# Pilot browser workflow\n\nUse the `pilot` MCP tools to operate Chrome through the Chrome DevTools Protocol.\n\n## Start and inspect\n\n1. Call `browser_start` before any other Pilot browser tool. Use visible mode unless the user requests headless operation or the environment has no graphical display.\n2. Navigate with `browser_navigate`, then confirm the result with `browser_page_info` or `browser_snapshot`.\n3. Use refs returned by `browser_snapshot` or `browser_find` for interaction. Take a fresh snapshot after navigation or substantial DOM changes because refs can become stale.\n4. For debugging, clear errors before reproducing the problem, then inspect `browser_errors`, `browser_console`, and `browser_network`. Use performance tracing only when the user asks about load or runtime performance.\n5. Call `browser_stop` when the browser is no longer needed.\n\nDo not enter credentials, submit consequential forms, upload files, or make other externally visible changes unless the user authorized that action.\n\n## Troubleshooting\n\n### Visible Chrome on Linux\n\nRun `pilot check` when `browser_start` fails. Visible Chrome requires `DISPLAY` or `WAYLAND_DISPLAY` in the Pilot MCP server process. Headless operation does not.\n\nIf desktop applications open but Pilot reports that the display is missing, inspect the graphical session with `printenv DISPLAY`. Forward the returned value through the MCP server configuration and restart the agent so Pilot is relaunched. For Codex:\n\n```toml\n[mcp_servers.pilot]\ncommand = "npx"\nargs = ["-y", "@everydaydevopsio/pilot"]\nenv = { DISPLAY = ":1" }\n```\n\nReplace `:1` with the actual value. If the X server requires a cookie, forward `XAUTHORITY` in the same map. For SSH, use trusted X11 forwarding (`ssh -Y`) when policy permits, or use a remote desktop session and its display value. Use `PILOT_HEADLESS=true` on systems without a desktop. In CI, use headless mode or run Pilot under Xvfb.\n\n### Other Linux preflight failures\n\n- If the profile directory is not writable, set `XDG_DATA_HOME` to a writable directory.\n- If loopback binding fails with `EPERM`, the host or container must allow binding on `127.0.0.1`; disabling Chrome\'s renderer sandbox does not fix it.\n- If Chrome is not detected, set `PILOT_CHROME_PATH` to its executable.\n- Avoid `PILOT_CHROME_NO_SANDBOX=true` unless the runtime genuinely cannot support Chrome\'s sandbox and the user accepts the security tradeoff.\n\n### Connection and page failures\n\n- Confirm the active page with `browser_page_info` and list tabs if Pilot controls the wrong tab.\n- Inspect failed document, script, XHR, and fetch requests with `browser_network`.\n- If element refs stop resolving after a page update, take another snapshot and retry with the new refs.\n';
+  '---\nname: pilot\ndescription: Control and debug web pages with the Pilot MCP browser tools. Use when the user asks to open, inspect, test, or troubleshoot a site in Chrome with Pilot.\n---\n\n# Pilot browser workflow\n\nUse the `pilot` MCP tools to operate Chrome through the Chrome DevTools Protocol.\n\n## Start and inspect\n\n1. Call `browser_start` before any other Pilot browser tool. Use visible mode unless the user requests headless operation or the environment has no graphical display.\n2. Navigate with `browser_navigate`, then confirm the result with `browser_page_info` or `browser_snapshot`.\n3. Use refs returned by `browser_snapshot` or `browser_find` for interaction. Take a fresh snapshot after navigation or substantial DOM changes because refs can become stale.\n4. For debugging, clear errors before reproducing the problem, then inspect `browser_errors`, `browser_console`, and `browser_network`. Use performance tracing only when the user asks about load or runtime performance.\n5. Call `browser_stop` when the browser is no longer needed.\n\nDo not enter credentials, submit consequential forms, upload files, or make other externally visible changes unless the user authorized that action.\n\n## Troubleshooting\n\n### Visible Chrome on Linux\n\nRun `pilot check` when `browser_start` fails. Visible Chrome requires `DISPLAY` or `WAYLAND_DISPLAY` in the Pilot MCP server process. Headless operation does not.\n\nIf desktop applications open but Pilot reports that the display is missing, inspect the graphical session with `printenv DISPLAY`. Forward the returned value through the MCP server configuration and restart the agent so Pilot is relaunched. For Codex:\n\n```toml\n[mcp_servers.pilot]\ncommand = "npx"\nargs = ["-y", "@everydaydevopsio/pilot"]\nenv = { DISPLAY = ":1" }\n```\n\nReplace `:1` with the actual value. If the X server requires a cookie, forward `XAUTHORITY` in the same map. For SSH, use trusted X11 forwarding (`ssh -Y`) when policy permits, or use a remote desktop session and its display value. Use `PILOT_HEADLESS=true` on systems without a desktop. In CI, use headless mode or run Pilot under Xvfb.\n\n### Startup failures\n\nRead the `Launch:`, `Cleanup:`, and `Next:` lines in the `browser_start` error before retrying.\n\n- A failed `browser_start` stops the Chrome it launched and frees the profile unless `Cleanup:` names a pid that did not stop. Do not switch profiles just because a start failed.\n- On a timeout, retry once with a larger `startupTimeoutMs` (for example `180000`). First runs and software-rendered Linux desktops can be slow.\n- If Chrome exited in visible mode, check the display (above) or retry with `headless: true`.\n- If the profile is already in use, the error names the owning Chrome pid and host. `browser_stop` cannot stop a browser that this session did not launch. Call `browser_status` to see which profiles are free and who holds the others. Use a different `profileName`, or, only after the user agrees, call `browser_stop_all`. It also stops browsers that other agents may be using.\n\n### Other Linux preflight failures\n\n- If the profile directory is not writable, set `XDG_DATA_HOME` to a writable directory.\n- If loopback binding fails with `EPERM`, the host or container must allow binding on `127.0.0.1`; disabling Chrome\'s renderer sandbox does not fix it.\n- If Chrome is not detected, set `PILOT_CHROME_PATH` to its executable.\n- Avoid `PILOT_CHROME_NO_SANDBOX=true` unless the runtime genuinely cannot support Chrome\'s sandbox and the user accepts the security tradeoff.\n\n### Connection and page failures\n\n- Confirm the active page with `browser_page_info` and list tabs if Pilot controls the wrong tab.\n- Inspect failed document, script, XHR, and fetch requests with `browser_network`.\n- If element refs stop resolving after a page update, take another snapshot and retry with the new refs.\n';

package/src/commands/connect.ts

@@ -1,4 +1,4 @@
-import type { BrowserManager } from '../browser/browser-manager.js';
+import type { BrowserDriver } from '../browser/driver/types.js';
 import type { TabInfo } from '../browser/types.js';
 
 export interface ConnectParams {
@@ -13,13 +13,13 @@ export interface ConnectResult {
 }
 
 export async function executeConnect(
-  manager: BrowserManager,
+  driver: Pick<BrowserDriver, 'connectExisting'>,
   params: ConnectParams
 ): Promise<ConnectResult> {
   const host = params.host ?? '127.0.0.1';
   const port = params.port ?? 9222;
 
-  const { tabs } = await manager.connectExisting({ host, port });
+  const { tabs } = await driver.connectExisting({ host, port });
 
   return { host, port, tabs };
 }

package/src/mcp/server.ts

@@ -1,18 +1,12 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { BrowserManager } from '../browser.js';
+import { createDriver } from '../browser/driver/factory.js';
+import type { BrowserDriver, DriverSession } from '../browser/driver/types.js';
 import { ElementRefMap } from '../browser/inspect/element-ref.js';
-import { resetCssState } from '../browser/inspect/styles.js';
 import { DialogQueue } from '../browser/interaction/dialogs.js';
-import { attachDialogHandler } from '../browser/interaction/dialogs.js';
-import {
-  DownloadTracker,
-  enableDownloads,
-  attachDownloadHandler
-} from '../browser/interaction/downloads.js';
+import { DownloadTracker } from '../browser/interaction/downloads.js';
 import { NetworkBuffer } from '../browser/network/network-buffer.js';
-import { attachNetworkMonitor } from '../browser/network/network-monitor.js';
 import { loadConfig } from '../util/config.js';
-import { ConsoleBuffer, type ConsoleMessage } from './console-buffer.js';
+import { ConsoleBuffer } from './console-buffer.js';
 import { registerBrowserTools } from './tools/browser.js';
 import { registerErrorTools } from './tools/errors.js';
 import { registerSnapshotTools } from './tools/snapshot.js';
@@ -24,6 +18,7 @@ import { registerFilesTools } from './tools/files.js';
 import { createTraceState } from '../browser/performance/trace.js';
 import { registerPerformanceTools } from './tools/performance.js';
 import { registerConnectTools } from './tools/connect.js';
+import { withCapabilityGate } from './tools/driver-context.js';
 
 export interface McpConfig {
   bufferSize: number;
@@ -31,17 +26,35 @@ export interface McpConfig {
   cdpHost?: string;
 }
 
-export interface BrowserContext {
-  manager: BrowserManager | null;
-  consoleBuffer: ConsoleBuffer;
-  elementRefMap: ElementRefMap;
-  networkBuffer: NetworkBuffer;
-  dialogQueue: DialogQueue;
-  downloadTracker: DownloadTracker;
-  traceState: ReturnType<typeof createTraceState>;
+export interface BrowserContext extends DriverSession {
+  driver: BrowserDriver | null;
   baseConfig: McpConfig;
 }
 
+export type DriverFactory = () => BrowserDriver;
+
+/**
+ * Register every Pilot tool behind the capability gate, so a tool the active
+ * driver cannot support fails before its handler runs.
+ */
+export function registerAllTools(
+  server: McpServer,
+  context: BrowserContext,
+  makeDriver: DriverFactory
+): void {
+  const gated = withCapabilityGate(server, () => context.driver);
+  registerBrowserTools(gated, context, makeDriver);
+  registerErrorTools(gated, context.consoleBuffer);
+  registerSnapshotTools(gated, context);
+  registerInteractionTools(gated, context);
+  registerNetworkTools(gated, context);
+  registerRuntimeTools(gated, context.consoleBuffer);
+  registerStylesTools(gated, context);
+  registerFilesTools(gated, context);
+  registerPerformanceTools(gated, context);
+  registerConnectTools(gated, context, makeDriver);
+}
+
 export async function createMcpServer(config: McpConfig): Promise<{
   server: McpServer;
   cleanup: () => Promise<void>;
@@ -51,88 +64,32 @@ export async function createMcpServer(config: McpConfig): Promise<{
     version: '0.1.0'
   });
 
-  const consoleBuffer = new ConsoleBuffer(config.bufferSize);
-  const elementRefMap = new ElementRefMap();
-  const networkBuffer = new NetworkBuffer();
-  const dialogQueue = new DialogQueue();
-  const downloadTracker = new DownloadTracker();
-  const traceState = createTraceState();
-
   const context: BrowserContext = {
-    manager: null,
-    consoleBuffer,
-    elementRefMap,
-    networkBuffer,
-    dialogQueue,
-    downloadTracker,
-    traceState,
+    driver: null,
+    consoleBuffer: new ConsoleBuffer(config.bufferSize),
+    elementRefMap: new ElementRefMap(),
+    networkBuffer: new NetworkBuffer(),
+    dialogQueue: new DialogQueue(),
+    downloadTracker: new DownloadTracker(),
+    traceState: createTraceState(),
     baseConfig: config
   };
 
-  function attachEventHandlers(manager: BrowserManager): void {
-    let monitoredClient: unknown = null;
-
-    function ensureMonitors(): void {
-      const client = manager.getClient();
-      if (client && client !== monitoredClient) {
-        attachNetworkMonitor(client, networkBuffer);
-        attachDialogHandler(client, dialogQueue);
-        attachDownloadHandler(client, downloadTracker);
-        void enableDownloads(client).catch(() => {
-          // Download behavior setup may fail in some environments
-        });
-        monitoredClient = client;
-      }
-    }
-
-    manager.setEventCallback((event, data) => {
-      if (event === 'console_message') {
-        consoleBuffer.push(data as ConsoleMessage);
-      }
-      if (event === 'page_navigated') {
-        elementRefMap.invalidate();
-      }
-      if (event === 'browser_connected') {
-        ensureMonitors();
-      }
-      if (event === 'browser_disconnected') {
-        monitoredClient = null;
-        resetCssState();
-        dialogQueue.clear();
-        downloadTracker.clear();
-      }
-      // Reattach after tab switch (new client, no connect event)
-      ensureMonitors();
-    });
-  }
-
-  function makeBrowserManager(): BrowserManager {
-    const browserConfig = loadConfig({
-      cdpPort: config.cdpPort,
-      cdpHost: config.cdpHost
-    });
-    const manager = new BrowserManager(browserConfig);
-    attachEventHandlers(manager);
-    return manager;
-  }
+  const makeDriver: DriverFactory = () =>
+    createDriver(
+      'chrome',
+      loadConfig({ cdpPort: config.cdpPort, cdpHost: config.cdpHost }),
+      context
+    );
 
-  registerBrowserTools(server, context, makeBrowserManager);
-  registerErrorTools(server, consoleBuffer);
-  registerSnapshotTools(server, context);
-  registerInteractionTools(server, context);
-  registerNetworkTools(server, context);
-  registerRuntimeTools(server, consoleBuffer);
-  registerStylesTools(server, context);
-  registerFilesTools(server, context);
-  registerPerformanceTools(server, context);
-  registerConnectTools(server, context, makeBrowserManager);
+  registerAllTools(server, context, makeDriver);
 
   return {
     server,
     cleanup: async () => {
-      if (context.manager) {
-        await context.manager.destroy();
-        context.manager = null;
+      if (context.driver) {
+        await context.driver.destroy();
+        context.driver = null;
       }
     }
   };