@web-auto/webauto 0.1.4 → 0.1.6

package/modules/workflow/config/workflowRegistry.ts

@@ -7,6 +7,7 @@ import { xiaohongshuPhase3CollectWorkflowV1 } from '../definitions/xiaohongshu-p
 import { xiaohongshuPhase1WorkflowV3 } from '../definitions/xiaohongshu-phase1-workflow-v3.js';
 import { xiaohongshuPhase2LinksWorkflowV3 } from '../definitions/xiaohongshu-phase2-links-workflow-v3.js';
 import { xiaohongshuPhase34FromLinksWorkflowV3 } from '../definitions/xiaohongshu-phase34-from-links-workflow-v3.js';
+import { weiboSearchWorkflowV1 } from '../definitions/weibo-search-workflow-v1.js'; // 导入微博搜索工作流
 
 const registry = new Map<string, WorkflowDefinitionInput>();
 
@@ -27,6 +28,7 @@ register(xiaohongshuPhase3CollectWorkflowV1, 'xiaohongshu-collect-phase3-v1');
 register(xiaohongshuPhase1WorkflowV3, 'xiaohongshu-phase1-v3');
 register(xiaohongshuPhase2LinksWorkflowV3, 'xiaohongshu-phase2-links-v3');
 register(xiaohongshuPhase34FromLinksWorkflowV3, 'xiaohongshu-phase34-from-links-v3');
+register(weiboSearchWorkflowV1, 'weibo-search-v1'); // 注册微博搜索工作流
 
 export function getWorkflowDefinition(id: string): WorkflowDefinitionInput | undefined {
   return registry.get(id);

package/modules/workflow/definitions/weibo-search-workflow-v1.ts

@@ -0,0 +1,47 @@
+/**
+ * 微博搜索工作流 v1
+ *
+ * 流程：
+ * 1) 执行搜索
+ * 2) 采集搜索结果链接（支持翻页）
+ * 3) 从链接采集详情内容和评论
+ */
+
+export const weiboSearchWorkflowV1 = {
+  id: 'weibo-search-v1',
+  name: '微博搜索采集 v1',
+  steps: [
+    {
+      blockName: 'ExecuteWeiboSearchBlock',
+      input: {
+        sessionId: '$sessionId',
+        keyword: '$keyword',
+        env: '$env',
+        serviceUrl: '$serviceUrl',
+      },
+    },
+    {
+      blockName: 'WeiboCollectSearchLinksBlock',
+      input: {
+        sessionId: '$sessionId',
+        keyword: '$keyword',
+        env: '$env',
+        targetCount: '$targetCount',
+        maxPages: '$maxPages',
+        serviceUrl: '$serviceUrl',
+      },
+    },
+    {
+      blockName: 'WeiboCollectFromLinksBlock',
+      input: {
+        sessionId: '$sessionId',
+        keyword: '$keyword',
+        env: '$env',
+        targetCount: '$targetCount',
+        maxComments: '$maxComments',
+        collectComments: '$collectComments',
+        serviceUrl: '$serviceUrl',
+      },
+    },
+  ],
+};

package/modules/workflow/src/runner.ts

@@ -16,6 +16,9 @@ import * as XiaohongshuFullCollectBlock from '../blocks/XiaohongshuFullCollectBl
 import * as XiaohongshuCollectLinksBlock from '../blocks/XiaohongshuCollectLinksBlock.js';
 import * as XiaohongshuCollectFromLinksBlock from '../blocks/XiaohongshuCollectFromLinksBlock.js';
 import * as ErrorRecoveryBlock from '../blocks/ErrorRecoveryBlock.js';
+import * as ExecuteWeiboSearchBlock from '../blocks/ExecuteWeiboSearchBlock.js';
+import * as WeiboCollectFromLinksBlock from '../blocks/WeiboCollectFromLinksBlock.js';
+import * as WeiboCollectCommentsBlock from '../blocks/WeiboCollectCommentsBlock.js';
 import * as AnchorVerificationBlock from '../blocks/AnchorVerificationBlock.js';
 import * as CallWorkflowBlock from '../blocks/CallWorkflowBlock.js';
 import * as RecordFixtureBlock from '../blocks/RecordFixtureBlock.js';
@@ -43,6 +46,9 @@ export function createDefaultWorkflowExecutor(): WorkflowExecutor {
   executor.registerBlock('XiaohongshuCollectLinksBlock', { execute: XiaohongshuCollectLinksBlock.execute });
   executor.registerBlock('XiaohongshuCollectFromLinksBlock', { execute: XiaohongshuCollectFromLinksBlock.execute });
   executor.registerBlock('OrganizeXhsNotesBlock', { execute: OrganizeXhsNotesBlock.execute });
+  executor.registerBlock('ExecuteWeiboSearchBlock', { execute: ExecuteWeiboSearchBlock.execute });
+  executor.registerBlock('WeiboCollectFromLinksBlock', { execute: WeiboCollectFromLinksBlock.execute });
+  executor.registerBlock('WeiboCollectCommentsBlock', { execute: WeiboCollectCommentsBlock.execute });
   return executor;
 }
 

package/modules/xiaohongshu/app/src/blocks/Phase1StartProfileBlock.ts

@@ -152,7 +152,7 @@ export async function execute(input: StartProfileInput): Promise<StartProfileOut
       height: viewport.height,
     }, browserServiceUrl);
     console.log('[Phase1StartProfile] window positioned at (0,0)');
-  } catch (err) {
+  } catch (err: any) {
     console.warn('[Phase1StartProfile] window move failed:', err?.message || String(err));
   }
   console.log(`[Phase1StartProfile] viewport set: ${viewport.width}x${viewport.height}`);

package/modules/xiaohongshu/app/src/blocks/Phase34PersistDetailBlock.ts

@@ -8,6 +8,7 @@
  */
 
 import { promises as fs } from 'node:fs';
+import { getCurrentTimestamp } from '../../../../collection-manager/date-utils.js';
 import os from 'node:os';
 import path from 'node:path';
 
@@ -122,6 +123,9 @@ export async function execute(input: PersistDetailInput): Promise<PersistDetailO
     lines.push(`- **Note ID**: ${noteId}`);
     lines.push(`- **作者**: ${detail.authorName || '未知'} (${detail.authorId || 'N/A'})`);
     lines.push(`- **发布时间**: ${detail.publishTime || '未知'}`);
+    const ts = getCurrentTimestamp();
+    lines.push(`- **采集时间**: ${ts.collectedAt}`);
+    lines.push(`- **采集时间(本地)**: ${ts.collectedAtLocal}`);
     lines.push(`- **原始链接**: \`https://www.xiaohongshu.com/explore/${noteId}\``);
     lines.push('');
     lines.push(`## 正文`);

package/modules/xiaohongshu/app/src/blocks/Phase3InteractBlock.ts

@@ -183,7 +183,7 @@ function parseLikeRuleToken(token: string): LikeRule | null {
   const raw = String(token || '').trim();
   if (!raw) return null;
 
-  const m = raw.match(/^\\{\\s*(.+?)\\s*([+\\-\\uFF0B\\uFF0D])\\s*(.+?)\\s*\\}$/);
+  const m = raw.match(/^\{\s*(.+?)\s*([+\-\uFF0B\uFF0D])\s*(.+?)\s*\}$/);
   if (!m) {
     return { kind: 'contains', include: raw, raw };
   }
@@ -192,7 +192,7 @@ function parseLikeRuleToken(token: string): LikeRule | null {
   const right = normalizeText(m[3]);
   if (!left || !right) return null;
 
-  const op = m[2] === '\\uFF0B' ? '+' : m[2] === '\\uFF0D' ? '-' : m[2];
+  const op = m[2] === '\uFF0B' ? '+' : m[2] === '\uFF0D' ? '-' : m[2];
   if (op === '+') {
     return { kind: 'and', includeA: left, includeB: right, raw: `{${left} + ${right}}` };
   }
@@ -1228,4 +1228,3 @@ export async function execute(input: InteractInput): Promise<InteractOutput> {
     stopReason: reachedBottom ? bottomReason : undefined,
   };
 }
-

package/modules/xiaohongshu/app/src/blocks/helpers/sharding.ts

@@ -1,9 +1,106 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+
+// Simplified inline types to avoid module resolution issues
+interface XhsCollectedUrl {
+  noteId: string;
+  safeUrl: string;
+  searchUrl?: string;
+  timestamp?: number;
+}
+
+function sanitizeForPath(name: string, fallback = 'unknown'): string {
+  const text = String(name || '').trim();
+  if (!text) return fallback;
+  const cleaned = text.replace(/[\\/:"*?<>|]+/g, '_').trim();
+  return cleaned || fallback;
+}
+
+function asStringArray(input: unknown): string[] {
+  if (!Array.isArray(input)) return [];
+  return input
+    .map((item) => String(item || '').trim())
+    .filter(Boolean);
+}
+
+function normalizeCollectedUrls(input: unknown, completedNoteIds: Set<string>): XhsCollectedUrl[] {
+  if (!Array.isArray(input)) return [];
+  const out: XhsCollectedUrl[] = [];
+  const seen = new Set<string>();
+  for (const row of input) {
+    if (!row || typeof row !== 'object') continue;
+    const noteId = String((row as Record<string, unknown>).noteId || '').trim();
+    if (!noteId || completedNoteIds.has(noteId) || seen.has(noteId)) continue;
+    seen.add(noteId);
+    const safeUrl = String((row as Record<string, unknown>).safeUrl || '').trim();
+    const searchUrl = String((row as Record<string, unknown>).searchUrl || '').trim();
+    const timestampRaw = Number((row as Record<string, unknown>).timestamp);
+    const item: XhsCollectedUrl = {
+      noteId,
+      safeUrl,
+      ...(searchUrl ? { searchUrl } : {}),
+      ...(Number.isFinite(timestampRaw) ? { timestamp: timestampRaw } : {}),
+    };
+    out.push(item);
+  }
+  return out;
+}
+
+async function resolveStatePath(input: { keyword: string; env: string; downloadRoot?: string }): Promise<string | null> {
+  const root = resolveDownloadRoot(input.downloadRoot);
+  const sanitizedEnv = sanitizeForPath(input.env, 'debug');
+  const sanitizedKeyword = sanitizeForPath(input.keyword, 'unknown');
+  const rawEnv = String(input.env || '').trim();
+  const rawKeyword = String(input.keyword || '').trim();
+
+  const candidates = [
+    path.join(root, 'xiaohongshu', sanitizedEnv, sanitizedKeyword, '.collect-state.json'),
+  ];
+  const legacyPath = path.join(root, 'xiaohongshu', rawEnv, rawKeyword, '.collect-state.json');
+  if (legacyPath !== candidates[0]) candidates.push(legacyPath);
+
+  for (const filePath of candidates) {
+    try {
+      await fs.access(filePath);
+      return filePath;
+    } catch {
+      // continue
+    }
+  }
+  return null;
+}
+
+async function getXhsPendingItems(input: { keyword: string; env: string; downloadRoot?: string }): Promise<XhsCollectedUrl[]> {
+  const statePath = await resolveStatePath(input);
+  if (!statePath) return [];
+  try {
+    const content = await fs.readFile(statePath, 'utf8');
+    const state = JSON.parse(content) as Record<string, any>;
+    const completed = new Set(asStringArray(state?.detailCollection?.completedNoteIds));
+    return normalizeCollectedUrls(state?.listCollection?.collectedUrls, completed);
+  } catch (error: any) {
+    const code = String(error?.code || '');
+    const kind = code === 'ENOENT' ? 'missing_state' : code === 'EACCES' ? 'access_denied' : 'invalid_state';
+    console.warn(
+      `[xhs.sharding] failed to load pending items (${kind}) from ${statePath}: ${error?.message || String(error)}`,
+    );
+    return [];
+  }
+}
+
 export interface ShardSpec {
   index: number;
   count: number;
   by?: 'noteId-hash' | 'index-mod';
 }
 
+export interface DynamicShardPlan {
+  profileId: string;
+  assignedNoteIds: string[];
+  totalPending: number;
+}
+
 export function fnv1a32(input: string) {
   // FNV-1a 32-bit
   let hash = 0x811c9dc5;
@@ -41,3 +138,58 @@ export function shardFilterByIndexMod<T>(items: T[], shard: ShardSpec) {
   if (shard.count <= 1) return list;
   return list.filter((_, idx) => idx % shard.count === shard.index);
 }
+
+export function resolveDownloadRoot(customRoot?: string): string {
+  const fromArg = String(customRoot || '').trim();
+  if (fromArg) return path.resolve(fromArg);
+  const fromEnv = String(process.env.WEBAUTO_DOWNLOAD_ROOT || process.env.WEBAUTO_DOWNLOAD_DIR || '').trim();
+  if (fromEnv) return path.resolve(fromEnv);
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  return path.join(home!, '.webauto', 'download');
+}
+
+export async function buildDynamicShardPlan(input: {
+  keyword: string;
+  env: string;
+  downloadRoot?: string;
+  validProfiles: string[];
+}): Promise<DynamicShardPlan[]> {
+  const { keyword, env, downloadRoot, validProfiles } = input;
+  if (!validProfiles.length) return [];
+
+  // Load pending items (not completed yet)
+  const pendingItems = await getXhsPendingItems({ keyword, env, downloadRoot });
+  if (pendingItems.length === 0) {
+    return validProfiles.map((profileId: string) => ({ profileId, assignedNoteIds: [] as string[], totalPending: 0 }));
+  }
+
+  // Calculate how many notes each profile should handle
+  // Using ceil to ensure we cover all pending items
+  const perProfileCount = Math.ceil(pendingItems.length / validProfiles.length);
+  
+  const plans: DynamicShardPlan[] = [];
+  for (let i = 0; i < validProfiles.length; i++) {
+    const profileId = validProfiles[i];
+    const startIdx = i * perProfileCount;
+    const endIdx = Math.min(startIdx + perProfileCount, pendingItems.length);
+    const assignedNoteIds: string[] = pendingItems.slice(startIdx, endIdx).map((item: XhsCollectedUrl) => item.noteId);
+    plans.push({
+      profileId,
+      assignedNoteIds,
+      totalPending: pendingItems.length,
+    });
+  }
+
+  return plans;
+}
+
+export async function getPendingItemsByNoteIds(input: {
+  keyword: string;
+  env: string;
+  downloadRoot?: string;
+  noteIds: string[];
+}): Promise<XhsCollectedUrl[]> {
+  const pendingItems = await getXhsPendingItems({ keyword: input.keyword, env: input.env, downloadRoot: input.downloadRoot });
+  const noteIdSet = new Set(input.noteIds);
+  return pendingItems.filter((item: XhsCollectedUrl) => noteIdSet.has(item.noteId));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-auto/webauto",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "bin": {
     "webauto": "bin/webauto.mjs"
@@ -14,6 +14,7 @@
     "apps/desktop-console/dist/",
     "apps/desktop-console/default-settings.json",
     "apps/desktop-console/entry/ui-console.mjs",
+    "apps/desktop-console/entry/ui-cli.mjs",
     "apps/webauto/",
     "!dist/**/*.map",
     "!dist/**/__tests__/**",
@@ -46,6 +47,7 @@
     "ws": "^8.19.0"
   },
   "scripts": {
+    "postinstall": "node scripts/postinstall-resources.mjs",
     "start:mcp:browser": "npx @browsermcp/mcp@latest",
     "build": "npm run prebuild && npm run build:services && npm run self-check:post-build && npm run ui:test && npm --prefix apps/desktop-console run build",
     "build:services": "tsc -p tsconfig.services.json",
@@ -57,10 +59,17 @@
     "check:modules": "echo \"Module checks skipped\"",
     "check:ts": "tsc --noEmit -p tsconfig.services.json",
     "test:modules:unit": "npx tsx --test $(find modules -name \"*.test.ts\" -o -name \"*.test.mts\" 2>/dev/null | tr \"\\n\" \" \")",
-    "test:desktop-console:unit": "tsx --test apps/desktop-console/src/main/profile-store.test.mts apps/desktop-console/src/main/index-streaming.test.mts",
+    "test:desktop-console:unit": "tsx --test apps/desktop-console/src/main/profile-store.test.mts apps/desktop-console/src/main/index-streaming.test.mts apps/desktop-console/src/main/ui-cli-bridge.test.mts apps/desktop-console/src/main/heartbeat-watchdog.test.mts apps/desktop-console/src/main/core-daemon-manager.test.mts apps/desktop-console/src/main/desktop-settings.test.mts apps/desktop-console/src/main/env-check.test.mts",
     "test:desktop-console:renderer": "npm --prefix apps/desktop-console run test:renderer",
-    "test:desktop-console:coverage": "c8 --reporter=text --reporter=lcov --all --src apps/desktop-console/src/main --extension .mts --extension .mjs --exclude \"**/*.test.mts\" --include \"apps/desktop-console/src/main/profile-store.mts\" tsx --test apps/desktop-console/src/main/profile-store.test.mts",
-    "test": "npm run check:modules && npm run check:ts && npm run test:modules:unit && npm run test:desktop-console:unit && npm run test:services:unit",
+    "test:desktop-console:coverage": "c8 --reporter=text --reporter=lcov --all --src apps/desktop-console/src/main --extension .mts --extension .mjs --extension .ts --exclude \"**/*.test.*\" --check-coverage --lines 75 --functions 75 --branches 55 --statements 75 --include \"apps/desktop-console/src/main/profile-store.mts\" --include \"apps/desktop-console/src/main/ui-cli-bridge.mts\" --include \"apps/desktop-console/src/main/heartbeat-watchdog.mts\" --include \"apps/desktop-console/src/main/core-daemon-manager.mts\" --include \"apps/desktop-console/src/main/desktop-settings.mts\" --include \"apps/desktop-console/src/main/env-check.mts\" tsx --test apps/desktop-console/src/main/profile-store.test.mts apps/desktop-console/src/main/index-streaming.test.mts apps/desktop-console/src/main/ui-cli-bridge.test.mts apps/desktop-console/src/main/heartbeat-watchdog.test.mts apps/desktop-console/src/main/core-daemon-manager.test.mts apps/desktop-console/src/main/desktop-settings.test.mts apps/desktop-console/src/main/env-check.test.mts",
+    "test:webauto:schedule:unit": "node --test tests/unit/webauto/schedule-store.test.mjs tests/unit/webauto/schedule-cli.test.mjs",
+    "test:webauto:ui-cli:unit": "node --test tests/unit/webauto/ui-cli-command.test.mjs",
+    "test:webauto:install:unit": "node --test tests/unit/webauto/xhs-install.test.mjs",
+    "test:webauto:schedule:coverage": "c8 --reporter=text --reporter=text-summary --check-coverage --lines 85 --functions 85 --branches 60 --statements 85 --include apps/webauto/entry/lib/schedule-store.mjs --include apps/webauto/entry/schedule.mjs node --test tests/unit/webauto/schedule-store.test.mjs tests/unit/webauto/schedule-cli.test.mjs",
+    "test:ci": "npm test && npm --prefix apps/desktop-console run test:renderer",
+    "coverage:ci": "node scripts/test/run-coverage.mjs",
+    "build:release": "node bin/webauto.mjs build:release",
+    "test": "npm run check:modules && npm run check:ts && npm run test:modules:unit && npm run test:webauto:schedule:unit && npm run test:webauto:ui-cli:unit && npm run test:webauto:install:unit && npm run test:desktop-console:unit && npm run test:services:unit",
     "cli:session-manager": "tsx modules/session-manager/src/cli.ts",
     "cli:logging": "tsx modules/logging/src/cli.ts",
     "cli:operations": "tsx modules/operations/src/cli.ts",

package/scripts/postinstall-resources.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function shouldSkipAutoPrepare() {
+  if (String(process.env.WEBAUTO_SKIP_AUTO_RESOURCES || '').trim() === '1') {
+    return { skip: true, reason: 'WEBAUTO_SKIP_AUTO_RESOURCES=1' };
+  }
+  if (String(process.env.CI || '').trim().toLowerCase() === 'true') {
+    return { skip: true, reason: 'CI=true' };
+  }
+  const force = String(process.env.WEBAUTO_AUTO_RESOURCES || '').trim() === '1';
+  if (!force && existsSync(path.join(ROOT, '.git'))) {
+    return { skip: true, reason: 'dev_repo_detected' };
+  }
+  return { skip: false, reason: '' };
+}
+
+function runAutoPrepare() {
+  const script = path.join(ROOT, 'apps', 'webauto', 'entry', 'xhs-install.mjs');
+  const ret = spawnSync(process.execPath, [script, '--auto', '--all', '--json'], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    windowsHide: true,
+    timeout: 10 * 60 * 1000,
+  });
+  return ret;
+}
+
+function main() {
+  const gate = shouldSkipAutoPrepare();
+  if (gate.skip) {
+    console.log(`[webauto:postinstall] skip auto resource prepare (${gate.reason})`);
+    return;
+  }
+
+  console.log('[webauto:postinstall] auto preparing resources (camoufox + geoip)...');
+  const ret = runAutoPrepare();
+  const stdout = String(ret.stdout || '').trim();
+  const stderr = String(ret.stderr || '').trim();
+  if (stdout) console.log(`[webauto:postinstall] ${stdout}`);
+  if (stderr) console.warn(`[webauto:postinstall] ${stderr}`);
+
+  if (ret.status === 0) {
+    console.log('[webauto:postinstall] resource prepare done');
+    return;
+  }
+
+  const strict = String(process.env.WEBAUTO_AUTO_RESOURCES_STRICT || '').trim() === '1';
+  const message = `[webauto:postinstall] auto resource prepare failed (exit=${ret.status ?? 'null'}). You can run: webauto deps install --all`;
+  if (strict) {
+    console.error(message);
+    process.exit(ret.status || 1);
+  }
+  console.warn(message);
+}
+
+main();

package/scripts/test/run-coverage.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+
+const ROOT = process.cwd();
+
+function resolveOnPath(candidates) {
+  const pathEnv = process.env.PATH || process.env.Path || '';
+  const dirs = pathEnv.split(path.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const name of candidates) {
+      const full = path.join(dir, name);
+      if (existsSync(full)) return full;
+    }
+  }
+  return null;
+}
+
+function npmRunner() {
+  if (process.platform !== 'win32') return { cmd: 'npm', prefix: [] };
+  const resolved = resolveOnPath(['npm.cmd', 'npm.exe', 'npm.bat', 'npm.ps1']) || 'npm.cmd';
+  const lower = String(resolved).toLowerCase();
+  if (lower.endsWith('.ps1')) {
+    return {
+      cmd: 'powershell.exe',
+      prefix: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', resolved],
+    };
+  }
+  if (lower.endsWith('.cmd') || lower.endsWith('.bat')) {
+    return {
+      cmd: 'cmd.exe',
+      prefix: ['/d', '/s', '/c', resolved],
+    };
+  }
+  return { cmd: resolved, prefix: [] };
+}
+
+async function run(label, cmd, args, cwd = ROOT) {
+  await new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd,
+      env: process.env,
+      stdio: 'inherit',
+      windowsHide: true,
+    });
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) return resolve();
+      reject(new Error(`${label} failed with exit ${code}`));
+    });
+  });
+}
+
+async function main() {
+  const npm = npmRunner();
+  const runNpm = async (label, args) => run(label, npm.cmd, [...npm.prefix, ...args], ROOT);
+
+  console.log('[coverage] running root desktop main coverage');
+  await runNpm('test:desktop-console:coverage', ['run', 'test:desktop-console:coverage']);
+
+  // Renderer suites are already enforced by `test:ci`.
+  // Keep this stage focused on deterministic coverage gates that are stable in CI.
+  console.log('[coverage] running desktop renderer smoke tests');
+  await runNpm('desktop renderer tests', ['--prefix', 'apps/desktop-console', 'run', 'test:renderer']);
+
+  console.log('[coverage] running webauto schedule coverage');
+  await runNpm('test:webauto:schedule:coverage', ['run', 'test:webauto:schedule:coverage']);
+
+  console.log('[coverage] done');
+}
+
+main().catch((err) => {
+  console.error('[coverage] failed:', err?.message || String(err));
+  process.exit(1);
+});

package/scripts/weibo/search.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env npx tsx
+/**
+ * Weibo Search Collection CLI
+ * 
+ * Usage:
+ *   webauto weibo search --profile <profile> --keyword <keyword> --target <count> [--mode fresh|incremental]
+ */
+
+import { Command } from 'commander';
+import { WeiboCollectSearchLinksBlock } from '../../modules/workflow/blocks/WeiboCollectSearchLinksBlock';
+import type { BlockContext } from '../../modules/workflow/types';
+
+const program = new Command();
+
+program
+  .name('webauto weibo search')
+  .description('Collect Weibo posts from search results')
+  .requiredOption('--profile <profile>', 'Browser profile to use')
+  .requiredOption('--keyword <keyword>', 'Search keyword')
+  .requiredOption('--target <count>', 'Target number of posts', parseInt)
+  .option('--mode <mode>', 'Collection mode: fresh or incremental', 'incremental')
+  .option('--max-pages <pages>', 'Maximum pages to search (0 = unlimited)', parseInt, 0)
+  .option('--env <env>', 'Environment (debug/production)', 'debug')
+  .parse(process.argv);
+
+const options = program.opts();
+
+async function main() {
+  console.log(`[Weibo Search] Starting collection`);
+  console.log(`  Profile: ${options.profile}`);
+  console.log(`  Keyword: ${options.keyword}`);
+  console.log(`  Target: ${options.target}`);
+  console.log(`  Mode: ${options.mode}`);
+  
+  // Use camo CLI for browser context
+  const { spawn } = await import('child_process');
+  const { promisify } = await import('util');
+  const exec = promisify(require('child_process').exec);
+  
+  // Create context via camo
+  const { stdout } = await exec(`camo start ${options.profile} --url https://s.weibo.com/weibo --alias weibo-search`);
+  console.log(stdout);
+  
+  // TODO: Connect to the browser via CDP and run the block
+  // For now, we output the configuration
+  console.log('\n[Ready] Browser started. Run the collection via UI.');
+}
+
+main().catch(console.error);

package/services/shared/serviceProcessLogger.ts

@@ -32,7 +32,7 @@ function ensureLogDir(): string {
 
 function safeAppend(filePath: string, line: string): void {
   try {
-    fs.appendFileSync(filePath, line);
+    fs.appendFileSync(filePath, line, 'utf8');
   } catch {
     // ignore
   }