@jackwener/opencli 1.1.0 → 1.2.0

package/src/synthesize.ts

@@ -7,16 +7,96 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { VOLATILE_PARAMS, SEARCH_PARAMS, LIMIT_PARAMS, PAGINATION_PARAMS } from './constants.js';
+import type { ExploreAuthSummary, ExploreEndpointArtifact, ExploreManifest } from './explore.js';
 
 /** Renamed aliases for backward compatibility with local references */
 const SEARCH_PARAM_NAMES = SEARCH_PARAMS;
 const LIMIT_PARAM_NAMES = LIMIT_PARAMS;
 const PAGE_PARAM_NAMES = PAGINATION_PARAMS;
 
+interface RecommendedArg {
+  name: string;
+  type?: string;
+  required?: boolean;
+  default?: unknown;
+}
+
+interface StoreHint {
+  store: string;
+  action: string;
+}
+
+export interface SynthesizeCapability {
+  name: string;
+  description: string;
+  strategy: string;
+  confidence?: number;
+  endpoint?: string;
+  itemPath?: string | null;
+  recommendedColumns?: string[];
+  recommendedArgs?: RecommendedArg[];
+  recommended_args?: RecommendedArg[];
+  recommendedColumnsLegacy?: string[];
+  recommended_columns?: string[];
+  storeHint?: StoreHint;
+}
+
+export interface GeneratedArgDefinition {
+  type: string;
+  required?: boolean;
+  default?: unknown;
+  description?: string;
+}
+
+type CandidatePipelineStep =
+  | { navigate: string }
+  | { wait: number }
+  | { evaluate: string }
+  | { select: string }
+  | { map: Record<string, string> }
+  | { limit: string }
+  | { fetch: { url: string } }
+  | { tap: { store: string; action: string; timeout: number; capture?: string; select?: string | null } };
+
+export interface CandidateYaml {
+  site: string;
+  name: string;
+  description: string;
+  domain: string;
+  strategy: string;
+  browser: boolean;
+  args: Record<string, GeneratedArgDefinition>;
+  pipeline: CandidatePipelineStep[];
+  columns: string[];
+}
+
+export interface SynthesizeCandidateSummary {
+  name: string;
+  path: string;
+  strategy: string;
+  confidence?: number;
+}
+
+export interface SynthesizeResult {
+  site: string;
+  explore_dir: string;
+  out_dir: string;
+  candidate_count: number;
+  candidates: SynthesizeCandidateSummary[];
+}
+
+type ExploreManifestLike = Pick<ExploreManifest, 'target_url' | 'final_url'> & Partial<ExploreManifest>;
+interface LoadedExploreBundle {
+  manifest: ExploreManifest;
+  endpoints: ExploreEndpointArtifact[];
+  capabilities: SynthesizeCapability[];
+  auth: ExploreAuthSummary;
+}
+
 export function synthesizeFromExplore(
   target: string,
   opts: { outDir?: string; top?: number } = {},
-): Record<string, any> {
+): SynthesizeResult {
   const exploreDir = resolveExploreDir(target);
   const bundle = loadExploreBundle(exploreDir);
 
@@ -25,9 +105,9 @@ export function synthesizeFromExplore(
 
   const site = bundle.manifest.site;
   const capabilities = (bundle.capabilities ?? [])
-    .sort((a: any, b: any) => (b.confidence ?? 0) - (a.confidence ?? 0))
+    .sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0))
     .slice(0, opts.top ?? 3);
-  const candidates: any[] = [];
+  const candidates: SynthesizeCandidateSummary[] = [];
 
   for (const cap of capabilities) {
     const endpoint = chooseEndpoint(cap, bundle.endpoints);
@@ -44,7 +124,7 @@ export function synthesizeFromExplore(
   return { site, explore_dir: exploreDir, out_dir: targetDir, candidate_count: candidates.length, candidates };
 }
 
-export function renderSynthesizeSummary(result: Record<string, any>): string {
+export function renderSynthesizeSummary(result: SynthesizeResult): string {
   const lines = ['opencli synthesize: OK', `Site: ${result.site}`, `Source: ${result.explore_dir}`, `Candidates: ${result.candidate_count}`];
   for (const c of result.candidates ?? []) lines.push(`  • ${c.name} (${c.strategy}, ${((c.confidence ?? 0) * 100).toFixed(0)}% confidence) → ${c.path}`);
   return lines.join('\n');
@@ -57,33 +137,34 @@ export function resolveExploreDir(target: string): string {
   throw new Error(`Explore directory not found: ${target}`);
 }
 
-export function loadExploreBundle(exploreDir: string): Record<string, any> {
+export function loadExploreBundle(exploreDir: string): LoadedExploreBundle {
   return {
-    manifest: JSON.parse(fs.readFileSync(path.join(exploreDir, 'manifest.json'), 'utf-8')),
-    endpoints: JSON.parse(fs.readFileSync(path.join(exploreDir, 'endpoints.json'), 'utf-8')),
-    capabilities: JSON.parse(fs.readFileSync(path.join(exploreDir, 'capabilities.json'), 'utf-8')),
+    manifest: JSON.parse(fs.readFileSync(path.join(exploreDir, 'manifest.json'), 'utf-8')) as ExploreManifest,
+    endpoints: JSON.parse(fs.readFileSync(path.join(exploreDir, 'endpoints.json'), 'utf-8')) as ExploreEndpointArtifact[],
+    capabilities: JSON.parse(fs.readFileSync(path.join(exploreDir, 'capabilities.json'), 'utf-8')) as SynthesizeCapability[],
     auth: JSON.parse(fs.readFileSync(path.join(exploreDir, 'auth.json'), 'utf-8')),
   };
 }
 
-function chooseEndpoint(cap: any, endpoints: any[]): any | null {
+function chooseEndpoint(cap: SynthesizeCapability, endpoints: ExploreEndpointArtifact[]): ExploreEndpointArtifact | null {
   if (!endpoints.length) return null;
   // Match by endpoint pattern from capability
   if (cap.endpoint) {
-    const match = endpoints.find((e: any) => e.pattern === cap.endpoint || e.url?.includes(cap.endpoint));
+    const endpointPattern = cap.endpoint;
+    const match = endpoints.find((endpoint) => endpoint.pattern === endpointPattern || endpoint.url?.includes(endpointPattern));
     if (match) return match;
   }
-  return endpoints.sort((a: any, b: any) => (b.score ?? 0) - (a.score ?? 0))[0];
+  return [...endpoints].sort((a, b) => (b.score ?? 0) - (a.score ?? 0))[0];
 }
 
 // ── URL templating ─────────────────────────────────────────────────────────
 
-function buildTemplatedUrl(rawUrl: string, cap: any, _endpoint: any): string {
+function buildTemplatedUrl(rawUrl: string, cap: SynthesizeCapability, _endpoint: ExploreEndpointArtifact): string {
   try {
     const u = new URL(rawUrl);
     const base = `${u.protocol}//${u.host}${u.pathname}`;
     const params: Array<[string, string]> = [];
-    const hasKeyword = cap.recommendedArgs?.some((a: any) => a.name === 'keyword');
+    const hasKeyword = cap.recommendedArgs?.some((arg) => arg.name === 'keyword');
 
     u.searchParams.forEach((v, k) => {
       if (VOLATILE_PARAMS.has(k)) return;
@@ -101,7 +182,7 @@ function buildTemplatedUrl(rawUrl: string, cap: any, _endpoint: any): string {
  * Build inline evaluate script for browser-based fetch+parse.
  * Follows patterns from bilibili/hot.yaml and twitter/trending.yaml.
  */
-function buildEvaluateScript(url: string, itemPath: string, endpoint: any): string {
+function buildEvaluateScript(url: string, itemPath: string, endpoint: ExploreEndpointArtifact): string {
   const pathChain = itemPath.split('.').map((p: string) => `?.${p}`).join('');
   const detectedFields = endpoint?.detectedFields ?? {};
   const hasFields = Object.keys(detectedFields).length > 0;
@@ -127,9 +208,9 @@ function buildEvaluateScript(url: string, itemPath: string, endpoint: any): stri
 
 // ── YAML pipeline generation ───────────────────────────────────────────────
 
-function buildCandidateYaml(site: string, manifest: any, cap: any, endpoint: any): { name: string; yaml: any } {
+function buildCandidateYaml(site: string, manifest: ExploreManifestLike, cap: SynthesizeCapability, endpoint: ExploreEndpointArtifact): { name: string; yaml: CandidateYaml } {
   const needsBrowser = cap.strategy !== 'public';
-  const pipeline: any[] = [];
+  const pipeline: CandidatePipelineStep[] = [];
   const templatedUrl = buildTemplatedUrl(endpoint?.url ?? manifest.target_url, cap, endpoint);
 
   let domain = '';
@@ -139,7 +220,7 @@ function buildCandidateYaml(site: string, manifest: any, cap: any, endpoint: any
     // Store Action: navigate + wait + tap (declarative, clean)
     pipeline.push({ navigate: manifest.target_url });
     pipeline.push({ wait: 3 });
-    const tapStep: Record<string, any> = {
+    const tapStep: { store: string; action: string; timeout: number; capture?: string; select?: string | null } = {
       store: cap.storeHint.store,
       action: cap.storeHint.action,
       timeout: 8,
@@ -170,7 +251,7 @@ function buildCandidateYaml(site: string, manifest: any, cap: any, endpoint: any
   // Map fields
   const mapStep: Record<string, string> = {};
   const columns = cap.recommendedColumns ?? ['title', 'url'];
-  if (!cap.recommendedArgs?.some((a: any) => a.name === 'keyword')) mapStep['rank'] = '${{ index + 1 }}';
+  if (!cap.recommendedArgs?.some((arg) => arg.name === 'keyword')) mapStep['rank'] = '${{ index + 1 }}';
   const detectedFields = endpoint?.detectedFields ?? {};
   for (const col of columns) {
     const fieldPath = detectedFields[col];
@@ -180,9 +261,9 @@ function buildCandidateYaml(site: string, manifest: any, cap: any, endpoint: any
   pipeline.push({ limit: '${{ args.limit | default(20) }}' });
 
   // Args
-  const argsDef: Record<string, any> = {};
+  const argsDef: Record<string, GeneratedArgDefinition> = {};
   for (const arg of cap.recommendedArgs ?? []) {
-    const def: any = { type: arg.type ?? 'str' };
+    const def: GeneratedArgDefinition = { type: arg.type ?? 'str' };
     if (arg.required) def.required = true;
     if (arg.default != null) def.default = arg.default;
     if (arg.name === 'keyword') def.description = 'Search keyword';
@@ -203,7 +284,7 @@ function buildCandidateYaml(site: string, manifest: any, cap: any, endpoint: any
 }
 
 /** Backward-compatible export for scaffold.ts */
-export function buildCandidate(site: string, targetUrl: string, cap: any, endpoint: any): any {
+export function buildCandidate(site: string, targetUrl: string, cap: SynthesizeCapability, endpoint: ExploreEndpointArtifact): { name: string; yaml: CandidateYaml } {
   // Map old-style field names to new ones
   const normalizedCap = {
     ...cap,

package/src/types.ts

@@ -5,23 +5,55 @@
  * instead of `any` for browser interactions.
  */
 
+export interface BrowserCookie {
+  name: string;
+  value: string;
+  domain: string;
+  path?: string;
+  secure?: boolean;
+  httpOnly?: boolean;
+  expirationDate?: number;
+}
+
+export interface SnapshotOptions {
+  interactive?: boolean;
+  compact?: boolean;
+  maxDepth?: number;
+  raw?: boolean;
+  viewportExpand?: number;
+  maxTextLength?: number;
+}
+
+export interface WaitOptions {
+  text?: string;
+  time?: number;
+  timeout?: number;
+}
+
+export interface ScreenshotOptions {
+  format?: 'png' | 'jpeg';
+  quality?: number;
+  fullPage?: boolean;
+  path?: string;
+}
+
+export interface BrowserSessionInfo {
+  workspace?: string;
+  connected?: boolean;
+  [key: string]: unknown;
+}
+
 export interface IPage {
-  goto(url: string): Promise<void>;
+  goto(url: string, options?: { waitUntil?: 'load' | 'none'; settleMs?: number }): Promise<void>;
   evaluate(js: string): Promise<any>;
-  getCookies(opts?: { domain?: string; url?: string }): Promise<Array<{
-    name: string;
-    value: string;
-    domain: string;
-    path?: string;
-    secure?: boolean;
-    httpOnly?: boolean;
-    expirationDate?: number;
-  }>>;
-  snapshot(opts?: { interactive?: boolean; compact?: boolean; maxDepth?: number; raw?: boolean }): Promise<any>;
+  getCookies(opts?: { domain?: string; url?: string }): Promise<BrowserCookie[]>;
+  snapshot(opts?: SnapshotOptions): Promise<any>;
   click(ref: string): Promise<void>;
   typeText(ref: string, text: string): Promise<void>;
   pressKey(key: string): Promise<void>;
-  wait(options: number | { text?: string; time?: number; timeout?: number }): Promise<void>;
+  scrollTo(ref: string): Promise<any>;
+  getFormState(): Promise<any>;
+  wait(options: number | WaitOptions): Promise<void>;
   tabs(): Promise<any>;
   closeTab(index?: number): Promise<void>;
   newTab(): Promise<void>;
@@ -32,5 +64,5 @@ export interface IPage {
   autoScroll(options?: { times?: number; delayMs?: number }): Promise<void>;
   installInterceptor(pattern: string): Promise<void>;
   getInterceptedRequests(): Promise<any[]>;
-  screenshot(options?: { format?: 'png' | 'jpeg'; quality?: number; fullPage?: boolean; path?: string }): Promise<string>;
+  screenshot(options?: ScreenshotOptions): Promise<string>;
 }

package/src/validate.ts

@@ -25,6 +25,22 @@ export interface ValidationReport {
   files: number;
 }
 
+interface ValidatedYamlCliDefinition {
+  site?: string;
+  name?: string;
+  pipeline?: unknown[];
+  columns?: unknown[];
+  args?: Record<string, unknown>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 export function validateClisWithTarget(dirs: string[], target?: string): ValidationReport {
   const results: FileValidationResult[] = [];
   let errors = 0; let warnings = 0; let files = 0;
@@ -53,8 +69,8 @@ function validateYamlFile(filePath: string): FileValidationResult {
   const errors: string[] = []; const warnings: string[] = [];
   try {
     const raw = fs.readFileSync(filePath, 'utf-8');
-    const def = yaml.load(raw) as any;
-    if (!def || typeof def !== 'object') { errors.push('Not a valid YAML object'); return { path: filePath, errors, warnings }; }
+    const def = yaml.load(raw) as ValidatedYamlCliDefinition | null;
+    if (!isRecord(def)) { errors.push('Not a valid YAML object'); return { path: filePath, errors, warnings }; }
     if (!def.site) errors.push('Missing "site"');
     if (!def.name) errors.push('Missing "name"');
     if (def.pipeline && !Array.isArray(def.pipeline)) errors.push('"pipeline" must be an array');
@@ -74,7 +90,7 @@ function validateYamlFile(filePath: string): FileValidationResult {
         }
       }
     }
-  } catch (e: any) { errors.push(`YAML parse error: ${e.message}`); }
+  } catch (e) { errors.push(`YAML parse error: ${getErrorMessage(e)}`); }
   return { path: filePath, errors, warnings };
 }
 
@@ -89,4 +105,3 @@ export function renderValidationReport(report: ValidationReport): string {
   }
   return lines.join('\n');
 }
-

package/tests/e2e/browser-public.test.ts

@@ -46,6 +46,31 @@ describe('browser public-data commands E2E', () => {
     }
   }, 60_000);
 
+  it('bloomberg news returns article detail when the article page is accessible', async () => {
+    const feedResult = await runCli(['bloomberg', 'tech', '--limit', '1', '-f', 'json']);
+    if (feedResult.code !== 0) {
+      console.warn('bloomberg news: skipped — could not load Bloomberg tech feed');
+      return;
+    }
+
+    const feedItems = parseJsonOutput(feedResult.stdout);
+    const link = Array.isArray(feedItems) ? feedItems[0]?.link : null;
+    if (!link) {
+      console.warn('bloomberg news: skipped — tech feed returned no link');
+      return;
+    }
+
+    const data = await tryBrowserCommand(['bloomberg', 'news', link, '-f', 'json']);
+    expectDataOrSkip(data, 'bloomberg news');
+    if (data) {
+      expect(data[0]).toHaveProperty('title');
+      expect(data[0]).toHaveProperty('summary');
+      expect(data[0]).toHaveProperty('link');
+      expect(data[0]).toHaveProperty('mediaLinks');
+      expect(data[0]).toHaveProperty('content');
+    }
+  }, 60_000);
+
   // ── v2ex daily (browser: true) ──
   it('v2ex daily returns topics', async () => {
     const data = await tryBrowserCommand(['v2ex', 'daily', '--limit', '3', '-f', 'json']);
@@ -161,6 +186,17 @@ describe('browser public-data commands E2E', () => {
     expectDataOrSkip(data, 'xiaohongshu search');
   }, 60_000);
 
+  // ── google search (browser: true, public strategy) ──
+  it('google search returns results', async () => {
+    const data = await tryBrowserCommand(['google', 'search', 'typescript', '--limit', '5', '-f', 'json']);
+    expectDataOrSkip(data, 'google search');
+    if (data) {
+      expect(data[0]).toHaveProperty('type');
+      expect(data[0]).toHaveProperty('title');
+      expect(data[0]).toHaveProperty('url');
+    }
+  }, 60_000);
+
   // ── yahoo-finance (browser: true) ──
   it('yahoo-finance quote returns stock data', async () => {
     const data = await tryBrowserCommand(['yahoo-finance', 'quote', '--symbol', 'AAPL', '-f', 'json']);

package/tests/e2e/public-commands.test.ts

@@ -11,10 +11,66 @@ function isExpectedChineseSiteRestriction(code: number, stderr: string): boolean
   return /Error \[FETCH_ERROR\]: HTTP (403|429|451|503)\b/.test(stderr);
 }
 
+function isExpectedApplePodcastsRestriction(code: number, stderr: string): boolean {
+  if (code === 0) return false;
+  return /Error \[FETCH_ERROR\]: (Charts API HTTP \d+|Unable to reach Apple Podcasts charts)/.test(stderr);
+}
+
+function isExpectedGoogleRestriction(code: number, stderr: string): boolean {
+  if (code === 0) return false;
+  // Network unreachable (DNS/proxy) or HTTP error from Google
+  return /fetch failed/.test(stderr) || /Error \[FETCH_ERROR\]: HTTP (403|429|451|503)\b/.test(stderr);
+}
+
 // Keep old name as alias for existing tests
 const isExpectedXiaoyuzhouRestriction = isExpectedChineseSiteRestriction;
 
 describe('public commands E2E', () => {
+  // ── bloomberg (RSS-backed, browser: false) ──
+  it('bloomberg main returns structured headline data', async () => {
+    const { stdout, code } = await runCli(['bloomberg', 'main', '--limit', '1', '-f', 'json']);
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+    expect(data.length).toBe(1);
+    expect(data[0]).toHaveProperty('title');
+    expect(data[0]).toHaveProperty('summary');
+    expect(data[0]).toHaveProperty('link');
+    expect(data[0]).toHaveProperty('mediaLinks');
+    expect(Array.isArray(data[0].mediaLinks)).toBe(true);
+  }, 30_000);
+
+  it.each(['markets', 'economics', 'industries', 'tech', 'politics', 'businessweek', 'opinions'])(
+    'bloomberg %s returns structured RSS items',
+    async (section) => {
+      const { stdout, code } = await runCli(['bloomberg', section, '--limit', '1', '-f', 'json']);
+      expect(code).toBe(0);
+      const data = parseJsonOutput(stdout);
+      expect(Array.isArray(data)).toBe(true);
+      expect(data.length).toBe(1);
+      expect(data[0]).toHaveProperty('title');
+      expect(data[0]).toHaveProperty('summary');
+      expect(data[0]).toHaveProperty('link');
+      expect(data[0]).toHaveProperty('mediaLinks');
+    },
+    30_000,
+  );
+
+  it('bloomberg feeds lists the supported RSS aliases', async () => {
+    const { stdout, code } = await runCli(['bloomberg', 'feeds', '-f', 'json']);
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+    expect(data).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: 'main' }),
+        expect.objectContaining({ name: 'markets' }),
+        expect.objectContaining({ name: 'tech' }),
+        expect.objectContaining({ name: 'opinions' }),
+      ]),
+    );
+  }, 30_000);
+
   // ── apple-podcasts ──
   it('apple-podcasts search returns structured podcast results', async () => {
     const { stdout, code } = await runCli(['apple-podcasts', 'search', 'technology', '--limit', '3', '-f', 'json']);
@@ -39,7 +95,11 @@ describe('public commands E2E', () => {
   }, 30_000);
 
   it('apple-podcasts top returns ranked podcasts', async () => {
-    const { stdout, code } = await runCli(['apple-podcasts', 'top', '--limit', '3', '--country', 'us', '-f', 'json']);
+    const { stdout, stderr, code } = await runCli(['apple-podcasts', 'top', '--limit', '3', '--country', 'us', '-f', 'json']);
+    if (isExpectedApplePodcastsRestriction(code, stderr)) {
+      console.warn(`apple-podcasts top skipped: ${stderr.trim()}`);
+      return;
+    }
     expect(code).toBe(0);
     const data = parseJsonOutput(stdout);
     expect(Array.isArray(data)).toBe(true);
@@ -153,6 +213,64 @@ describe('public commands E2E', () => {
     expect(stderr).toMatch(/limit must be a positive integer|Argument "limit" must be a valid number/);
   }, 30_000);
 
+  // ── google suggest (public JSON API) ──
+  it('google suggest returns suggestions', async () => {
+    const { stdout, stderr, code } = await runCli(['google', 'suggest', 'python', '-f', 'json']);
+    if (isExpectedGoogleRestriction(code, stderr)) {
+      console.warn(`google suggest skipped: ${stderr.trim()}`);
+      return;
+    }
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+    expect(data.length).toBeGreaterThanOrEqual(1);
+    expect(data[0]).toHaveProperty('suggestion');
+  }, 30_000);
+
+  // ── google news (public RSS) ──
+  it('google news returns headlines', async () => {
+    const { stdout, stderr, code } = await runCli(['google', 'news', '--limit', '3', '-f', 'json']);
+    if (isExpectedGoogleRestriction(code, stderr)) {
+      console.warn(`google news skipped: ${stderr.trim()}`);
+      return;
+    }
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+    expect(data.length).toBeGreaterThanOrEqual(1);
+    expect(data[0]).toHaveProperty('title');
+    expect(data[0]).toHaveProperty('source');
+    expect(data[0]).toHaveProperty('url');
+  }, 30_000);
+
+  it('google news search returns results', async () => {
+    const { stdout, stderr, code } = await runCli(['google', 'news', 'AI', '--limit', '3', '-f', 'json']);
+    if (isExpectedGoogleRestriction(code, stderr)) {
+      console.warn(`google news search skipped: ${stderr.trim()}`);
+      return;
+    }
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+    expect(data.length).toBeGreaterThanOrEqual(1);
+    expect(data[0]).toHaveProperty('title');
+  }, 30_000);
+
+  // ── google trends (public RSS) ──
+  it('google trends returns trending searches', async () => {
+    const { stdout, stderr, code } = await runCli(['google', 'trends', '--region', 'US', '--limit', '3', '-f', 'json']);
+    if (isExpectedGoogleRestriction(code, stderr)) {
+      console.warn(`google trends skipped: ${stderr.trim()}`);
+      return;
+    }
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+    expect(data.length).toBeGreaterThanOrEqual(1);
+    expect(data[0]).toHaveProperty('title');
+    expect(data[0]).toHaveProperty('traffic');
+  }, 30_000);
+
   // ── weread (Chinese site — may return empty on overseas CI runners) ──
   it('weread search returns books', async () => {
     const { stdout, stderr, code } = await runCli(['weread', 'search', 'python', '--limit', '3', '-f', 'json']);

package/dist/clis/feishu/new.d.ts

@@ -1 +0,0 @@
-export declare const newCommand: import("../../registry.js").CliCommand;

package/dist/clis/feishu/new.js

@@ -1,27 +0,0 @@
-import { execSync } from 'node:child_process';
-import { cli, Strategy } from '../../registry.js';
-export const newCommand = cli({
-    site: 'feishu',
-    name: 'new',
-    description: 'Create a new message or document in Feishu',
-    domain: 'localhost',
-    strategy: Strategy.PUBLIC,
-    browser: false,
-    args: [],
-    columns: ['Status'],
-    func: async (page) => {
-        try {
-            execSync("osascript -e 'tell application \"Lark\" to activate'");
-            execSync("osascript -e 'delay 0.3'");
-            // Cmd+N for new conversation/document
-            execSync("osascript " +
-                "-e 'tell application \"System Events\"' " +
-                "-e 'keystroke \"n\" using command down' " +
-                "-e 'end tell'");
-            return [{ Status: 'New item dialog opened (Cmd+N)' }];
-        }
-        catch (err) {
-            return [{ Status: 'Error: ' + err.message }];
-        }
-    },
-});

package/dist/clis/feishu/read.d.ts

@@ -1 +0,0 @@
-export declare const readCommand: import("../../registry.js").CliCommand;

package/dist/clis/feishu/read.js

@@ -1,40 +0,0 @@
-import { execSync, spawnSync } from 'node:child_process';
-import { cli, Strategy } from '../../registry.js';
-export const readCommand = cli({
-    site: 'feishu',
-    name: 'read',
-    description: 'Read the current chat content by selecting all and copying',
-    domain: 'localhost',
-    strategy: Strategy.PUBLIC,
-    browser: false,
-    args: [],
-    columns: ['Content'],
-    func: async (page) => {
-        try {
-            let clipBackup = '';
-            try {
-                clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
-            }
-            catch { /* empty */ }
-            execSync("osascript -e 'tell application \"Lark\" to activate'");
-            execSync("osascript -e 'delay 0.3'");
-            execSync("osascript " +
-                "-e 'tell application \"System Events\"' " +
-                "-e 'keystroke \"a\" using command down' " +
-                "-e 'delay 0.2' " +
-                "-e 'keystroke \"c\" using command down' " +
-                "-e 'delay 0.2' " +
-                "-e 'end tell'");
-            const content = execSync('pbpaste', { encoding: 'utf-8' }).trim();
-            if (clipBackup) {
-                spawnSync('pbcopy', { input: clipBackup });
-            }
-            // Deselect
-            execSync("osascript -e 'tell application \"System Events\" to key code 53'");
-            return [{ Content: content || '(no content captured)' }];
-        }
-        catch (err) {
-            return [{ Content: 'Error: ' + err.message }];
-        }
-    },
-});

package/dist/clis/feishu/search.d.ts

@@ -1 +0,0 @@
-export declare const searchCommand: import("../../registry.js").CliCommand;

package/dist/clis/feishu/search.js

@@ -1,30 +0,0 @@
-import { execSync } from 'node:child_process';
-import { cli, Strategy } from '../../registry.js';
-export const searchCommand = cli({
-    site: 'feishu',
-    name: 'search',
-    description: 'Open Feishu global search and type a query (Cmd+K)',
-    domain: 'localhost',
-    strategy: Strategy.PUBLIC,
-    browser: false,
-    args: [{ name: 'query', required: true, positional: true, help: 'Search query' }],
-    columns: ['Status'],
-    func: async (page, kwargs) => {
-        const query = kwargs.query;
-        try {
-            execSync("osascript -e 'tell application \"Lark\" to activate'");
-            execSync("osascript -e 'delay 0.3'");
-            // Feishu uses Cmd+K for global search (similar to Slack/Notion)
-            execSync("osascript " +
-                "-e 'tell application \"System Events\"' " +
-                "-e 'keystroke \"k\" using command down' " +
-                "-e 'delay 0.5' " +
-                `-e 'keystroke ${JSON.stringify(query)}' ` +
-                "-e 'end tell'");
-            return [{ Status: `Searching for: ${query}` }];
-        }
-        catch (err) {
-            return [{ Status: 'Error: ' + err.message }];
-        }
-    },
-});

package/dist/clis/feishu/send.d.ts

@@ -1 +0,0 @@
-export declare const sendCommand: import("../../registry.js").CliCommand;