@jackwener/opencli 1.0.0 → 1.0.1

package/extension/src/background.ts

@@ -7,7 +7,7 @@
 
 import type { Command, Result } from './protocol';
 import { DAEMON_WS_URL, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY } from './protocol';
-import * as cdp from './cdp';
+import * as executor from './cdp';
 
 let ws: WebSocket | null = null;
 let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
@@ -85,6 +85,66 @@ function scheduleReconnect(): void {
   }, delay);
 }
 
+// ─── Automation window isolation ─────────────────────────────────────
+// All opencli operations happen in a dedicated Chrome window so the
+// user's active browsing session is never touched.
+// The window auto-closes after 30s of idle (no commands).
+
+let automationWindowId: number | null = null;
+let windowIdleTimer: ReturnType<typeof setTimeout> | null = null;
+const WINDOW_IDLE_TIMEOUT = 30000; // 30s
+
+function resetWindowIdleTimer(): void {
+  if (windowIdleTimer) clearTimeout(windowIdleTimer);
+  windowIdleTimer = setTimeout(async () => {
+    if (automationWindowId !== null) {
+      try {
+        await chrome.windows.remove(automationWindowId);
+        console.log(`[opencli] Automation window ${automationWindowId} closed (idle timeout)`);
+      } catch {
+        // Already gone
+      }
+      automationWindowId = null;
+    }
+    windowIdleTimer = null;
+  }, WINDOW_IDLE_TIMEOUT);
+}
+
+/** Get or create the dedicated automation window. */
+async function getAutomationWindow(): Promise<number> {
+  // Check if our window is still alive
+  if (automationWindowId !== null) {
+    try {
+      await chrome.windows.get(automationWindowId);
+      return automationWindowId;
+    } catch {
+      // Window was closed by user
+      automationWindowId = null;
+    }
+  }
+
+  // Create a new window with about:blank (not chrome://newtab which blocks scripting)
+  const win = await chrome.windows.create({
+    url: 'about:blank',
+    focused: false,
+    width: 1280,
+    height: 900,
+    type: 'normal',
+  });
+  automationWindowId = win.id!;
+  console.log(`[opencli] Created automation window ${automationWindowId}`);
+  return automationWindowId;
+}
+
+// Clean up when the automation window is closed
+chrome.windows.onRemoved.addListener((windowId) => {
+  if (windowId === automationWindowId) {
+    console.log('[opencli] Automation window closed');
+    automationWindowId = null;
+    if (windowIdleTimer) { clearTimeout(windowIdleTimer); windowIdleTimer = null; }
+  }
+});
+
 // ─── Lifecycle events ────────────────────────────────────────────────
 
 let initialized = false;
@@ -93,7 +153,7 @@ function initialize(): void {
   if (initialized) return;
   initialized = true;
   chrome.alarms.create('keepalive', { periodInMinutes: 0.4 }); // ~24 seconds
-  cdp.registerListeners();
+  executor.registerListeners();
   connect();
   console.log('[opencli] Browser Bridge extension initialized');
 }
@@ -113,6 +173,8 @@ chrome.alarms.onAlarm.addListener((alarm) => {
 // ─── Command dispatcher ─────────────────────────────────────────────
 
 async function handleCommand(cmd: Command): Promise<Result> {
+  // Reset idle timer on every command (window stays alive while active)
+  resetWindowIdleTimer();
   try {
     switch (cmd.action) {
       case 'exec':
@@ -125,6 +187,8 @@ async function handleCommand(cmd: Command): Promise<Result> {
         return await handleCookies(cmd);
       case 'screenshot':
         return await handleScreenshot(cmd);
+      case 'close-window':
+        return await handleCloseWindow(cmd);
       default:
         return { id: cmd.id, ok: false, error: `Unknown action: ${cmd.action}` };
     }
@@ -145,27 +209,28 @@ function isWebUrl(url?: string): boolean {
   return !url.startsWith('chrome://') && !url.startsWith('chrome-extension://');
 }
 
-/** Resolve target tab: use specified tabId or fall back to active web page tab */
+/**
+ * Resolve target tab in the automation window.
+ * If explicit tabId is given, use that directly.
+ * Otherwise, find or create a tab in the dedicated automation window.
+ */
 async function resolveTabId(tabId?: number): Promise<number> {
   if (tabId !== undefined) return tabId;
 
-  // Try the active tab first
-  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
-  if (activeTab?.id && isWebUrl(activeTab.url)) {
-    return activeTab.id;
-  }
+  // Get (or create) the automation window
+  const windowId = await getAutomationWindow();
 
-  // Active tab is not debuggable — try to find any open web page tab
-  const allTabs = await chrome.tabs.query({ currentWindow: true });
-  const webTab = allTabs.find(t => t.id && isWebUrl(t.url));
-  if (webTab?.id) {
-    await chrome.tabs.update(webTab.id, { active: true });
-    return webTab.id;
-  }
+  // Find the active tab in our automation window
+  const tabs = await chrome.tabs.query({ windowId });
+  const webTab = tabs.find(t => t.id && isWebUrl(t.url));
+  if (webTab?.id) return webTab.id;
 
-  // No web tabs at all — create one
-  const newTab = await chrome.tabs.create({ url: 'about:blank', active: true });
-  if (!newTab.id) throw new Error('Failed to create new tab');
+  // Use the first tab if it's a blank/new tab page
+  if (tabs.length > 0 && tabs[0]?.id) return tabs[0].id;
+
+  // No suitable tab — create one
+  const newTab = await chrome.tabs.create({ windowId, url: 'about:blank', active: true });
+  if (!newTab.id) throw new Error('Failed to create tab in automation window');
   return newTab.id;
 }
 
@@ -173,7 +238,7 @@ async function handleExec(cmd: Command): Promise<Result> {
   if (!cmd.code) return { id: cmd.id, ok: false, error: 'Missing code' };
   const tabId = await resolveTabId(cmd.tabId);
   try {
-    const data = await cdp.evaluateAsync(tabId, cmd.code);
+    const data = await executor.evaluateAsync(tabId, cmd.code);
     return { id: cmd.id, ok: true, data };
   } catch (err) {
     return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
@@ -235,12 +300,12 @@ async function handleTabs(cmd: Command): Promise<Result> {
         const target = tabs[cmd.index];
         if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
         await chrome.tabs.remove(target.id);
-        cdp.detach(target.id);
+        executor.detach(target.id);
         return { id: cmd.id, ok: true, data: { closed: target.id } };
       }
       const tabId = await resolveTabId(cmd.tabId);
       await chrome.tabs.remove(tabId);
-      cdp.detach(tabId);
+      executor.detach(tabId);
       return { id: cmd.id, ok: true, data: { closed: tabId } };
     }
     case 'select': {
@@ -281,7 +346,7 @@ async function handleCookies(cmd: Command): Promise<Result> {
 async function handleScreenshot(cmd: Command): Promise<Result> {
   const tabId = await resolveTabId(cmd.tabId);
   try {
-    const data = await cdp.screenshot(tabId, {
+    const data = await executor.screenshot(tabId, {
       format: cmd.format,
       quality: cmd.quality,
       fullPage: cmd.fullPage,
@@ -291,3 +356,15 @@ async function handleScreenshot(cmd: Command): Promise<Result> {
     return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
+
+async function handleCloseWindow(cmd: Command): Promise<Result> {
+  if (automationWindowId !== null) {
+    try {
+      await chrome.windows.remove(automationWindowId);
+    } catch {
+      // Window may already be closed
+    }
+    automationWindowId = null;
+  }
+  return { id: cmd.id, ok: true, data: { closed: true } };
+}

package/extension/src/protocol.ts

@@ -5,7 +5,7 @@
  * Everything else is just JS code sent via 'exec'.
  */
 
-export type Action = 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot';
+export type Action = 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window';
 
 export interface Command {
   /** Unique request ID */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "publishConfig": {
     "access": "public"
   },

package/src/browser/daemon-client.ts

@@ -15,7 +15,7 @@ function generateId(): string {
 
 export interface DaemonCommand {
   id: string;
-  action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot';
+  action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window';
   tabId?: number;
   code?: string;
   url?: string;

package/src/browser/index.ts

@@ -6,14 +6,9 @@
  */
 
 export { Page } from './page.js';
-export { PlaywrightMCP } from './mcp.js';
+export { BrowserBridge, BrowserBridge as PlaywrightMCP } from './mcp.js';
 export { isDaemonRunning } from './daemon-client.js';
 
-// Backward compatibility: getTokenFingerprint is no longer needed but kept as no-op export
-export function getTokenFingerprint(_token: string | undefined): string | null {
-  return null;
-}
-
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
 import { withTimeoutMs } from '../runtime.js';
 

package/src/browser/mcp.ts

@@ -1,8 +1,5 @@
 /**
  * Browser session manager — auto-spawns daemon and provides IPage.
- *
- * Replaces the old PlaywrightMCP class. Still exports as PlaywrightMCP
- * for backward compatibility with main.ts and other consumers.
  */
 
 import { spawn, type ChildProcess } from 'node:child_process';
@@ -15,21 +12,17 @@ import { isDaemonRunning, isExtensionConnected } from './daemon-client.js';
 
 const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 
-export type PlaywrightMCPState = 'idle' | 'connecting' | 'connected' | 'closing' | 'closed';
-
-
+export type BrowserBridgeState = 'idle' | 'connecting' | 'connected' | 'closing' | 'closed';
 
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
- *
- * Kept as `PlaywrightMCP` class name for backward compatibility.
  */
-export class PlaywrightMCP {
-  private _state: PlaywrightMCPState = 'idle';
+export class BrowserBridge {
+  private _state: BrowserBridgeState = 'idle';
   private _page: Page | null = null;
   private _daemonProc: ChildProcess | null = null;
 
-  get state(): PlaywrightMCPState {
+  get state(): BrowserBridgeState {
     return this._state;
   }
 
@@ -78,10 +71,13 @@ export class PlaywrightMCP {
       console.error(`[opencli] Starting daemon (${isTs ? 'ts' : 'js'})...`);
     }
 
-    // Use the current runtime to spawn daemon — avoids slow npx resolution.
-    // If already running under tsx (dev), process.execPath is tsx's node.
-    // If running compiled (node dist/), process.execPath is node.
-    this._daemonProc = spawn(process.execPath, [daemonPath], {
+    // For compiled .js, use the current node binary directly (fast).
+    // For .ts dev mode, node can't run .ts files — use tsx via --import.
+    const spawnArgs = isTs
+      ? [process.execPath, '--import', 'tsx/esm', daemonPath]
+      : [process.execPath, daemonPath];
+
+    this._daemonProc = spawn(spawnArgs[0], spawnArgs.slice(1), {
       detached: true,
       stdio: 'ignore',
       env: { ...process.env },
@@ -110,3 +106,6 @@ export class PlaywrightMCP {
     );
   }
 }
+
+/** @deprecated Use BrowserBridge instead */
+export const PlaywrightMCP = BrowserBridge;

package/src/browser/page.ts

@@ -37,6 +37,15 @@ export class Page implements IPage {
     }
   }
 
+  /** Close the automation window in the extension */
+  async closeWindow(): Promise<void> {
+    try {
+      await sendCommand('close-window', {});
+    } catch {
+      // Window may already be closed or daemon may be down
+    }
+  }
+
   async evaluate(js: string): Promise<any> {
     const code = wrapForEval(js);
     return sendCommand('exec', { code, ...this._tabOpt() });
@@ -183,12 +192,12 @@ export class Page implements IPage {
     return sendCommand('exec', { code, ...this._tabOpt() });
   }
 
-  async consoleMessages(level: string = 'info'): Promise<any> {
-    // Console messages can't be retrospectively read via CDP Runtime.evaluate.
-    // Would need Runtime.consoleAPICalled event listener, which is not yet implemented.
-    if (process.env.OPENCLI_VERBOSE) {
-      console.error('[page] consoleMessages() not supported in lightweight mode — returning empty');
-    }
+  /**
+   * 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<any> {
     return [];
   }
 
@@ -260,21 +269,18 @@ export class Page implements IPage {
 
   async installInterceptor(pattern: string): Promise<void> {
     const { generateInterceptorJs } = await import('../interceptor.js');
-    await sendCommand('exec', {
-      code: generateInterceptorJs(JSON.stringify(pattern), {
-        arrayName: '__opencli_xhr',
-        patchGuard: '__opencli_interceptor_patched',
-      }),
-      ...this._tabOpt(),
-    });
+    // 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<any[]> {
     const { generateReadInterceptedJs } = await import('../interceptor.js');
-    const result = await sendCommand('exec', {
-      code: generateReadInterceptedJs('__opencli_xhr'),
-      ...this._tabOpt(),
-    });
+    // Same as installInterceptor: must go through evaluate() for IIFE wrapping
+    const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
     return (result as any[]) || [];
   }
 }

package/src/browser.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, it, expect, vi } from 'vitest';
-import { PlaywrightMCP, __test__ } from './browser/index.js';
+import { BrowserBridge, __test__ } from './browser/index.js';
 
 describe('browser helpers', () => {
   it('extracts tab entries from string snapshots', () => {
@@ -45,9 +45,9 @@ describe('browser helpers', () => {
   });
 });
 
-describe('PlaywrightMCP state', () => {
+describe('BrowserBridge state', () => {
   it('transitions to closed after close()', async () => {
-    const mcp = new PlaywrightMCP();
+    const mcp = new BrowserBridge();
 
     expect(mcp.state).toBe('idle');
 
@@ -57,21 +57,21 @@ describe('PlaywrightMCP state', () => {
   });
 
   it('rejects connect() after the session has been closed', async () => {
-    const mcp = new PlaywrightMCP();
+    const mcp = new BrowserBridge();
     await mcp.close();
 
     await expect(mcp.connect()).rejects.toThrow('Session is closed');
   });
 
   it('rejects connect() while already connecting', async () => {
-    const mcp = new PlaywrightMCP();
+    const mcp = new BrowserBridge();
     (mcp as any)._state = 'connecting';
 
     await expect(mcp.connect()).rejects.toThrow('Already connecting');
   });
 
   it('rejects connect() while closing', async () => {
-    const mcp = new PlaywrightMCP();
+    const mcp = new BrowserBridge();
     (mcp as any)._state = 'closing';
 
     await expect(mcp.connect()).rejects.toThrow('Session is closing');

package/src/clis/apple-podcasts/episodes.ts

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { itunesFetch, formatDuration, formatDate } from './utils.js';
+
+cli({
+  site: 'apple-podcasts',
+  name: 'episodes',
+  description: 'List recent episodes of an Apple Podcast (use ID from search)',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'id', positional: true, required: true, help: 'Podcast ID (collectionId from search output)' },
+    { name: 'limit', type: 'int', default: 15, help: 'Max episodes to show' },
+  ],
+  columns: ['title', 'duration', 'date'],
+  func: async (_page, args) => {
+    const limit = Math.max(1, Math.min(Number(args.limit), 200));
+    // results[0] is the podcast itself; the rest are episodes
+    const data = await itunesFetch(`/lookup?id=${args.id}&entity=podcastEpisode&limit=${limit + 1}`);
+    const episodes = (data.results ?? []).filter((r: any) => r.kind === 'podcast-episode');
+    if (!episodes.length) throw new CliError('NOT_FOUND', 'No episodes found', 'Check the podcast ID from: opencli apple-podcasts search <keyword>');
+    return episodes.slice(0, limit).map((ep: any) => ({
+      title: ep.trackName,
+      duration: formatDuration(ep.trackTimeMillis),
+      date: formatDate(ep.releaseDate),
+    }));
+  },
+});

package/src/clis/apple-podcasts/search.ts

@@ -0,0 +1,29 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { itunesFetch } from './utils.js';
+
+cli({
+  site: 'apple-podcasts',
+  name: 'search',
+  description: 'Search Apple Podcasts',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'keyword', positional: true, required: true, help: 'Search keyword' },
+    { name: 'limit', type: 'int', default: 10, help: 'Max results' },
+  ],
+  columns: ['id', 'title', 'author', 'episodes', 'genre'],
+  func: async (_page, args) => {
+    const term = encodeURIComponent(args.keyword);
+    const limit = Math.max(1, Math.min(Number(args.limit), 25));
+    const data = await itunesFetch(`/search?term=${term}&media=podcast&limit=${limit}`);
+    if (!data.results?.length) throw new CliError('NOT_FOUND', 'No podcasts found', `Try a different keyword`);
+    return data.results.map((p: any) => ({
+      id: p.collectionId,
+      title: p.collectionName,
+      author: p.artistName,
+      episodes: p.trackCount ?? '-',
+      genre: p.primaryGenreName ?? '-',
+    }));
+  },
+});

package/src/clis/apple-podcasts/top.ts

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+
+// Apple Marketing Tools RSS API — public, no key required
+const CHARTS_URL = 'https://rss.applemarketingtools.com/api/v2';
+
+cli({
+  site: 'apple-podcasts',
+  name: 'top',
+  description: 'Top podcasts chart on Apple Podcasts',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of podcasts (max 100)' },
+    { name: 'country', default: 'us', help: 'Country code (e.g. us, cn, gb, jp)' },
+  ],
+  columns: ['rank', 'title', 'author', 'id'],
+  func: async (_page, args) => {
+    const limit = Math.max(1, Math.min(Number(args.limit), 100));
+    const country = String(args.country || 'us').trim().toLowerCase();
+    const url = `${CHARTS_URL}/${country}/podcasts/top/${limit}/podcasts.json`;
+    const resp = await fetch(url);
+    if (!resp.ok) throw new CliError('FETCH_ERROR', `Charts API HTTP ${resp.status}`, `Check country code: ${country}`);
+    const data = await resp.json();
+    const results = data?.feed?.results;
+    if (!results?.length) throw new CliError('NOT_FOUND', 'No chart data found', `Try a different country code`);
+    return results.map((p: any, i: number) => ({
+      rank: i + 1,
+      title: p.name,
+      author: p.artistName,
+      id: p.id,
+    }));
+  },
+});

package/src/clis/apple-podcasts/utils.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { formatDuration, formatDate, itunesFetch } from './utils.js';
+
+describe('formatDuration', () => {
+  it('formats typical duration in ms', () => {
+    expect(formatDuration(3661000)).toBe('61:01');
+  });
+
+  it('pads single-digit seconds', () => {
+    expect(formatDuration(65000)).toBe('1:05');
+  });
+
+  it('formats exact minutes', () => {
+    expect(formatDuration(3600000)).toBe('60:00');
+  });
+
+  it('rounds fractional milliseconds', () => {
+    expect(formatDuration(3600500)).toBe('60:01');
+  });
+
+  it('returns dash for zero', () => {
+    expect(formatDuration(0)).toBe('-');
+  });
+
+  it('returns dash for NaN', () => {
+    expect(formatDuration(NaN)).toBe('-');
+  });
+});
+
+describe('formatDate', () => {
+  it('extracts YYYY-MM-DD from ISO string', () => {
+    expect(formatDate('2026-03-19T12:00:00.000Z')).toBe('2026-03-19');
+  });
+
+  it('handles date-only string', () => {
+    expect(formatDate('2025-01-01')).toBe('2025-01-01');
+  });
+
+  it('returns dash for empty string', () => {
+    expect(formatDate('')).toBe('-');
+  });
+
+  it('returns dash for undefined', () => {
+    expect(formatDate(undefined as any)).toBe('-');
+  });
+});
+
+describe('itunesFetch', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns parsed JSON on success', async () => {
+    const mockData = { resultCount: 1, results: [{ collectionId: 123 }] };
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(mockData),
+    }));
+
+    const result = await itunesFetch('/search?term=test&media=podcast&limit=1');
+    expect(result).toEqual(mockData);
+  });
+
+  it('throws CliError on HTTP error', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 403,
+    }));
+
+    await expect(itunesFetch('/search?term=test')).rejects.toThrow('iTunes API HTTP 403');
+  });
+});

package/src/clis/apple-podcasts/utils.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared Apple Podcasts utilities.
+ *
+ * Uses the public iTunes Search API — no API key required.
+ * https://developer.apple.com/library/archive/documentation/AudioVideo/Conceptual/iTuneSearchAPI/
+ */
+
+import { CliError } from '../../errors.js';
+
+const BASE = 'https://itunes.apple.com';
+
+export async function itunesFetch(path: string): Promise<any> {
+  const resp = await fetch(`${BASE}${path}`);
+  if (!resp.ok) {
+    throw new CliError(
+      'FETCH_ERROR',
+      `iTunes API HTTP ${resp.status}`,
+      'Check your search term or podcast ID',
+    );
+  }
+  return resp.json();
+}
+
+/** Format milliseconds to mm:ss. Returns '-' for missing input. */
+export function formatDuration(ms: number): string {
+  if (!ms || !Number.isFinite(ms)) return '-';
+  const totalSec = Math.round(ms / 1000);
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  return `${m}:${String(s).padStart(2, '0')}`;
+}
+
+/** Format ISO date string to YYYY-MM-DD. Returns '-' for missing input. */
+export function formatDate(iso: string): string {
+  if (!iso) return '-';
+  return iso.slice(0, 10);
+}

package/src/clis/chatwise/history.ts

@@ -42,6 +42,20 @@ export const historyCommand = cli({
       return [{ Index: 0, Title: 'No history found. Ensure the sidebar is visible.' }];
     }
 
-    return items;
+    const dateHeaders = /^(today|yesterday|last week|last month|last year|this week|this month|older|previous \d+ days|\d+ days ago)$/i;
+    const numericOnly = /^[\d\s]+$/;
+    const modelPath = /^[\w.-]+\/[\w.-]/;
+    const seen = new Set<string>();
+    const deduped = items.filter((item: { Index: number; Title: string }) => {
+      const t = item.Title.trim();
+      if (dateHeaders.test(t)) return false;
+      if (numericOnly.test(t)) return false;
+      if (modelPath.test(t)) return false;
+      if (seen.has(t)) return false;
+      seen.add(t);
+      return true;
+    }).map((item: { Index: number; Title: string }, i: number) => ({ Index: i + 1, Title: item.Title }));
+
+    return deduped;
   },
 });