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

package/dist/plugin/loader.js

@@ -1,18 +1,94 @@
 import { readdirSync, existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { join, basename } from "node:path";
+import os from "node:os";
 import { PluginStorageManager } from "./storage.js";
 import { PluginExtensionBridge } from "./extension_bridge.js";
+import { getSiteProfile, learnPattern, recordPatternExecution, getPatternReliability, recordQuirk } from "../intelligence/patternCompiler.js";
 const require = createRequire(import.meta.url);
+import { WEAVETAB_VERSION } from "../version.js";
+const RUNTIME_VERSION = WEAVETAB_VERSION;
 function getNodeModulesDirs(customDir) {
     if (customDir)
         return [customDir];
+    const cwd = process.cwd();
     const dirs = [
-        join(process.cwd(), "node_modules"),
-        join(process.cwd(), "MCP", "node_modules"),
+        join(cwd, "node_modules"),
+        join(cwd, "MCP", "node_modules"),
+        join(cwd, "..", "node_modules"),
+        join(os.homedir(), ".weavetab", "plugins", "node_modules"),
+        join(os.homedir(), ".weavetab-system", "plugins", "node_modules"),
     ];
     return Array.from(new Set(dirs.filter((d) => existsSync(d))));
 }
+/**
+ * Normalizes permissions format across legacy arrays and object aliases (filesystem vs fs).
+ */
+export function normalizePermissions(perms) {
+    if (!perms)
+        return {};
+    // Handle flat string array: ["browser.evaluate", "browser.navigate", "fs.read", ...]
+    if (Array.isArray(perms)) {
+        const normalized = { cdp: {}, fs: {}, extension: {} };
+        for (const item of perms) {
+            if (typeof item !== "string")
+                continue;
+            const [cat, sub] = item.split(".");
+            if (cat === "browser" || cat === "cdp") {
+                normalized.cdp[sub || "evaluate"] = true;
+            }
+            else if (cat === "fs" || cat === "filesystem") {
+                normalized.fs[sub || "read"] = ["*"];
+            }
+            else if (cat === "extension" || cat === "hud") {
+                normalized.extension[sub || "hud"] = true;
+            }
+        }
+        return normalized;
+    }
+    const result = { ...perms };
+    // Reconcile filesystem <-> fs alias
+    if (perms.filesystem && !perms.fs) {
+        result.fs = perms.filesystem;
+    }
+    else if (perms.fs && !perms.filesystem) {
+        result.filesystem = perms.fs;
+    }
+    return result;
+}
+/**
+ * Validates whether the plugin's engine requirement matches the current runtime version.
+ */
+function checkEngineCompatibility(engineReq) {
+    if (!engineReq || engineReq === "*" || engineReq === "latest") {
+        return { compatible: true };
+    }
+    // Simple semver range parsing (handles ^x.y.z, >=x.y.z, ~x.y.z, x.y.z)
+    const cleanReq = engineReq.replace(/[\^~>=]/g, "").trim();
+    const reqParts = cleanReq.split(".").map((p) => parseInt(p, 10));
+    const curParts = RUNTIME_VERSION.split("-")[0].split(".").map((p) => parseInt(p, 10));
+    if (engineReq.startsWith("^")) {
+        // Caret: same major
+        if (curParts[0] === reqParts[0] && (curParts[1] > reqParts[1] || (curParts[1] === reqParts[1] && curParts[2] >= reqParts[2]))) {
+            return { compatible: true };
+        }
+    }
+    else if (engineReq.startsWith(">=")) {
+        if (curParts[0] > reqParts[0] || (curParts[0] === reqParts[0] && curParts[1] >= reqParts[1])) {
+            return { compatible: true };
+        }
+    }
+    else {
+        // Exact or direct match
+        if (curParts[0] === reqParts[0] && curParts[1] === reqParts[1]) {
+            return { compatible: true };
+        }
+    }
+    return {
+        compatible: false,
+        message: `Plugin requires Weavetab version ${engineReq}, but current runtime is ${RUNTIME_VERSION}.`,
+    };
+}
 /**
  * Reads the manifest (weavetab.json) and package.json for an installed package
  * without executing its runtime code (safe for listing/inspection).
@@ -59,7 +135,7 @@ export function listInstalledPlugins(pluginDir) {
                 if (!entry.isDirectory() && !entry.isSymbolicLink())
                     continue;
                 if (entry.name.startsWith("@")) {
-                    // Scoped packages (@weavetab/plugin-xyz, @scope/xyz)
+                    // Scoped packages (@weavetab/plugin-xyz, @scope/xyz, @fy2ne/wt-youtube)
                     const scopeDir = join(modulesDir, entry.name);
                     try {
                         const scopeEntries = readdirSync(scopeDir, { withFileTypes: true });
@@ -76,7 +152,7 @@ export function listInstalledPlugins(pluginDir) {
                     catch { /* scope dir unreadable */ }
                 }
                 else {
-                    // Top-level packages (any name)
+                    // Top-level packages (any name: wt-github, custom-plugin, etc.)
                     const info = inspectInstalledPackage(join(modulesDir, entry.name));
                     if (info && !seenPackages.has(info.packageName)) {
                         seenPackages.add(info.packageName);
@@ -89,10 +165,89 @@ export function listInstalledPlugins(pluginDir) {
     }
     return results;
 }
+/**
+ * Builds the canonical rich PluginContext for a loaded plugin.
+ */
+export function buildPluginContext(plugin, storageManager, extensionBridge, pluginConfig, hooks) {
+    return {
+        name: plugin.name,
+        version: plugin.version,
+        pluginDir: storageManager.getDirectory(),
+        config: pluginConfig,
+        storage: storageManager,
+        extension: extensionBridge,
+        mcp: {
+            registerTool: (tool) => {
+                plugin.tools = plugin.tools || [];
+                const existingIndex = plugin.tools.findIndex((t) => t.name === tool.name);
+                if (existingIndex >= 0) {
+                    plugin.tools[existingIndex] = tool;
+                }
+                else {
+                    plugin.tools.push(tool);
+                }
+            },
+            overrideTool: (toolName, overrideHandler) => {
+                plugin.overrides = plugin.overrides || [];
+                plugin.overrides.push({ name: toolName, handler: overrideHandler });
+            },
+            removeTool: (toolName) => {
+                plugin.removeTools = plugin.removeTools || [];
+                plugin.removeTools.push(toolName);
+            },
+            unregisterTool: (toolName) => {
+                plugin.removeTools = plugin.removeTools || [];
+                plugin.removeTools.push(toolName);
+            },
+        },
+        hooks: {
+            onBeforeAction: (fn) => {
+                if (typeof fn === "function")
+                    hooks.beforeToolCall.push(fn);
+            },
+            onAfterAction: (fn) => {
+                if (typeof fn === "function") {
+                    hooks.afterToolCall.push(async (toolName, args, result, session) => {
+                        return await fn(toolName, result, session, args);
+                    });
+                }
+            },
+            onDOMMutation: (fn) => {
+                if (typeof fn === "function")
+                    hooks.onDOMMutation?.push(fn);
+            },
+            beforeToolCall: (fn) => {
+                if (typeof fn === "function")
+                    hooks.beforeToolCall.push(fn);
+            },
+            afterToolCall: (fn) => {
+                if (typeof fn === "function")
+                    hooks.afterToolCall.push(fn);
+            },
+            onPageNavigate: (fn) => {
+                if (typeof fn === "function")
+                    hooks.onPageNavigate.push(fn);
+            },
+        },
+        memory: {
+            getSiteProfile: (origin) => getSiteProfile(origin),
+            learnPattern: (origin, name, pattern) => learnPattern(origin, name, pattern),
+            recordExecution: (origin, name, success, durationMs) => recordPatternExecution(origin, name, success, durationMs),
+            getReliability: (origin, patternName) => getPatternReliability(origin, patternName),
+            recordQuirk: (origin, quirkKey, quirkData) => recordQuirk(origin, quirkKey, quirkData),
+        },
+        logger: {
+            info: (...args) => console.error(`[Plugin: ${plugin.name}] [INFO]`, ...args),
+            warn: (...args) => console.error(`[Plugin: ${plugin.name}] [WARN]`, ...args),
+            error: (...args) => console.error(`[Plugin: ${plugin.name}] [ERROR]`, ...args),
+            debug: (...args) => console.error(`[Plugin: ${plugin.name}] [DEBUG]`, ...args),
+        },
+    };
+}
 /**
  * Attempt to load a single package as a Weavetab plugin for MCP server execution.
- * The presence of weavetab.json is the ONLY requirement — no name check needed.
- * This gives developers complete freedom to name their packages anything.
+ * The presence of weavetab.json is the ONLY requirement — any package name works.
+ * Constructs the rich PluginContext WITHOUT executing onLoad eagerly.
  */
 function tryLoadPlugin(pkgDir) {
     const manifestPath = join(pkgDir, "weavetab.json");
@@ -101,19 +256,47 @@ function tryLoadPlugin(pkgDir) {
     try {
         const rawManifest = readFileSync(manifestPath, "utf-8");
         const manifest = JSON.parse(rawManifest);
+        // Check engine compatibility
+        if (manifest.engines?.weavetab) {
+            const compat = checkEngineCompatibility(manifest.engines.weavetab);
+            if (!compat.compatible) {
+                console.error(`[Weavetab] Warning: ${compat.message}`);
+            }
+        }
         let pkg = {};
         const pkgPath = join(pkgDir, "package.json");
         if (existsSync(pkgPath)) {
-            pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            try {
+                pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            }
+            catch { /* malformed package.json */ }
+        }
+        // Resolve entry point: manifest.entry > pkg.main > "dist/index.js" > "index.js"
+        let entryFile = manifest.entry || pkg.main;
+        if (!entryFile) {
+            if (existsSync(join(pkgDir, "dist", "index.js"))) {
+                entryFile = "dist/index.js";
+            }
+            else {
+                entryFile = "index.js";
+            }
         }
-        const pluginMain = pkg.main || "index.js";
-        const pluginModule = require(join(pkgDir, pluginMain));
+        const resolvedEntry = join(pkgDir, entryFile);
+        if (!existsSync(resolvedEntry)) {
+            console.error(`[Weavetab] Plugin entry point not found: ${resolvedEntry}`);
+            return null;
+        }
+        const pluginModule = require(resolvedEntry);
         const plugin = pluginModule.default || pluginModule.plugin || pluginModule;
+        const normalizedPerms = normalizePermissions(manifest.permissions);
         if (plugin &&
             (Array.isArray(plugin.tools) ||
                 Array.isArray(plugin.overrides) ||
                 Array.isArray(plugin.removeTools) ||
-                Boolean(manifest.permissions?.tools) ||
+                typeof plugin.onBeforeAction === "function" ||
+                typeof plugin.onAfterAction === "function" ||
+                typeof plugin.onDOMMutation === "function" ||
+                Boolean(normalizedPerms?.tools) ||
                 typeof plugin.onLoad === "function")) {
             plugin.name = plugin.name || manifest.name || pkg.name || basename(pkgDir);
             plugin.version = plugin.version || manifest.version || pkg.version || "1.0.0";
@@ -121,80 +304,44 @@ function tryLoadPlugin(pkgDir) {
             plugin.manifest = manifest;
             plugin.tools = Array.isArray(plugin.tools) ? plugin.tools : [];
             plugin.overrides = Array.isArray(plugin.overrides) ? plugin.overrides : [];
+            plugin.manifest.permissions = normalizedPerms;
             plugin.removeTools = Array.isArray(plugin.removeTools)
                 ? plugin.removeTools
-                : manifest.permissions?.tools?.remove || [];
+                : normalizedPerms.tools?.remove || [];
             // Initialize isolated storage sandbox in ~/.weavetab/plugins/<plugin-name>/
             const storageManager = new PluginStorageManager(plugin.name);
-            const extensionBridge = new PluginExtensionBridge(plugin.name, manifest.permissions);
+            const extensionBridge = new PluginExtensionBridge(plugin.name, normalizedPerms);
             const pluginConfig = storageManager.loadConfig(plugin.defaultConfig || manifest.defaultConfig || {});
             const hooks = {
                 beforeToolCall: [],
                 afterToolCall: [],
+                onDOMMutation: [],
                 onPageNavigate: [],
             };
+            // Top-level plugin definition hooks
+            if (typeof plugin.onBeforeAction === "function") {
+                hooks.beforeToolCall.push(plugin.onBeforeAction);
+            }
+            if (typeof plugin.onAfterAction === "function") {
+                hooks.afterToolCall.push(async (toolName, args, result, session) => {
+                    return await plugin.onAfterAction(toolName, result, session, args);
+                });
+            }
+            if (typeof plugin.onDOMMutation === "function") {
+                hooks.onDOMMutation.push(plugin.onDOMMutation);
+            }
             plugin.storage = storageManager;
             plugin.extension = extensionBridge;
             plugin.hooks = hooks;
-            // Construct rich PluginContext
-            const pluginContext = {
-                name: plugin.name,
-                version: plugin.version,
-                pluginDir: storageManager.getDirectory(),
-                config: pluginConfig,
-                storage: storageManager,
-                extension: extensionBridge,
-                mcp: {
-                    registerTool: (tool) => {
-                        plugin.tools = plugin.tools || [];
-                        const existingIndex = plugin.tools.findIndex((t) => t.name === tool.name);
-                        if (existingIndex >= 0) {
-                            plugin.tools[existingIndex] = tool;
-                        }
-                        else {
-                            plugin.tools.push(tool);
-                        }
-                    },
-                    overrideTool: (toolName, overrideHandler) => {
-                        plugin.overrides = plugin.overrides || [];
-                        plugin.overrides.push({ name: toolName, handler: overrideHandler });
-                    },
-                    removeTool: (toolName) => {
-                        plugin.removeTools = plugin.removeTools || [];
-                        plugin.removeTools.push(toolName);
-                    },
-                },
-                hooks: {
-                    beforeToolCall: (fn) => hooks.beforeToolCall.push(fn),
-                    afterToolCall: (fn) => hooks.afterToolCall.push(fn),
-                    onPageNavigate: (fn) => hooks.onPageNavigate.push(fn),
-                },
-                logger: {
-                    info: (...args) => console.error(`[Plugin: ${plugin.name}] [INFO]`, ...args),
-                    warn: (...args) => console.error(`[Plugin: ${plugin.name}] [WARN]`, ...args),
-                    error: (...args) => console.error(`[Plugin: ${plugin.name}] [ERROR]`, ...args),
-                    debug: (...args) => console.error(`[Plugin: ${plugin.name}] [DEBUG]`, ...args),
-                },
-            };
-            // Execute dynamic onLoad if present
-            if (typeof plugin.onLoad === "function") {
-                try {
-                    const loadPromise = plugin.onLoad(pluginContext);
-                    if (loadPromise && typeof loadPromise.then === "function") {
-                        loadPromise.catch((err) => {
-                            console.error(`[Weavetab] Error in plugin "${plugin.name}" onLoad:`, err);
-                        });
-                    }
-                }
-                catch (e) {
-                    console.error(`[Weavetab] Synchronous error in plugin "${plugin.name}" onLoad:`, e);
-                }
-            }
+            // Construct authoritative PluginContext
+            const pluginContext = buildPluginContext(plugin, storageManager, extensionBridge, pluginConfig, hooks);
+            plugin._context = pluginContext;
+            // Note: We do NOT invoke plugin.onLoad here. server.ts is the sole lifecycle owner.
             return plugin;
         }
     }
     catch (e) {
-        // console.error(`Failed loading plugin at ${pkgDir}:`, e);
+        console.error(`[Weavetab] Failed loading plugin at ${pkgDir}:`, e?.message || e);
     }
     return null;
 }
@@ -209,7 +356,7 @@ export function discoverPlugins(pluginDir) {
                 if (!entry.isDirectory() && !entry.isSymbolicLink())
                     continue;
                 if (entry.name.startsWith("@")) {
-                    // Scoped package directory (e.g. @weavetab, @microsoft, @mycompany)
+                    // Scoped package directory (e.g. @weavetab, @fy2ne, @mycompany)
                     const scopeDir = join(modulesDir, entry.name);
                     try {
                         const scopeEntries = readdirSync(scopeDir, { withFileTypes: true });
@@ -226,7 +373,7 @@ export function discoverPlugins(pluginDir) {
                     catch { /* scope dir unreadable */ }
                 }
                 else {
-                    // Top-level package — any name works: wt-github, my-cool-plugin, etc.
+                    // Top-level package — any name works: wt-youtube, my-plugin, etc.
                     const plugin = tryLoadPlugin(join(modulesDir, entry.name));
                     if (plugin && !seenPluginNames.has(plugin.name)) {
                         seenPluginNames.add(plugin.name);
@@ -255,7 +402,7 @@ export function loadPluginByName(name, pluginDir) {
                 if (p)
                     return p;
             }
-            // Check if it's a scoped package (e.g. @weavetab/name)
+            // Check if it's a scoped package (e.g. @scope/name)
             if (name.startsWith("@")) {
                 const scopeParts = name.split("/");
                 if (scopeParts.length === 2) {

package/dist/plugin/pipeline.d.ts

@@ -0,0 +1,75 @@
+/**
+ * src/plugin/pipeline.ts — Central Hook Dispatch Pipeline for Weavetab Plugins
+ *
+ * Dispatches lifecycle events:
+ * - onBeforeAction / beforeToolCall: Intercept tool calls, modify arguments, or block unauthorized actions
+ * - onAfterAction / afterToolCall: Transform, redact, or augment tool return results
+ * - onDOMMutation: Stream real-time DOM mutation deltas to registered plugins
+ * - onPageNavigate: Notify plugins upon browser navigation
+ */
+import type { DOMMutationDelta } from "./interface.js";
+export type BeforeToolCallHook = (toolName: string, args: Record<string, any>, session?: any) => Promise<Record<string, any> | {
+    __blocked: boolean;
+    reason?: string;
+} | void> | Record<string, any> | {
+    __blocked: boolean;
+    reason?: string;
+} | void;
+export type AfterToolCallHook = (toolName: string, args: Record<string, any>, result: any, session?: any) => Promise<any | void> | any | void;
+export type PageNavigateHook = (url: string, session?: any) => Promise<void> | void;
+export type DOMMutationHook = (delta: DOMMutationDelta, session?: any) => Promise<void> | void;
+export interface PluginHooksRegistry {
+    beforeToolCall?: BeforeToolCallHook[] | BeforeToolCallHook;
+    afterToolCall?: AfterToolCallHook[] | AfterToolCallHook;
+    onBeforeAction?: BeforeToolCallHook[] | BeforeToolCallHook;
+    onAfterAction?: Array<(tool: string, result: any, session?: any, args?: Record<string, any>) => any> | ((tool: string, result: any, session?: any, args?: Record<string, any>) => any);
+    onDOMMutation?: DOMMutationHook[] | DOMMutationHook;
+    onPageNavigate?: PageNavigateHook[] | PageNavigateHook;
+}
+declare class HookPipeline {
+    private beforeToolCallHooks;
+    private afterToolCallHooks;
+    private onDOMMutationHooks;
+    private onPageNavigateHooks;
+    /**
+     * Register hooks for a specific plugin.
+     */
+    registerPluginHooks(pluginName: string, hooks: Partial<PluginHooksRegistry> & Record<string, any>): void;
+    /**
+     * Remove all hooks registered by a plugin on unload.
+     */
+    unregisterPluginHooks(pluginName: string): void;
+    /**
+     * Dispatches beforeAction / beforeToolCall hooks in sequence.
+     * If a hook returns an object, arguments are augmented/modified.
+     * If a hook returns { __blocked: true, reason } or throws, execution is aborted.
+     */
+    dispatchBeforeToolCall(toolName: string, args: Record<string, any>, session?: any): Promise<Record<string, any>>;
+    /**
+     * Alias for dispatchBeforeToolCall.
+     */
+    dispatchBeforeAction(toolName: string, args: Record<string, any>, session?: any): Promise<Record<string, any>>;
+    /**
+     * Dispatches afterAction / afterToolCall hooks in sequence.
+     * Allows plugins to inspect, transform, or redact tool results.
+     */
+    dispatchAfterToolCall(toolName: string, args: Record<string, any>, result: any, session?: any): Promise<any>;
+    /**
+     * Alias for dispatchAfterToolCall.
+     */
+    dispatchAfterAction(toolName: string, result: any, session?: any, args?: Record<string, any>): Promise<any>;
+    /**
+     * Dispatches DOM mutation deltas to all listening plugins.
+     */
+    dispatchDOMMutation(delta: DOMMutationDelta, session?: any): Promise<void>;
+    /**
+     * Dispatches onPageNavigate hooks when navigation occurs.
+     */
+    dispatchPageNavigate(url: string, session?: any): Promise<void>;
+    /**
+     * Clears all registered hooks.
+     */
+    clearAllHooks(): void;
+}
+export declare const hookPipeline: HookPipeline;
+export {};

package/dist/plugin/pipeline.js

@@ -0,0 +1,183 @@
+/**
+ * src/plugin/pipeline.ts — Central Hook Dispatch Pipeline for Weavetab Plugins
+ *
+ * Dispatches lifecycle events:
+ * - onBeforeAction / beforeToolCall: Intercept tool calls, modify arguments, or block unauthorized actions
+ * - onAfterAction / afterToolCall: Transform, redact, or augment tool return results
+ * - onDOMMutation: Stream real-time DOM mutation deltas to registered plugins
+ * - onPageNavigate: Notify plugins upon browser navigation
+ */
+class HookPipeline {
+    beforeToolCallHooks = [];
+    afterToolCallHooks = [];
+    onDOMMutationHooks = [];
+    onPageNavigateHooks = [];
+    /**
+     * Register hooks for a specific plugin.
+     */
+    registerPluginHooks(pluginName, hooks) {
+        if (!hooks)
+            return;
+        // 1. Before Action / Before Tool Call
+        const beforeFns = hooks.onBeforeAction || hooks.beforeToolCall;
+        if (beforeFns) {
+            const list = Array.isArray(beforeFns) ? beforeFns : [beforeFns];
+            for (const fn of list) {
+                if (typeof fn === "function") {
+                    this.beforeToolCallHooks.push({ pluginName, fn });
+                }
+            }
+        }
+        // 2. After Action (signature: (tool, result, session, args))
+        if (hooks.onAfterAction) {
+            const list = Array.isArray(hooks.onAfterAction) ? hooks.onAfterAction : [hooks.onAfterAction];
+            for (const fn of list) {
+                if (typeof fn === "function") {
+                    this.afterToolCallHooks.push({
+                        pluginName,
+                        fn: async (toolName, args, result, session) => {
+                            return await fn(toolName, result, session, args);
+                        },
+                    });
+                }
+            }
+        }
+        // Legacy After Tool Call (signature: (tool, args, result, session))
+        if (hooks.afterToolCall) {
+            const list = Array.isArray(hooks.afterToolCall) ? hooks.afterToolCall : [hooks.afterToolCall];
+            for (const fn of list) {
+                if (typeof fn === "function") {
+                    this.afterToolCallHooks.push({ pluginName, fn });
+                }
+            }
+        }
+        // 3. DOM Mutation Hooks
+        if (hooks.onDOMMutation) {
+            const list = Array.isArray(hooks.onDOMMutation) ? hooks.onDOMMutation : [hooks.onDOMMutation];
+            for (const fn of list) {
+                if (typeof fn === "function") {
+                    this.onDOMMutationHooks.push({ pluginName, fn });
+                }
+            }
+        }
+        // 4. Page Navigate Hooks
+        if (hooks.onPageNavigate) {
+            const list = Array.isArray(hooks.onPageNavigate) ? hooks.onPageNavigate : [hooks.onPageNavigate];
+            for (const fn of list) {
+                if (typeof fn === "function") {
+                    this.onPageNavigateHooks.push({ pluginName, fn });
+                }
+            }
+        }
+    }
+    /**
+     * Remove all hooks registered by a plugin on unload.
+     */
+    unregisterPluginHooks(pluginName) {
+        this.beforeToolCallHooks = this.beforeToolCallHooks.filter((h) => h.pluginName !== pluginName);
+        this.afterToolCallHooks = this.afterToolCallHooks.filter((h) => h.pluginName !== pluginName);
+        this.onDOMMutationHooks = this.onDOMMutationHooks.filter((h) => h.pluginName !== pluginName);
+        this.onPageNavigateHooks = this.onPageNavigateHooks.filter((h) => h.pluginName !== pluginName);
+    }
+    /**
+     * Dispatches beforeAction / beforeToolCall hooks in sequence.
+     * If a hook returns an object, arguments are augmented/modified.
+     * If a hook returns { __blocked: true, reason } or throws, execution is aborted.
+     */
+    async dispatchBeforeToolCall(toolName, args, session) {
+        let currentArgs = { ...args };
+        for (const { pluginName, fn } of this.beforeToolCallHooks) {
+            try {
+                const modified = await fn(toolName, currentArgs, session);
+                if (modified && typeof modified === "object") {
+                    if (modified.__blocked) {
+                        const reason = modified.reason || `Action '${toolName}' blocked by plugin '${pluginName}'`;
+                        const blockError = new Error(reason);
+                        blockError.isBlocked = true;
+                        blockError.pluginName = pluginName;
+                        throw blockError;
+                    }
+                    if (!Array.isArray(modified)) {
+                        currentArgs = { ...currentArgs, ...modified };
+                    }
+                }
+            }
+            catch (err) {
+                if (err?.isBlocked) {
+                    throw err;
+                }
+                process.stderr.write(`[Weavetab Hooks] Error in beforeToolCall (${pluginName} on ${toolName}): ${err?.message || err}\n`);
+            }
+        }
+        return currentArgs;
+    }
+    /**
+     * Alias for dispatchBeforeToolCall.
+     */
+    async dispatchBeforeAction(toolName, args, session) {
+        return this.dispatchBeforeToolCall(toolName, args, session);
+    }
+    /**
+     * Dispatches afterAction / afterToolCall hooks in sequence.
+     * Allows plugins to inspect, transform, or redact tool results.
+     */
+    async dispatchAfterToolCall(toolName, args, result, session) {
+        let currentResult = result;
+        for (const { pluginName, fn } of this.afterToolCallHooks) {
+            try {
+                const modified = await fn(toolName, args, currentResult, session);
+                if (modified !== undefined) {
+                    currentResult = modified;
+                }
+            }
+            catch (err) {
+                process.stderr.write(`[Weavetab Hooks] Error in afterToolCall (${pluginName} on ${toolName}): ${err?.message || err}\n`);
+            }
+        }
+        return currentResult;
+    }
+    /**
+     * Alias for dispatchAfterToolCall.
+     */
+    async dispatchAfterAction(toolName, result, session, args) {
+        return this.dispatchAfterToolCall(toolName, args || {}, result, session);
+    }
+    /**
+     * Dispatches DOM mutation deltas to all listening plugins.
+     */
+    async dispatchDOMMutation(delta, session) {
+        if (this.onDOMMutationHooks.length === 0)
+            return;
+        for (const { pluginName, fn } of this.onDOMMutationHooks) {
+            try {
+                await fn(delta, session);
+            }
+            catch (err) {
+                process.stderr.write(`[Weavetab Hooks] Error in onDOMMutation (${pluginName}): ${err?.message || err}\n`);
+            }
+        }
+    }
+    /**
+     * Dispatches onPageNavigate hooks when navigation occurs.
+     */
+    async dispatchPageNavigate(url, session) {
+        for (const { pluginName, fn } of this.onPageNavigateHooks) {
+            try {
+                await fn(url, session);
+            }
+            catch (err) {
+                process.stderr.write(`[Weavetab Hooks] Error in onPageNavigate (${pluginName}): ${err?.message || err}\n`);
+            }
+        }
+    }
+    /**
+     * Clears all registered hooks.
+     */
+    clearAllHooks() {
+        this.beforeToolCallHooks = [];
+        this.afterToolCallHooks = [];
+        this.onDOMMutationHooks = [];
+        this.onPageNavigateHooks = [];
+    }
+}
+export const hookPipeline = new HookPipeline();

package/dist/plugin/registry.js

@@ -2,13 +2,14 @@ import { readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
+import { WEAVETAB_VERSION } from "../version.js";
 const _require = createRequire(import.meta.url);
 function getVersion() {
     try {
-        return _require("../../package.json").version || "2.4.0";
+        return _require("../../package.json").version || WEAVETAB_VERSION;
     }
     catch {
-        return "2.4.0";
+        return WEAVETAB_VERSION;
     }
 }
 const __filename = fileURLToPath(import.meta.url);

package/dist/security/secrets.d.ts

@@ -69,6 +69,7 @@ declare class SessionSecretTrackerImpl {
     isNodeSecret(sessionId: string, backendNodeId: number): boolean;
     registerSecretValue(sessionId: string, value: string): void;
     redact(sessionId: string, text: string): string;
+    redactAll(text: string): string;
     clearSession(sessionId: string): void;
 }
 export declare const SessionSecretTracker: SessionSecretTrackerImpl;