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

package/dist/plugin/loader.js

@@ -1,18 +1,111 @@
 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", "tools.add", "tools", "fs.read", ...]
+    if (Array.isArray(perms)) {
+        const normalized = { cdp: {}, fs: {}, filesystem: {}, extension: {}, tools: {}, hooks: {} };
+        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"] = ["*"];
+                normalized.filesystem[sub || "read"] = ["*"];
+            }
+            else if (cat === "extension" || cat === "hud") {
+                normalized.extension[sub || "hud"] = true;
+            }
+            else if (cat === "tools") {
+                normalized.tools = normalized.tools || {};
+                if (!sub || sub === "add") {
+                    normalized.tools.add = true;
+                }
+            }
+            else if (cat === "hooks") {
+                normalized.hooks = normalized.hooks || {};
+                if (sub) {
+                    normalized.hooks[sub] = true;
+                }
+                else {
+                    normalized.hooks.onBeforeAction = true;
+                    normalized.hooks.onAfterAction = 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 +152,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 +169,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 +182,131 @@ export function listInstalledPlugins(pluginDir) {
     }
     return results;
 }
+export function buildPluginContext(plugin, storageManager, extensionBridge, pluginConfig, hooks) {
+    const perms = plugin.manifest?.permissions ?? {};
+    const pname = plugin.name;
+    return {
+        name: pname,
+        version: plugin.version,
+        pluginDir: storageManager.getDirectory(),
+        config: pluginConfig,
+        storage: storageManager,
+        extension: extensionBridge,
+        mcp: {
+            registerTool: (tool) => {
+                if (!perms.tools?.add) {
+                    console.error(`[Plugin: ${pname}] blocked registerTool("${tool?.name}"): permissions.tools.add not declared`);
+                    return;
+                }
+                plugin.tools = plugin.tools || [];
+                const idx = plugin.tools.findIndex((t) => t.name === tool.name);
+                if (idx >= 0) {
+                    plugin.tools[idx] = tool;
+                }
+                else {
+                    plugin.tools.push(tool);
+                }
+            },
+            overrideTool: (toolName, overrideHandler) => {
+                const allowed = perms.tools?.override ?? [];
+                if (!allowed.includes(toolName)) {
+                    console.error(`[Plugin: ${pname}] blocked overrideTool("${toolName}"): not listed in permissions.tools.override`);
+                    return;
+                }
+                plugin.overrides = plugin.overrides || [];
+                plugin.overrides.push({ name: toolName, handler: overrideHandler });
+            },
+            removeTool: (toolName) => {
+                const allowed = perms.tools?.remove ?? [];
+                if (!allowed.includes(toolName)) {
+                    console.error(`[Plugin: ${pname}] blocked removeTool("${toolName}"): not listed in permissions.tools.remove`);
+                    return;
+                }
+                plugin.removeTools = plugin.removeTools || [];
+                plugin.removeTools.push(toolName);
+            },
+            unregisterTool: (toolName) => {
+                const allowed = perms.tools?.remove ?? [];
+                if (!allowed.includes(toolName)) {
+                    console.error(`[Plugin: ${pname}] blocked unregisterTool("${toolName}"): not listed in permissions.tools.remove`);
+                    return;
+                }
+                plugin.removeTools = plugin.removeTools || [];
+                plugin.removeTools.push(toolName);
+            },
+        },
+        hooks: {
+            onBeforeAction: (fn) => {
+                if (!perms.hooks?.onBeforeAction) {
+                    console.error(`[Plugin: ${pname}] blocked onBeforeAction hook: permissions.hooks.onBeforeAction not declared`);
+                    return;
+                }
+                if (typeof fn === "function")
+                    hooks.beforeToolCall.push(fn);
+            },
+            onAfterAction: (fn) => {
+                if (!perms.hooks?.onAfterAction) {
+                    console.error(`[Plugin: ${pname}] blocked onAfterAction hook: permissions.hooks.onAfterAction not declared`);
+                    return;
+                }
+                if (typeof fn === "function") {
+                    hooks.afterToolCall.push(async (toolName, args, result, session) => {
+                        return await fn(toolName, result, session, args);
+                    });
+                }
+            },
+            onDOMMutation: (fn) => {
+                if (!perms.hooks?.onDOMMutation) {
+                    console.error(`[Plugin: ${pname}] blocked onDOMMutation hook: permissions.hooks.onDOMMutation not declared`);
+                    return;
+                }
+                if (typeof fn === "function")
+                    hooks.onDOMMutation?.push(fn);
+            },
+            beforeToolCall: (fn) => {
+                if (!perms.hooks?.onBeforeAction) {
+                    console.error(`[Plugin: ${pname}] blocked beforeToolCall hook: permissions.hooks.onBeforeAction not declared`);
+                    return;
+                }
+                if (typeof fn === "function")
+                    hooks.beforeToolCall.push(fn);
+            },
+            afterToolCall: (fn) => {
+                if (!perms.hooks?.onAfterAction) {
+                    console.error(`[Plugin: ${pname}] blocked afterToolCall hook: permissions.hooks.onAfterAction not declared`);
+                    return;
+                }
+                if (typeof fn === "function")
+                    hooks.afterToolCall.push(fn);
+            },
+            onPageNavigate: (fn) => {
+                if (!perms.hooks?.onPageNavigate) {
+                    console.error(`[Plugin: ${pname}] blocked onPageNavigate hook: permissions.hooks.onPageNavigate not declared`);
+                    return;
+                }
+                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: ${pname}] [INFO]`, ...args),
+            warn: (...args) => console.error(`[Plugin: ${pname}] [WARN]`, ...args),
+            error: (...args) => console.error(`[Plugin: ${pname}] [ERROR]`, ...args),
+            debug: (...args) => console.error(`[Plugin: ${pname}] [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,100 +315,96 @@ 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 rawPerms = Array.isArray(manifest.permissions)
+            ? manifest.permissions
+            : { ...(plugin?.permissions || {}), ...(manifest?.permissions || {}) };
+        const normalizedPerms = normalizePermissions(rawPerms);
         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";
             plugin.description = plugin.description || manifest.description || pkg.description || "";
             plugin.manifest = manifest;
+            plugin.permissions = normalizedPerms;
+            plugin.manifest.permissions = normalizedPerms;
             plugin.tools = Array.isArray(plugin.tools) ? plugin.tools : [];
             plugin.overrides = Array.isArray(plugin.overrides) ? plugin.overrides : [];
             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 +419,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 +436,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 +465,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 {};