@ulpi/browse 0.1.0 → 0.2.1

package/src/server.ts

@@ -14,6 +14,7 @@ import { SessionManager, type Session } from './session-manager';
 import { handleReadCommand } from './commands/read';
 import { handleWriteCommand } from './commands/write';
 import { handleMetaCommand } from './commands/meta';
+import { PolicyChecker } from './policy';
 import { DEFAULTS } from './constants';
 import { type LogEntry, type NetworkEntry } from './buffers';
 import * as fs from 'fs';
@@ -26,7 +27,8 @@ export { type LogEntry, type NetworkEntry };
 // ─── Auth (inline) ─────────────────────────────────────────────
 const AUTH_TOKEN = crypto.randomUUID();
 const BROWSE_PORT = parseInt(process.env.BROWSE_PORT || '0', 10); // 0 = auto-scan
-const INSTANCE_SUFFIX = BROWSE_PORT ? `-${BROWSE_PORT}` : '';
+const BROWSE_INSTANCE = process.env.BROWSE_INSTANCE || '';
+const INSTANCE_SUFFIX = BROWSE_PORT ? `-${BROWSE_PORT}` : (BROWSE_INSTANCE ? `-${BROWSE_INSTANCE}` : '');
 const LOCAL_DIR = process.env.BROWSE_LOCAL_DIR || '/tmp';
 const STATE_FILE = process.env.BROWSE_STATE_FILE || `${LOCAL_DIR}/browse-server${INSTANCE_SUFFIX}.json`;
 const IDLE_TIMEOUT_MS = parseInt(process.env.BROWSE_IDLE_TIMEOUT || String(DEFAULTS.IDLE_TIMEOUT_MS), 10);
@@ -46,9 +48,8 @@ function flushAllBuffers(sessionManager: SessionManager, final = false) {
 }
 
 function flushSessionBuffers(session: Session, final: boolean) {
-  const suffix = session.id === 'default' ? INSTANCE_SUFFIX : `-${session.id}`;
-  const consolePath = `${LOCAL_DIR}/browse-console${suffix}.log`;
-  const networkPath = `${LOCAL_DIR}/browse-network${suffix}.log`;
+  const consolePath = `${session.outputDir}/console.log`;
+  const networkPath = `${session.outputDir}/network.log`;
   const buffers = session.buffers;
 
   // Console flush
@@ -98,19 +99,25 @@ function flushSessionBuffers(session: Session, final: boolean) {
 let sessionManager: SessionManager;
 let browser: Browser;
 let isShuttingDown = false;
+let isRemoteBrowser = false;
+const policyChecker = new PolicyChecker();
 
 // Read/write/meta command sets for routing
 const READ_COMMANDS = new Set([
   'text', 'html', 'links', 'forms', 'accessibility',
-  'js', 'eval', 'css', 'attrs', 'state', 'dialog',
+  'js', 'eval', 'css', 'attrs', 'element-state', 'dialog',
   'console', 'network', 'cookies', 'storage', 'perf', 'devices',
+  'value', 'count',
 ]);
 
 const WRITE_COMMANDS = new Set([
   'goto', 'back', 'forward', 'reload',
-  'click', 'fill', 'select', 'hover', 'type', 'press', 'scroll', 'wait',
+  'click', 'dblclick', 'fill', 'select', 'hover', 'focus', 'check', 'uncheck',
+  'type', 'press', 'scroll', 'wait',
   'viewport', 'cookie', 'header', 'useragent',
   'upload', 'dialog-accept', 'dialog-dismiss', 'emulate',
+  'drag', 'keydown', 'keyup',
+  'highlight', 'download', 'route', 'offline',
 ]);
 
 const META_COMMANDS = new Set([
@@ -120,42 +127,133 @@ const META_COMMANDS = new Set([
   'chain', 'diff',
   'url', 'snapshot', 'snapshot-diff',
   'sessions', 'session-close',
+  'frame', 'state',
+  'auth', 'har',
 ]);
 
+// Probe if a port is free using net.createServer (not Bun.serve which fatally crashes on EADDRINUSE)
+import * as net from 'net';
+
+function isPortFree(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const srv = net.createServer();
+    srv.once('error', () => resolve(false));
+    srv.once('listening', () => { srv.close(() => resolve(true)); });
+    srv.listen(port, '127.0.0.1');
+  });
+}
+
 // Find port: use BROWSE_PORT or scan range
 async function findPort(): Promise<number> {
   if (BROWSE_PORT) {
-    try {
-      const testServer = Bun.serve({ port: BROWSE_PORT, fetch: () => new Response('ok') });
-      testServer.stop();
-      return BROWSE_PORT;
-    } catch {
-      throw new Error(`[browse] Port ${BROWSE_PORT} is in use`);
-    }
+    if (await isPortFree(BROWSE_PORT)) return BROWSE_PORT;
+    throw new Error(`[browse] Port ${BROWSE_PORT} is in use`);
   }
 
   // Scan range
   const start = parseInt(process.env.BROWSE_PORT_START || String(DEFAULTS.PORT_RANGE_START), 10);
   const end = start + (DEFAULTS.PORT_RANGE_END - DEFAULTS.PORT_RANGE_START);
   for (let port = start; port <= end; port++) {
-    try {
-      const testServer = Bun.serve({ port, fetch: () => new Response('ok') });
-      testServer.stop();
-      return port;
-    } catch {
-      continue;
-    }
+    if (await isPortFree(port)) return port;
   }
   throw new Error(`[browse] No available port in range ${start}-${end}`);
 }
 
-async function handleCommand(body: any, session: Session): Promise<Response> {
+// Commands that return page-derived content (for --content-boundaries wrapping).
+// Action commands (click, goto) and meta commands (status, tabs) are NOT wrapped.
+const PAGE_CONTENT_COMMANDS = new Set([
+  'text', 'html', 'links', 'forms', 'accessibility',
+  'js', 'eval', 'console', 'network', 'snapshot',
+]);
+
+// Nonce for content boundaries — generated once per server process
+const BOUNDARY_NONCE = crypto.randomUUID();
+
+interface RequestOptions {
+  jsonMode: boolean;
+  contentBoundaries: boolean;
+}
+
+/**
+ * Rewrite Playwright error messages into actionable hints for AI agents.
+ * Raw errors like "locator.click: Timeout 5000ms exceeded" are unhelpful.
+ */
+function rewriteError(msg: string): string {
+  if (msg.includes('strict mode violation')) {
+    const countMatch = msg.match(/resolved to (\d+) elements/);
+    return `Multiple elements matched (${countMatch?.[1] || 'several'}). Use a more specific selector or run 'snapshot -i' to find exact refs.`;
+  }
+  if (msg.includes('Timeout') && msg.includes('exceeded')) {
+    const timeMatch = msg.match(/Timeout (\d+)ms/);
+    return `Element not found within ${timeMatch?.[1] || '?'}ms. The element may not exist, be hidden, or the page is still loading. Try 'wait <selector>' first, or check with 'snapshot -i'.`;
+  }
+  if (msg.includes('waiting for locator') || msg.includes('waiting for selector')) {
+    return `Element not found on the page. Run 'snapshot -i' to see available elements, or check the current URL with 'url'.`;
+  }
+  if (msg.includes('not an HTMLInputElement') || msg.includes('not an input')) {
+    return `Cannot fill this element — it's not an input field. Use 'click' instead, or run 'snapshot -i' to find the correct input.`;
+  }
+  if (msg.includes('Element is not visible')) {
+    return `Element exists but is hidden (display:none or visibility:hidden). Try scrolling to it with 'scroll <selector>' or wait for it with 'wait <selector>'.`;
+  }
+  if (msg.includes('Element is outside of the viewport')) {
+    return `Element is off-screen. Scroll to it first with 'scroll <selector>'.`;
+  }
+  if (msg.includes('intercepts pointer events')) {
+    return `Another element is covering the target (e.g., a modal, overlay, or cookie banner). Close the overlay first or use 'js' to click directly.`;
+  }
+  if (msg.includes('Frame was detached') || msg.includes('frame was detached')) {
+    return `The iframe was removed or navigated away. Run 'frame main' to return to the main page, then re-navigate.`;
+  }
+  if (msg.includes('Target closed') || msg.includes('target closed')) {
+    return `The page or tab was closed. Use 'tabs' to list open tabs, or 'goto' to navigate to a new page.`;
+  }
+  if (msg.includes('net::ERR_')) {
+    const errMatch = msg.match(/(net::\w+)/);
+    return `Network error: ${errMatch?.[1] || 'connection failed'}. Check the URL and ensure the site is reachable.`;
+  }
+  return msg;
+}
+
+async function handleCommand(body: any, session: Session, opts: RequestOptions): Promise<Response> {
   const { command, args = [] } = body;
 
   if (!command) {
-    return new Response(JSON.stringify({ error: 'Missing "command" field' }), {
-      status: 400,
-      headers: { 'Content-Type': 'application/json' },
+    const error = 'Missing "command" field';
+    if (opts.jsonMode) {
+      return new Response(JSON.stringify({ success: false, error }), {
+        status: 400, headers: { 'Content-Type': 'application/json' },
+      });
+    }
+    return new Response(JSON.stringify({ error }), {
+      status: 400, headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  // Policy check
+  const policyResult = policyChecker.check(command);
+  if (policyResult === 'deny') {
+    const error = `Command '${command}' denied by policy`;
+    const hint = 'Update browse-policy.json to allow this command.';
+    if (opts.jsonMode) {
+      return new Response(JSON.stringify({ success: false, error, hint }), {
+        status: 403, headers: { 'Content-Type': 'application/json' },
+      });
+    }
+    return new Response(JSON.stringify({ error, hint }), {
+      status: 403, headers: { 'Content-Type': 'application/json' },
+    });
+  }
+  if (policyResult === 'confirm') {
+    const error = `Command '${command}' requires confirmation (policy). Non-interactive CLI cannot confirm.`;
+    const hint = 'Move this command to the allow list in browse-policy.json.';
+    if (opts.jsonMode) {
+      return new Response(JSON.stringify({ success: false, error, hint }), {
+        status: 403, headers: { 'Content-Type': 'application/json' },
+      });
+    }
+    return new Response(JSON.stringify({ error, hint }), {
+      status: 403, headers: { 'Content-Type': 'application/json' },
     });
   }
 
@@ -165,27 +263,47 @@ async function handleCommand(body: any, session: Session): Promise<Response> {
     if (READ_COMMANDS.has(command)) {
       result = await handleReadCommand(command, args, session.manager, session.buffers);
     } else if (WRITE_COMMANDS.has(command)) {
-      result = await handleWriteCommand(command, args, session.manager);
+      result = await handleWriteCommand(command, args, session.manager, session.domainFilter);
     } else if (META_COMMANDS.has(command)) {
       result = await handleMetaCommand(command, args, session.manager, shutdown, sessionManager, session);
     } else {
-      return new Response(JSON.stringify({
-        error: `Unknown command: ${command}`,
-        hint: `Available commands: ${[...READ_COMMANDS, ...WRITE_COMMANDS, ...META_COMMANDS].sort().join(', ')}`,
-      }), {
-        status: 400,
-        headers: { 'Content-Type': 'application/json' },
+      const error = `Unknown command: ${command}`;
+      const hint = `Available commands: ${[...READ_COMMANDS, ...WRITE_COMMANDS, ...META_COMMANDS].sort().join(', ')}`;
+      if (opts.jsonMode) {
+        return new Response(JSON.stringify({ success: false, error, hint }), {
+          status: 400, headers: { 'Content-Type': 'application/json' },
+        });
+      }
+      return new Response(JSON.stringify({ error, hint }), {
+        status: 400, headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
+    // Apply content boundaries for page-content commands
+    if (opts.contentBoundaries && PAGE_CONTENT_COMMANDS.has(command)) {
+      const origin = session.manager.getCurrentUrl();
+      result = `--- BROWSE_CONTENT nonce=${BOUNDARY_NONCE} origin=${origin} ---\n${result}\n--- END_BROWSE_CONTENT nonce=${BOUNDARY_NONCE} ---`;
+    }
+
+    // Apply JSON wrapping
+    if (opts.jsonMode) {
+      return new Response(JSON.stringify({ success: true, data: result, command }), {
+        status: 200, headers: { 'Content-Type': 'application/json' },
       });
     }
 
     return new Response(result, {
-      status: 200,
-      headers: { 'Content-Type': 'text/plain' },
+      status: 200, headers: { 'Content-Type': 'text/plain' },
     });
   } catch (err: any) {
-    return new Response(JSON.stringify({ error: err.message }), {
-      status: 500,
-      headers: { 'Content-Type': 'application/json' },
+    const friendlyError = rewriteError(err.message);
+    if (opts.jsonMode) {
+      return new Response(JSON.stringify({ success: false, error: friendlyError, command }), {
+        status: 500, headers: { 'Content-Type': 'application/json' },
+      });
+    }
+    return new Response(JSON.stringify({ error: friendlyError }), {
+      status: 500, headers: { 'Content-Type': 'application/json' },
     });
   }
 }
@@ -201,8 +319,8 @@ async function shutdown() {
 
   await sessionManager.closeAll();
 
-  // Close the shared browser
-  if (browser) {
+  // Close the shared browser (skip if remote — we don't own it)
+  if (browser && !isRemoteBrowser) {
     browser.removeAllListeners('disconnected');
     await browser.close().catch(() => {});
   }
@@ -246,24 +364,41 @@ const sessionCleanupInterval = setInterval(async () => {
 async function start() {
   const port = await findPort();
 
-  // Launch shared Chromium
-  browser = await chromium.launch({ headless: true });
-
-  // Chromium crash → flush, cleanup, exit
-  browser.on('disconnected', () => {
-    console.error('[browse] FATAL: Chromium process crashed or was killed. Server exiting.');
-    if (sessionManager) flushAllBuffers(sessionManager, true);
-    try {
-      const currentState = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
-      if (currentState.pid === process.pid || currentState.token === AUTH_TOKEN) {
-        fs.unlinkSync(STATE_FILE);
+  // Launch or connect to browser
+  const cdpUrl = process.env.BROWSE_CDP_URL;
+  if (cdpUrl) {
+    // Connect to remote Chrome via CDP
+    browser = await chromium.connectOverCDP(cdpUrl);
+    isRemoteBrowser = true;
+    console.log(`[browse] Connected to remote Chrome via CDP: ${cdpUrl}`);
+  } else {
+    // Launch local Chromium
+    const launchOptions: Record<string, any> = { headless: true };
+    const proxyServer = process.env.BROWSE_PROXY;
+    if (proxyServer) {
+      launchOptions.proxy = { server: proxyServer };
+      if (process.env.BROWSE_PROXY_BYPASS) {
+        launchOptions.proxy.bypass = process.env.BROWSE_PROXY_BYPASS;
       }
-    } catch {}
-    process.exit(1);
-  });
+    }
+    browser = await chromium.launch(launchOptions);
+
+    // Chromium crash → flush, cleanup, exit (only for owned browser)
+    browser.on('disconnected', () => {
+      console.error('[browse] FATAL: Chromium process crashed or was killed. Server exiting.');
+      if (sessionManager) flushAllBuffers(sessionManager, true);
+      try {
+        const currentState = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+        if (currentState.pid === process.pid || currentState.token === AUTH_TOKEN) {
+          fs.unlinkSync(STATE_FILE);
+        }
+      } catch {}
+      process.exit(1);
+    });
+  }
 
   // Create session manager
-  sessionManager = new SessionManager(browser);
+  sessionManager = new SessionManager(browser, LOCAL_DIR);
 
   const startTime = Date.now();
   const server = Bun.serve({
@@ -274,7 +409,7 @@ async function start() {
 
       // Health check — no auth required
       if (url.pathname === '/health') {
-        const healthy = browser.isConnected();
+        const healthy = !isShuttingDown && browser.isConnected();
         return new Response(JSON.stringify({
           status: healthy ? 'healthy' : 'unhealthy',
           uptime: Math.floor((Date.now() - startTime) / 1000),
@@ -296,8 +431,13 @@ async function start() {
       if (url.pathname === '/command' && req.method === 'POST') {
         const body = await req.json();
         const sessionId = req.headers.get('x-browse-session') || 'default';
-        const session = await sessionManager.getOrCreate(sessionId);
-        return handleCommand(body, session);
+        const allowedDomains = req.headers.get('x-browse-allowed-domains') || undefined;
+        const session = await sessionManager.getOrCreate(sessionId, allowedDomains);
+        const opts: RequestOptions = {
+          jsonMode: req.headers.get('x-browse-json') === '1',
+          contentBoundaries: req.headers.get('x-browse-boundaries') === '1',
+        };
+        return handleCommand(body, session, opts);
       }
 
       return new Response('Not found', { status: 404 });

package/src/session-manager.ts

@@ -9,11 +9,17 @@
 import type { Browser } from 'playwright';
 import { BrowserManager } from './browser-manager';
 import { SessionBuffers } from './buffers';
+import { DomainFilter } from './domain-filter';
+import { sanitizeName } from './sanitize';
+import * as fs from 'fs';
+import * as path from 'path';
 
 export interface Session {
   id: string;
   manager: BrowserManager;
   buffers: SessionBuffers;
+  domainFilter: DomainFilter | null;
+  outputDir: string;
   lastActivity: number;
   createdAt: number;
 }
@@ -21,30 +27,87 @@ export interface Session {
 export class SessionManager {
   private sessions = new Map<string, Session>();
   private browser: Browser;
+  private localDir: string;
 
-  constructor(browser: Browser) {
+  constructor(browser: Browser, localDir: string = '/tmp') {
     this.browser = browser;
+    this.localDir = localDir;
   }
 
   /**
    * Get an existing session or create a new one.
    * Creating a session launches a new BrowserContext on the shared Chromium.
    */
-  async getOrCreate(sessionId: string): Promise<Session> {
+  async getOrCreate(sessionId: string, allowedDomains?: string): Promise<Session> {
     let session = this.sessions.get(sessionId);
     if (session) {
       session.lastActivity = Date.now();
+      // Update domain filter if provided and session doesn't already have one
+      if (allowedDomains && !session.domainFilter) {
+        const domains = allowedDomains.split(',').map(d => d.trim()).filter(Boolean);
+        if (domains.length > 0) {
+          const domainFilter = new DomainFilter(domains);
+          session.manager.setDomainFilter(domainFilter);
+          const context = session.manager.getContext();
+          if (context) {
+            await context.route('**/*', (route) => {
+              const url = route.request().url();
+              if (domainFilter.isAllowed(url)) {
+                route.continue();
+              } else {
+                route.abort('blockedbyclient');
+              }
+            });
+            const initScript = domainFilter.generateInitScript();
+            await context.addInitScript(initScript);
+            session.manager.setInitScript(initScript);
+          }
+          session.domainFilter = domainFilter;
+        }
+      }
       return session;
     }
 
+    // Create per-session output directory
+    const outputDir = path.join(this.localDir, 'sessions', sanitizeName(sessionId));
+    fs.mkdirSync(outputDir, { recursive: true });
+
     const buffers = new SessionBuffers();
     const manager = new BrowserManager(buffers);
     await manager.launchWithBrowser(this.browser);
 
+    // Apply domain filter if allowed domains are specified
+    let domainFilter: DomainFilter | null = null;
+    if (allowedDomains) {
+      const domains = allowedDomains.split(',').map(d => d.trim()).filter(Boolean);
+      if (domains.length > 0) {
+        domainFilter = new DomainFilter(domains);
+        manager.setDomainFilter(domainFilter);
+        const context = manager.getContext();
+        if (context) {
+          // Block disallowed domains at the network level via Playwright route()
+          await context.route('**/*', (route) => {
+            const url = route.request().url();
+            if (domainFilter!.isAllowed(url)) {
+              route.continue();
+            } else {
+              route.abort('blockedbyclient');
+            }
+          });
+          // Block WebSocket, EventSource, sendBeacon via JS injection
+          const initScript = domainFilter.generateInitScript();
+          await context.addInitScript(initScript);
+          manager.setInitScript(initScript);
+        }
+      }
+    }
+
     session = {
       id: sessionId,
       manager,
       buffers,
+      domainFilter,
+      outputDir,
       lastActivity: Date.now(),
       createdAt: Date.now(),
     };

package/src/snapshot.ts

@@ -18,7 +18,7 @@
  * Later: "click @e3" → look up Locator → locator.click()
  */
 
-import type { Page, Locator } from 'playwright';
+import type { Page, Frame, FrameLocator, Locator } from 'playwright';
 import type { BrowserManager } from './browser-manager';
 
 // Roles considered "interactive" for the -i flag
@@ -146,13 +146,13 @@ const NATIVE_INTERACTIVE_TAGS = new Set([
  *   - Elements already covered by ARIA roles
  */
 async function findCursorInteractiveElements(
-  page: Page,
+  evalCtx: Page | Frame,
   scopeSelector?: string,
 ): Promise<CursorElement[]> {
   const interactiveRolesList = [...INTERACTIVE_ROLES];
   const nativeTagsList = [...NATIVE_INTERACTIVE_TAGS];
 
-  return await page.evaluate(
+  return await evalCtx.evaluate(
     ({ scopeSel, interactiveRoles, nativeTags }) => {
       const root = scopeSel
         ? document.querySelector(scopeSel) || document.body
@@ -323,23 +323,27 @@ export async function handleSnapshot(
 ): Promise<string> {
   const opts = parseSnapshotArgs(args);
   const page = bm.getPage();
+  // When a frame is active, scope snapshot to the frame's content
+  const locatorRoot = bm.getLocatorRoot();
 
   // Get accessibility tree via ariaSnapshot
   let rootLocator: Locator;
   if (opts.selector) {
-    rootLocator = page.locator(opts.selector);
+    rootLocator = locatorRoot.locator(opts.selector);
     const count = await rootLocator.count();
     if (count === 0) throw new Error(`Selector not found: ${opts.selector}`);
   } else {
-    rootLocator = page.locator('body');
+    rootLocator = locatorRoot.locator('body');
   }
 
   const ariaText = await rootLocator.ariaSnapshot();
+  // Get frame context for evaluate calls (cursor-interactive scan)
+  const evalCtx = await bm.getFrameContext() || page;
   if (!ariaText || ariaText.trim().length === 0) {
     bm.setRefMap(new Map());
     // If -C is active, still scan for cursor-interactive even with empty ARIA
     if (opts.cursor) {
-      const result = await appendCursorElements(page, opts, [], new Map(), 1, bm);
+      const result = await appendCursorElements(evalCtx, locatorRoot, opts, [], new Map(), 1, bm);
       bm.setLastSnapshot(result, args);
       return result;
     }
@@ -396,11 +400,11 @@ export async function handleSnapshot(
 
     let locator: Locator;
     if (opts.selector) {
-      locator = page.locator(opts.selector).getByRole(node.role as any, {
+      locator = locatorRoot.locator(opts.selector).getByRole(node.role as any, {
         name: node.name || undefined,
       });
     } else {
-      locator = page.getByRole(node.role as any, {
+      locator = locatorRoot.getByRole(node.role as any, {
         name: node.name || undefined,
       });
     }
@@ -423,7 +427,7 @@ export async function handleSnapshot(
 
   // Cursor-interactive detection: supplement ARIA tree with DOM-level scan
   if (opts.cursor) {
-    const result = await appendCursorElements(page, opts, output, refMap, refCounter, bm);
+    const result = await appendCursorElements(evalCtx, locatorRoot, opts, output, refMap, refCounter, bm);
     bm.setLastSnapshot(result, args);
     return result;
   }
@@ -446,14 +450,15 @@ export async function handleSnapshot(
  * Called when -C flag is active.
  */
 async function appendCursorElements(
-  page: Page,
+  evalCtx: Page | Frame,
+  locatorRoot: Page | FrameLocator,
   opts: SnapshotOptions,
   output: string[],
   refMap: Map<string, Locator>,
   refCounter: number,
   bm: BrowserManager,
 ): Promise<string> {
-  const cursorElements = await findCursorInteractiveElements(page, opts.selector);
+  const cursorElements = await findCursorInteractiveElements(evalCtx, opts.selector);
 
   if (cursorElements.length > 0) {
     output.push('');
@@ -468,9 +473,9 @@ async function appendCursorElements(
       // share the same selector.
       let baseLocator: Locator;
       if (opts.selector) {
-        baseLocator = page.locator(opts.selector).locator(elem.cssSelector);
+        baseLocator = locatorRoot.locator(opts.selector).locator(elem.cssSelector);
       } else {
-        baseLocator = page.locator(elem.cssSelector);
+        baseLocator = locatorRoot.locator(elem.cssSelector);
       }
       const locator = baseLocator.nth(elem.selectorIndex);