openclaw-multi-auto 1.4.5 → 1.4.7

package/extensions/page-action-cache/src/cache-invalidator.ts

@@ -0,0 +1,271 @@
+/**
+ * Cache Invalidator
+ * 缓存失效检测器 - 检测页面变化并失效缓存
+ */
+
+import type {
+  PageViewport,
+  PageChangeDetection,
+  PageActionCacheEntry,
+  DOMHashFeatures,
+} from "./types.js";
+
+// ============================================================================
+// Cache Invalidator 类
+// ============================================================================
+
+/**
+ * 缓存失效检测器
+ */
+export class CacheInvalidator {
+  /**
+   * 检测页面是否发生变化
+   */
+  async detectPageChange(
+    html: string,
+    _url: string,
+    _viewport: PageViewport,
+    cachedEntry?: PageActionCacheEntry
+  ): Promise<PageChangeDetection> {
+    // 计算当前 DOM hash
+    const currentHash = this.calculateDOMHash(html);
+
+    if (!cachedEntry || !cachedEntry.pageChangeDetection) {
+      return {
+        hasChanged: true,
+        changeType: "none",
+        confidence: 0,
+        domHash: currentHash,
+        lastCheckedAt: Date.now(),
+      };
+    }
+
+    const cachedHash = cachedEntry.pageChangeDetection.domHash;
+
+    // 比较 hash
+    if (currentHash === cachedHash) {
+      return {
+        hasChanged: false,
+        changeType: "none",
+        confidence: 100,
+        domHash: currentHash,
+        lastCheckedAt: Date.now(),
+      };
+    }
+
+    // 检测变化类型
+    const structureChanged = this.detectStructureChange(html);
+    const contentChanged = this.detectContentChange(html, cachedEntry);
+
+    if (structureChanged || contentChanged) {
+      return {
+        hasChanged: true,
+        changeType: structureChanged ? "structure" : "content",
+        confidence: Math.max(
+          structureChanged ? 80 : 0,
+          contentChanged ? 80 : 0
+        ),
+        domHash: currentHash,
+        lastCheckedAt: Date.now(),
+        details: structureChanged
+          ? "Form/Button count changed"
+          : "Content hash changed",
+      };
+    }
+
+    // hash 不同但结构未变，可能是动态内容
+    return {
+      hasChanged: true,
+      changeType: "content",
+      confidence: 50, // 低置信度，可能是动态内容
+      domHash: currentHash,
+      lastCheckedAt: Date.now(),
+      details: "Hash changed but structure is similar",
+    };
+  }
+
+  /**
+   * 计算 DOM hash
+   */
+  calculateDOMHash(html: string): string {
+    const features = this.extractDOMFeatures(html);
+    return this.combineFeaturesHash(features);
+  }
+
+  /**
+   * 提取 DOM 特征
+   */
+  private extractDOMFeatures(html: string): DOMHashFeatures {
+    return {
+      formCount: this.countElements(html, "form"),
+      buttonCount: this.countElements(html, "button"),
+      linkCount: this.countElements(html, "a"),
+      scriptCount: this.countElements(html, "script"),
+      headingCount:
+        this.countElements(html, "h1") +
+        this.countElements(html, "h2") +
+        this.countElements(html, "h3"),
+    };
+  }
+
+  /**
+   * 计算元素数量
+   */
+  private countElements(html: string, tagName: string): number {
+    const regex = new RegExp(`<${tagName}\\b`, "gi");
+    return (html.match(regex) || []).length;
+  }
+
+  /**
+   * 组合特征为 hash
+   */
+  private combineFeaturesHash(features: DOMHashFeatures): string {
+    const values = [
+      features.formCount,
+      features.buttonCount,
+      features.linkCount,
+      features.scriptCount,
+      features.headingCount,
+    ];
+
+    // 简单 hash 算法
+    let hash = 0;
+    for (const value of values) {
+      hash = ((hash << 5) - hash + value) | 0;
+    }
+    return hash.toString(16);
+  }
+
+  /**
+   * 检测结构变化
+   */
+  private detectStructureChange(html: string): boolean {
+    // 检查表单和按钮数量是否发生显著变化
+    const features = this.extractDOMFeatures(html);
+
+    // 如果表单数量变化，认为是结构变化
+    // 这里简化处理，实际应该与缓存条目比较
+    const hasForm = features.formCount > 0;
+
+    return !hasForm;
+  }
+
+  /**
+   * 检测内容变化
+   */
+  private detectContentChange(
+    html: string,
+    cachedEntry: PageActionCacheEntry
+  ): boolean {
+    // 简化处理：检查 HTML 长度变化
+    const lengthChanged = Math.abs(html.length - (cachedEntry.actions.length * 100)) > 500;
+
+    return lengthChanged;
+  }
+
+  /**
+   * 判断是否应该失效缓存
+   */
+  shouldInvalidate(
+    entry: PageActionCacheEntry,
+    changeResult: PageChangeDetection,
+    threshold: number = 80
+  ): boolean {
+    // 根据页面类型和置信度决定是否失效
+    const pageType = entry.pageType || "mixed";
+
+    if (pageType === "static") {
+      // 静态页面：高置信度时失效
+      return changeResult.hasChanged && changeResult.confidence >= threshold;
+    } else if (pageType === "dynamic") {
+      // 动态页面：只在结构变化时失效
+      return (
+        changeResult.hasChanged && changeResult.changeType === "structure"
+      );
+    } else {
+      // 混合页面：中等置信度时失效
+      return (
+        changeResult.hasChanged && changeResult.confidence >= threshold - 10
+      );
+    }
+  }
+
+  /**
+   * 创建渐进式失效器
+   */
+  createProgressiveInvalidator(): ProgressiveInvalidator {
+    return new ProgressiveInvalidator();
+  }
+}
+
+// ============================================================================
+// Progressive Invalidator 类
+// ============================================================================
+
+/**
+ * 渐进式失效：保留多版本
+ */
+export class ProgressiveInvalidator {
+  private versions: Map<string, string[]> = new Map();
+
+  /**
+   * 添加版本
+   */
+  addVersion(entry: PageActionCacheEntry, versionId: string): void {
+    const key = entry.key;
+
+    if (!this.versions.has(key)) {
+      this.versions.set(key, []);
+    }
+
+    const versions = this.versions.get(key)!;
+    versions.push(versionId);
+
+    // 只保留最近的 N 个版本（默认 3 个）
+    if (versions.length > 3) {
+      versions.shift();
+    }
+  }
+
+  /**
+   * 获取版本列表
+   */
+  getVersions(key: string): string[] {
+    return this.versions.get(key) || [];
+  }
+
+  /**
+   * 生成版本标识
+   */
+  generateVersion(entry: PageActionCacheEntry): string {
+    const time = new Date(entry.createdAt).toISOString().slice(0, 10); // YYYY-MM-DD
+    const pageType = entry.pageType || "unknown";
+
+    return `${pageType}-${entry.scenario}-${time}`;
+  }
+
+  /**
+   * 清理旧版本
+   */
+  cleanupOldVersions(key: string, maxVersions: number = 3): void {
+    const versions = this.getVersions(key);
+
+    if (versions.length > maxVersions) {
+      const toKeep = versions.slice(-maxVersions);
+      this.versions.set(key, toKeep);
+    }
+  }
+}
+
+// ============================================================================
+// 单例
+// ============================================================================
+
+let cacheInvalidatorInstance: CacheInvalidator | null = null;
+
+export function getCacheInvalidator(): CacheInvalidator {
+  if (!cacheInvalidatorInstance) {
+    cacheInvalidatorInstance = new CacheInvalidator();
+  }
+  return cacheInvalidatorInstance;
+}

package/extensions/page-action-cache/src/cache-store.ts

@@ -0,0 +1,457 @@
+/**
+ * Page Action Cache Store
+ * 管理页面操作缓存的存储
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import type {
+  PageActionCacheEntry,
+  PageActionCacheStore,
+  PageViewport,
+  CacheStats,
+  ScenarioMatch,
+} from "./types.js";
+
+// ============================================================================
+// 配置
+// ============================================================================
+
+const CACHE_DIR = path.join(
+  process.env.HOME || process.env.USERPROFILE || ".",
+  ".openclaw",
+  "cache",
+  "page-actions"
+);
+
+const CACHE_FILE = path.join(CACHE_DIR, "cache.json");
+const CACHE_VERSION = 1;
+
+const DEFAULT_TTL = {
+  L3: 7 * 24 * 60 * 60 * 1000, // 7 天
+  L2: 3 * 24 * 60 * 60 * 1000, // 3 天
+  L1: 30 * 60 * 1000, // 30 分钟
+};
+
+// ============================================================================
+// CacheStore 类
+// ============================================================================
+
+/**
+ * 缓存存储管理器
+ */
+export class CacheStore {
+  private store: PageActionCacheStore;
+
+  constructor() {
+    this.store = this.load();
+  }
+
+  // -------------------------------------------------------------------------
+  // 初始化和加载
+  // -------------------------------------------------------------------------
+
+  private load(): PageActionCacheStore {
+    try {
+      if (fs.existsSync(CACHE_FILE)) {
+        const data = fs.readFileSync(CACHE_FILE, "utf-8");
+        const loaded = JSON.parse(data) as PageActionCacheStore;
+
+        // 版本检查
+        if (loaded.version !== CACHE_VERSION) {
+          console.warn(
+            `[CacheStore] Cache version mismatch (expected ${CACHE_VERSION}, got ${loaded.version}), clearing cache`
+          );
+          return this.createEmptyStore();
+        }
+
+        return loaded;
+      }
+    } catch (error) {
+      console.error(`[CacheStore] Failed to load cache:`, error);
+    }
+
+    return this.createEmptyStore();
+  }
+
+  private createEmptyStore(): PageActionCacheStore {
+    return {
+      version: CACHE_VERSION,
+      entries: {},
+      scenarios: new Map<string, ScenarioMatch>(),
+      stats: {
+        totalEntries: 0,
+        totalHits: 0,
+        totalMisses: 0,
+        hitRate: 0,
+        l3Hits: 0,
+        l2Hits: 0,
+        l1Hits: 0,
+        scenarioMatches: 0,
+        llmClassifications: 0,
+        learnedAssociations: 0,
+        savedTokens: 0,
+        savedTime: 0,
+        avgExecutionTime: 0,
+        userConfirmations: 0,
+        userForcedRefreshes: 0,
+        cacheErrors: 0,
+      },
+    };
+  }
+
+  private ensureCacheDir(): void {
+    if (!fs.existsSync(CACHE_DIR)) {
+      fs.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // 保存
+  // -------------------------------------------------------------------------
+
+  private save(): void {
+    try {
+      this.ensureCacheDir();
+
+      // 序列化（处理 Map）
+      const serialized = {
+        ...this.store,
+        scenarios: Array.from(this.store.scenarios.entries()),
+      };
+
+      fs.writeFileSync(CACHE_FILE, JSON.stringify(serialized, null, 2));
+    } catch (error) {
+      console.error(`[CacheStore] Failed to save cache:`, error);
+    }
+  }
+
+  private scheduleSave(): void {
+    // 防抖保存（100ms）
+    if (this._saveTimeout) {
+      clearTimeout(this._saveTimeout);
+    }
+    this._saveTimeout = setTimeout(() => this.save(), 100);
+  }
+
+  private _saveTimeout: NodeJS.Timeout | null = null;
+
+  // -------------------------------------------------------------------------
+  // 缓存键生成
+  // -------------------------------------------------------------------------
+
+  private generateKey(url: string, viewport: PageViewport): string {
+    const normalizedUrl = this.normalizeUrl(url);
+    const viewportStr = `${viewport.width}x${viewport.height}`;
+    const hash = createHash("md5")
+      .update(`${normalizedUrl}:${viewportStr}`)
+      .digest("hex");
+    return hash || `fallback-${Date.now()}`; // 确保 hash 不为空
+  }
+
+  private normalizeUrl(url: string): string {
+    try {
+      const parsed = new URL(url);
+      // 移除查询参数和哈希（可根据配置调整）
+      parsed.search = "";
+      parsed.hash = "";
+      return parsed.toString();
+    } catch {
+      return url;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // 基本操作
+  // -------------------------------------------------------------------------
+
+  /**
+   * 设置缓存条目
+   */
+  set(
+    url: string,
+    viewport: PageViewport,
+    actions: any[],
+    metadata: {
+      scenario: string;
+      cacheLevel: "L3" | "L2" | "L1";
+      variables?: Record<string, string>;
+      description?: string;
+      pageType?: "static" | "dynamic" | "mixed";
+    }
+  ): string {
+    const key = this.generateKey(url, viewport);
+    const now = Date.now();
+    const ttl = DEFAULT_TTL[metadata.cacheLevel];
+
+    const entry: PageActionCacheEntry = {
+      key,
+      url: this.normalizeUrl(url),
+      viewport,
+      cacheLevel: metadata.cacheLevel,
+      scenario: metadata.scenario,
+      description: metadata.description || `Cached ${metadata.scenario} actions`,
+      variables: metadata.variables,
+      actions,
+      createdAt: now,
+      lastAccessTime: now,
+      accessCount: 0,
+      expiresAt: now + ttl,
+      pageChangeDetection: {
+        hasChanged: false,
+        changeType: "none",
+        confidence: 100,
+        domHash: "",
+        lastCheckedAt: now,
+      },
+      source: "llm",
+      version: 1,
+      successCount: 0,
+      failCount: 0,
+      avgExecutionTime: 0,
+      pageType: metadata.pageType || "mixed",
+    };
+
+    this.store.entries[key] = entry;
+    this.store.stats.totalEntries++;
+
+    this.scheduleSave();
+    return key;
+  }
+
+  /**
+   * 获取缓存条目
+   */
+  get(url: string, viewport: PageViewport): PageActionCacheEntry | null {
+    const key = this.generateKey(url, viewport);
+    const entry = this.store.entries[key];
+
+    if (!entry) {
+      this.store.stats.totalMisses++;
+      this.updateHitRate();
+      return null;
+    }
+
+    // 检查过期
+    if (Date.now() > entry.expiresAt) {
+      delete this.store.entries[key];
+      this.store.stats.totalEntries--;
+      this.store.stats.totalMisses++;
+      this.updateHitRate();
+      this.scheduleSave();
+      return null;
+    }
+
+    // 更新访问统计
+    entry.lastAccessTime = Date.now();
+    entry.accessCount++;
+
+    // 更新层级统计
+    this.store.stats.totalHits++;
+    switch (entry.cacheLevel) {
+      case "L3":
+        this.store.stats.l3Hits++;
+        break;
+      case "L2":
+        this.store.stats.l2Hits++;
+        break;
+      case "L1":
+        this.store.stats.l1Hits++;
+        break;
+    }
+
+    this.updateHitRate();
+    this.scheduleSave();
+
+    return entry;
+  }
+
+  /**
+   * 删除缓存条目
+   */
+  delete(url: string, viewport: PageViewport): boolean {
+    const key = this.generateKey(url, viewport);
+    const existed = !!this.store.entries[key];
+
+    if (existed) {
+      delete this.store.entries[key];
+      this.store.stats.totalEntries--;
+      this.scheduleSave();
+    }
+
+    return existed;
+  }
+
+  /**
+   * 按模式删除缓存条目
+   */
+  deleteByPattern(urlPattern: string): number {
+    let deleted = 0;
+
+    for (const [key, entry] of Object.entries(this.store.entries)) {
+      if (entry.url.includes(urlPattern)) {
+        delete this.store.entries[key];
+        this.store.stats.totalEntries--;
+        deleted++;
+      }
+    }
+
+    if (deleted > 0) {
+      this.scheduleSave();
+    }
+
+    return deleted;
+  }
+
+  /**
+   * 清空所有缓存
+   */
+  clear(): void {
+    this.store.entries = {};
+    this.store.scenarios.clear();
+    this.store.stats = this.createEmptyStore().stats;
+    this.scheduleSave();
+  }
+
+  // -------------------------------------------------------------------------
+  // 统计更新
+  // -------------------------------------------------------------------------
+
+  private updateHitRate(): void {
+    const total = this.store.stats.totalHits + this.store.stats.totalMisses;
+    this.store.stats.hitRate =
+      total > 0 ? (this.store.stats.totalHits / total) * 100 : 0;
+  }
+
+  /**
+   * 更新执行统计
+   */
+  updateExecutionStats(
+    key: string,
+    results: Array<{ success: boolean; duration: number }>
+  ): void {
+    const entry = this.store.entries[key];
+    if (!entry) return;
+
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.length - successCount;
+    const avgDuration =
+      results.reduce((sum, r) => sum + r.duration, 0) / results.length;
+
+    // 更新统计（加权平均）
+    const oldCount = entry.successCount + entry.failCount;
+    const newCount = oldCount + results.length;
+
+    entry.successCount += successCount;
+    entry.failCount += failCount;
+    entry.avgExecutionTime =
+      (entry.avgExecutionTime * oldCount + avgDuration * results.length) /
+      newCount;
+
+    // 估算节省的 token 和时间
+    this.store.stats.savedTokens += 5000; // 估算值
+    this.store.stats.savedTime += 2000; // 估算值（毫秒）
+
+    this.scheduleSave();
+  }
+
+  // -------------------------------------------------------------------------
+  // 场景匹配管理
+  // -------------------------------------------------------------------------
+
+  /**
+   * 保存场景匹配
+   */
+  saveScenarioMatch(match: ScenarioMatch): void {
+    this.store.scenarios.set(match.scenario, match);
+    this.store.stats.scenarioMatches++;
+    this.scheduleSave();
+  }
+
+  /**
+   * 获取场景匹配
+   */
+  getScenarioMatch(scenario: string): ScenarioMatch | undefined {
+    return this.store.scenarios.get(scenario);
+  }
+
+  // -------------------------------------------------------------------------
+  // 查询方法
+  // -------------------------------------------------------------------------
+
+  /**
+   * 获取统计信息
+   */
+  getStats(): CacheStats {
+    return { ...this.store.stats };
+  }
+
+  /**
+   * 列出所有缓存条目
+   */
+  listEntries(): PageActionCacheEntry[] {
+    return Object.values(this.store.entries).sort(
+      (a, b) => b.lastAccessTime - a.lastAccessTime
+    );
+  }
+
+  /**
+   * 获取热门场景
+   */
+  getTopScenarios(limit: number = 5): string {
+    const scenarioCounts = new Map<string, number>();
+
+    for (const entry of Object.values(this.store.entries)) {
+      const count = scenarioCounts.get(entry.scenario) || 0;
+      scenarioCounts.set(entry.scenario, count + entry.accessCount);
+    }
+
+    const sorted = Array.from(scenarioCounts.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, limit);
+
+    return sorted
+      .map(([scenario, count]) => `- ${scenario}: ${count} 次`)
+      .join("\n");
+  }
+
+  // -------------------------------------------------------------------------
+  // 清理
+  // -------------------------------------------------------------------------
+
+  /**
+   * 清理过期缓存
+   */
+  cleanupExpired(): number {
+    const now = Date.now();
+    let cleaned = 0;
+
+    for (const [key, entry] of Object.entries(this.store.entries)) {
+      if (now > entry.expiresAt) {
+        delete this.store.entries[key];
+        this.store.stats.totalEntries--;
+        cleaned++;
+      }
+    }
+
+    if (cleaned > 0) {
+      this.scheduleSave();
+    }
+
+    return cleaned;
+  }
+}
+
+// ============================================================================
+// 单例
+// ============================================================================
+
+let cacheStoreInstance: CacheStore | null = null;
+
+export function getCacheStore(): CacheStore {
+  if (!cacheStoreInstance) {
+    cacheStoreInstance = new CacheStore();
+  }
+  return cacheStoreInstance;
+}