@weavetab/mcp 2.5.0-beta.1 → 2.5.0-beta.4

package/dist/intelligence/patternCompiler.js

@@ -0,0 +1,259 @@
+/**
+ * Weavetab — intelligence/patternCompiler.ts
+ *
+ * Compiles raw browser session trails (action sequences) into persistent,
+ * reusable site workflow patterns stored under ~/.weavetab-system/memory/sites/.
+ *
+ * Design invariants:
+ *  - One file per origin (sanitized hostname). Never creates per-path or per-run files.
+ *  - Pattern names are caller-supplied (snake_case). Duplicate calls for the same
+ *    name on the same origin UPDATE the existing pattern rather than creating a new file.
+ *  - Volatile / unstable selectors (auto-generated classes, nth-child paths) are
+ *    stripped and replaced with semantic anchors where possible.
+ *  - Never reads or writes to ~/.weavetab/ (user config space).
+ */
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import fs from "fs";
+import { getSystemMemorySitesDir } from "../config/loader.js";
+import { logDebug } from "../audit/logger.js";
+// ─── Volatile selector detection ────────────────────────────────────────────
+const VOLATILE_PATTERNS = [
+    /\[class\*="[a-z0-9]+-[a-z0-9]+"\]/, // CSS-module hash attribute selectors
+    /:nth-child\(\d+\)/, // positional pseudo-selectors
+    /\.\w{8,}[-_]\w{4,}/, // hashed Tailwind / CSS-module class combos
+    /div > div > div > /, // deep anonymous structural chains (3+ levels)
+];
+function isVolatileSelector(sel) {
+    return VOLATILE_PATTERNS.some((rx) => rx.test(sel));
+}
+function stabilizeSelector(sel) {
+    if (!sel)
+        return undefined;
+    if (isVolatileSelector(sel)) {
+        logDebug(`[PatternCompiler] Dropping volatile selector: ${sel}`);
+        return undefined;
+    }
+    return sel;
+}
+// ─── File path helpers ───────────────────────────────────────────────────────
+function originToFilename(origin) {
+    return origin
+        .replace(/^https?:\/\//, "")
+        .replace(/[^a-zA-Z0-9.-]/g, "_");
+}
+function siteProfilePath(origin) {
+    const sitesDir = getSystemMemorySitesDir();
+    return join(sitesDir, `${originToFilename(origin)}.json`);
+}
+// ─── In-process LRU cache ───────────────────────────────────────────────────
+const profileCache = new Map();
+const CACHE_MAX = 100;
+function cacheSet(origin, profile) {
+    if (profileCache.size >= CACHE_MAX && !profileCache.has(origin)) {
+        const firstKey = profileCache.keys().next().value;
+        if (firstKey !== undefined)
+            profileCache.delete(firstKey);
+    }
+    profileCache.set(origin, profile);
+}
+export function clearSiteProfileCache() {
+    profileCache.clear();
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Load a site profile from disk. Returns null if the site has never been profiled.
+ * Hits in-process cache first — no redundant disk reads within a session.
+ */
+export async function getSiteProfile(origin) {
+    if (profileCache.has(origin))
+        return profileCache.get(origin);
+    const filePath = siteProfilePath(origin);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        const profile = JSON.parse(raw);
+        cacheSet(origin, profile);
+        return profile;
+    }
+    catch (e) {
+        logDebug(`[PatternCompiler] Failed to parse site profile for ${origin}: ${e}`);
+        return null;
+    }
+}
+/**
+ * Persist a site profile. Always deep-merges into existing data on disk — never
+ * blindly overwrites — so concurrent tool calls don't clobber each other.
+ */
+export async function saveSiteProfile(profile) {
+    const filePath = siteProfilePath(profile.origin);
+    let base = null;
+    if (fs.existsSync(filePath)) {
+        try {
+            base = JSON.parse(await readFile(filePath, "utf-8"));
+        }
+        catch { /* treat corrupt file as empty */ }
+    }
+    const merged = {
+        ...base,
+        ...profile,
+        origin: profile.origin,
+        patterns: { ...(base?.patterns ?? {}), ...profile.patterns },
+        quirks: { ...(base?.quirks ?? {}), ...profile.quirks },
+        visitCount: profile.visitCount ?? base?.visitCount ?? 0,
+        updatedAt: new Date().toISOString(),
+    };
+    cacheSet(profile.origin, merged);
+    await writeFile(filePath, JSON.stringify(merged, null, 2), "utf-8");
+    logDebug(`[PatternCompiler] Saved site profile → ${filePath}`);
+}
+/**
+ * Learn or update a named workflow pattern for a given origin.
+ * - Duplicate name = merge/update, never duplicate file.
+ * - Volatile selectors in steps are dropped to keep patterns stable.
+ * - Anti-spam: skips disk write when content is identical to existing.
+ */
+export async function learnPattern(origin, name, incoming) {
+    const profile = (await getSiteProfile(origin)) ?? {
+        origin,
+        quirks: {},
+        patterns: {},
+        visitCount: 0,
+        updatedAt: new Date().toISOString(),
+    };
+    const existing = profile.patterns[name] ?? {
+        name,
+        steps: [],
+        reliability: 1.0,
+        strikes: 0,
+        last_verified: new Date().toISOString(),
+        total_executions: 0,
+        successful_executions: 0,
+    };
+    const stabilizedSteps = (incoming.steps ?? existing.steps).map((step) => ({
+        ...step,
+        target: step.target ? stabilizeSelector(step.target) : undefined,
+    }));
+    const hasChanges = (!profile.patterns[name] ||
+        (incoming.steps !== undefined && JSON.stringify(stabilizedSteps) !== JSON.stringify(existing.steps)) ||
+        (incoming.success_indicator !== undefined && incoming.success_indicator !== existing.success_indicator) ||
+        (incoming.entry !== undefined && incoming.entry !== existing.entry));
+    if (hasChanges) {
+        const updated = {
+            ...existing,
+            ...incoming,
+            name,
+            steps: stabilizedSteps,
+            last_verified: new Date().toISOString(),
+        };
+        await saveSiteProfile({
+            ...profile,
+            patterns: { ...profile.patterns, [name]: updated },
+        });
+        logDebug(`[PatternCompiler] Pattern "${name}" learned/updated for ${origin}`);
+        return updated;
+    }
+    else {
+        logDebug(`[PatternCompiler] Pattern "${name}" unchanged — skipping write`);
+        return existing;
+    }
+}
+/**
+ * Record the outcome of executing a named pattern.
+ * Updates reliability via EWMA (α=0.15) and tracks consecutive strikes.
+ * 3 strikes → reliability will naturally fall below 0.4, agent should re-explore.
+ */
+export async function recordPatternExecution(origin, patternName, success, durationMs) {
+    const profile = await getSiteProfile(origin);
+    if (!profile)
+        return null;
+    const pattern = profile.patterns[patternName];
+    if (!pattern)
+        return null;
+    const alpha = 0.15;
+    const newReliability = Math.round((0.85 * pattern.reliability + alpha * (success ? 1 : 0)) * 1000) / 1000;
+    const updated = {
+        ...pattern,
+        reliability: newReliability,
+        strikes: success ? 0 : pattern.strikes + 1,
+        last_verified: success ? new Date().toISOString() : pattern.last_verified,
+        total_executions: pattern.total_executions + 1,
+        successful_executions: success ? pattern.successful_executions + 1 : pattern.successful_executions,
+        avg_duration_ms: durationMs !== undefined
+            ? Math.round(pattern.avg_duration_ms !== undefined
+                ? 0.8 * pattern.avg_duration_ms + 0.2 * durationMs
+                : durationMs)
+            : pattern.avg_duration_ms,
+    };
+    if (updated.strikes >= 3) {
+        logDebug(`[PatternCompiler] ⚠ Pattern "${patternName}" on ${origin} hit 3 strikes (reliability: ${updated.reliability}) — re-learning recommended`);
+    }
+    await saveSiteProfile({
+        ...profile,
+        patterns: { ...profile.patterns, [patternName]: updated },
+    });
+    return updated;
+}
+/**
+ * Record or update a site quirk (cookie banner, rate limit, modal popup, etc.)
+ * Only writes if the stored data differs from incoming — prevents spam writes.
+ */
+export async function recordQuirk(origin, quirkKey, quirkData) {
+    const profile = (await getSiteProfile(origin)) ?? {
+        origin,
+        quirks: {},
+        patterns: {},
+        visitCount: 0,
+        updatedAt: new Date().toISOString(),
+    };
+    const existing = profile.quirks[quirkKey];
+    if (JSON.stringify(existing) === JSON.stringify(quirkData)) {
+        logDebug(`[PatternCompiler] Quirk "${quirkKey}" unchanged — skipping write`);
+        return;
+    }
+    await saveSiteProfile({
+        ...profile,
+        quirks: { ...profile.quirks, [quirkKey]: quirkData },
+    });
+    logDebug(`[PatternCompiler] Recorded quirk "${quirkKey}" for ${origin}`);
+}
+/**
+ * Returns the reliability score (0–1) of a named pattern, or -1 if unknown.
+ */
+export async function getPatternReliability(origin, patternName) {
+    const profile = await getSiteProfile(origin);
+    if (!profile)
+        return -1;
+    return profile.patterns[patternName]?.reliability ?? -1;
+}
+/**
+ * Formats a compact site profile hint string for agent system prompt injection.
+ * Called at session start when navigating to a known origin.
+ */
+export function formatSiteProfileHint(profile) {
+    const lines = [`[SiteProfile] ${profile.origin}`];
+    if (profile.framework)
+        lines.push(`  framework: ${profile.framework}`);
+    if (profile.captcha_frequency && profile.captcha_frequency !== "none") {
+        lines.push(`  captcha_frequency: ${profile.captcha_frequency}`);
+    }
+    const patternNames = Object.keys(profile.patterns);
+    if (patternNames.length > 0) {
+        lines.push("  known_patterns:");
+        for (const name of patternNames) {
+            const p = profile.patterns[name];
+            const flag = p.strikes >= 3
+                ? " [RE-LEARN NEEDED]"
+                : p.reliability >= 0.8
+                    ? " [fast-path eligible]"
+                    : "";
+            lines.push(`    - ${name}: reliability=${p.reliability.toFixed(2)}, steps=${p.steps.length}${flag}`);
+        }
+    }
+    const quirkKeys = Object.keys(profile.quirks).filter((k) => profile.quirks[k] !== undefined && profile.quirks[k] !== null);
+    if (quirkKeys.length > 0) {
+        lines.push(`  quirks: ${quirkKeys.join(", ")}`);
+    }
+    return lines.join("\n");
+}

package/dist/intelligence/sessionMemory.d.ts

@@ -34,6 +34,8 @@ export interface DomainProfile {
     updatedAt: string;
     visitCount: number;
 }
+export declare function clearMemoryCache(): void;
+export declare function getDomainFilePath(hostname: string): string;
 export declare function loadDomainProfile(hostname: string): Promise<DomainProfile | null>;
 export declare function saveDomainProfile(hostname: string, updates: Partial<DomainProfile>): Promise<DomainProfile>;
 /**

package/dist/intelligence/sessionMemory.js

@@ -1,20 +1,30 @@
 import { readFile, writeFile } from "fs/promises";
 import { join } from "path";
-import { GLOBAL_CONFIG_DIR } from "../config/loader.js";
+import { GLOBAL_CONFIG_DIR, getSystemDir } from "../config/loader.js";
 import { logDebug } from "../audit/logger.js";
 import fs from "fs";
 function domainFile(hostname) {
     const safe = hostname.replace(/[^a-zA-Z0-9.-]/g, "_");
-    const memoryDir = join(GLOBAL_CONFIG_DIR, "memory");
-    if (!fs.existsSync(memoryDir))
-        fs.mkdirSync(memoryDir, { recursive: true });
-    return join(memoryDir, `${safe}.json`);
+    const memoryDir = getSystemDir("memory");
+    const systemPath = join(memoryDir, `${safe}.json`);
+    // Backward compatibility: migrate legacy ~/.weavetab/memory/<safe>.json if it exists
+    const legacyPath = join(GLOBAL_CONFIG_DIR, "memory", `${safe}.json`);
+    if (!fs.existsSync(systemPath) && fs.existsSync(legacyPath)) {
+        try {
+            fs.copyFileSync(legacyPath, systemPath);
+        }
+        catch { /* ignore migration error */ }
+    }
+    return systemPath;
 }
-// memoryCache is capped at 200 DomainProfile entries (one per unique hostname).
-// When the cap is hit, the oldest entry is evicted (insertion-order LRU) so the
-// cache can't grow without bound over a long session.
 const memoryCache = new Map();
 const MEMORY_CACHE_MAX = 200;
+export function clearMemoryCache() {
+    memoryCache.clear();
+}
+export function getDomainFilePath(hostname) {
+    return domainFile(hostname);
+}
 function memoryCacheSet(hostname, profile) {
     if (memoryCache.size >= MEMORY_CACHE_MAX && !memoryCache.has(hostname)) {
         // Evict the oldest (first) entry

package/dist/overlay/ghost.js

@@ -1,5 +1,5 @@
 import { logDebug } from "../audit/logger.js";
-import { getConfigHeadless, getConfigVisuals } from "../config/loader.js";
+import { getConfigHeadless } from "../config/loader.js";
 function sleep(ms) {
     return new Promise(r => setTimeout(r, ms));
 }
@@ -378,7 +378,7 @@ export async function ghostMove(session, targetX, targetY, config, label, profil
         return;
     }
     wtCursor(session, currentX, currentY, label && distance >= 150 ? "searching" : "idle", cursorOpts);
-    if (label && distance >= 150 && getConfigVisuals(config) !== false) {
+    if (label && distance >= 150) {
         wtThought(session, `moving to ${label.slice(0, 40)}...`);
         await sleep(60 + Math.random() * 80);
     }

package/dist/overlay/injector.js

@@ -1,5 +1,5 @@
 import { logDebug } from "../audit/logger.js";
-import { getConfigVisuals, getConfigDevMode } from "../config/loader.js";
+import { getConfigDevMode } from "../config/loader.js";
 // ─── Minimal Overlay Script ───────────────────────────────────────────────────
 export function getMinimalOverlayScript() {
     return `(function(){
@@ -67,7 +67,6 @@ export function getMinimalOverlayScript() {
 
     window.__wt_setConfig = function(c) {
       if (c && c.devMode) window.__wt_devMode = true;
-      if (c && c.visuals !== undefined) window.__wt_showVisuals = !!c.visuals;
     };
 
     window.__wt_status = function() { return JSON.stringify({ rootInjected: true }); };
@@ -121,7 +120,6 @@ function buildConfigExpr(config) {
     return `
 if(window.__wt_setConfig)window.__wt_setConfig(${JSON.stringify({
         ...config,
-        visuals: getConfigVisuals(config) !== false,
     })});
 window.postMessage({type:'Weavetab-msg-in',data:${JSON.stringify(msg)}},'*');
 `;
@@ -154,7 +152,7 @@ export async function ensureVisualLayer(session, config, client) {
                 returnByValue: true
             });
             if (checkResult?.value) {
-                logDebug(`[Weavetab] [OK] Minimal overlay injected successfully`);
+                logDebug(`[Weavetab] overlay injected`);
             }
             else {
                 logDebug(`[Weavetab] [!] Minimal overlay injection failed - element not found`);
@@ -173,7 +171,7 @@ export async function setupOverlay(session, config) {
     await ensureVisualLayer(session, config);
 }
 export async function setFaviconState(_session, _state) {
-    // Handled robustly via extension content.js
+    // handled via extension content.js
 }
 export async function removeTitleBadge(_session) {
     // No-op: title dot prefix removed in favor of favicon indicators

package/dist/plugin/extension_bridge.d.ts

@@ -0,0 +1,40 @@
+import type CDP from "chrome-remote-interface";
+import type { WeavetabPermissions } from "./interface.js";
+export interface IPluginExtensionBridge {
+    send(session: CDP.Client, message: object): Promise<boolean>;
+    setHudState(session: CDP.Client, state: {
+        action?: string;
+        badge?: string;
+        badgeColor?: string;
+        groupState?: string;
+    }): Promise<void>;
+    showThought(session: CDP.Client, text: string, options?: {
+        durationMs?: number;
+    }): Promise<void>;
+    clearThought(session: CDP.Client): Promise<void>;
+    injectStyles(session: CDP.Client, css: string): Promise<void>;
+    injectScript<T = any>(session: CDP.Client, js: string): Promise<T>;
+    hideOverlay(session: CDP.Client): Promise<void>;
+    restoreOverlay(session: CDP.Client): Promise<void>;
+}
+export declare class PluginExtensionBridge implements IPluginExtensionBridge {
+    readonly pluginName: string;
+    private readonly permissions?;
+    constructor(pluginName: string, permissions?: WeavetabPermissions | undefined);
+    private checkPermission;
+    send(session: CDP.Client, message: object): Promise<boolean>;
+    setHudState(session: CDP.Client, state: {
+        action?: string;
+        badge?: string;
+        badgeColor?: string;
+        groupState?: string;
+    }): Promise<void>;
+    showThought(session: CDP.Client, text: string, options?: {
+        durationMs?: number;
+    }): Promise<void>;
+    clearThought(session: CDP.Client): Promise<void>;
+    injectStyles(session: CDP.Client, css: string): Promise<void>;
+    injectScript<T = any>(session: CDP.Client, js: string): Promise<T>;
+    hideOverlay(session: CDP.Client): Promise<void>;
+    restoreOverlay(session: CDP.Client): Promise<void>;
+}

package/dist/plugin/extension_bridge.js

@@ -0,0 +1,158 @@
+import { sendToExtension, hideWeaveTabOverlay, restoreWeaveTabOverlay } from "../cdp/helpers.js";
+import { logDebug } from "../audit/logger.js";
+export class PluginExtensionBridge {
+    pluginName;
+    permissions;
+    constructor(pluginName, permissions) {
+        this.pluginName = pluginName;
+        this.permissions = permissions;
+    }
+    checkPermission(category) {
+        if (!this.permissions || !this.permissions.extension)
+            return true; // Default permissive if not restricted
+        return this.permissions.extension[category] !== false;
+    }
+    async send(session, message) {
+        if (!session)
+            return false;
+        return await sendToExtension(session, {
+            ...message,
+            plugin: this.pluginName,
+        });
+    }
+    async setHudState(session, state) {
+        if (!this.checkPermission("hud")) {
+            logDebug(`[Weavetab PluginExtension] Plugin "${this.pluginName}" lacks permissions.extension.hud`);
+            return;
+        }
+        await this.send(session, {
+            type: "wt-hud-update",
+            action: state.action,
+            badge: state.badge,
+            badgeColor: state.badgeColor,
+            groupState: state.groupState,
+            timestamp: Date.now(),
+        });
+    }
+    async showThought(session, text, options) {
+        if (!this.checkPermission("hud"))
+            return;
+        if (!session || !session.Runtime)
+            return;
+        const duration = options?.durationMs || 4000;
+        const safeText = JSON.stringify(text);
+        try {
+            await session.Runtime.evaluate({
+                expression: `(function() {
+          var existing = document.getElementById('__wt_plugin_thought_${this.pluginName}');
+          if (existing) existing.remove();
+
+          var bubble = document.createElement('div');
+          bubble.id = '__wt_plugin_thought_${this.pluginName}';
+          bubble.className = 'wt-bubble';
+          bubble.setAttribute('data-wt-internal', 'true');
+          bubble.style.cssText = [
+            'position: fixed',
+            'bottom: 24px',
+            'right: 24px',
+            'background: linear-gradient(135deg, rgba(17, 24, 39, 0.95), rgba(30, 41, 59, 0.95))',
+            'color: #f8fafc',
+            'padding: 12px 18px',
+            'border-radius: 12px',
+            'font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+            'font-size: 13px',
+            'font-weight: 500',
+            'box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(255, 255, 255, 0.1)',
+            'z-index: 2147483647',
+            'backdrop-filter: blur(8px)',
+            'pointer-events: none',
+            'animation: wtThoughtFade 0.25s cubic-bezier(0.16, 1, 0.3, 1)',
+            'display: flex',
+            'align-items: center',
+            'gap: 8px'
+          ].join(';');
+
+          var icon = document.createElement('span');
+          icon.textContent = '✨';
+          var textSpan = document.createElement('span');
+          textSpan.textContent = ${safeText};
+
+          bubble.appendChild(icon);
+          bubble.appendChild(textSpan);
+          document.body.appendChild(bubble);
+
+          setTimeout(function() {
+            if (bubble && bubble.parentNode) {
+              bubble.style.opacity = '0';
+              bubble.style.transition = 'opacity 0.3s ease';
+              setTimeout(function() { bubble.remove(); }, 300);
+            }
+          }, ${duration});
+        })()`,
+                returnByValue: false,
+            });
+        }
+        catch (e) {
+            logDebug(`[Weavetab PluginExtension] Failed to show thought:`, e);
+        }
+    }
+    async clearThought(session) {
+        if (!session || !session.Runtime)
+            return;
+        try {
+            await session.Runtime.evaluate({
+                expression: `(function() {
+          var existing = document.getElementById('__wt_plugin_thought_${this.pluginName}');
+          if (existing) existing.remove();
+        })()`,
+                returnByValue: false,
+            });
+        }
+        catch { /* ignore */ }
+    }
+    async injectStyles(session, css) {
+        if (!this.checkPermission("styles")) {
+            throw new Error(`Permission Denied: Plugin "${this.pluginName}" does not have permissions.extension.styles`);
+        }
+        if (!session || !session.Runtime)
+            return;
+        const safeCss = JSON.stringify(css);
+        await session.Runtime.evaluate({
+            expression: `(function() {
+        var styleId = '__wt_plugin_styles_${this.pluginName}';
+        var style = document.getElementById(styleId) || document.createElement('style');
+        style.id = styleId;
+        style.textContent = ${safeCss};
+        if (!style.parentNode) document.head.appendChild(style);
+      })()`,
+            returnByValue: false,
+        });
+    }
+    async injectScript(session, js) {
+        if (!this.checkPermission("scripts")) {
+            throw new Error(`Permission Denied: Plugin "${this.pluginName}" does not have permissions.extension.scripts`);
+        }
+        if (!session || !session.Runtime)
+            throw new Error("No active CDP session available");
+        const res = await session.Runtime.evaluate({
+            expression: js,
+            returnByValue: true,
+            awaitPromise: true,
+        });
+        return res.result?.value ?? res;
+    }
+    async hideOverlay(session) {
+        if (!this.checkPermission("overlay"))
+            return;
+        if (!session)
+            return;
+        await hideWeaveTabOverlay(session);
+    }
+    async restoreOverlay(session) {
+        if (!this.checkPermission("overlay"))
+            return;
+        if (!session)
+            return;
+        await restoreWeaveTabOverlay(session);
+    }
+}