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

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);
+    }
+}

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;
 }