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

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