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

package/dist/plugin/interface.d.ts

@@ -1,6 +1,8 @@
 import type { z } from "zod";
 import type CDP from "chrome-remote-interface";
 import type { Config } from "../config/loader.js";
+import type { IPluginStorage } from "./storage.js";
+import type { IPluginExtensionBridge } from "./extension_bridge.js";
 export interface WeavetabToolDefinition {
     name: string;
     description: string;
@@ -23,10 +25,25 @@ export interface WeavetabManifestTool {
     name: string;
     description: string;
     inputSchema?: Record<string, any>;
+    parameters?: Record<string, any>;
 }
-export interface WeavetabManifestPermissions {
+export interface WeavetabPermissions {
+    config?: {
+        read?: boolean;
+        write?: boolean;
+        default?: Record<string, any>;
+        reason?: string;
+    };
+    extension?: {
+        hud?: boolean;
+        overlay?: boolean;
+        styles?: boolean;
+        scripts?: boolean;
+        reason?: string;
+    };
     network?: {
         domains?: string[];
+        hosts?: string[];
         intercept?: boolean;
         reason?: string;
     };
@@ -36,6 +53,7 @@ export interface WeavetabManifestPermissions {
         click?: boolean;
         input?: boolean;
         screenshot?: boolean;
+        dom?: boolean;
         reason?: string;
         [key: string]: any;
     };
@@ -49,14 +67,18 @@ export interface WeavetabManifestPermissions {
         override?: string[];
         /** List of built-in tool names this plugin is permitted to remove */
         remove?: string[];
+        hooks?: boolean;
         reason?: string;
     };
+    [key: string]: any;
 }
+export type WeavetabManifestPermissions = WeavetabPermissions;
 export interface WeavetabManifestAuthor {
     name: string;
     role?: string;
     avatar?: string;
     url?: string;
+    email?: string;
 }
 export interface WeavetabManifestLinks {
     github?: string;
@@ -65,10 +87,6 @@ export interface WeavetabManifestLinks {
     issues?: string;
     homepage?: string;
 }
-export interface WeavetabCompatibility {
-    weavetab?: string;
-    node?: string;
-}
 export interface WeavetabManifest {
     /** Schema identifier */
     $schema?: string;
@@ -82,9 +100,9 @@ export interface WeavetabManifest {
     author?: string | WeavetabManifestAuthor | (string | WeavetabManifestAuthor)[];
     /** Array of authors */
     authors?: (string | WeavetabManifestAuthor)[];
-    /** Path to plugin logo (e.g. "images/logo.svg" or "images/logo.png") */
+    /** Path to plugin logo */
     logo?: string;
-    /** Path to plugin header banner (e.g. "images/banner.png" or "images/banner.webp") */
+    /** Path to plugin header banner */
     banner?: string;
     /** Path to README markdown file (default: "README.md") */
     readme?: string;
@@ -92,43 +110,87 @@ export interface WeavetabManifest {
     tags?: string[];
     /** External links */
     links?: WeavetabManifestLinks;
-    /** Runtime compatibility requirements */
-    compatibility?: WeavetabCompatibility;
+    /** Engine dependencies */
+    engines?: Record<string, string>;
+    /** Supported environments */
+    environments?: string[];
     /** Tools exposed by this plugin to the MCP server */
     tools?: WeavetabManifestTool[];
+    /** Default configuration template */
+    defaultConfig?: Record<string, any>;
     /** Required permissions with security rationale */
-    permissions?: WeavetabManifestPermissions;
+    permissions?: WeavetabPermissions;
     /** Open source license */
     license?: string;
+    [key: string]: any;
 }
 export interface WeavetabPluginTool<TArgs = any> {
     name: string;
     description: string;
     schema?: Record<string, any> | Record<string, z.ZodType<any>>;
     inputSchema?: Record<string, any>;
+    parameters?: Record<string, any>;
     handler: (args: TArgs, session?: any, config?: any) => Promise<any>;
 }
+export interface PluginHooksContext {
+    beforeToolCall: (handler: (toolName: string, args: Record<string, any>, session?: any) => Promise<any> | void) => void;
+    afterToolCall: (handler: (toolName: string, args: Record<string, any>, result: any, session?: any) => Promise<any> | void) => void;
+    onPageNavigate?: (handler: (url: string, session?: any) => Promise<void> | void) => void;
+}
+export interface PluginMcpContext {
+    registerTool: (tool: WeavetabPluginTool | any) => void;
+    overrideTool?: (toolName: string, overrideHandler: any) => void;
+    removeTool?: (toolName: string) => void;
+    unregisterTool?: (toolName: string) => void;
+    [key: string]: any;
+}
+export interface PluginContext {
+    name: string;
+    version?: string;
+    pluginDir: string;
+    config: Record<string, any>;
+    storage: IPluginStorage;
+    extension: IPluginExtensionBridge;
+    mcp: PluginMcpContext;
+    hooks: PluginHooksContext;
+    logger: {
+        info: (...args: any[]) => void;
+        warn: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+        debug: (...args: any[]) => void;
+    };
+    [key: string]: any;
+}
 export interface WeavetabPluginDefinition {
     name: string;
-    version: string;
+    version?: string;
     description?: string;
     tools?: WeavetabPluginTool[];
     overrides?: WeavetabToolOverride[];
     removeTools?: string[];
-    onLoad?: () => Promise<void>;
-    onUnload?: () => Promise<void>;
+    defaultConfig?: Record<string, any>;
+    onLoad?: (ctx: PluginContext) => Promise<void> | void;
+    onUnload?: (ctx: PluginContext) => Promise<void> | void;
 }
 export interface WeavetabPlugin {
     name: string;
     version: string;
     description?: string;
     /** Add new tools */
-    tools?: WeavetabToolDefinition[];
+    tools?: WeavetabToolDefinition[] | WeavetabPluginTool[];
     /** Override or wrap existing tools */
     overrides?: WeavetabToolOverride[];
     /** Built-in tools to remove or disable */
     removeTools?: string[];
+    defaultConfig?: Record<string, any>;
     manifest?: WeavetabManifest;
-    onLoad?: () => Promise<void>;
-    onUnload?: () => Promise<void>;
+    storage?: IPluginStorage;
+    extension?: IPluginExtensionBridge;
+    hooks?: {
+        beforeToolCall: Array<(toolName: string, args: Record<string, any>, session?: any) => Promise<any> | void>;
+        afterToolCall: Array<(toolName: string, args: Record<string, any>, result: any, session?: any) => Promise<any> | void>;
+        onPageNavigate: Array<(url: string, session?: any) => Promise<void> | void>;
+    };
+    onLoad?: (ctx: PluginContext) => Promise<void> | void;
+    onUnload?: (ctx: PluginContext) => Promise<void> | void;
 }

package/dist/plugin/loader.d.ts

@@ -16,3 +16,7 @@ export declare function inspectInstalledPackage(pkgDir: string): InstalledPlugin
  */
 export declare function listInstalledPlugins(pluginDir?: string): InstalledPluginInfo[];
 export declare function discoverPlugins(pluginDir?: string): WeavetabPlugin[];
+/**
+ * Loads a specific plugin by name from node_modules.
+ */
+export declare function loadPluginByName(name: string, pluginDir?: string): WeavetabPlugin | null;

package/dist/plugin/loader.js

@@ -1,7 +1,18 @@
 import { readdirSync, existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { join, basename } from "node:path";
+import { PluginStorageManager } from "./storage.js";
+import { PluginExtensionBridge } from "./extension_bridge.js";
 const require = createRequire(import.meta.url);
+function getNodeModulesDirs(customDir) {
+    if (customDir)
+        return [customDir];
+    const dirs = [
+        join(process.cwd(), "node_modules"),
+        join(process.cwd(), "MCP", "node_modules"),
+    ];
+    return Array.from(new Set(dirs.filter((d) => existsSync(d))));
+}
 /**
  * Reads the manifest (weavetab.json) and package.json for an installed package
  * without executing its runtime code (safe for listing/inspection).
@@ -39,38 +50,43 @@ export function inspectInstalledPackage(pkgDir) {
  */
 export function listInstalledPlugins(pluginDir) {
     const results = [];
-    try {
-        const modulesDir = pluginDir || join(process.cwd(), "node_modules");
-        if (!existsSync(modulesDir))
-            return results;
-        const entries = readdirSync(modulesDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (entry.name.startsWith("@")) {
-                // Scoped packages (@weavetab/plugin-xyz, @scope/xyz)
-                const scopeDir = join(modulesDir, entry.name);
-                try {
-                    const scopeEntries = readdirSync(scopeDir, { withFileTypes: true });
-                    for (const scopeEntry of scopeEntries) {
-                        if (!scopeEntry.isDirectory())
-                            continue;
-                        const info = inspectInstalledPackage(join(scopeDir, scopeEntry.name));
-                        if (info)
-                            results.push(info);
+    const seenPackages = new Set();
+    const modulesDirs = getNodeModulesDirs(pluginDir);
+    for (const modulesDir of modulesDirs) {
+        try {
+            const entries = readdirSync(modulesDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory() && !entry.isSymbolicLink())
+                    continue;
+                if (entry.name.startsWith("@")) {
+                    // Scoped packages (@weavetab/plugin-xyz, @scope/xyz)
+                    const scopeDir = join(modulesDir, entry.name);
+                    try {
+                        const scopeEntries = readdirSync(scopeDir, { withFileTypes: true });
+                        for (const scopeEntry of scopeEntries) {
+                            if (!scopeEntry.isDirectory() && !scopeEntry.isSymbolicLink())
+                                continue;
+                            const info = inspectInstalledPackage(join(scopeDir, scopeEntry.name));
+                            if (info && !seenPackages.has(info.packageName)) {
+                                seenPackages.add(info.packageName);
+                                results.push(info);
+                            }
+                        }
+                    }
+                    catch { /* scope dir unreadable */ }
+                }
+                else {
+                    // Top-level packages (any name)
+                    const info = inspectInstalledPackage(join(modulesDir, entry.name));
+                    if (info && !seenPackages.has(info.packageName)) {
+                        seenPackages.add(info.packageName);
+                        results.push(info);
                     }
                 }
-                catch { /* scope dir unreadable */ }
-            }
-            else {
-                // Top-level packages (any name)
-                const info = inspectInstalledPackage(join(modulesDir, entry.name));
-                if (info)
-                    results.push(info);
             }
         }
+        catch { /* ignore filesystem errors */ }
     }
-    catch { /* ignore filesystem errors */ }
     return results;
 }
 /**
@@ -97,7 +113,8 @@ function tryLoadPlugin(pkgDir) {
             (Array.isArray(plugin.tools) ||
                 Array.isArray(plugin.overrides) ||
                 Array.isArray(plugin.removeTools) ||
-                Boolean(manifest.permissions?.tools))) {
+                Boolean(manifest.permissions?.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 || "";
@@ -107,49 +124,153 @@ function tryLoadPlugin(pkgDir) {
             plugin.removeTools = Array.isArray(plugin.removeTools)
                 ? plugin.removeTools
                 : manifest.permissions?.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 pluginConfig = storageManager.loadConfig(plugin.defaultConfig || manifest.defaultConfig || {});
+            const hooks = {
+                beforeToolCall: [],
+                afterToolCall: [],
+                onPageNavigate: [],
+            };
+            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);
+                }
+            }
             return plugin;
         }
     }
-    catch {
-        // Not a valid plugin — skip silently
+    catch (e) {
+        // console.error(`Failed loading plugin at ${pkgDir}:`, e);
     }
     return null;
 }
 export function discoverPlugins(pluginDir) {
     const plugins = [];
-    try {
-        const modulesDir = pluginDir || join(process.cwd(), "node_modules");
-        if (!existsSync(modulesDir))
-            return plugins;
-        const entries = readdirSync(modulesDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (entry.name.startsWith("@")) {
-                // Scoped package directory (e.g. @weavetab, @microsoft, @mycompany)
-                const scopeDir = join(modulesDir, entry.name);
-                try {
-                    const scopeEntries = readdirSync(scopeDir, { withFileTypes: true });
-                    for (const scopeEntry of scopeEntries) {
-                        if (!scopeEntry.isDirectory())
-                            continue;
-                        const plugin = tryLoadPlugin(join(scopeDir, scopeEntry.name));
-                        if (plugin)
-                            plugins.push(plugin);
+    const seenPluginNames = new Set();
+    const modulesDirs = getNodeModulesDirs(pluginDir);
+    for (const modulesDir of modulesDirs) {
+        try {
+            const entries = readdirSync(modulesDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory() && !entry.isSymbolicLink())
+                    continue;
+                if (entry.name.startsWith("@")) {
+                    // Scoped package directory (e.g. @weavetab, @microsoft, @mycompany)
+                    const scopeDir = join(modulesDir, entry.name);
+                    try {
+                        const scopeEntries = readdirSync(scopeDir, { withFileTypes: true });
+                        for (const scopeEntry of scopeEntries) {
+                            if (!scopeEntry.isDirectory() && !scopeEntry.isSymbolicLink())
+                                continue;
+                            const plugin = tryLoadPlugin(join(scopeDir, scopeEntry.name));
+                            if (plugin && !seenPluginNames.has(plugin.name)) {
+                                seenPluginNames.add(plugin.name);
+                                plugins.push(plugin);
+                            }
+                        }
                     }
+                    catch { /* scope dir unreadable */ }
                 }
-                catch { /* scope dir unreadable */ }
+                else {
+                    // Top-level package — any name works: wt-github, my-cool-plugin, etc.
+                    const plugin = tryLoadPlugin(join(modulesDir, entry.name));
+                    if (plugin && !seenPluginNames.has(plugin.name)) {
+                        seenPluginNames.add(plugin.name);
+                        plugins.push(plugin);
+                    }
+                }
+            }
+        }
+        catch {
+            // node_modules may not exist or be inaccessible
+        }
+    }
+    return plugins;
+}
+/**
+ * Loads a specific plugin by name from node_modules.
+ */
+export function loadPluginByName(name, pluginDir) {
+    try {
+        const modulesDirs = getNodeModulesDirs(pluginDir);
+        for (const modulesDir of modulesDirs) {
+            // Check if it's a top-level package
+            let pkgDir = join(modulesDir, name);
+            if (existsSync(pkgDir)) {
+                const p = tryLoadPlugin(pkgDir);
+                if (p)
+                    return p;
             }
-            else {
-                // Top-level package — any name works: wt-github, my-cool-plugin, etc.
-                const plugin = tryLoadPlugin(join(modulesDir, entry.name));
-                if (plugin)
-                    plugins.push(plugin);
+            // Check if it's a scoped package (e.g. @weavetab/name)
+            if (name.startsWith("@")) {
+                const scopeParts = name.split("/");
+                if (scopeParts.length === 2) {
+                    pkgDir = join(modulesDir, scopeParts[0], scopeParts[1]);
+                    if (existsSync(pkgDir)) {
+                        const p = tryLoadPlugin(pkgDir);
+                        if (p)
+                            return p;
+                    }
+                }
             }
         }
     }
     catch {
-        // node_modules may not exist or be inaccessible
+        // Ignore
     }
-    return plugins;
+    return null;
 }

package/dist/plugin/registry.js

@@ -1,6 +1,16 @@
 import { readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+const _require = createRequire(import.meta.url);
+function getVersion() {
+    try {
+        return _require("../../package.json").version || "2.4.0";
+    }
+    catch {
+        return "2.4.0";
+    }
+}
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // ---------------------------------------------------------------------------
@@ -142,7 +152,7 @@ export async function checkNpmPackageExists(pkgName) {
         const res = await fetch(`https://registry.npmjs.org/${encodedName}`, {
             method: "HEAD",
             signal: AbortSignal.timeout(3000),
-            headers: { "User-Agent": "Weavetab-CLI/2.5.0" },
+            headers: { "User-Agent": `Weavetab/${getVersion()}` },
         });
         return res.status === 200;
     }

package/dist/plugin/storage.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Interface for isolated plugin file and key-value storage.
+ */
+export interface IPluginStorage {
+    get<T = any>(key: string, defaultValue?: T): Promise<T | null>;
+    set<T = any>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    getJSON<T = any>(filename: string): Promise<T | null>;
+    setJSON<T = any>(filename: string, data: T): Promise<void>;
+    getPath(subpath?: string): string;
+    list(subpath?: string): Promise<string[]>;
+}
+/**
+ * Creates an isolated storage sandbox for a plugin under:
+ * ~/.weavetab/plugins/<plugin-name>/
+ */
+export declare class PluginStorageManager implements IPluginStorage {
+    readonly pluginName: string;
+    private readonly pluginDir;
+    private readonly configPath;
+    private readonly kvStorePath;
+    private inMemoryKV;
+    constructor(pluginName: string);
+    /**
+     * Returns the absolute path to the plugin's isolated directory.
+     */
+    getDirectory(): string;
+    /**
+     * Returns the absolute path to the plugin's config.json.
+     */
+    getConfigPath(): string;
+    private ensureDir;
+    /**
+     * Loads the plugin's isolated config.json. If it does not exist and a defaultConfig is provided,
+     * writes the default config to ~/.weavetab/plugins/<plugin-name>/config.json.
+     */
+    loadConfig(defaultConfig?: Record<string, any>): Record<string, any>;
+    /**
+     * Saves updated configuration to ~/.weavetab/plugins/<plugin-name>/config.json.
+     */
+    saveConfig(configData: Record<string, any>): void;
+    private loadKV;
+    private persistKV;
+    get<T = any>(key: string, defaultValue?: T): Promise<T | null>;
+    set<T = any>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    getPath(subpath?: string): string;
+    getJSON<T = any>(filename: string): Promise<T | null>;
+    setJSON<T = any>(filename: string, data: T): Promise<void>;
+    list(subpath?: string): Promise<string[]>;
+}