@web-auto/webauto 0.1.4 → 0.1.6

package/modules/process-registry/index.ts

@@ -0,0 +1,284 @@
+/**
+ * ProcessRegistry - 进程生命周期管理
+ */
+
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { execSync } from 'node:child_process';
+
+export type ProcessType = 'weibo-search' | 'weibo-detail' | 'xhs-search' | 'xhs-detail' | 'xhs-interact';
+
+export interface ProcessEntry {
+  pid: number;
+  type: ProcessType;
+  profileId: string;
+  keyword?: string;
+  startedAt: number;
+  lastHeartbeat: number;
+  status: 'running' | 'stale' | 'dead';
+  metadata?: Record<string, any>;
+}
+
+export interface ProcessRegistryConfig {
+  heartbeatIntervalMs: number;
+  staleTimeoutMs: number;
+  cleanupIntervalMs: number;
+}
+
+const DEFAULT_CONFIG: ProcessRegistryConfig = {
+  heartbeatIntervalMs: 30000,
+  staleTimeoutMs: 120000,
+  cleanupIntervalMs: 60000,
+};
+
+function resolveRegistryPath(): string {
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  return path.join(home, '.webauto', 'process-registry.json');
+}
+
+export class ProcessRegistry {
+  private static instance: ProcessRegistry | null = null;
+  
+  private entries: Map<number, ProcessEntry> = new Map();
+  private registryPath: string;
+  private config: ProcessRegistryConfig;
+  private ownPid: number;
+  private heartbeatTimer: NodeJS.Timeout | null = null;
+  private cleanupTimer: NodeJS.Timeout | null = null;
+  private initialized = false;
+  private shutdownHandlersRegistered = false;
+  
+  private constructor(config: Partial<ProcessRegistryConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.registryPath = resolveRegistryPath();
+    this.ownPid = process.pid;
+  }
+  
+  static getInstance(config?: Partial<ProcessRegistryConfig>): ProcessRegistry {
+    if (!ProcessRegistry.instance) {
+      ProcessRegistry.instance = new ProcessRegistry(config);
+    }
+    return ProcessRegistry.instance;
+  }
+  
+  async init(): Promise<void> {
+    if (this.initialized) return;
+    
+    try {
+      const content = await fs.readFile(this.registryPath, 'utf-8');
+      const data = JSON.parse(content);
+      for (const entry of Object.values(data) as ProcessEntry[]) {
+        this.entries.set(entry.pid, entry);
+      }
+      console.log('[ProcessRegistry] Loaded', this.entries.size, 'entries');
+    } catch {
+      // 无记录
+    }
+    
+    this.startCleanupTimer();
+    this.initialized = true;
+  }
+  
+  async register(
+    type: ProcessType,
+    profileId: string,
+    metadata?: { keyword?: string; [key: string]: any }
+  ): Promise<number> {
+    await this.init();
+    
+    const entry: ProcessEntry = {
+      pid: this.ownPid,
+      type,
+      profileId,
+      keyword: metadata?.keyword,
+      startedAt: Date.now(),
+      lastHeartbeat: Date.now(),
+      status: 'running',
+      metadata,
+    };
+    
+    this.entries.set(this.ownPid, entry);
+    await this.persist();
+    
+    console.log(`[ProcessRegistry] Registered: pid=${this.ownPid} type=${type} profile=${profileId}`);
+    
+    this.startHeartbeat();
+    
+    // 注册一次 exit 处理器
+    if (!this.shutdownHandlersRegistered) {
+      this.registerShutdownHandlers();
+      this.shutdownHandlersRegistered = true;
+    }
+    
+    return this.ownPid;
+  }
+  
+  private registerShutdownHandlers(): void {
+    const handler = async () => {
+      await this.unregister();
+    };
+    
+    process.once('SIGINT', handler);
+    process.once('SIGTERM', handler);
+    process.once('beforeExit', handler);
+  }
+  
+  heartbeat(): void {
+    const entry = this.entries.get(this.ownPid);
+    if (entry) {
+      entry.lastHeartbeat = Date.now();
+      entry.status = 'running';
+      this.persist().catch(() => {});
+    }
+  }
+  
+  async unregister(): Promise<void> {
+    if (!this.entries.has(this.ownPid)) return;
+    
+    this.stopHeartbeat();
+    this.entries.delete(this.ownPid);
+    await this.persist();
+    console.log(`[ProcessRegistry] Unregistered: pid=${this.ownPid}`);
+  }
+  
+  getAll(): ProcessEntry[] {
+    return Array.from(this.entries.values());
+  }
+  
+  getRunning(): ProcessEntry[] {
+    return this.getAll().filter(e => e.status === 'running');
+  }
+  
+  async cleanStale(): Promise<{ cleaned: number; killed: string[] }> {
+    await this.init();
+    
+    const now = Date.now();
+    const cleaned: string[] = [];
+    
+    for (const [pid, entry] of this.entries) {
+      if (pid === this.ownPid) continue;
+      
+      if (now - entry.lastHeartbeat > this.config.staleTimeoutMs) {
+        entry.status = 'stale';
+        const isAlive = this.isProcessAlive(pid);
+        
+        if (!isAlive) {
+          this.entries.delete(pid);
+          cleaned.push(`pid=${pid} (dead)`);
+          await this.cleanupBrowserSession(entry.profileId);
+        } else {
+          console.log(`[ProcessRegistry] Killing stale process: pid=${pid} type=${entry.type}`);
+          this.killProcess(pid);
+          this.entries.delete(pid);
+          cleaned.push(`pid=${pid} (killed)`);
+          await this.cleanupBrowserSession(entry.profileId);
+        }
+      }
+    }
+    
+    if (cleaned.length > 0) {
+      await this.persist();
+      console.log(`[ProcessRegistry] Cleaned ${cleaned.length} stale entries`);
+    }
+    
+    return { cleaned: cleaned.length, killed: cleaned };
+  }
+  
+  getStatus(): { pid: number; type: ProcessType; profileId: string; uptime: number } | null {
+    const entry = this.entries.get(this.ownPid);
+    if (!entry) return null;
+    
+    return {
+      pid: entry.pid,
+      type: entry.type,
+      profileId: entry.profileId,
+      uptime: Date.now() - entry.startedAt,
+    };
+  }
+  
+  private startHeartbeat(): void {
+    if (this.heartbeatTimer) return;
+    
+    this.heartbeatTimer = setInterval(() => {
+      this.heartbeat();
+    }, this.config.heartbeatIntervalMs);
+    
+    this.heartbeatTimer.unref();
+  }
+  
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  
+  private startCleanupTimer(): void {
+    if (this.cleanupTimer) return;
+    
+    this.cleanupTimer = setInterval(() => {
+      this.cleanStale().catch(() => {});
+    }, this.config.cleanupIntervalMs);
+    
+    this.cleanupTimer.unref();
+  }
+  
+  private isProcessAlive(pid: number): boolean {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  
+  private killProcess(pid: number): void {
+    try {
+      if (process.platform === 'win32') {
+        execSync(`taskkill /PID ${pid} /T /F`, { stdio: 'ignore' });
+      } else {
+        process.kill(pid, 'SIGTERM');
+        setTimeout(() => {
+          if (this.isProcessAlive(pid)) {
+            try { process.kill(pid, 'SIGKILL'); } catch {}
+          }
+        }, 5000);
+      }
+    } catch {}
+  }
+  
+  private async cleanupBrowserSession(profileId: string): Promise<void> {
+    try {
+      execSync(`camo stop ${profileId}`, { stdio: 'ignore', timeout: 10000 });
+      console.log(`[ProcessRegistry] Cleaned browser: ${profileId}`);
+    } catch {}
+  }
+  
+  private async persist(): Promise<void> {
+    try {
+      const dir = path.dirname(this.registryPath);
+      await fs.mkdir(dir, { recursive: true });
+      
+      const data: Record<number, ProcessEntry> = {};
+      for (const [pid, entry] of this.entries) {
+        data[pid] = entry;
+      }
+      
+      await fs.writeFile(this.registryPath, JSON.stringify(data, null, 2), 'utf-8');
+    } catch (err) {
+      console.error('[ProcessRegistry] Failed to persist:', err);
+    }
+  }
+  
+  async shutdown(): Promise<void> {
+    this.stopHeartbeat();
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    await this.unregister();
+  }
+}
+
+export const processRegistry = ProcessRegistry.getInstance();

package/modules/rate-limiter/index.ts

@@ -0,0 +1,322 @@
+/**
+ * RateLimiter - 统一流控配额系统
+ *
+ * 功能：
+ * - 管理 search/like/comment 等操作的配额
+ * - 支持多维度限制（关键字、profile、全局）
+ * - 可配置规则，支持持久化
+ *
+ * 使用方式：
+ *   const limiter = RateLimiter.getInstance();
+ *   const result = await limiter.acquire('search', { keyword: '春晚' });
+ *   if (!result.granted) {
+ *     console.log(`被拒绝: ${result.reason}, 需等待 ${result.waitMs}ms`);
+ *     return;
+ *   }
+ *   // 执行搜索...
+ *   await limiter.record('search', { keyword: '春晚' });
+ */
+
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+
+// 配额类型
+export type QuotaType = 'search' | 'like' | 'comment' | 'follow' | 'repost';
+
+// 配额范围
+export type QuotaScope = 'keyword' | 'profile' | 'global';
+
+// 规则定义
+export interface QuotaRule {
+  scope: QuotaScope;
+  windowMs: number;      // 时间窗口（毫秒）
+  max: number;           // 窗口内最大次数
+  key?: string;          // 可读描述
+}
+
+// 配额类型配置
+export interface QuotaConfig {
+  rules: QuotaRule[];
+}
+
+// 完整配置
+export interface RateLimiterConfig {
+  [type: string]: QuotaConfig;
+}
+
+// 历史记录条目
+interface HistoryEntry {
+  ts: number;            // 时间戳
+  key: string;           // 维度键（如 keyword:春晚, profile:xxx）
+}
+
+// 申请结果
+export interface AcquireResult {
+  granted: boolean;
+  reason?: string;
+  waitMs?: number;       // 建议等待时间
+  ruleKey?: string;      // 触发的规则
+}
+
+// 默认配置
+const DEFAULT_CONFIG: RateLimiterConfig = {
+  search: {
+    rules: [
+      { scope: 'keyword', windowMs: 600000, max: 3, key: '同一关键字10分钟内最多3次' },
+      { scope: 'global', windowMs: 60000, max: 10, key: '全局搜索1分钟内最多10次' },
+    ],
+  },
+  like: {
+    rules: [
+      { scope: 'profile', windowMs: 60000, max: 6, key: '同一账号1分钟内最多点赞6次' },
+      { scope: 'profile', windowMs: 3600000, max: 100, key: '同一账号1小时内最多点赞100次' },
+    ],
+  },
+  comment: {
+    rules: [
+      { scope: 'profile', windowMs: 60000, max: 1, key: '同一账号1分钟内最多评论1次' },
+      { scope: 'profile', windowMs: 3600000, max: 30, key: '同一账号1小时内最多评论30次' },
+    ],
+  },
+  follow: {
+    rules: [
+      { scope: 'profile', windowMs: 60000, max: 2, key: '同一账号1分钟内最多关注2次' },
+      { scope: 'profile', windowMs: 3600000, max: 20, key: '同一账号1小时内最多关注20次' },
+    ],
+  },
+  repost: {
+    rules: [
+      { scope: 'profile', windowMs: 60000, max: 1, key: '同一账号1分钟内最多转发1次' },
+      { scope: 'profile', windowMs: 3600000, max: 10, key: '同一账号1小时内最多转发10次' },
+    ],
+  },
+};
+
+function resolveConfigPath(): string {
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  return path.join(home, '.webauto', 'config', 'rate-limits.json');
+}
+
+function resolveHistoryPath(): string {
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  return path.join(home, '.webauto', 'rate-limiter-history.json');
+}
+
+export class RateLimiter {
+  private static instance: RateLimiter | null = null;
+  
+  private config: RateLimiterConfig;
+  private history: Map<string, HistoryEntry[]> = new Map();
+  private configPath: string;
+  private historyPath: string;
+  private initialized = false;
+  
+  private constructor() {
+    this.config = { ...DEFAULT_CONFIG };
+    this.configPath = resolveConfigPath();
+    this.historyPath = resolveHistoryPath();
+  }
+  
+  static getInstance(): RateLimiter {
+    if (!RateLimiter.instance) {
+      RateLimiter.instance = new RateLimiter();
+    }
+    return RateLimiter.instance;
+  }
+  
+  // 初始化：加载配置和历史
+  async init(): Promise<void> {
+    if (this.initialized) return;
+    
+    // 加载用户配置（覆盖默认值）
+    try {
+      const content = await fs.readFile(this.configPath, 'utf-8');
+      const userConfig = JSON.parse(content);
+      this.config = { ...DEFAULT_CONFIG, ...userConfig };
+      console.log('[RateLimiter] Loaded user config from', this.configPath);
+    } catch {
+      // 使用默认配置
+    }
+    
+    // 加载历史记录
+    try {
+      const content = await fs.readFile(this.historyPath, 'utf-8');
+      const data = JSON.parse(content);
+      for (const [key, entries] of Object.entries(data)) {
+        this.history.set(key, entries as HistoryEntry[]);
+      }
+      // 清理过期历史
+      this.cleanExpiredHistory();
+    } catch {
+      // 无历史记录
+    }
+    
+    this.initialized = true;
+  }
+  
+  // 申请配额
+  async acquire(
+    type: QuotaType,
+    params: { keyword?: string; profileId?: string; platform?: string }
+  ): Promise<AcquireResult> {
+    await this.init();
+    
+    const typeConfig = this.config[type];
+    if (!typeConfig) {
+      return { granted: true }; // 无配置的类型默认允许
+    }
+    
+    const now = Date.now();
+    
+    for (const rule of typeConfig.rules) {
+      const key = this.buildKey(type, rule.scope, params);
+      const entries = this.history.get(key) || [];
+      
+      // 统计窗口内的次数
+      const windowStart = now - rule.windowMs;
+      const count = entries.filter(e => e.ts > windowStart).length;
+      
+      if (count >= rule.max) {
+        // 找到最早的过期时间，计算等待时间
+        const oldestInWindow = entries.find(e => e.ts > windowStart);
+        const waitMs = oldestInWindow ? (oldestInWindow.ts + rule.windowMs - now) : rule.windowMs;
+        
+        return {
+          granted: false,
+          reason: rule.key || `配额已用尽: ${rule.scope} ${rule.windowMs}ms 内最多 ${rule.max} 次`,
+          waitMs: Math.max(0, waitMs),
+          ruleKey: `${type}:${rule.scope}:${rule.windowMs}`,
+        };
+      }
+    }
+    
+    return { granted: true };
+  }
+  
+  // 记录执行
+  async record(
+    type: QuotaType,
+    params: { keyword?: string; profileId?: string; platform?: string }
+  ): Promise<void> {
+    await this.init();
+    
+    const typeConfig = this.config[type];
+    if (!typeConfig) return;
+    
+    const now = Date.now();
+    
+    // 为所有相关维度记录
+    for (const rule of typeConfig.rules) {
+      const key = this.buildKey(type, rule.scope, params);
+      const entries = this.history.get(key) || [];
+      entries.push({ ts: now, key });
+      this.history.set(key, entries);
+    }
+    
+    // 持久化历史（异步，不阻塞）
+    this.persistHistory().catch(() => {});
+  }
+  
+  // 构建维度键
+  private buildKey(
+    type: QuotaType,
+    scope: QuotaScope,
+    params: { keyword?: string; profileId?: string; platform?: string }
+  ): string {
+    switch (scope) {
+      case 'keyword':
+        return `${type}:keyword:${params.keyword || '*'}`;
+      case 'profile':
+        return `${type}:profile:${params.profileId || '*'}`;
+      case 'global':
+        return `${type}:global`;
+      default:
+        return `${type}:unknown`;
+    }
+  }
+  
+  // 清理过期历史
+  private cleanExpiredHistory(): void {
+    const now = Date.now();
+    const maxWindow = 3600000; // 1小时
+    
+    for (const [key, entries] of this.history) {
+      const filtered = entries.filter(e => now - e.ts < maxWindow);
+      if (filtered.length === 0) {
+        this.history.delete(key);
+      } else if (filtered.length !== entries.length) {
+        this.history.set(key, filtered);
+      }
+    }
+  }
+  
+  // 持久化历史
+  private async persistHistory(): Promise<void> {
+    try {
+      const dir = path.dirname(this.historyPath);
+      await fs.mkdir(dir, { recursive: true });
+      
+      const data: Record<string, HistoryEntry[]> = {};
+      for (const [key, entries] of this.history) {
+        data[key] = entries;
+      }
+      
+      await fs.writeFile(this.historyPath, JSON.stringify(data), 'utf-8');
+    } catch (err) {
+      console.error('[RateLimiter] Failed to persist history:', err);
+    }
+  }
+  
+  // 获取当前配置
+  getConfig(): RateLimiterConfig {
+    return { ...this.config };
+  }
+  
+  // 更新配置
+  async updateConfig(newConfig: Partial<RateLimiterConfig>): Promise<void> {
+    this.config = { ...this.config, ...newConfig };
+    
+    try {
+      const dir = path.dirname(this.configPath);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2), 'utf-8');
+      console.log('[RateLimiter] Config saved to', this.configPath);
+    } catch (err) {
+      console.error('[RateLimiter] Failed to save config:', err);
+    }
+  }
+  
+  // 获取状态（用于调试/UI）
+  getStatus(): { type: QuotaType; scope: QuotaScope; count: number; max: number; windowMs: number }[] {
+    const result: { type: QuotaType; scope: QuotaScope; count: number; max: number; windowMs: number }[] = [];
+    const now = Date.now();
+    
+    for (const [type, typeConfig] of Object.entries(this.config)) {
+      for (const rule of typeConfig.rules) {
+        const key = `${type}:${rule.scope}`;
+        let totalCount = 0;
+        
+        for (const [k, entries] of this.history) {
+          if (k.startsWith(key)) {
+            const windowStart = now - rule.windowMs;
+            totalCount += entries.filter(e => e.ts > windowStart).length;
+          }
+        }
+        
+        result.push({
+          type: type as QuotaType,
+          scope: rule.scope,
+          count: totalCount,
+          max: rule.max,
+          windowMs: rule.windowMs,
+        });
+      }
+    }
+    
+    return result;
+  }
+}
+
+// 单例导出
+export const rateLimiter = RateLimiter.getInstance();

package/modules/state/src/paths.ts

@@ -1,5 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
+import { existsSync } from 'node:fs';
 
 export function resolveHomeDir(): string {
   const fromEnv = process.platform === 'win32' ? process.env.USERPROFILE : process.env.HOME;
@@ -11,6 +12,14 @@ export function resolveHomeDir(): string {
 export function resolveDownloadRoot(): string {
   const custom = String(process.env.WEBAUTO_DOWNLOAD_ROOT || process.env.WEBAUTO_DOWNLOAD_DIR || '').trim();
   if (custom) return custom;
+  if (process.platform === 'win32') {
+    try {
+      if (existsSync('D:\\')) return 'D:\\webauto';
+    } catch {
+      // ignore
+    }
+    return path.join(resolveHomeDir(), '.webauto');
+  }
   return path.join(resolveHomeDir(), '.webauto', 'download');
 }
 
@@ -29,4 +38,3 @@ export function resolvePlatformEnvKeywordDir(input: {
   if (!keyword) throw new Error('keyword 不能为空');
   return path.join(downloadRoot, platform, env, keyword);
 }
-