page-action-cache 2.0.9 → 2026.2.1

package/dist/index.js

@@ -1,408 +1,258 @@
 /**
  * Page Action Cache - OpenClaw Extension
- * 页面操作缓存扩展 - OpenClaw 扩展
+ * 页面操作缓存扩展
  */
-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';
+// 内存缓存（页面会话级别）
+const memoryCache = new Map();
+const MAX_CACHE_SIZE = 50;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 分钟
 /**
- * 主扩展入口
+ * 生成缓存键
  */
-export function register(api) {
-    console.log('[PageActionCache] Initializing extension...');
-    // 获取插件配置 - 详细日志
-    const rawConfig = api.getConfig?.();
-    console.log('[PageActionCache] Raw config object:', JSON.stringify(rawConfig, null, 2));
-    // 检查配置对象是否有效
-    let config = rawConfig;
-    if (!config || typeof config !== 'object') {
-        console.log('[PageActionCache] Invalid config object type:', typeof rawConfig);
-        // 配置无效，使用空对象继续
-        config = {};
-    }
-    const pluginConfig = config?.plugins?.entries?.['page-action-cache'] ?? {};
-    console.log('[PageActionCache] Plugin config for page-action-cache:', JSON.stringify(pluginConfig, null, 2));
-    const pageActionCacheConfig = pluginConfig ?? {};
-    console.log('[PageActionCache] Parsed pageActionCacheConfig:', JSON.stringify(pageActionCacheConfig, null, 2));
-    const enabled = pageActionCacheConfig.enabled !== false;
-    console.log('[PageActionCache] Enabled status:', enabled);
-    if (!enabled) {
-        console.log('[PageActionCache] Extension disabled by configuration');
-        return;
-    }
-    console.log('[PageActionCache] Extension enabled, proceeding with tool registration...');
-    // 应用配置
-    if (pageActionCacheConfig.cacheLevelStrategy) {
-        multiLevelCache.setStrategy(pageActionCacheConfig.cacheLevelStrategy);
-        console.log('[PageActionCache] Set cache level strategy:', pageActionCacheConfig.cacheLevelStrategy);
-    }
-    if (pageActionCacheConfig.llmClassificationThreshold !== undefined) {
-        multiLevelCache.setLLMThreshold(pageActionCacheConfig.llmClassificationThreshold);
-        console.log('[PageActionCache] Set LLM classification threshold:', pageActionCacheConfig.llmClassificationThreshold);
-    }
-    if (pageActionCacheConfig.invalidationStrategy) {
-        cacheInvalidation.setStrategy(pageActionCacheConfig.invalidationStrategy);
-        console.log('[PageActionCache] Set invalidation strategy:', pageActionCacheConfig.invalidationStrategy);
+function getCacheKey(url, viewport) {
+    if (!url)
+        return '';
+    return viewport ? `${url}:${viewport}` : url;
+}
+/**
+ * 清理过期缓存
+ */
+function cleanupExpiredCache() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [key, entry] of memoryCache.entries()) {
+        if (now - entry.timestamp > CACHE_TTL_MS) {
+            memoryCache.delete(key);
+            cleaned++;
+        }
     }
-    if (pageActionCacheConfig.changeInvalidationThreshold !== undefined) {
-        cacheInvalidation.setChangeThreshold(pageActionCacheConfig.changeInvalidationThreshold);
-        console.log('[PageActionCache] Set change invalidation threshold:', pageActionCacheConfig.changeInvalidationThreshold);
+    // LRU 清理
+    while (memoryCache.size > MAX_CACHE_SIZE) {
+        const oldestKey = memoryCache.keys().next().value;
+        if (oldestKey) {
+            memoryCache.delete(oldestKey);
+            cleaned++;
+        }
     }
-    // 注册缓存执行工具
-    api.registerTool({
-        name: 'browser_cache_execute',
-        description: '执行缓存的页面操作序列，支持自动缓存匹配、场景识别和变量提取',
-        async execute(ctx) {
+    return cleaned;
+}
+/**
+ * 主扩展入口
+ */
+export default function register(api) {
+    console.log('[PageActionCache] Initializing extension...');
+    try {
+        // ✅ 方法 1：通过 getToolContext 获取配置
+        let toolContext = undefined;
+        if (typeof api.getToolContext === 'function') {
+            toolContext = api.getToolContext();
+            console.log('[PageActionCache] Method 1: config via getToolContext:', toolContext ? 'available' : 'not available');
+        }
+        // ✅ 方法 2：直接从 api 对象读取（某些版本）
+        if (!toolContext || typeof toolContext.config === 'undefined') {
             try {
-                console.log('[PageActionCache] browser_cache_execute called');
-                console.log('[PageActionCache] Context type:', typeof ctx);
-                console.log('[PageActionCache] Context config:', ctx.config ? JSON.stringify(ctx.config, null, 2) : 'null');
-                console.log('[PageActionCache] Context params:', ctx.params ? JSON.stringify(ctx.params, null, 2) : 'null');
-                // 从插件配置中读取 enabled 状态
-                const pluginConfig = ctx.config?.plugins?.entries?.['page-action-cache'] ?? {};
-                const enabled = pluginConfig.enabled !== false;
-                if (!enabled) {
-                    console.log('[PageActionCache] Extension disabled by context config');
-                    return {
-                        success: false,
-                        message: 'Extension is disabled',
-                        executedActions: 0,
-                        skippedActions: 0,
-                        failedActions: 0,
-                        savedTime: 0
-                    };
+                if (typeof api.config === 'object' && api.config) {
+                    toolContext = { config: api.config };
+                    console.log('[PageActionCache] Method 2: config via api.config:', toolContext);
                 }
-                const params = ctx.params || {};
-                const url = params.url;
-                const viewport = params.viewport || '1920x1080';
-                const scenario = params.scenario;
-                const actions = params.actions;
-                const useCache = params.useCache !== false; // 默认使用缓存
-                const forceRefresh = params.forceRefresh === true;
-                const llmClassificationScore = params.llmClassificationScore;
-                console.log('[PageActionCache] Parsed params:', { url, viewport, scenario, useCache, forceRefresh, llmClassificationScore });
-                if (!url) {
-                    return {
-                        success: false,
-                        message: 'Missing required parameter: url',
-                        executedActions: 0,
-                        skippedActions: 0,
-                        failedActions: 0,
-                        savedTime: 0
-                    };
-                }
-                // 识别场景
-                let recognizedScenario = scenario || scenarioRecognizer.recognize(url);
-                console.log('[PageActionCache] Recognized scenario:', recognizedScenario);
-                let cachedEntry = null;
-                let isCacheHit = false;
-                let executedActions = 0;
-                let skippedActions = 0;
-                let failedActions = 0;
-                let savedTime = 0;
-                let cacheId = '';
-                // 尝试从缓存中查找
-                if (useCache && !forceRefresh) {
-                    console.log('[PageActionCache] Checking cache...');
-                    cachedEntry = multiLevelCache.queryCache(url, viewport);
-                    if (cachedEntry) {
-                        console.log('[PageActionCache] Cache hit found:', cachedEntry.id);
-                        isCacheHit = true;
-                        cacheId = cachedEntry.id;
-                        // 检查页面是否发生变化（如果提供了 HTML）
-                        if (pageActionCacheConfig.pageChangeDetectionEnabled && params.html) {
-                            const shouldInvalidate = cacheInvalidation.shouldInvalidate(url, viewport, params.html);
-                            if (shouldInvalidate) {
-                                console.log('[PageActionCache] Page changed, cache invalidated');
-                                multiLevelCache.deleteCache(url, viewport);
-                                cachedEntry = null;
-                                isCacheHit = false;
-                            }
-                            else {
-                                console.log('[PageActionCache] Page unchanged, cache valid');
-                            }
-                        }
-                    }
-                    else {
-                        console.log('[PageActionCache] Cache miss');
-                    }
-                }
-                // 如果没有缓存或需要强制刷新，执行新的操作
-                if (!cachedEntry) {
-                    console.log('[PageActionCache] Executing new actions...');
-                    if (!actions || actions.length === 0) {
-                        return {
-                            success: false,
-                            message: 'No actions provided and no cache found',
-                            executedActions: 0,
-                            skippedActions: 0,
-                            failedActions: 0,
-                            savedTime: 0
-                        };
-                    }
-                    // 执行操作
-                    const actionResults = [];
-                    for (let i = 0; i < actions.length; i++) {
-                        const action = actions[i];
-                        console.log('[PageActionCache] Executing action', i + 1, ':', action.type);
-                        try {
-                            const startTime = Date.now();
-                            let result;
-                            switch (action.type) {
-                                case 'navigate':
-                                    if (!action.params?.url) {
-                                        result = { success: false, message: 'Missing URL' };
-                                    }
-                                    else {
-                                        // 模拟导航操作
-                                        console.log('[PageActionCache] Navigating to:', action.params.url);
-                                        result = { success: true, message: `Navigated to ${action.params.url}` };
-                                    }
-                                    break;
-                                case 'click':
-                                    if (!action.params?.selector) {
-                                        result = { success: false, message: 'Missing selector' };
-                                    }
-                                    else {
-                                        console.log('[PageActionCache] Clicking:', action.params.selector);
-                                        result = { success: true, message: `Clicked ${action.params.selector}` };
-                                    }
-                                    break;
-                                case 'type':
-                                    if (!action.params?.selector || action.params?.text === undefined) {
-                                        result = { success: false, message: 'Missing selector or text' };
-                                    }
-                                    else {
-                                        console.log('[PageActionCache] Typing:', action.params.text);
-                                        result = { success: true, message: `Typed text` };
-                                    }
-                                    break;
-                                case 'screenshot':
-                                    console.log('[PageActionCache] Taking screenshot');
-                                    result = { success: true, message: 'Screenshot taken' };
-                                    break;
-                                case 'script':
-                                    if (!action.params?.script) {
-                                        result = { success: false, message: 'Missing script' };
-                                    }
-                                    else {
-                                        console.log('[PageActionCache] Executing script');
-                                        result = { success: true, message: 'Script executed' };
-                                    }
-                                    break;
-                                default:
-                                    result = { success: false, message: `Unknown action type: ${action.type}` };
-                            }
-                            const executionTime = Date.now() - startTime;
-                            result.executionTime = executionTime;
-                            actionResults.push(result);
-                            if (result.success) {
-                                executedActions++;
+            }
+            catch (e) {
+                console.log('[PageActionCache] Method 2 failed, api.config not available');
+            }
+        }
+        // ✅ 方法 3：从 config 对象获取（通过其他方式）
+        if (!toolContext) {
+            try {
+                const configMethod = api.getConfig;
+                if (typeof configMethod === 'function') {
+                    const rawConfig = configMethod();
+                    console.log('[PageActionCache] Method 3: config via getConfig:', rawConfig);
+                    if (rawConfig && typeof rawConfig === 'object') {
+                        const pluginsConfig = rawConfig.plugins;
+                        if (pluginsConfig && typeof pluginsConfig === 'object') {
+                            const extensionConfig = pluginsConfig.entries?.['page-action-cache'];
+                            if (extensionConfig && typeof extensionConfig === 'object') {
+                                toolContext = { config: { 'page-action-cache': extensionConfig } };
+                                console.log('[PageActionCache] Method 3 success: config loaded');
                             }
                             else {
-                                failedActions++;
+                                console.log('[PageActionCache] Method 3: page-action-cache entry not found');
                             }
                         }
-                        catch (error) {
-                            console.error('[PageActionCache] Action execution error:', error);
-                            failedActions++;
-                            actionResults.push({
-                                success: false,
-                                message: `Error: ${error instanceof Error ? error.message : String(error)}`
-                            });
+                        else {
+                            console.log('[PageActionCache] Method 3: plugins entries not found');
                         }
                     }
-                    // 保存到缓存
-                    const processedActions = actions.map((action, index) => ({
-                        type: action.type,
-                        params: action.params,
-                        successCount: actionResults[index]?.success ? 1 : 0,
-                        failCount: actionResults[index]?.success ? 0 : 1
-                    }));
-                    cacheId = multiLevelCache.addCache(url, viewport, processedActions, recognizedScenario, llmClassificationScore);
-                    // 保存页面快照（如果提供了 HTML）
-                    if (params.html) {
-                        cacheInvalidation.saveSnapshot(url, viewport, params.html);
+                    else {
+                        console.log('[PageActionCache] Method 3: raw config is not an object');
                     }
-                    console.log('[PageActionCache] Saved to cache with ID:', cacheId);
-                    savedTime = 0; // 首次执行不节省时间
-                }
-                else {
-                    // 使用缓存执行
-                    console.log('[PageActionCache] Using cached entry...');
-                    const result = await browserActionExecutor.executeCacheEntry(cachedEntry);
-                    executedActions = result.executedActions;
-                    skippedActions = result.skippedActions;
-                    failedActions = result.failedActions;
-                    savedTime = result.savedTime;
-                    console.log('[PageActionCache] Cache execution result:', result);
                 }
-                // 生成返回消息
-                let message = isCacheHit ? 'Cached Execution' : 'New Execution';
-                message += '\n\n';
-                message += `Execution completed ${isCacheHit ? 'from cache' : 'successfully'}\n\n`;
-                message += `- Executed Actions: ${executedActions}\n`;
-                message += `- Skipped Actions: ${skippedActions}\n`;
-                message += `- Failed Actions: ${failedActions}\n`;
-                message += `- Saved Time: ${savedTime}ms\n\n`;
-                message += `Cache ID: ${cacheId}\n`;
-                message += `URL: ${url}\n`;
-                message += `Scenario: ${recognizedScenario}\n`;
-                if (isCacheHit && cachedEntry) {
-                    message += `Cache Level: ${cachedEntry.level}\n`;
-                    message += `Access Count: ${cachedEntry.accessCount}\n`;
-                }
-                console.log('[PageActionCache] Returning result:', message);
-                return {
-                    success: failedActions === 0,
-                    message,
-                    executedActions,
-                    skippedActions,
-                    failedActions,
-                    savedTime,
-                    cacheId,
-                    url,
-                    scenario: recognizedScenario,
-                    isCacheHit,
-                    cacheLevel: cachedEntry?.level
-                };
             }
-            catch (error) {
-                console.error('[PageActionCache] Error in browser_cache_execute:', error);
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                return {
-                    success: false,
-                    message: `Error: ${errorMessage}`,
-                    executedActions: 0,
-                    skippedActions: 0,
-                    failedActions: 0,
-                    savedTime: 0
-                };
+            catch (e) {
+                console.log('[PageActionCache] Method 3 failed:', e);
             }
         }
-    });
-    // 注册缓存统计工具
-    api.registerTool({
-        name: 'browser_cache_stats',
-        description: '查看页面操作缓存的统计信息',
-        async execute(ctx) {
-            try {
-                console.log('[PageActionCache] browser_cache_stats called');
-                const pluginConfig = ctx.config?.plugins?.entries?.['page-action-cache'] ?? {};
-                const enabled = pluginConfig.enabled !== false;
-                if (!enabled) {
+        // 使用默认配置
+        const pluginConfig = {
+            enabled: toolContext?.config?.['page-action-cache']?.enabled !== false,
+            autoUseCache: toolContext?.config?.['page-action-cache']?.autoUseCache !== false,
+        };
+        console.log('[PageActionCache] Final config:', JSON.stringify(pluginConfig));
+        if (!pluginConfig.enabled) {
+            console.log('[PageActionCache] Extension disabled by configuration');
+            return;
+        }
+        console.log('[PageActionCache] Extension enabled, registering tools...');
+        // 注册页面快照缓存工具
+        api.registerTool({
+            name: 'page_snapshot_cache',
+            description: 'Cache and retrieve page snapshots to speed up repeated operations',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    url: {
+                        type: 'string',
+                        description: 'Page URL'
+                    },
+                    snapshot: {
+                        type: 'string',
+                        description: 'Page snapshot to store'
+                    },
+                    refs: {
+                        type: 'object',
+                        description: 'Role references map'
+                    },
+                    invalidate: {
+                        type: 'boolean',
+                        description: 'Invalidate cache for this URL',
+                        default: false
+                    }
+                },
+                required: ['url']
+            },
+            async execute(params) {
+                console.log('[PageActionCache] page_snapshot_cache called:', JSON.stringify(params));
+                const { url, snapshot, refs, invalidate = false } = params;
+                // 处理失效请求
+                if (invalidate) {
+                    const key = getCacheKey(url);
+                    memoryCache.delete(key);
+                    console.log(`[PageActionCache] Cache invalidated for: ${url}`);
                     return {
-                        success: false,
-                        message: 'Extension is disabled'
+                        text: `Cache invalidated for ${url}`,
+                        invalidated: true
                     };
                 }
-                const stats = multiLevelCache.getStats();
-                const invalidationStats = cacheInvalidation.getInvalidationStats();
-                console.log('[PageActionCache] Stats:', stats);
-                console.log('[PageActionCache] Invalidation stats:', invalidationStats);
-                // 生成统计报告
-                let message = '## Page Action Cache Statistics\n\n';
-                message += '### Overall Performance\n';
-                message += `- Total Cache Entries: ${stats.totalEntries}\n`;
-                message += `- Total Cache Hits: ${stats.totalHits}\n`;
-                message += `- Cache Hit Rate: ${stats.hitRate.toFixed(2)}%\n\n`;
-                message += '### Multi-Level Cache Distribution\n';
-                for (const [level, levelStats] of Object.entries(stats.levelStats)) {
-                    message += `#### ${level} Cache\n`;
-                    message += `- Size: ${levelStats.size}/${levelStats.maxCapacity} (${(levelStats.usageRate * 100).toFixed(1)}% full)\n`;
-                    message += `- Average Access Count: ${levelStats.avgAccessCount.toFixed(1)}\n\n`;
+                // 处理存储请求
+                if (snapshot && refs) {
+                    const key = getCacheKey(url);
+                    const entry = {
+                        url,
+                        snapshot,
+                        refs,
+                        timestamp: Date.now(),
+                        hitCount: 0
+                    };
+                    memoryCache.set(key, entry);
+                    // 清理过期缓存
+                    cleanupExpiredCache();
+                    console.log(`[PageActionCache] Cache stored for: ${url}`);
+                    return {
+                        text: `Snapshot cached for ${url}`,
+                        cached: true
+                    };
                 }
-                message += '### Cache Invalidation\n';
-                message += `- Total Snapshots: ${invalidationStats.totalSnapshots}\n`;
-                message += `- Active Snapshots: ${invalidationStats.activeSnapshots}\n`;
-                message += `- Invalidation Rate: ${(invalidationStats.invalidationRate * 100).toFixed(2)}%\n`;
+                // 处理查询请求
+                const key = getCacheKey(url);
+                const cached = memoryCache.get(key);
+                if (cached && pluginConfig.autoUseCache) {
+                    // 更新访问统计
+                    cached.hitCount++;
+                    cached.timestamp = Date.now();
+                    console.log(`[PageActionCache] Cache HIT for: ${url} (hit #${cached.hitCount})`);
+                    return {
+                        text: `Cache hit for ${url}`,
+                        snapshot: cached.snapshot,
+                        refs: cached.refs,
+                        hitCount: cached.hitCount,
+                        cached: true
+                    };
+                }
+                console.log(`[PageActionCache] Cache MISS for: ${url}`);
                 return {
-                    success: true,
-                    message,
-                    stats,
-                    invalidationStats
+                    text: `Cache miss for ${url}`,
+                    cached: false
                 };
             }
-            catch (error) {
-                console.error('[PageActionCache] Error in browser_cache_stats:', error);
-                return {
-                    success: false,
-                    message: `Error: ${error instanceof Error ? error.message : String(error)}`
+        });
+        // 注册缓存统计工具
+        api.registerTool({
+            name: 'page_cache_stats',
+            description: 'View page snapshot cache statistics',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: []
+            },
+            async execute() {
+                console.log('[PageActionCache] page_cache_stats called');
+                // 清理过期缓存
+                const cleaned = cleanupExpiredCache();
+                const stats = {
+                    totalEntries: memoryCache.size,
+                    hits: Array.from(memoryCache.values()).reduce((sum, e) => sum + e.hitCount, 0),
+                    avgHitCount: memoryCache.size > 0
+                        ? Array.from(memoryCache.values()).reduce((sum, e) => sum + e.hitCount, 0) / memoryCache.size
+                        : 0,
+                    oldestEntry: memoryCache.size > 0
+                        ? Math.min(...Array.from(memoryCache.values()).map(e => e.timestamp))
+                        : null,
+                    newestEntry: memoryCache.size > 0
+                        ? Math.max(...Array.from(memoryCache.values()).map(e => e.timestamp))
+                        : null
                 };
-            }
-        }
-    });
-    // 注册缓存清空工具
-    api.registerTool({
-        name: 'browser_cache_clear',
-        description: '清空页面操作缓存',
-        async execute(ctx) {
-            try {
-                console.log('[PageActionCache] browser_cache_clear called');
-                console.log('[PageActionCache] Context params:', ctx.params ? JSON.stringify(ctx.params, null, 2) : 'null');
-                const pluginConfig = ctx.config?.plugins?.entries?.['page-action-cache'] ?? {};
-                const enabled = pluginConfig.enabled !== false;
-                if (!enabled) {
-                    return {
-                        success: false,
-                        message: 'Extension is disabled'
-                    };
-                }
-                const params = ctx.params || {};
-                const level = params.level || 'all'; // 'all', 'L3', 'L2', 'L1'
-                const url = params.url;
-                const viewport = params.viewport;
-                console.log('[PageActionCache] Clear params:', { level, url, viewport });
-                let cleared = 0;
-                if (level === 'all') {
-                    if (url) {
-                        // 清空特定 URL 的所有缓存
-                        multiLevelCache.deleteCacheByUrl(url);
-                        cacheInvalidation.invalidateByUrl(url);
-                        cleared = 1;
-                    }
-                    else {
-                        // 清空所有缓存
-                        multiLevelCache.clearAll();
-                        cacheInvalidation.reset();
-                        cleared = 1;
-                    }
-                }
-                else if (level === 'L3' || level === 'L2' || level === 'L1') {
-                    if (url && viewport) {
-                        multiLevelCache.deleteCache(url, viewport);
-                        cacheInvalidation.invalidate(url, viewport);
-                        cleared = 1;
-                    }
-                    else {
-                        multiLevelCache.clearLevel(level);
-                        cleared = 1;
-                    }
-                }
-                console.log('[PageActionCache] Cleared cache entries');
-                const levelText = level === 'all' ? 'all caches' : `${level} cache`;
-                const urlText = url ? ` for ${url}` : '';
-                const message = `Cleared ${levelText}${urlText}`;
+                console.log('[PageActionCache] Stats:', JSON.stringify(stats));
+                const hitRate = stats.totalEntries > 0
+                    ? (stats.hits / stats.totalEntries * 100).toFixed(2)
+                    : '0.00';
                 return {
-                    success: true,
-                    message,
-                    level,
-                    url,
-                    cleared
+                    text: `## Page Snapshot Cache Statistics\n\n` +
+                        `- Total Entries: ${stats.totalEntries}\n` +
+                        `- Total Hits: ${stats.hits}\n` +
+                        `- Hit Rate: ${hitRate}%\n` +
+                        `- Avg Hit Count: ${stats.avgHitCount.toFixed(1)}\n` +
+                        `- Cleaned Entries: ${cleaned}\n` +
+                        `- Oldest Entry: ${stats.oldestEntry ? new Date(stats.oldestEntry).toISOString() : 'N/A'}\n` +
+                        `- Newest Entry: ${stats.newestEntry ? new Date(stats.newestEntry).toISOString() : 'N/A'}`,
+                    stats
                 };
             }
-            catch (error) {
-                console.error('[PageActionCache] Error in browser_cache_clear:', error);
+        });
+        // 注册缓存清空工具
+        api.registerTool({
+            name: 'page_cache_clear',
+            description: 'Clear page snapshot cache',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: []
+            },
+            async execute() {
+                console.log('[PageActionCache] page_cache_clear called');
+                const count = memoryCache.size;
+                memoryCache.clear();
+                console.log(`[PageActionCache] Cleared ${count} cache entries`);
                 return {
-                    success: false,
-                    message: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    text: `Cleared ${count} cache entries`,
+                    cleared: count
                 };
             }
-        }
-    });
-    console.log('[PageActionCache] All tools registered successfully');
+        });
+        console.log('[PageActionCache] All tools registered successfully');
+    }
+    catch (error) {
+        console.error('[PageActionCache] Fatal error during plugin registration:', error);
+        // 即使发生错误，也尝试注册基本工具以确保插件可用
+    }
 }
-// Export register as registerTools for backward compatibility with tests
-export const registerTools = register;
 //# sourceMappingURL=index.js.map