@jackwener/opencli 1.0.3 → 1.0.4

package/src/clis/zhihu/download.ts

@@ -8,7 +8,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { cli, Strategy } from '../../registry.js';
-import { sanitizeFilename, httpDownload } from '../../download/index.js';
+import { sanitizeFilename, httpDownload, formatCookieHeader } from '../../download/index.js';
 import { formatBytes } from '../../download/progress.js';
 
 /**
@@ -178,7 +178,7 @@ cli({
       const imagesDir = path.join(output, 'images');
       fs.mkdirSync(imagesDir, { recursive: true });
 
-      const cookies = await page.evaluate(`(() => document.cookie)()`);
+      const cookies = formatCookieHeader(await page.getCookies({ domain: 'zhihu.com' }));
 
       for (let i = 0; i < data.images.length; i++) {
         const imgUrl = data.images[i];
@@ -188,7 +188,7 @@ cli({
 
         try {
           await httpDownload(imgUrl, imgPath, {
-            cookies: typeof cookies === 'string' ? cookies : '',
+            cookies,
             timeout: 30000,
           });
 

package/src/doctor.ts

@@ -8,12 +8,13 @@
 import chalk from 'chalk';
 import { checkDaemonStatus } from './browser/discover.js';
 import { BrowserBridge } from './browser/index.js';
-import { browserSession } from './runtime.js';
+import { listSessions } from './browser/daemon-client.js';
 
 export type DoctorOptions = {
   fix?: boolean;
   yes?: boolean;
   live?: boolean;
+  sessions?: boolean;
   cliVersion?: string;
 };
 
@@ -28,6 +29,7 @@ export type DoctorReport = {
   daemonRunning: boolean;
   extensionConnected: boolean;
   connectivity?: ConnectivityResult;
+  sessions?: Array<{ workspace: string; windowId: number; tabCount: number; idleMsRemaining: number }>;
   issues: string[];
 };
 
@@ -55,6 +57,9 @@ export async function runBrowserDoctor(opts: DoctorOptions = {}): Promise<Doctor
   if (opts.live) {
     connectivity = await checkConnectivity();
   }
+  const sessions = opts.sessions && status.running && status.extensionConnected
+    ? await listSessions() as Array<{ workspace: string; windowId: number; tabCount: number; idleMsRemaining: number }>
+    : undefined;
 
   const issues: string[] = [];
   if (!status.running) {
@@ -78,6 +83,7 @@ export async function runBrowserDoctor(opts: DoctorOptions = {}): Promise<Doctor
     daemonRunning: status.running,
     extensionConnected: status.extensionConnected,
     connectivity,
+    sessions,
     issues,
   };
 }
@@ -104,6 +110,17 @@ export function renderBrowserDoctorReport(report: DoctorReport): string {
     lines.push(`${chalk.dim('[SKIP]')} Connectivity: not tested (use --live)`);
   }
 
+  if (report.sessions) {
+    lines.push('', chalk.bold('Sessions:'));
+    if (report.sessions.length === 0) {
+      lines.push(chalk.dim('  • no active automation sessions'));
+    } else {
+      for (const session of report.sessions) {
+        lines.push(chalk.dim(`  • ${session.workspace} → window ${session.windowId}, tabs=${session.tabCount}, idle=${Math.ceil(session.idleMsRemaining / 1000)}s`));
+      }
+    }
+  }
+
   if (report.issues.length) {
     lines.push('', chalk.yellow('Issues:'));
     for (const issue of report.issues) {
@@ -115,4 +132,3 @@ export function renderBrowserDoctorReport(report: DoctorReport): string {
 
   return lines.join('\n');
 }
-

package/src/download/index.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { formatCookieHeader, resolveRedirectUrl } from './index.js';
+
+describe('download helpers', () => {
+  it('resolves relative redirects against the original URL', () => {
+    expect(resolveRedirectUrl('https://example.com/a/file', '/cdn/file.bin')).toBe('https://example.com/cdn/file.bin');
+    expect(resolveRedirectUrl('https://example.com/a/file', '../next')).toBe('https://example.com/next');
+  });
+
+  it('formats browser cookies into a Cookie header', () => {
+    expect(formatCookieHeader([
+      { name: 'sid', value: 'abc', domain: 'example.com' },
+      { name: 'ct0', value: 'def', domain: 'example.com' },
+    ])).toBe('sid=abc; ct0=def');
+  });
+});

package/src/download/index.ts

@@ -26,6 +26,16 @@ export interface YtdlpOptions {
   onProgress?: (percent: number) => void;
 }
 
+export interface BrowserCookie {
+  name: string;
+  value: string;
+  domain: string;
+  path?: string;
+  secure?: boolean;
+  httpOnly?: boolean;
+  expirationDate?: number;
+}
+
 /**
  * Check if yt-dlp is available in PATH.
  */
@@ -142,14 +152,14 @@ export async function httpDownload(
       // Handle redirects
       if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
         file.close();
-        fs.unlinkSync(tempPath);
-        httpDownload(response.headers.location, destPath, options).then(resolve);
+        if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+        httpDownload(resolveRedirectUrl(url, response.headers.location), destPath, options).then(resolve);
         return;
       }
 
       if (response.statusCode !== 200) {
         file.close();
-        fs.unlinkSync(tempPath);
+        if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
         resolve({ success: false, size: 0, error: `HTTP ${response.statusCode}` });
         return;
       }
@@ -187,11 +197,15 @@ export async function httpDownload(
   });
 }
 
+export function resolveRedirectUrl(currentUrl: string, location: string): string {
+  return new URL(location, currentUrl).toString();
+}
+
 /**
  * Export cookies to Netscape format for yt-dlp.
  */
 export function exportCookiesToNetscape(
-  cookies: Array<{ name: string; value: string; domain: string; path?: string; secure?: boolean; httpOnly?: boolean }>,
+  cookies: BrowserCookie[],
   filePath: string,
 ): void {
   const lines = [
@@ -214,6 +228,10 @@ export function exportCookiesToNetscape(
   fs.writeFileSync(filePath, lines.join('\n'));
 }
 
+export function formatCookieHeader(cookies: BrowserCookie[]): string {
+  return cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join('; ');
+}
+
 /**
  * Download video using yt-dlp.
  */

package/src/engine.ts

@@ -99,12 +99,12 @@ async function loadFromManifest(manifestPath: string, clisDir: string): Promise<
 async function discoverClisFromFs(dir: string): Promise<void> {
   try { await fs.promises.access(dir); } catch { return; }
   const promises: Promise<any>[] = [];
-  const sites = await fs.promises.readdir(dir);
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
   
-  for (const site of sites) {
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const site = entry.name;
     const siteDir = path.join(dir, site);
-    const stat = await fs.promises.stat(siteDir);
-    if (!stat.isDirectory()) continue;
     const files = await fs.promises.readdir(siteDir);
     for (const file of files) {
       const filePath = path.join(siteDir, file);

package/src/explore.ts

@@ -231,7 +231,7 @@ export async function exploreUrl(
     BrowserFactory: new () => any;
     site?: string; goal?: string; authenticated?: boolean;
     outDir?: string; waitSeconds?: number; query?: string;
-    clickLabels?: string[]; auto?: boolean;
+    clickLabels?: string[]; auto?: boolean; workspace?: string;
   },
 ): Promise<Record<string, any>> {
   const waitSeconds = opts.waitSeconds ?? 3.0;
@@ -280,7 +280,7 @@ export async function exploreUrl(
 
       // Step 5: For JSON endpoints missing a body, carefully re-fetch in-browser via a pristine iframe
       const jsonEndpoints = networkEntries.filter(e => e.contentType.includes('json') && e.method === 'GET' && e.status === 200 && !e.responseBody);
-      for (const ep of jsonEndpoints.slice(0, 5)) {
+      await Promise.allSettled(jsonEndpoints.slice(0, 5).map(async (ep) => {
         try {
           const body = await page.evaluate(`async () => {
             let iframe = null;
@@ -302,7 +302,7 @@ export async function exploreUrl(
           if (body && typeof body === 'string') { try { ep.responseBody = JSON.parse(body); } catch {} }
           else if (body && typeof body === 'object') ep.responseBody = body;
         } catch {}
-      }
+      }));
 
       // Step 6: Detect framework
       let framework: Record<string, boolean> = {};
@@ -438,7 +438,7 @@ export async function exploreUrl(
 
       return { ...result, out_dir: targetDir };
     })(), { timeout: exploreTimeout, label: `Explore ${url}` });
-  });
+  }, { workspace: opts.workspace });
 }
 
 export function renderExploreSummary(result: Record<string, any>): string {

package/src/generate.ts

@@ -65,6 +65,7 @@ export async function generateCliFromUrl(opts: any): Promise<any> {
     site: opts.site,
     goal: normalizeGoal(opts.goal) ?? opts.goal,
     waitSeconds: opts.waitSeconds ?? 3,
+    workspace: opts.workspace,
   });
 
   // Step 2: Synthesize candidates

package/src/interceptor.ts

@@ -27,6 +27,7 @@ export function generateInterceptorJs(
   return `
     () => {
       window.${arr} = window.${arr} || [];
+      window.${arr}_errors = window.${arr}_errors || [];
       const __pattern = ${patternExpr};
 
       if (!window.${guard}) {
@@ -43,7 +44,7 @@ export function generateInterceptorJs(
               const clone = response.clone();
               const json = await clone.json();
               window.${arr}.push(json);
-            } catch(e) {}
+            } catch(e) { window.${arr}_errors.push({ url: reqUrl, error: String(e) }); }
           }
           return response;
         };
@@ -61,7 +62,7 @@ export function generateInterceptorJs(
             this.addEventListener('load', function() {
               try {
                 window.${arr}.push(JSON.parse(this.responseText));
-              } catch(e) {}
+              } catch(e) { window.${arr}_errors.push({ url: this.__opencli_url, error: String(e) }); }
             });
           }
           return __origSend.apply(this, arguments);

package/src/output.ts

@@ -12,6 +12,7 @@ export interface RenderOptions {
   title?: string;
   elapsed?: number;
   source?: string;
+  footerExtra?: string;
 }
 
 export function render(data: unknown, opts: RenderOptions = {}): void {
@@ -56,6 +57,7 @@ function renderTable(data: unknown, opts: RenderOptions): void {
   footer.push(`${rows.length} items`);
   if (opts.elapsed) footer.push(`${opts.elapsed.toFixed(1)}s`);
   if (opts.source) footer.push(opts.source);
+  if (opts.footerExtra) footer.push(opts.footerExtra);
   console.log(chalk.dim(footer.join(' · ')));
 }
 
@@ -82,7 +84,7 @@ function renderCsv(data: unknown, opts: RenderOptions): void {
   for (const row of rows) {
     console.log(columns.map(c => {
       const v = String((row as Record<string, unknown>)[c] ?? '');
-      return v.includes(',') || v.includes('"') || v.includes('\n')
+      return v.includes(',') || v.includes('"') || v.includes('\n') || v.includes('\r')
         ? `"${v.replace(/"/g, '""')}"` : v;
     }).join(','));
   }

package/src/pipeline/executor.test.ts

@@ -11,6 +11,7 @@ function createMockPage(overrides: Partial<IPage> = {}): IPage {
   return {
     goto: vi.fn(),
     evaluate: vi.fn().mockResolvedValue(null),
+    getCookies: vi.fn().mockResolvedValue([]),
     snapshot: vi.fn().mockResolvedValue(''),
     click: vi.fn(),
     typeText: vi.fn(),

package/src/pipeline/steps/download.ts

@@ -23,6 +23,7 @@ import {
   generateFilename,
   exportCookiesToNetscape,
   getTempDir,
+  formatCookieHeader,
 } from '../../download/index.js';
 import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
 
@@ -62,9 +63,8 @@ async function mapConcurrent<T, R>(
  */
 async function extractBrowserCookies(page: IPage, domain?: string): Promise<string> {
   try {
-    // Use browser evaluate to get document.cookie
-    const cookieString = await page.evaluate(`(() => document.cookie)()`);
-    return typeof cookieString === 'string' ? cookieString : '';
+    const cookies = await page.getCookies(domain ? { domain } : {});
+    return formatCookieHeader(cookies);
   } catch {
     return '';
   }
@@ -78,20 +78,17 @@ async function extractCookiesArray(
   domain: string,
 ): Promise<Array<{ name: string; value: string; domain: string; path: string; secure: boolean; httpOnly: boolean }>> {
   try {
-    const cookieString = await extractBrowserCookies(page);
-    if (!cookieString) return [];
-
-    return cookieString.split(';').map((c) => {
-      const [name, ...rest] = c.trim().split('=');
-      return {
-        name: name || '',
-        value: rest.join('=') || '',
-        domain,
-        path: '/',
-        secure: true,
-        httpOnly: false,
-      };
-    }).filter((c) => c.name);
+    const cookies = await page.getCookies({ domain });
+    return cookies
+      .filter((cookie) => cookie.name)
+      .map((cookie) => ({
+        name: cookie.name,
+        value: cookie.value,
+        domain: cookie.domain,
+        path: cookie.path ?? '/',
+        secure: cookie.secure ?? false,
+        httpOnly: cookie.httpOnly ?? false,
+      }));
   } catch {
     return [];
   }

package/src/registry.ts

@@ -35,6 +35,7 @@ export interface CliCommand {
   pipeline?: Record<string, unknown>[];
   timeoutSeconds?: number;
   source?: string;
+  footerExtra?: (kwargs: Record<string, any>) => string | undefined;
 }
 
 /** Internal extension for lazy-loaded TS modules (not exposed in public API) */
@@ -51,18 +52,21 @@ export interface CliOptions extends Partial<Omit<CliCommand, 'args' | 'descripti
 const _registry = new Map<string, CliCommand>();
 
 export function cli(opts: CliOptions): CliCommand {
+  const strategy = opts.strategy ?? (opts.browser === false ? Strategy.PUBLIC : Strategy.COOKIE);
+  const browser = opts.browser ?? (strategy !== Strategy.PUBLIC);
   const cmd: CliCommand = {
     site: opts.site,
     name: opts.name,
     description: opts.description ?? '',
     domain: opts.domain,
-    strategy: opts.strategy ?? (opts.browser === false ? Strategy.PUBLIC : Strategy.COOKIE),
-    browser: opts.browser ?? (opts.strategy === Strategy.PUBLIC ? false : true),
+    strategy,
+    browser,
     args: opts.args ?? [],
     columns: opts.columns,
     func: opts.func,
     pipeline: opts.pipeline,
     timeoutSeconds: opts.timeoutSeconds,
+    footerExtra: opts.footerExtra,
   };
 
   const key = fullName(cmd);

package/src/runtime.ts

@@ -30,17 +30,18 @@ export function withTimeoutMs<T>(promise: Promise<T>, timeoutMs: number, message
 
 /** Interface for browser factory (BrowserBridge or test mocks) */
 export interface IBrowserFactory {
-  connect(opts?: { timeout?: number }): Promise<IPage>;
+  connect(opts?: { timeout?: number; workspace?: string }): Promise<IPage>;
   close(): Promise<void>;
 }
 
 export async function browserSession<T>(
   BrowserFactory: new () => IBrowserFactory,
   fn: (page: IPage) => Promise<T>,
+  opts: { workspace?: string } = {},
 ): Promise<T> {
   const mcp = new BrowserFactory();
   try {
-    const page = await mcp.connect({ timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT });
+    const page = await mcp.connect({ timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT, workspace: opts.workspace });
     return await fn(page);
   } finally {
     await mcp.close().catch(() => {});

package/src/types.ts

@@ -8,6 +8,15 @@
 export interface IPage {
   goto(url: string): 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>;
   click(ref: string): Promise<void>;
   typeText(ref: string, text: string): Promise<void>;

package/src/verify.ts

@@ -7,6 +7,9 @@
  */
 
 import { validateClisWithTarget, renderValidationReport, type ValidationReport } from './validate.js';
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
 export interface VerifyOptions {
   builtinClis: string;
@@ -18,15 +21,73 @@ export interface VerifyOptions {
 export interface VerifyReport {
   ok: boolean;
   validation: ValidationReport;
-  smoke: null;
+  smoke: null | {
+    requested: boolean;
+    executed: boolean;
+    ok: boolean;
+    summary: string;
+  };
 }
 
 export async function verifyClis(opts: VerifyOptions): Promise<VerifyReport> {
   const report = validateClisWithTarget([opts.builtinClis, opts.userClis], opts.target);
-  return { ok: report.ok, validation: report, smoke: null };
+  let smoke: VerifyReport['smoke'] = null;
+  if (opts.smoke) {
+    smoke = await runSmokeTests(opts.builtinClis);
+  }
+  return { ok: report.ok && (smoke?.ok ?? true), validation: report, smoke };
 }
 
 export function renderVerifyReport(report: VerifyReport): string {
-  return renderValidationReport(report.validation);
+  const base = renderValidationReport(report.validation);
+  if (!report.smoke) return base;
+  const status = report.smoke.ok ? 'PASS' : 'FAIL';
+  const mode = report.smoke.executed ? 'executed' : 'skipped';
+  return `${base}\nSmoke: ${status} (${mode}) — ${report.smoke.summary}`;
 }
 
+async function runSmokeTests(builtinClis: string): Promise<NonNullable<VerifyReport['smoke']>> {
+  const projectRoot = path.resolve(builtinClis, '..', '..');
+  const smokeDir = path.join(projectRoot, 'tests', 'smoke');
+
+  if (!fs.existsSync(smokeDir)) {
+    return {
+      requested: true,
+      executed: false,
+      ok: false,
+      summary: 'Smoke tests are unavailable in this package/environment.',
+    };
+  }
+
+  const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+  return new Promise((resolve) => {
+    const child = spawn(npx, ['vitest', 'run', 'tests/smoke/', '--reporter=dot'], {
+      cwd: projectRoot,
+      env: { ...process.env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stderr = '';
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on('error', (error) => {
+      resolve({
+        requested: true,
+        executed: false,
+        ok: false,
+        summary: `Failed to start smoke tests: ${error.message}`,
+      });
+    });
+
+    child.on('close', (code) => {
+      resolve({
+        requested: true,
+        executed: true,
+        ok: code === 0,
+        summary: code === 0 ? 'tests/smoke passed' : (stderr.trim() || `vitest exited with code ${code}`),
+      });
+    });
+  });
+}