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

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[]>;
+}

package/dist/plugin/storage.js

@@ -0,0 +1,164 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { GLOBAL_CONFIG_DIR } from "../config/loader.js";
+import { logDebug } from "../audit/logger.js";
+/**
+ * Creates an isolated storage sandbox for a plugin under:
+ * ~/.weavetab/plugins/<plugin-name>/
+ */
+export class PluginStorageManager {
+    pluginName;
+    pluginDir;
+    configPath;
+    kvStorePath;
+    inMemoryKV = null;
+    constructor(pluginName) {
+        this.pluginName = pluginName;
+        // Sanitize plugin name for safe filesystem directory creation
+        const safeName = pluginName.replace(/[^a-zA-Z0-9_.-]/g, "_");
+        this.pluginDir = path.join(GLOBAL_CONFIG_DIR, "plugins", safeName);
+        this.configPath = path.join(this.pluginDir, "config.json");
+        this.kvStorePath = path.join(this.pluginDir, "storage.json");
+        this.ensureDir(this.pluginDir);
+    }
+    /**
+     * Returns the absolute path to the plugin's isolated directory.
+     */
+    getDirectory() {
+        return this.pluginDir;
+    }
+    /**
+     * Returns the absolute path to the plugin's config.json.
+     */
+    getConfigPath() {
+        return this.configPath;
+    }
+    ensureDir(dir) {
+        if (!fs.existsSync(dir)) {
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            catch (e) {
+                logDebug(`[Weavetab PluginStorage] Failed to create dir ${dir}:`, e);
+            }
+        }
+    }
+    /**
+     * 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 = {}) {
+        try {
+            if (fs.existsSync(this.configPath)) {
+                const raw = fs.readFileSync(this.configPath, "utf-8").trim();
+                if (raw) {
+                    return JSON.parse(raw);
+                }
+            }
+            // If config.json doesn't exist yet, save default config
+            this.ensureDir(this.pluginDir);
+            fs.writeFileSync(this.configPath, JSON.stringify(defaultConfig, null, 2), "utf-8");
+            logDebug(`[Weavetab PluginStorage] Created default config for "${this.pluginName}" at: ${this.configPath}`);
+            return { ...defaultConfig };
+        }
+        catch (e) {
+            logDebug(`[Weavetab PluginStorage] Error loading config for "${this.pluginName}":`, e);
+            return { ...defaultConfig };
+        }
+    }
+    /**
+     * Saves updated configuration to ~/.weavetab/plugins/<plugin-name>/config.json.
+     */
+    saveConfig(configData) {
+        try {
+            this.ensureDir(this.pluginDir);
+            fs.writeFileSync(this.configPath, JSON.stringify(configData, null, 2), "utf-8");
+        }
+        catch (e) {
+            logDebug(`[Weavetab PluginStorage] Error saving config for "${this.pluginName}":`, e);
+            throw e;
+        }
+    }
+    loadKV() {
+        if (this.inMemoryKV !== null)
+            return this.inMemoryKV;
+        try {
+            if (fs.existsSync(this.kvStorePath)) {
+                const raw = fs.readFileSync(this.kvStorePath, "utf-8").trim();
+                this.inMemoryKV = raw ? JSON.parse(raw) : {};
+            }
+            else {
+                this.inMemoryKV = {};
+            }
+        }
+        catch {
+            this.inMemoryKV = {};
+        }
+        return this.inMemoryKV || {};
+    }
+    persistKV() {
+        try {
+            this.ensureDir(this.pluginDir);
+            fs.writeFileSync(this.kvStorePath, JSON.stringify(this.inMemoryKV || {}, null, 2), "utf-8");
+        }
+        catch (e) {
+            logDebug(`[Weavetab PluginStorage] Failed to persist KV for "${this.pluginName}":`, e);
+        }
+    }
+    async get(key, defaultValue) {
+        const kv = this.loadKV();
+        return key in kv ? kv[key] : defaultValue !== undefined ? defaultValue : null;
+    }
+    async set(key, value) {
+        const kv = this.loadKV();
+        kv[key] = value;
+        this.persistKV();
+    }
+    async delete(key) {
+        const kv = this.loadKV();
+        if (key in kv) {
+            delete kv[key];
+            this.persistKV();
+            return true;
+        }
+        return false;
+    }
+    getPath(subpath = "") {
+        const resolved = path.resolve(this.pluginDir, subpath);
+        // Security check: ensure subpath does not escape the plugin directory
+        if (!resolved.startsWith(this.pluginDir)) {
+            throw new Error(`Security Violation: Path "${subpath}" attempts to escape plugin directory.`);
+        }
+        return resolved;
+    }
+    async getJSON(filename) {
+        const filePath = this.getPath(filename);
+        if (!fs.existsSync(filePath))
+            return null;
+        try {
+            const raw = fs.readFileSync(filePath, "utf-8");
+            return JSON.parse(raw);
+        }
+        catch (e) {
+            logDebug(`[Weavetab PluginStorage] Error reading JSON from "${filePath}":`, e);
+            return null;
+        }
+    }
+    async setJSON(filename, data) {
+        const filePath = this.getPath(filename);
+        const parent = path.dirname(filePath);
+        this.ensureDir(parent);
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+    }
+    async list(subpath = "") {
+        const targetDir = this.getPath(subpath);
+        if (!fs.existsSync(targetDir))
+            return [];
+        try {
+            return fs.readdirSync(targetDir);
+        }
+        catch {
+            return [];
+        }
+    }
+}