page-action-cache 1.0.4 → 2.0.0

package/src/cache-manager.ts

@@ -0,0 +1,211 @@
+/**
+ * Cache Manager - Page Action Cache Core
+ * 缓存管理器 - 页面操作缓存管理器
+ */
+
+import type { CacheEntry, CacheStats, ScenarioType } from './types.js';
+import { clearInterval, setInterval } from 'node:timers';
+
+/**
+ * 缓存管理器
+ */
+class CacheManager {
+  private cache: Map<string, CacheEntry> = new Map();
+  private stats: CacheStats = {
+    totalEntries: 0,
+    totalActions: 0,
+    hitRate: 0,
+    savedActions: 0,
+    savedTime: 0
+  };
+  private autoSaveInterval: NodeJS.Timeout | null = null;
+  private totalQueries: number = 0;
+  private totalHits: number = 0;
+
+  constructor() {
+    this.loadCache();
+    this.startAutoSave();
+  }
+
+  /**
+   * 加载缓存
+   */
+  private loadCache(): void {
+    try {
+      const cacheFile = process.env.PAGE_ACTION_CACHE_FILE || '/tmp/page-action-cache.json';
+      const fs = require('fs');
+      if (fs.existsSync(cacheFile)) {
+        const data = fs.readFileSync(cacheFile, 'utf8');
+        this.cache = new Map(JSON.parse(data));
+      }
+      console.log(`[CacheManager] Loaded ${this.cache.size} cache entries`);
+    } catch (error: any) {
+      console.error(`[CacheManager] Failed to load cache: ${error.message}`);
+    }
+  }
+
+  /**
+   * 保存缓存
+   */
+  private saveCache(): void {
+    try {
+      const cacheFile = process.env.PAGE_ACTION_CACHE_FILE || '/tmp/page-action-cache.json';
+      const fs = require('fs');
+      const data = Array.from(this.cache.entries());
+      fs.writeFileSync(cacheFile, JSON.stringify(data, null, 2));
+      console.log(`[CacheManager] Saved ${data.length} cache entries`);
+    } catch (error: any) {
+      console.error(`[CacheManager] Failed to save cache: ${error.message}`);
+    }
+  }
+
+  /**
+   * 自动保存
+   */
+  private startAutoSave(): void {
+    setInterval(() => this.saveCache(), 60000); // 每分钟保存一次
+  }
+
+  /**
+   * 查询缓存
+   */
+  query(url: string, viewport?: string): CacheEntry | null {
+    const key = this.getCacheKey(url, viewport);
+
+    if (!key) {
+      return null;
+    }
+
+    this.totalQueries++;
+    const entry = this.cache.get(key);
+    if (entry) {
+      this.totalHits++;
+      return entry;
+    }
+    return null;
+  }
+
+  /**
+   * 更新缓存状态
+   */
+  updateCacheStatus(id: string, success: boolean): void {
+    const entry = this.cache.get(id);
+    if (!entry) {
+      return;
+    }
+
+    // CacheEntry doesn't have successCount/failCount, so we skip this
+    // This is a compatibility method for older API
+    console.log(`[CacheManager] Cache status update requested for ${id}: ${success}`);
+  }
+
+  /**
+   * 生成缓存键
+   */
+  private getCacheKey(url: string, viewport?: string | { width?: number; height?: number }): string {
+    let viewportStr = 'default';
+    if (viewport) {
+      if (typeof viewport === 'string') {
+        viewportStr = viewport;
+      } else if (viewport.width && viewport.height) {
+        viewportStr = `${viewport.width}x${viewport.height}`;
+      }
+    }
+    return `${url}:${viewportStr}`;
+  }
+
+  /**
+   * 添加缓存条目
+   */
+  addCache(params: {
+    url: string;
+    actions: Array<{ type: 'navigate' | 'click' | 'screenshot' | 'type' | 'script'; params?: any; successCount?: number; failCount?: number }>;
+    scenario?: ScenarioType;
+    viewport?: string | { width?: number; height?: number };
+  }): string {
+    const key = this.getCacheKey(params.url, params.viewport);
+    const entry: CacheEntry = {
+      id: Date.now().toString(),
+      url: params.url,
+      viewport: typeof params.viewport === 'string' ? params.viewport : (params.viewport ? `${params.viewport.width}x${params.viewport.height}` : '1920x1080'),
+      actions: params.actions.map(action => ({
+        ...action,
+        successCount: action.successCount || 0,
+        failCount: action.failCount || 0
+      })),
+      scenario: params.scenario || 'unknown',
+      timestamp: Date.now(),
+      hitRate: 0,
+      savedActions: 0,
+      savedTime: 0
+    };
+
+    this.cache.set(key, entry);
+    this.stats.totalEntries = this.cache.size;
+    this.stats.totalActions += params.actions.length;
+
+    return entry.id;
+  }
+
+  /**
+   * 获取缓存
+   */
+  getCache(id: string): CacheEntry | null {
+    return this.cache.get(id) || null;
+  }
+
+  /**
+   * 清空缓存
+   */
+  clearCache(): void {
+    this.cache.clear();
+    this.stats = {
+      totalEntries: 0,
+      totalActions: 0,
+      hitRate: 0,
+      savedActions: 0,
+      savedTime: 0
+    };
+    this.totalQueries = 0;
+    this.totalHits = 0;
+    console.log('[CacheManager] Cache cleared');
+  }
+
+  /**
+   * 获取统计
+   */
+  getStats(): CacheStats & {
+    totalQueries: number;
+    totalHits: number;
+    savedTimeFormatted: string;
+  } {
+    const hitRate = this.totalQueries > 0 ? (this.totalHits / this.totalQueries) * 100 : 0;
+    const savedTimePerMin = this.stats.savedTime > 0 ? this.stats.savedTime / 60000 : 0; // 转换为分钟
+
+    return {
+      ...this.stats,
+      hitRate: Math.round(hitRate * 100) / 100,
+      totalQueries: this.totalQueries,
+      totalHits: this.totalHits,
+      savedTimeFormatted: savedTimePerMin > 0
+          ? `${savedTimePerMin > 60 ? Math.floor(savedTimePerMin) : savedTimePerMin.toFixed(2)} 分钟`
+          : '0 分钟'
+    };
+  }
+
+  /**
+   * 销毁
+   */
+  destroy(): void {
+    this.cache.clear();
+    if (this.autoSaveInterval) {
+      clearInterval(this.autoSaveInterval);
+      this.autoSaveInterval = null;
+    }
+  }
+}
+
+/**
+ * 单例导出
+ */
+export const cacheManager = new CacheManager();

package/src/index.ts

@@ -0,0 +1,306 @@
+/**
+ * Page Action Cache - OpenClaw Extension
+ * 页面操作缓存扩展 - OpenClaw 扩展
+ */
+
+import type { OpenClawPluginApi } from './types-mock.js';
+import { scenarioRecognizer } from './scenario-recognizer.js';
+import { multiLevelCache } from './multi-level-cache.js';
+import { cacheInvalidation } from './cache-invalidation.js';
+import { browserActionExecutor } from './browser-action-executor.js';
+
+/**
+ * 配置接口
+ */
+interface PageActionCacheConfig {
+  enabled: boolean;
+  autoUseCache?: boolean;
+  scenarioRecognitionEnabled?: boolean;
+  llmClassificationThreshold?: number;
+  cacheLevelStrategy?: 'auto' | 'l3-only' | 'l2-only' | 'l1-only';
+  defaultCacheLevel?: 'L3' | 'L2' | 'L1';
+  pageChangeDetectionEnabled?: boolean;
+  changeInvalidationThreshold?: number;
+  invalidationStrategy?: 'soft' | 'hard';
+  variableExtractionEnabled?: boolean;
+  allowUserConfirmVariables?: boolean;
+  allowUserForcedRefresh?: boolean;
+  enableUserCacheErrorReport?: boolean;
+  trackExecutionStats?: boolean;
+  statsUpdateInterval?: number;
+}
+
+/**
+ * 主扩展入口
+ */
+export function register(api: OpenClawPluginApi): void {
+  console.log('[PageActionCache] Initializing extension...');
+
+  // 获取插件配置
+  const config = (api.getConfig?.() || {}) as PageActionCacheConfig;
+  const enabled = config.enabled !== false;
+
+  if (!enabled) {
+    console.log('[PageActionCache] Extension disabled by configuration');
+    return;
+  }
+
+  // 配置扩展
+  if (config.scenarioRecognitionEnabled !== false) {
+    console.log('[PageActionCache] Scenario recognition enabled');
+  }
+
+  if (config.pageChangeDetectionEnabled !== false) {
+    cacheInvalidation.setStrategy(config.invalidationStrategy || 'soft');
+    cacheInvalidation.setChangeThreshold(config.changeInvalidationThreshold || 0.5);
+    console.log('[PageActionCache] Cache invalidation enabled');
+  }
+
+  if (config.cacheLevelStrategy) {
+    multiLevelCache.setStrategy(config.cacheLevelStrategy);
+    console.log(`[PageActionCache] Cache level strategy: ${config.cacheLevelStrategy}`);
+  }
+
+  if (config.llmClassificationThreshold) {
+    multiLevelCache.setLLMThreshold(config.llmClassificationThreshold);
+  }
+
+  // 注册缓存执行工具
+  api.registerTool({
+    name: 'browser_cache_execute',
+    description: '执行缓存的页面操作序列，支持自动缓存匹配、场景识别和变量提取',
+    async execute(ctx: any) {
+      try {
+        console.log('[PageActionCache] browser_cache_execute called');
+
+        const enabled = ctx.config?.plugins?.entries?.['page-action-cache']?.config?.enabled ?? true;
+
+        if (!enabled) {
+          return {
+            type: 'text',
+            content: 'Page Action Cache 功能已禁用'
+          };
+        }
+
+        const request = ctx.params as any;
+        const url = request?.url;
+
+        if (!url) {
+          return {
+            type: 'text',
+            content: 'Missing required parameter: url'
+          };
+        }
+
+        // 尝试从缓存中查找
+        const cachedEntry = multiLevelCache.queryCache(url, request.viewport || '1920x1080');
+
+        if (cachedEntry && !request.forceRefresh) {
+          console.log('[PageActionCache] Cache hit found');
+          return await executeFromCache(cachedEntry);
+        }
+
+        // 缓存未命中或强制刷新，创建新缓存并执行
+        console.log('[PageActionCache] Cache miss or forced refresh, creating new entry');
+
+        // 识别场景
+        let scenario = request.scenario;
+        if (!scenario) {
+          scenario = scenarioRecognizer.recognizeByUrl(url);
+        }
+
+        // 创建缓存条目
+        const actions = request.actions || [];
+        const cacheActions = actions.map((action: any) => ({
+          type: action.type,
+          params: action.params,
+          successCount: 0,
+          failCount: 0
+        }));
+
+        const cacheId = multiLevelCache.addCache(
+          url,
+          request.viewport || '1920x1080',
+          cacheActions,
+          scenario,
+          request.llmClassificationScore
+        );
+
+        // 执行操作
+        const entry = {
+          id: cacheId,
+          url,
+          viewport: request.viewport || '1920x1080',
+          actions: cacheActions,
+          scenario,
+          timestamp: Date.now(),
+          hitRate: 0,
+          savedActions: 0,
+          savedTime: 0,
+          level: 'L1' as const,
+          createdAt: Date.now(),
+          lastAccessed: Date.now(),
+          accessCount: 0,
+          expiresAt: Date.now() + 86400000 // 24小时
+        };
+
+        const result = await browserActionExecutor.executeCacheEntry(entry);
+
+        return {
+          type: 'text',
+          content: `## Cache Execution Result
+
+${result.message}
+
+- Executed Actions: ${result.executedActions}
+- Skipped Actions: ${result.skippedActions}
+- Failed Actions: ${result.failedActions}
+- Saved Time: ${result.savedTime}ms
+
+Cache ID: ${cacheId}
+URL: ${url}
+Scenario: ${scenario}
+LLM Classification Score: ${request.llmClassificationScore || 'N/A'}`
+        };
+      } catch (error: any) {
+        console.error('[PageActionCache] Error:', error);
+        return {
+          type: 'text',
+          content: `执行失败: ${error.message}`
+        };
+      }
+    }
+  });
+
+  // 注册缓存统计工具
+  api.registerTool({
+    name: 'browser_cache_stats',
+    description: '查看页面操作缓存的统计信息',
+    async execute(_ctx: any) {
+      try {
+        const stats = multiLevelCache.getStats();
+        const invalidationStats = cacheInvalidation.getInvalidationStats();
+
+        return {
+          type: 'text',
+          content: `## Page Action Cache Statistics
+
+### Overall Performance
+- Total Cache Entries: ${stats.totalEntries}
+- Total Cache Hits: ${stats.totalHits}
+- Cache Hit Rate: ${stats.hitRate.toFixed(2)}%
+
+### Multi-Level Cache Distribution
+${Object.entries(stats.levelStats).map(([level, data]) => `
+#### ${level} Cache
+- Size: ${data.size}/${data.maxCapacity} (${(data.usageRate * 100).toFixed(1)}% full)
+- Average Access Count: ${data.avgAccessCount.toFixed(1)}
+`).join('')}
+
+### Cache Invalidation
+- Total Snapshots: ${invalidationStats.totalSnapshots}
+- Active Snapshots: ${invalidationStats.activeSnapshots}
+- Invalidation Rate: ${(invalidationStats.invalidationRate * 100).toFixed(2)}%`
+        };
+      } catch (error: any) {
+        return {
+          type: 'text',
+          content: `统计功能错误: ${error.message}`
+        };
+      }
+    }
+  });
+
+  // 注册缓存清除工具
+  api.registerTool({
+    name: 'browser_cache_clear',
+    description: '清空页面操作缓存',
+    async execute(ctx: any) {
+      try {
+        const request = ctx.params as any;
+
+        if (request.url && request.viewport) {
+          // 删除特定缓存条目
+          const deleted = multiLevelCache.deleteCache(request.url, request.viewport || '1920x1080');
+          cacheInvalidation.invalidate(request.url, request.viewport || '1920x1080');
+
+          return {
+            type: 'text',
+            content: deleted
+              ? `Cache entry deleted for ${request.url}:${request.viewport || '1920x1080'}`
+              : `No cache entry found for ${request.url}:${request.viewport || '1920x1080'}`
+          };
+        } else if (request.url) {
+          // 删除 URL 相关的所有缓存
+          multiLevelCache.deleteCacheByUrl(request.url);
+          cacheInvalidation.invalidateByUrl(request.url);
+
+          return {
+            type: 'text',
+            content: `All cache entries for ${request.url} have been deleted`
+          };
+        } else if (request.level) {
+          // 按级别删除
+          if (request.level === 'all') {
+            multiLevelCache.clearAll();
+            cacheInvalidation.reset();
+          } else {
+            multiLevelCache.clearLevel(request.level);
+          }
+
+          return {
+            type: 'text',
+            content: `Cache cleared for level: ${request.level}`
+          };
+        } else {
+          // 默认清空所有缓存
+          multiLevelCache.clearAll();
+          cacheInvalidation.reset();
+
+          return {
+            type: 'text',
+            content: 'All page action cache has been cleared'
+          };
+        }
+      } catch (error: any) {
+        return {
+          type: 'text',
+          content: `清除功能错误: ${error.message}`
+        };
+      }
+    }
+  });
+
+  console.log('[PageActionCache] Tools registered successfully');
+
+  // 定期清理过期缓存
+  setInterval(() => {
+    multiLevelCache.cleanupExpired();
+    cacheInvalidation.cleanup();
+  }, 60 * 60 * 1000); // 每小时清理一次
+}
+
+/**
+ * 从缓存执行
+ */
+async function executeFromCache(cachedEntry: any) {
+  const result = await browserActionExecutor.executeCacheEntry(cachedEntry);
+
+  return {
+    type: 'text',
+    content: `## Cached Execution
+
+${result.message}
+
+- Executed Actions: ${result.executedActions}
+- Skipped Actions: ${result.skippedActions}
+- Failed Actions: ${result.failedActions}
+- Saved Time: ${result.savedTime}ms
+
+Cache ID: ${cachedEntry.id}
+URL: ${cachedEntry.url}
+Scenario: ${cachedEntry.scenario}
+Cache Level: ${cachedEntry.level}
+Access Count: ${cachedEntry.accessCount || 0}`
+  };
+}