@jackwener/opencli 1.5.7 → 1.5.9

package/src/browser/page.ts

@@ -10,25 +10,13 @@
  * chrome-extension:// tab that can't be debugged.
  */
 
-import { formatSnapshot } from '../snapshotFormatter.js';
-import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
+import type { BrowserCookie, ScreenshotOptions } from '../types.js';
 import { sendCommand } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
 import { saveBase64ToFile } from '../utils.js';
-import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 import { generateStealthJs } from './stealth.js';
-import {
-  clickJs,
-  typeTextJs,
-  pressKeyJs,
-  waitForTextJs,
-  waitForCaptureJs,
-  waitForSelectorJs,
-  scrollJs,
-  autoScrollJs,
-  networkRequestsJs,
-  waitForDomStableJs,
-} from './dom-helpers.js';
+import { waitForDomStableJs } from './dom-helpers.js';
+import { BasePage } from './base-page.js';
 
 export function isRetryableSettleError(err: unknown): boolean {
   const message = err instanceof Error ? err.message : String(err);
@@ -39,13 +27,13 @@ export function isRetryableSettleError(err: unknown): boolean {
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
-export class Page implements IPage {
-  constructor(private readonly workspace: string = 'default') {}
+export class Page extends BasePage {
+  constructor(private readonly workspace: string = 'default') {
+    super();
+  }
 
   /** Active tab ID, set after navigate and used in all subsequent commands */
   private _tabId: number | undefined;
-  /** Last navigated URL, tracked in-memory to avoid extra round-trips */
-  private _lastUrl: string | null = null;
 
   /** Helper: spread workspace into command params */
   private _wsOpt(): { workspace: string } {
@@ -107,27 +95,8 @@ export class Page implements IPage {
     }
   }
 
-  async getCurrentUrl(): Promise<string | null> {
-    if (this._lastUrl) return this._lastUrl;
-    try {
-      const current = await this.evaluate('window.location.href');
-      if (typeof current === 'string' && current) {
-        this._lastUrl = current;
-        return current;
-      }
-    } catch {
-      // Best-effort: some commands may run before a debuggable tab is ready.
-    }
-    return null;
-  }
-
-  /** Close the automation window in the extension */
-  async closeWindow(): Promise<void> {
-    try {
-      await sendCommand('close-window', { ...this._wsOpt() });
-    } catch {
-      // Window may already be closed or daemon may be down
-    }
+  getActiveTabId(): number | undefined {
+    return this._tabId;
   }
 
   async evaluate(js: string): Promise<unknown> {
@@ -146,124 +115,12 @@ export class Page implements IPage {
     return Array.isArray(result) ? result : [];
   }
 
-  async snapshot(opts: SnapshotOptions = {}): Promise<unknown> {
-    // Primary: use the advanced DOM snapshot engine with multi-layer pruning
-    const snapshotJs = generateSnapshotJs({
-      viewportExpand: opts.viewportExpand ?? 800,
-      maxDepth: Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200)),
-      interactiveOnly: opts.interactive ?? false,
-      maxTextLength: opts.maxTextLength ?? 120,
-      includeScrollInfo: true,
-      bboxDedup: true,
-    });
-
+  /** Close the automation window in the extension */
+  async closeWindow(): Promise<void> {
     try {
-      const result = await sendCommand('exec', { code: snapshotJs, ...this._cmdOpts() });
-      // The advanced engine already produces a clean, pruned, LLM-friendly output.
-      // Do NOT pass through formatSnapshot — its format is incompatible.
-      return result;
+      await sendCommand('close-window', { ...this._wsOpt() });
     } catch {
-      // Fallback: basic DOM snapshot (original implementation)
-      return this._basicSnapshot(opts);
-    }
-  }
-
-  /** Fallback basic snapshot — original buildTree approach */
-  private async _basicSnapshot(opts: Pick<SnapshotOptions, 'interactive' | 'compact' | 'maxDepth' | 'raw'> = {}): Promise<unknown> {
-    const maxDepth = Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200));
-    const code = `
-      (async () => {
-        function buildTree(node, depth) {
-          if (depth > ${maxDepth}) return '';
-          const role = node.getAttribute?.('role') || node.tagName?.toLowerCase() || 'generic';
-          const name = node.getAttribute?.('aria-label') || node.getAttribute?.('alt') || node.textContent?.trim().slice(0, 80) || '';
-          const isInteractive = ['a', 'button', 'input', 'select', 'textarea'].includes(node.tagName?.toLowerCase()) || node.getAttribute?.('tabindex') != null;
-
-          ${opts.interactive ? 'if (!isInteractive && !node.children?.length) return "";' : ''}
-
-          let indent = '  '.repeat(depth);
-          let line = indent + role;
-          if (name) line += ' "' + name.replace(/"/g, '\\\\\\"') + '"';
-          if (node.tagName?.toLowerCase() === 'a' && node.href) line += ' [' + node.href + ']';
-          if (node.tagName?.toLowerCase() === 'input') line += ' [' + (node.type || 'text') + ']';
-
-          let result = line + '\\n';
-          if (node.children) {
-            for (const child of node.children) {
-              result += buildTree(child, depth + 1);
-            }
-          }
-          return result;
-        }
-        return buildTree(document.body, 0);
-      })()
-    `;
-    const raw = await sendCommand('exec', { code, ...this._cmdOpts() });
-    if (opts.raw) return raw;
-    if (typeof raw === 'string') return formatSnapshot(raw, opts);
-    return raw;
-  }
-
-  async click(ref: string): Promise<void> {
-    const code = clickJs(ref);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async typeText(ref: string, text: string): Promise<void> {
-    const code = typeTextJs(ref, text);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async pressKey(key: string): Promise<void> {
-    const code = pressKeyJs(key);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async scrollTo(ref: string): Promise<unknown> {
-    const code = scrollToRefJs(ref);
-    return sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async getFormState(): Promise<Record<string, unknown>> {
-    const code = getFormStateJs();
-    return (await sendCommand('exec', { code, ...this._cmdOpts() })) as Record<string, unknown>;
-  }
-
-  async wait(options: number | WaitOptions): Promise<void> {
-    if (typeof options === 'number') {
-      if (options >= 1) {
-        // For waits >= 1s, use DOM-stable check: return early when the page
-        // stops mutating, with the original wait time as the hard cap.
-        // This turns e.g. `page.wait(5)` from a fixed 5s sleep into
-        // "wait until DOM is stable, max 5s" — often completing in <1s.
-        try {
-          const maxMs = options * 1000;
-          await sendCommand('exec', {
-            code: waitForDomStableJs(maxMs, Math.min(500, maxMs)),
-            ...this._cmdOpts(),
-          });
-          return;
-        } catch {
-          // Fallback: fixed sleep (e.g. if page has no DOM yet)
-        }
-      }
-      await new Promise(resolve => setTimeout(resolve, options * 1000));
-      return;
-    }
-    if (typeof options.time === 'number') {
-      await new Promise(resolve => setTimeout(resolve, options.time! * 1000));
-      return;
-    }
-    if (options.selector) {
-      const timeout = (options.timeout ?? 10) * 1000;
-      const code = waitForSelectorJs(options.selector, timeout);
-      await sendCommand('exec', { code, ...this._cmdOpts() });
-      return;
-    }
-    if (options.text) {
-      const timeout = (options.timeout ?? 30) * 1000;
-      const code = waitForTextJs(options.text, timeout);
-      await sendCommand('exec', { code, ...this._cmdOpts() });
+      // Window may already be closed or daemon may be down
     }
   }
 
@@ -289,27 +146,8 @@ export class Page implements IPage {
     if (result?.selected) this._tabId = result.selected;
   }
 
-  async networkRequests(includeStatic: boolean = false): Promise<unknown[]> {
-    const code = networkRequestsJs(includeStatic);
-    const result = await sendCommand('exec', { code, ...this._cmdOpts() });
-    return Array.isArray(result) ? result : [];
-  }
-
-  /**
-   * Console messages are not available in lightweight daemon mode.
-   * Would require CDP Runtime.consoleAPICalled event listener.
-   * @returns Always returns empty array.
-   */
-  async consoleMessages(_level: string = 'info'): Promise<unknown[]> {
-    return [];
-  }
-
   /**
    * Capture a screenshot via CDP Page.captureScreenshot.
-   * @param options.format - 'png' (default) or 'jpeg'
-   * @param options.quality - JPEG quality 0-100
-   * @param options.fullPage - capture full scrollable page
-   * @param options.path - save to file path (returns base64 if omitted)
    */
   async screenshot(options: ScreenshotOptions = {}): Promise<string> {
     const base64 = await sendCommand('screenshot', {
@@ -326,35 +164,6 @@ export class Page implements IPage {
     return base64;
   }
 
-  async scroll(direction: string = 'down', amount: number = 500): Promise<void> {
-    const code = scrollJs(direction, amount);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async autoScroll(options: { times?: number; delayMs?: number } = {}): Promise<void> {
-    const times = options.times ?? 3;
-    const delayMs = options.delayMs ?? 2000;
-    const code = autoScrollJs(times, delayMs);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async installInterceptor(pattern: string): Promise<void> {
-    const { generateInterceptorJs } = await import('../interceptor.js');
-    // Must use evaluate() so wrapForEval() converts the arrow function into an IIFE;
-    // sendCommand('exec') sends the code as-is, and CDP never executes a bare arrow.
-    await this.evaluate(generateInterceptorJs(JSON.stringify(pattern), {
-      arrayName: '__opencli_xhr',
-      patchGuard: '__opencli_interceptor_patched',
-    }));
-  }
-
-  async getInterceptedRequests(): Promise<unknown[]> {
-    const { generateReadInterceptedJs } = await import('../interceptor.js');
-    // Same as installInterceptor: must go through evaluate() for IIFE wrapping
-    const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
-    return Array.isArray(result) ? result : [];
-  }
-
   /**
    * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
    * Chrome reads the files directly from the local filesystem, avoiding the
@@ -370,14 +179,6 @@ export class Page implements IPage {
       throw new Error('setFileInput returned no count — command may not be supported by the extension');
     }
   }
-
-  async waitForCapture(timeout: number = 10): Promise<void> {
-    const maxMs = timeout * 1000;
-    await sendCommand('exec', {
-      code: waitForCaptureJs(maxMs),
-      ...this._cmdOpts(),
-    });
-  }
 }
 
 // (End of file)

package/src/browser/tabs.ts

@@ -21,12 +21,12 @@ export function extractTabEntries(raw: unknown): Array<{ index: number; identity
       .map(line => line.trim())
       .filter(Boolean)
       .map(line => {
-        // Match actual Playwright MCP format: "- 0: (current) [title](url)"  or  "- 1: [title](url)"
-        const mcpMatch = line.match(/^-\s+(\d+):\s*(.*)$/);
-        if (mcpMatch) {
+        // Match tab list format: "- 0: (current) [title](url)"  or  "- 1: [title](url)"
+        const tabMatch = line.match(/^-\s+(\d+):\s*(.*)$/);
+        if (tabMatch) {
           return {
-            index: parseInt(mcpMatch[1], 10),
-            identity: mcpMatch[2].trim() || `tab-${mcpMatch[1]}`,
+            index: parseInt(tabMatch[1], 10),
+            identity: tabMatch[2].trim() || `tab-${tabMatch[1]}`,
           };
         }
         // Legacy format: "Tab 0 ..."

package/src/browser.test.ts

@@ -104,43 +104,43 @@ describe('browser helpers', () => {
 
 describe('BrowserBridge state', () => {
   it('transitions to closed after close()', async () => {
-    const mcp = new BrowserBridge();
+    const bridge = new BrowserBridge();
 
-    expect(mcp.state).toBe('idle');
+    expect(bridge.state).toBe('idle');
 
-    await mcp.close();
+    await bridge.close();
 
-    expect(mcp.state).toBe('closed');
+    expect(bridge.state).toBe('closed');
   });
 
   it('rejects connect() after the session has been closed', async () => {
-    const mcp = new BrowserBridge();
-    await mcp.close();
+    const bridge = new BrowserBridge();
+    await bridge.close();
 
-    await expect(mcp.connect()).rejects.toThrow('Session is closed');
+    await expect(bridge.connect()).rejects.toThrow('Session is closed');
   });
 
   it('rejects connect() while already connecting', async () => {
-    const mcp = new BrowserBridge();
-    (mcp as any)._state = 'connecting';
+    const bridge = new BrowserBridge();
+    (bridge as any)._state = 'connecting';
 
-    await expect(mcp.connect()).rejects.toThrow('Already connecting');
+    await expect(bridge.connect()).rejects.toThrow('Already connecting');
   });
 
   it('rejects connect() while closing', async () => {
-    const mcp = new BrowserBridge();
-    (mcp as any)._state = 'closing';
+    const bridge = new BrowserBridge();
+    (bridge as any)._state = 'closing';
 
-    await expect(mcp.connect()).rejects.toThrow('Session is closing');
+    await expect(bridge.connect()).rejects.toThrow('Session is closing');
   });
 
   it('fails fast when daemon is running but extension is disconnected', async () => {
     vi.spyOn(daemonClient, 'isExtensionConnected').mockResolvedValue(false);
     vi.spyOn(daemonClient, 'isDaemonRunning').mockResolvedValue(true);
 
-    const mcp = new BrowserBridge();
+    const bridge = new BrowserBridge();
 
-    await expect(mcp.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
+    await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
   });
 });
 

package/src/clis/amazon/bestsellers.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './bestsellers.js';
+
+describe('amazon bestsellers normalization', () => {
+  it('normalizes bestseller cards and infers review counts from card text', () => {
+    const result = __test__.normalizeBestsellerCandidate({
+      asin: 'B0DR31GC3D',
+      title: '',
+      href: 'https://www.amazon.com/NUTIKAS-Shelves-Desktop-Orgnizer-Shlef/dp/B0DR31GC3D/ref=zg_bs',
+      price_text: '$25.92',
+      rating_text: '4.3 out of 5 stars',
+      review_count_text: '',
+      card_text: 'Desk Shelves Desktop Organizer Shlef\n4.3 out of 5 stars\n435\n$25.92',
+    }, 2, 'Amazon Best Sellers: Best Desktop & Off-Surface Shelves', 'https://www.amazon.com/example');
+
+    expect(result.rank).toBe(2);
+    expect(result.asin).toBe('B0DR31GC3D');
+    expect(result.title).toBe('Desk Shelves Desktop Organizer Shlef');
+    expect(result.review_count).toBe(435);
+    expect(result.list_title).toBe('Amazon Best Sellers: Best Desktop & Off-Surface Shelves');
+  });
+});

package/src/clis/amazon/bestsellers.ts

@@ -0,0 +1,180 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import {
+  buildProvenance,
+  cleanText,
+  extractAsin,
+  extractReviewCountFromCardText,
+  firstMeaningfulLine,
+  normalizeProductUrl,
+  parsePriceText,
+  parseRatingValue,
+  parseReviewCount,
+  resolveBestsellersUrl,
+  uniqueNonEmpty,
+  assertUsableState,
+  gotoAndReadState,
+} from './shared.js';
+
+interface BestsellersPagePayload {
+  href?: string;
+  title?: string;
+  list_title?: string;
+  cards?: Array<{
+    rank_text?: string | null;
+    asin?: string | null;
+    title?: string | null;
+    href?: string | null;
+    price_text?: string | null;
+    rating_text?: string | null;
+    review_count_text?: string | null;
+    card_text?: string | null;
+  }>;
+  page_links?: string[];
+}
+
+function normalizeBestsellerCandidate(
+  candidate: NonNullable<BestsellersPagePayload['cards']>[number],
+  rank: number,
+  listTitle: string | null,
+  sourceUrl: string,
+): Record<string, unknown> {
+  const productUrl = normalizeProductUrl(candidate.href);
+  const asin = extractAsin(candidate.asin ?? '') ?? extractAsin(productUrl ?? '') ?? null;
+  const title = cleanText(candidate.title) || firstMeaningfulLine(candidate.card_text);
+  const price = parsePriceText(cleanText(candidate.price_text) || candidate.card_text);
+  const ratingText = cleanText(candidate.rating_text) || null;
+  const reviewCountText = cleanText(candidate.review_count_text)
+    || extractReviewCountFromCardText(candidate.card_text)
+    || null;
+  const provenance = buildProvenance(sourceUrl);
+
+  return {
+    rank,
+    asin,
+    title: title || null,
+    product_url: productUrl,
+    list_title: listTitle,
+    ...provenance,
+    price_text: price.price_text,
+    price_value: price.price_value,
+    currency: price.currency,
+    rating_text: ratingText,
+    rating_value: parseRatingValue(ratingText),
+    review_count_text: reviewCountText,
+    review_count: parseReviewCount(reviewCountText),
+  };
+}
+
+async function readBestsellersPage(page: IPage, url: string): Promise<BestsellersPagePayload> {
+  const state = await gotoAndReadState(page, url, 2500, 'bestsellers');
+  assertUsableState(state, 'bestsellers');
+
+  return await page.evaluate(`
+    (() => ({
+      href: window.location.href,
+      title: document.title || '',
+      list_title:
+        document.querySelector('#zg_banner_text')?.textContent
+        || document.querySelector('h1')?.textContent
+        || '',
+      cards: Array.from(document.querySelectorAll('.p13n-sc-uncoverable-faceout'))
+        .map((card) => ({
+          rank_text:
+            card.querySelector('.zg-bdg-text')?.textContent
+            || card.querySelector('[class*="rank"]')?.textContent
+            || '',
+          asin: card.id || '',
+          title:
+            card.querySelector('[class*="line-clamp"]')?.textContent
+            || card.querySelector('img')?.getAttribute('alt')
+            || '',
+          href: card.querySelector('a[href*="/dp/"]')?.href || '',
+          price_text: card.querySelector('.a-price .a-offscreen')?.textContent || '',
+          rating_text: card.querySelector('[aria-label*="out of 5 stars"]')?.getAttribute('aria-label') || '',
+          review_count_text:
+            card.querySelector('a[href*="#customerReviews"]')?.textContent
+            || card.querySelector('.a-size-small')?.textContent
+            || '',
+          card_text: card.innerText || '',
+        })),
+      page_links: Array.from(document.querySelectorAll('li.a-normal a, li.a-selected a'))
+        .map((anchor) => anchor.href || '')
+        .filter((href) => /\\/zgbs\\//.test(href) && /(?:[?&]pg=|ref=zg_bs_pg_)/.test(href)),
+    }))()
+  `) as BestsellersPagePayload;
+}
+
+cli({
+  site: 'amazon',
+  name: 'bestsellers',
+  description: 'Amazon Best Sellers pages for category candidate discovery',
+  domain: 'amazon.com',
+  strategy: Strategy.COOKIE,
+  navigateBefore: false,
+  args: [
+    {
+      name: 'input',
+      positional: true,
+      help: 'Best sellers URL or /zgbs path. Omit to use the root Best Sellers page.',
+    },
+    {
+      name: 'limit',
+      type: 'int',
+      default: 100,
+      help: 'Maximum number of ranked items to return (default 100)',
+    },
+  ],
+  columns: ['rank', 'asin', 'title', 'price_text', 'rating_value', 'review_count'],
+  func: async (page, kwargs) => {
+    const limit = Math.max(1, Number(kwargs.limit) || 100);
+    const initialUrl = resolveBestsellersUrl(typeof kwargs.input === 'string' ? kwargs.input : undefined);
+
+    const queue = [initialUrl];
+    const visited = new Set<string>();
+    const seenAsins = new Set<string>();
+    const results: Record<string, unknown>[] = [];
+    let listTitle: string | null = null;
+
+    while (queue.length > 0 && results.length < limit) {
+      const nextUrl = queue.shift()!;
+      if (visited.has(nextUrl)) continue;
+      visited.add(nextUrl);
+
+      const payload = await readBestsellersPage(page, nextUrl);
+      const sourceUrl = cleanText(payload.href) || nextUrl;
+      listTitle = cleanText(payload.list_title) || cleanText(payload.title) || listTitle;
+      const cards = payload.cards ?? [];
+
+      for (const card of cards) {
+        const normalized = normalizeBestsellerCandidate(card, results.length + 1, listTitle, sourceUrl);
+        const asin = cleanText(String(normalized.asin ?? ''));
+        if (!asin || seenAsins.has(asin)) continue;
+        seenAsins.add(asin);
+        results.push(normalized);
+        if (results.length >= limit) break;
+      }
+
+      const pageLinks = uniqueNonEmpty(payload.page_links ?? []);
+      for (const href of pageLinks) {
+        if (!visited.has(href) && !queue.includes(href)) {
+          queue.push(href);
+        }
+      }
+    }
+
+    if (results.length === 0) {
+      throw new CommandExecutionError(
+        'amazon bestsellers did not expose any ranked items',
+        'Open the same best sellers page in Chrome, verify it is a real Amazon ranking page, and retry.',
+      );
+    }
+
+    return results.slice(0, limit);
+  },
+});
+
+export const __test__ = {
+  normalizeBestsellerCandidate,
+};

package/src/clis/amazon/discussion.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './discussion.js';
+
+describe('amazon discussion normalization', () => {
+  it('normalizes review summary and sample reviews', () => {
+    const result = __test__.normalizeDiscussionPayload({
+      href: 'https://www.amazon.com/product-reviews/B0FJS72893',
+      average_rating_text: '3.9 out of 5',
+      total_review_count_text: '27 global ratings',
+      qa_links: [],
+      review_samples: [
+        {
+          title: '5.0 out of 5 stars Great value and quality',
+          rating_text: '5.0 out of 5 stars',
+          author: 'GTreader2',
+          date_text: 'Reviewed in the United States on February 21, 2026',
+          body: 'Small but mighty.',
+          verified: true,
+        },
+      ],
+    });
+
+    expect(result.asin).toBe('B0FJS72893');
+    expect(result.average_rating_value).toBe(3.9);
+    expect(result.total_review_count).toBe(27);
+    expect(result.review_samples).toEqual([
+      {
+        title: 'Great value and quality',
+        rating_text: '5.0 out of 5 stars',
+        rating_value: 5,
+        author: 'GTreader2',
+        date_text: 'Reviewed in the United States on February 21, 2026',
+        body: 'Small but mighty.',
+        verified_purchase: true,
+      },
+    ]);
+  });
+});