@jackwener/opencli 0.9.6 → 1.0.0

package/src/pipeline/steps/download.ts

@@ -0,0 +1,310 @@
+/**
+ * Pipeline step: download — file download with concurrency and progress.
+ *
+ * Supports:
+ * - Direct HTTP downloads (images, documents)
+ * - yt-dlp integration for video platforms
+ * - Browser cookie forwarding for authenticated downloads
+ * - Filename templating and deduplication
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import type { IPage } from '../../types.js';
+import { render } from '../template.js';
+import {
+  httpDownload,
+  ytdlpDownload,
+  saveDocument,
+  detectContentType,
+  requiresYtdlp,
+  sanitizeFilename,
+  generateFilename,
+  exportCookiesToNetscape,
+  getTempDir,
+} from '../../download/index.js';
+import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
+
+export interface DownloadResult {
+  status: 'success' | 'skipped' | 'failed';
+  path?: string;
+  size?: number;
+  error?: string;
+  duration?: number;
+}
+
+/**
+ * Simple async concurrency limiter for downloads.
+ */
+async function mapConcurrent<T, R>(
+  items: T[],
+  limit: number,
+  fn: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  let index = 0;
+
+  async function worker() {
+    while (index < items.length) {
+      const i = index++;
+      results[i] = await fn(items[i], i);
+    }
+  }
+
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
+/**
+ * Extract cookies from browser page.
+ */
+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 : '';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Extract cookies as array for yt-dlp Netscape format.
+ */
+async function extractCookiesArray(
+  page: IPage,
+  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);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Download step handler for YAML pipelines.
+ *
+ * Usage in YAML:
+ * ```yaml
+ * pipeline:
+ *   - download:
+ *       url: ${{ item.imageUrl }}
+ *       dir: ./downloads
+ *       filename: ${{ item.title }}.jpg
+ *       concurrency: 5
+ *       skip_existing: true
+ *       use_ytdlp: false
+ *       type: auto
+ * ```
+ */
+export async function stepDownload(
+  page: IPage | null,
+  params: any,
+  data: any,
+  args: Record<string, any>,
+): Promise<any> {
+  // Parse parameters with defaults
+  const urlTemplate = typeof params === 'string' ? params : (params?.url ?? '');
+  const dirTemplate = params?.dir ?? './downloads';
+  const filenameTemplate = params?.filename ?? '';
+  const concurrency = typeof params?.concurrency === 'number' ? params.concurrency : 3;
+  const skipExisting = params?.skip_existing !== false;
+  const timeout = typeof params?.timeout === 'number' ? params.timeout * 1000 : 30000;
+  const useYtdlp = params?.use_ytdlp ?? false;
+  const ytdlpArgs = Array.isArray(params?.ytdlp_args) ? params.ytdlp_args : [];
+  const contentType = params?.type ?? 'auto';
+  const showProgress = params?.progress !== false;
+  const contentTemplate = params?.content;
+  const metadataTemplate = params?.metadata;
+
+  // Resolve output directory
+  const dir = String(render(dirTemplate, { args, data }));
+  fs.mkdirSync(dir, { recursive: true });
+
+  // Normalize data to array
+  const items: any[] = Array.isArray(data) ? data : data ? [data] : [];
+  if (items.length === 0) {
+    return [];
+  }
+
+  // Create progress tracker
+  const tracker = new DownloadProgressTracker(items.length, showProgress);
+
+  // Extract cookies if browser is available
+  let cookies = '';
+  let cookiesFile: string | undefined;
+
+  if (page) {
+    cookies = await extractBrowserCookies(page);
+
+    // For yt-dlp, we need to export cookies to Netscape format
+    if (useYtdlp || items.some((item, index) => {
+      const url = String(render(urlTemplate, { args, data, item, index }));
+      return requiresYtdlp(url);
+    })) {
+      try {
+        // Try to get domain from first URL
+        const firstUrl = String(render(urlTemplate, { args, data, item: items[0], index: 0 }));
+        const domain = new URL(firstUrl).hostname;
+        const cookiesArray = await extractCookiesArray(page, domain);
+
+        if (cookiesArray.length > 0) {
+          const tempDir = getTempDir();
+          fs.mkdirSync(tempDir, { recursive: true });
+          cookiesFile = path.join(tempDir, `cookies_${Date.now()}.txt`);
+          exportCookiesToNetscape(cookiesArray, cookiesFile);
+        }
+      } catch {
+        // Ignore cookie extraction errors
+      }
+    }
+  }
+
+  // Process downloads with concurrency
+  const results = await mapConcurrent(items, concurrency, async (item, index): Promise<any> => {
+    const startTime = Date.now();
+
+    // Render URL
+    const url = String(render(urlTemplate, { args, data, item, index }));
+    if (!url) {
+      tracker.onFileComplete(false);
+      return {
+        ...item,
+        _download: { status: 'failed', error: 'Empty URL' } as DownloadResult,
+      };
+    }
+
+    // Render filename
+    let filename: string;
+    if (filenameTemplate) {
+      filename = String(render(filenameTemplate, { args, data, item, index }));
+    } else {
+      filename = generateFilename(url, index);
+    }
+    filename = sanitizeFilename(filename);
+
+    const destPath = path.join(dir, filename);
+
+    // Check if file exists and skip_existing is true
+    if (skipExisting && fs.existsSync(destPath)) {
+      tracker.onFileComplete(true, true);
+      return {
+        ...item,
+        _download: {
+          status: 'skipped',
+          path: destPath,
+          size: fs.statSync(destPath).size,
+        } as DownloadResult,
+      };
+    }
+
+    // Create progress bar for this file
+    const progressBar = tracker.onFileStart(filename, index);
+
+    // Determine download method
+    const detectedType = contentType === 'auto' ? detectContentType(url) : contentType;
+    const shouldUseYtdlp = useYtdlp || (detectedType === 'video' && requiresYtdlp(url));
+
+    let result: { success: boolean; size: number; error?: string };
+
+    try {
+      if (detectedType === 'document' && contentTemplate) {
+        // Save extracted content as document
+        const content = String(render(contentTemplate, { args, data, item, index }));
+        const metadata = metadataTemplate
+          ? Object.fromEntries(
+              Object.entries(metadataTemplate).map(([k, v]) => [k, render(v, { args, data, item, index })]),
+            )
+          : undefined;
+
+        const ext = path.extname(filename).toLowerCase();
+        const format = ext === '.json' ? 'json' : ext === '.html' ? 'html' : 'markdown';
+        result = await saveDocument(content, destPath, format, metadata);
+
+        if (progressBar) {
+          progressBar.complete(result.success, result.success ? formatBytes(result.size) : undefined);
+        }
+      } else if (shouldUseYtdlp) {
+        // Use yt-dlp for video downloads
+        result = await ytdlpDownload(url, destPath, {
+          cookiesFile,
+          extraArgs: ytdlpArgs,
+          onProgress: (percent) => {
+            if (progressBar) {
+              progressBar.update(percent, 100);
+            }
+          },
+        });
+
+        if (progressBar) {
+          progressBar.complete(result.success, result.success ? formatBytes(result.size) : undefined);
+        }
+      } else {
+        // Direct HTTP download
+        result = await httpDownload(url, destPath, {
+          cookies,
+          timeout,
+          onProgress: (received, total) => {
+            if (progressBar) {
+              progressBar.update(received, total);
+            }
+          },
+        });
+
+        if (progressBar) {
+          progressBar.complete(result.success, result.success ? formatBytes(result.size) : undefined);
+        }
+      }
+    } catch (err: any) {
+      result = { success: false, size: 0, error: err.message };
+      if (progressBar) {
+        progressBar.fail(err.message);
+      }
+    }
+
+    tracker.onFileComplete(result.success);
+
+    const duration = Date.now() - startTime;
+
+    return {
+      ...item,
+      _download: {
+        status: result.success ? 'success' : 'failed',
+        path: result.success ? destPath : undefined,
+        size: result.size,
+        error: result.error,
+        duration,
+      } as DownloadResult,
+    };
+  });
+
+  // Cleanup temp cookie file
+  if (cookiesFile && fs.existsSync(cookiesFile)) {
+    try {
+      fs.unlinkSync(cookiesFile);
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+
+  // Show summary
+  tracker.finish();
+
+  return results;
+}

package/src/pipeline/steps/intercept.ts

@@ -3,7 +3,7 @@
  */
 
 import type { IPage } from '../../types.js';
-import { render } from '../template.js';
+import { render, normalizeEvaluateSource } from '../template.js';
 import { generateInterceptorJs, generateReadInterceptedJs } from '../../interceptor.js';
 
 export async function stepIntercept(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any> {
@@ -24,7 +24,6 @@ export async function stepIntercept(page: IPage | null, params: any, data: any,
     await page!.goto(String(url));
   } else if (trigger.startsWith('evaluate:')) {
     const js = trigger.slice('evaluate:'.length);
-    const { normalizeEvaluateSource } = await import('../template.js');
     await page!.evaluate(normalizeEvaluateSource(render(js, { args, data }) as string));
   } else if (trigger.startsWith('click:')) {
     const ref = render(trigger.slice('click:'.length), { args, data });

package/src/pipeline/template.ts

@@ -119,6 +119,32 @@ function applyFilter(filterExpr: string, value: any): any {
       return Array.isArray(value) ? value[value.length - 1] : value;
     case 'json':
       return JSON.stringify(value ?? null);
+    case 'slugify':
+      // Convert to URL-safe slug
+      return typeof value === 'string'
+        ? value
+            .toLowerCase()
+            .replace(/[^\p{L}\p{N}]+/gu, '-')
+            .replace(/^-|-$/g, '')
+        : value;
+    case 'sanitize':
+      // Remove invalid filename characters
+      return typeof value === 'string'
+        ? value.replace(/[<>:"/\\|?*\x00-\x1f]/g, '_')
+        : value;
+    case 'ext': {
+      // Extract file extension from URL or path
+      if (typeof value !== 'string') return value;
+      const lastDot = value.lastIndexOf('.');
+      const lastSlash = Math.max(value.lastIndexOf('/'), value.lastIndexOf('\\'));
+      return lastDot > lastSlash ? value.slice(lastDot) : '';
+    }
+    case 'basename': {
+      // Extract filename from URL or path
+      if (typeof value !== 'string') return value;
+      const parts = value.split(/[/\\]/);
+      return parts[parts.length - 1] || value;
+    }
     default:
       return value;
   }

package/src/setup.ts

@@ -1,205 +1,69 @@
 /**
- * setup.ts — Interactive Playwright MCP token setup
+ * setup.ts — Interactive browser setup for opencli
  *
- * Discovers the extension token, shows an interactive checkbox
- * for selecting which config files to update, and applies changes.
+ * Simplified for daemon-based architecture. No more token management.
+ * Just verifies daemon + extension connectivity.
  */
-import * as fs from 'node:fs';
+
 import chalk from 'chalk';
-import { createInterface } from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import {
-  type DoctorReport,
-  PLAYWRIGHT_TOKEN_ENV,
-  checkExtensionInstalled,
-  checkTokenConnectivity,
-  discoverExtensionToken,
-  fileExists,
-  getDefaultShellRcPath,
-  runBrowserDoctor,
-  shortenPath,
-  toolName,
-  upsertJsonConfigToken,
-  upsertShellToken,
-  upsertTomlConfigToken,
-  writeFileWithMkdir,
-} from './doctor.js';
-import { getTokenFingerprint } from './browser/index.js';
-import { type CheckboxItem, checkboxPrompt } from './tui.js';
+import { checkDaemonStatus } from './browser/discover.js';
+import { checkConnectivity } from './doctor.js';
+import { PlaywrightMCP } from './browser/index.js';
 
 export async function runSetup(opts: { cliVersion?: string; token?: string } = {}) {
   console.log();
-  console.log(chalk.bold('  opencli setup') + chalk.dim(' — Playwright MCP token configuration'));
+  console.log(chalk.bold('  opencli setup') + chalk.dim(' — browser bridge configuration'));
   console.log();
 
-  // Step 1: Discover token
-  let token = opts.token ?? null;
-
-  if (!token) {
-    const extensionToken = discoverExtensionToken();
-    const envToken = process.env[PLAYWRIGHT_TOKEN_ENV] ?? null;
+  // Step 1: Check daemon
+  console.log(chalk.dim('  Checking daemon status...'));
+  const status = await checkDaemonStatus();
 
-    if (extensionToken && envToken && extensionToken === envToken) {
-      token = extensionToken;
-      console.log(`  ${chalk.green('✓')} Token auto-discovered from Chrome extension`);
-      console.log(`    Fingerprint: ${chalk.bold(getTokenFingerprint(token) ?? 'unknown')}`);
-    } else if (extensionToken) {
-      token = extensionToken;
-      console.log(`  ${chalk.green('✓')} Token discovered from Chrome extension ` +
-        chalk.dim(`(${getTokenFingerprint(token)})`));
-      if (envToken && envToken !== extensionToken) {
-        console.log(`  ${chalk.yellow('!')} Environment has different token ` +
-          chalk.dim(`(${getTokenFingerprint(envToken)})`));
-      }
-    } else if (envToken) {
-      token = envToken;
-      console.log(`  ${chalk.green('✓')} Token from environment variable ` +
-        chalk.dim(`(${getTokenFingerprint(token)})`));
-    }
+  if (status.running) {
+    console.log(`  ${chalk.green('✓')} Daemon is running on port 19825`);
   } else {
-    console.log(`  ${chalk.green('✓')} Using provided token ` +
-      chalk.dim(`(${getTokenFingerprint(token)})`));
+    console.log(`  ${chalk.yellow('!')} Daemon is not running`);
+    console.log(chalk.dim('    The daemon starts automatically when you run a browser command.'));
+    console.log(chalk.dim('    Starting daemon now...'));
+
+    // Try to spawn daemon
+    const mcp = new PlaywrightMCP();
+    try {
+      await mcp.connect({ timeout: 5 });
+      await mcp.close();
+      console.log(`  ${chalk.green('✓')} Daemon started successfully`);
+    } catch {
+      console.log(`  ${chalk.yellow('!')} Could not start daemon automatically`);
+    }
   }
 
-  if (!token) {
-    // Give precise diagnosis of why token scan failed
-    const extInstall = checkExtensionInstalled();
-
-    console.log(`  ${chalk.red('✗')} Browser token scan failed\n`);
-    if (!extInstall.installed) {
-      console.log(chalk.dim('  Cause: Playwright MCP Bridge extension is not installed'));
-      console.log(chalk.dim('  Fix:   Install from https://chromewebstore.google.com/detail/'));
-      console.log(chalk.dim('         playwright-mcp-bridge/mmlmfjhmonkocbjadbfplnigmagldckm'));
-    } else {
-      console.log(chalk.dim(`  Cause: Extension is installed (${extInstall.browsers.join(', ')}) but token not found in LevelDB`));
-      console.log(chalk.dim('  Fix:   1) Open the extension popup and verify the token is generated'));
-      console.log(chalk.dim('         2) Close Chrome completely, then re-run setup'));
-    }
+  // Step 2: Check extension
+  const statusAfter = await checkDaemonStatus();
+  if (statusAfter.extensionConnected) {
+    console.log(`  ${chalk.green('✓')} Chrome extension connected`);
+  } else {
+    console.log(`  ${chalk.red('✗')} Chrome extension not connected`);
     console.log();
-    console.log(`  You can enter the token manually, or fix the above and re-run ${chalk.bold('opencli setup')}.`);
+    console.log(chalk.dim('  To install the opencli Browser Bridge extension:'));
+    console.log(chalk.dim('    1. Download from GitHub Releases'));
+    console.log(chalk.dim('    2. Open chrome://extensions/ → Enable Developer Mode'));
+    console.log(chalk.dim('    3. Click "Load unpacked" → select the extension folder'));
+    console.log(chalk.dim('    4. Make sure Chrome is running'));
     console.log();
-    const rl = createInterface({ input, output });
-    const answer = await rl.question('  Token (press Enter to abort): ');
-    rl.close();
-    token = answer.trim();
-    if (!token) {
-      console.log(chalk.red('\n  No token provided. Aborting.\n'));
-      return;
-    }
-  }
-
-  const fingerprint = getTokenFingerprint(token) ?? 'unknown';
-  console.log();
-
-  // Step 2: Scan all config locations
-  const report = await runBrowserDoctor({ token, cliVersion: opts.cliVersion });
-
-  // Step 3: Build checkbox items
-  const items: CheckboxItem[] = [];
-
-  // Shell file
-  const shellPath = report.shellFiles[0]?.path ?? getDefaultShellRcPath();
-  const shellStatus = report.shellFiles[0];
-  const shellFp = shellStatus?.fingerprint;
-  const shellOk = shellFp === fingerprint;
-  const shellTool = toolName(shellPath) || 'Shell';
-  items.push({
-    label: padRight(shortenPath(shellPath), 50) + chalk.dim(` [${shellTool}]`),
-    value: `shell:${shellPath}`,
-    checked: !shellOk,
-    status: shellOk ? `configured (${shellFp})` : shellFp ? `mismatch (${shellFp})` : 'missing',
-    statusColor: shellOk ? 'green' : shellFp ? 'yellow' : 'red',
-  });
-
-  // Config files
-  for (const config of report.configs) {
-    const fp = config.fingerprint;
-    const ok = fp === fingerprint;
-    const tool = toolName(config.path);
-    items.push({
-      label: padRight(shortenPath(config.path), 50) + chalk.dim(tool ? ` [${tool}]` : ''),
-      value: `config:${config.path}`,
-      checked: false,  // let user explicitly select which tools to configure
-      status: ok ? `configured (${fp})` : !config.exists ? 'will create' : fp ? `mismatch (${fp})` : 'missing',
-      statusColor: ok ? 'green' : 'yellow',
-    });
-  }
-
-  // Step 4: Show interactive checkbox
-  console.clear();
-  const selected = await checkboxPrompt(items, {
-    title: `  ${chalk.bold('opencli setup')} — token ${chalk.cyan(fingerprint)}`,
-  });
-
-  if (selected.length === 0) {
-    console.log(chalk.dim('  No changes made.\n'));
     return;
   }
 
-  // Step 5: Apply changes
-  const written: string[] = [];
-  let wroteShell = false;
-
-  for (const sel of selected) {
-    if (sel.startsWith('shell:')) {
-      const p = sel.slice('shell:'.length);
-      const before = fileExists(p) ? fs.readFileSync(p, 'utf-8') : '';
-      writeFileWithMkdir(p, upsertShellToken(before, token, p));
-      written.push(p);
-      wroteShell = true;
-    } else if (sel.startsWith('config:')) {
-      const p = sel.slice('config:'.length);
-      const config = report.configs.find(c => c.path === p);
-      if (config && config.parseError) continue;
-      const before = fileExists(p) ? fs.readFileSync(p, 'utf-8') : '';
-      const format = config?.format ?? (p.endsWith('.toml') ? 'toml' : 'json');
-      const next = format === 'toml' ? upsertTomlConfigToken(before, token) : upsertJsonConfigToken(before, token, p);
-      writeFileWithMkdir(p, next);
-      written.push(p);
-    }
-  }
-
-  process.env[PLAYWRIGHT_TOKEN_ENV] = token;
-
-  // Step 6: Summary
-  if (written.length > 0) {
-    console.log(chalk.green.bold(`  ✓ Updated ${written.length} file(s):`));
-    for (const p of written) {
-      const tool = toolName(p);
-      console.log(`    ${chalk.dim('•')} ${shortenPath(p)}${tool ? chalk.dim(` [${tool}]`) : ''}`);
-    }
-    if (wroteShell) {
-      console.log();
-      console.log(chalk.cyan(`  💡 Run ${chalk.bold(`source ${shortenPath(shellPath)}`)} to apply token to current shell.`));
-    }
-  } else {
-    console.log(chalk.yellow('  No files were changed.'));
-  }
+  // Step 3: Test connectivity
   console.log();
-
-  // Step 7: Auto-verify browser connectivity
-  console.log(chalk.dim('  Verifying browser connectivity...'));
-  try {
-    const result = await checkTokenConnectivity({ timeout: 5 });
-    if (result.ok) {
-      console.log(`  ${chalk.green('✓')} Browser connected in ${(result.durationMs / 1000).toFixed(1)}s`);
-    } else {
-      console.log(`  ${chalk.green('✓')} Token saved successfully.`);
-      console.log(`  ${chalk.yellow('!')} Browser connectivity test failed: ${result.error ?? 'unknown'}`);
-      console.log(chalk.dim('    Token configuration is complete. To use opencli, make sure Chrome'));
-      console.log(chalk.dim('    is running with the Playwright MCP Bridge extension enabled.'));
-      console.log(chalk.dim(`    Run ${chalk.bold('opencli doctor --live')} to re-test connectivity.`));
-    }
-  } catch {
-    console.log(`  ${chalk.green('✓')} Token saved successfully.`);
-    console.log(`  ${chalk.yellow('!')} Browser connectivity test skipped (Chrome may not be running).`);
-    console.log(chalk.dim('    Token configuration is complete. Start Chrome to begin using opencli.'));
-    console.log(chalk.dim(`    Run ${chalk.bold('opencli doctor --live')} to re-test connectivity.`));
+  console.log(chalk.dim('  Testing browser connectivity...'));
+  const conn = await checkConnectivity({ timeout: 5 });
+  if (conn.ok) {
+    console.log(`  ${chalk.green('✓')} Browser connected in ${(conn.durationMs / 1000).toFixed(1)}s`);
+    console.log();
+    console.log(chalk.green.bold('  ✓ Setup complete! You can now use opencli browser commands.'));
+  } else {
+    console.log(`  ${chalk.yellow('!')} Connectivity test failed: ${conn.error ?? 'unknown'}`);
+    console.log(chalk.dim(`    Run ${chalk.bold('opencli doctor --live')} to diagnose.`));
   }
   console.log();
 }
-
-function padRight(s: string, n: number): string {
-  const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
-  return visible.length >= n ? s : s + ' '.repeat(n - visible.length);
-}

package/src/types.ts

@@ -23,4 +23,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>;
 }

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

@@ -79,6 +79,31 @@ describe('login-required commands — graceful failure', () => {
     await expectGracefulAuthFailure(['xueqiu', 'watchlist', '-f', 'json'], 'xueqiu watchlist');
   }, 60_000);
 
+  // ── linux-do (requires login — all endpoints need authentication) ──
+  it('linux-do hot fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'hot', '--limit', '3', '-f', 'json'], 'linux-do hot');
+  }, 60_000);
+
+  it('linux-do latest fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'latest', '--limit', '3', '-f', 'json'], 'linux-do latest');
+  }, 60_000);
+
+  it('linux-do categories fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'categories', '--limit', '3', '-f', 'json'], 'linux-do categories');
+  }, 60_000);
+
+  it('linux-do category fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'category', '--slug', 'general', '--id', '1', '--limit', '3', '-f', 'json'], 'linux-do category');
+  }, 60_000);
+
+  it('linux-do topic fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'topic', '--id', '1', '-f', 'json'], 'linux-do topic');
+  }, 60_000);
+
+  it('linux-do search fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'search', '--keyword', 'test', '--limit', '3', '-f', 'json'], 'linux-do search');
+  }, 60_000);
+
   // ── xiaohongshu (requires login) ──
   it('xiaohongshu feed fails gracefully without login', async () => {
     await expectGracefulAuthFailure(['xiaohongshu', 'feed', '--limit', '3', '-f', 'json'], 'xiaohongshu feed');