mcp-fs-shell-windows 0.2.20 → 0.2.29

package/dist/system/handler.js

@@ -0,0 +1,239 @@
+// system/handler.ts — the 6 Beledarian-parity system tools (MCP filesystem fork).
+//
+// Ported from the reference Beledarian toolsProvider (get_system_info,
+// read_clipboard, write_clipboard, send_notification, open_file,
+// preview_html) and registered under the same names with the reference
+// parameter shapes and return shapes:
+//
+//   - get_system_info: the reference's fields verbatim ({platform, arch,
+//     release, hostname, total_memory, free_memory, cpus, node_version}).
+//   - read_clipboard / write_clipboard: the reference's platform branches
+//     (PowerShell Get-Clipboard / Set-Clipboard on Windows, pbpaste / pbcopy
+//     on macOS, xclip elsewhere), the reference's Promise.race 5-second
+//     timeout, and the reference's error strings. An EMPTY clipboard reads
+//     back as content "" (not an error), exactly as the reference. 
+//     write_clipboard keeps the reference's base64 Set-Clipboard approach
+//     (the content is base64-encoded into the PowerShell command line, so
+//     quotes, newlines, and Unicode need no escaping).
+//   - send_notification: node-notifier (the reference's dependency, the only
+//     new one in this version) with the reference's options (title, message,
+//     sound: true, wait: false), dispatched fire-and-forget; returns the
+//     reference's {success: true, message}.
+//   - open_file: the Beledarian-named equivalent of this fork's launch_file —
+//     the same `target` parameter, the same policy, and the same internal
+//     launch helper (handleLaunchFile -> launchDetached -> explorer.exe),
+//     with the reference's {success: true, message} shape on success.
+//   - preview_html: writes the HTML to a temp .html file in the system temp
+//     dir and launches it in the default browser with the same detached
+//     opener launch_file uses; returns the reference's {success, path,
+//     message}. The user-supplied file_name is reduced to its last path
+//     segment (the file always lands in the temp dir); when omitted the
+//     reference's `preview_<timestamp>.html` default is used.
+import os from "os";
+import path from "path";
+import fs from "fs/promises";
+import { spawn } from "child_process";
+import notifier from "node-notifier";
+import { launchDetached, openerPath, handleLaunchFile } from "../launch_file/handler.js";
+// ---------------------------------------------------------------------------
+// get_system_info
+// ---------------------------------------------------------------------------
+/**
+ * Get information about the system (OS, CPU, Memory). The reference's fields
+ * verbatim: platform, arch, release, hostname, total_memory, free_memory,
+ * cpus (logical CPU count), node_version.
+ */
+export async function handleGetSystemInfo() {
+    return JSON.stringify({
+        platform: os.platform(),
+        arch: os.arch(),
+        release: os.release(),
+        hostname: os.hostname(),
+        total_memory: os.totalmem(),
+        free_memory: os.freemem(),
+        cpus: os.cpus().length,
+        node_version: process.version,
+    });
+}
+/**
+ * Race a clipboard child-process op against the reference's 5-second
+ * timeout (the timeout rejects; the op itself resolves with an error
+ * object on failure — same settlement shape as the reference).
+ */
+function clipboardRace(op) {
+    return Promise.race([
+        op(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Clipboard operation timeout")), 5000)),
+    ]);
+}
+/**
+ * Read text content from the system clipboard (Windows: `powershell
+ * -command Get-Clipboard`, macOS: `pbpaste`, other: `xclip -selection
+ * clipboard -o`). An empty clipboard yields content "" (NOT an error).
+ * 5-second race timeout; a failed read or timeout yields a clear error.
+ */
+export async function handleReadClipboard() {
+    let command = "";
+    let args = [];
+    if (process.platform === "win32") {
+        command = "powershell";
+        args = ["-command", "Get-Clipboard"];
+    }
+    else if (process.platform === "darwin") {
+        command = "pbpaste";
+    }
+    else {
+        // Linux fallback (might fail if tools missing)
+        command = "xclip";
+        args = ["-selection", "clipboard", "-o"];
+    }
+    const result = await clipboardRace(() => new Promise((resolve) => {
+        const child = spawn(command, args);
+        let output = "";
+        let error = "";
+        child.stdout.on("data", (data) => (output += data.toString()));
+        child.stderr.on("data", (data) => (error += data.toString()));
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve({ content: output.trim() });
+            }
+            else {
+                resolve({ error: `Failed to read clipboard. Exit code: ${code}. Error: ${error}` });
+            }
+        });
+        child.on("error", (err) => {
+            resolve({ error: `Failed to spawn clipboard command: ${err.message}` });
+        });
+    })).catch((err) => ({ error: err instanceof Error ? err.message : String(err) }));
+    if (result.error) {
+        throw new Error(result.error);
+    }
+    return JSON.stringify({ content: result.content ?? "" });
+}
+/**
+ * Write text content to the system clipboard (Windows: the reference's
+ * base64 approach — the content is UTF-8 base64-encoded into the
+ * PowerShell command line and `Set-Clipboard` stores the decoded text, so
+ * arbitrary text (quotes, newlines, Unicode) passes through with no
+ * escaping; macOS: `pbcopy`, other: `xclip -selection clipboard -i` with
+ * the content on stdin). 5-second race timeout.
+ */
+export async function handleWriteClipboard(content) {
+    let command = "";
+    let args = [];
+    let input = content;
+    if (process.platform === "win32") {
+        command = "powershell";
+        // Use base64 to avoid complex escaping issues in PowerShell
+        const base64Content = Buffer.from(content, "utf8").toString("base64");
+        // Command decodes base64 and sets clipboard
+        args = [
+            "-command",
+            `$str = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('${base64Content}')); Set-Clipboard -Value $str`,
+        ];
+        input = ""; // Input handled via args
+    }
+    else if (process.platform === "darwin") {
+        command = "pbcopy";
+    }
+    else {
+        command = "xclip";
+        args = ["-selection", "clipboard", "-i"];
+    }
+    const result = await clipboardRace(() => new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ["pipe", "ignore", "pipe"] });
+        if (input && process.platform !== "win32") {
+            child.stdin.write(input);
+            child.stdin.end();
+        }
+        else if (process.platform === "win32") {
+            child.stdin.end();
+        }
+        let error = "";
+        child.stderr.on("data", (data) => (error += data.toString()));
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else {
+                resolve({ error: `Failed to write to clipboard. Exit code: ${code}. Error: ${error}` });
+            }
+        });
+        child.on("error", (err) => {
+            resolve({ error: `Failed to spawn clipboard command: ${err.message}` });
+        });
+    })).catch((err) => ({ error: err instanceof Error ? err.message : String(err) }));
+    if (result.error) {
+        throw new Error(result.error);
+    }
+    return JSON.stringify({ success: true });
+}
+// ---------------------------------------------------------------------------
+// send_notification
+// ---------------------------------------------------------------------------
+/**
+ * Send a system notification to the user. node-notifier picks the platform
+ * backend (on Windows: the bundled snoretoast WinRT toast; a balloon via
+ * notifu as fallback) — dispatch is fire-and-forget exactly as the
+ * reference, which passes the reference's options (title, message,
+ * sound: true, wait: false) and returns success immediately. The `sound`
+ * option is part of the reference call but not in the DefinitelyTyped
+ * declaration, so the options object is cast to the notify() parameter
+ * type to keep the reference call verbatim.
+ */
+export async function handleSendNotification(title, message) {
+    notifier.notify({
+        title: title,
+        message: message,
+        sound: true,
+        wait: false,
+    });
+    return JSON.stringify({ success: true, message: "Notification sent." });
+}
+// ---------------------------------------------------------------------------
+// open_file
+// ---------------------------------------------------------------------------
+/**
+ * Open a file, folder, or http(s) URL in the OS default app. The
+ * Beledarian-named equivalent of launch_file: same `target` parameter and
+ * same policy, delegating to the exact same internal launch helper chain
+ * (handleLaunchFile -> launchDetached -> explorer.exe), with the
+ * reference's success shape. Errors (unsupported URL scheme, path outside
+ * the allowed roots, missing file, failed opener spawn) propagate from
+ * handleLaunchFile as clear thrown errors.
+ */
+export async function handleOpenFile(target, allowedDirectories) {
+    await handleLaunchFile(target, allowedDirectories);
+    return JSON.stringify({
+        success: true,
+        message: `Opened ${(target ?? "").trim()}`,
+    });
+}
+// ---------------------------------------------------------------------------
+// preview_html
+// ---------------------------------------------------------------------------
+/**
+ * Render and preview HTML content in the system's default browser. Writes
+ * the content to a temp .html file in the system temp dir and launches it
+ * with the same detached opener launch_file uses. The user-supplied
+ * file_name is reduced to its last path segment (the file always lands in
+ * the temp dir; an existing file of that name is overwritten); when
+ * omitted, the reference's `preview_<timestamp>.html` default is used.
+ * The temp file is left on disk and its path is returned.
+ */
+export async function handlePreviewHtml(htmlContent, fileName) {
+    const name = path.basename((fileName && fileName.trim()) || `preview_${Date.now()}.html`);
+    const filePath = path.join(os.tmpdir(), name);
+    await fs.writeFile(filePath, htmlContent, "utf-8");
+    try {
+        await launchDetached(openerPath(), filePath);
+    }
+    catch (err) {
+        throw new Error(`Failed to launch preview: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return JSON.stringify({
+        success: true,
+        path: filePath,
+        message: "HTML preview launched in browser.",
+    });
+}

package/dist/system/schema.js

@@ -0,0 +1,21 @@
+// system/schema.ts — argument schemas for the 6 system tools.
+// (MCP filesystem fork; Beledarian-parity system utilities: OS/CPU/memory
+// info, clipboard read/write, desktop notifications, open file/URL, HTML
+// preview. Ported from the reference Beledarian toolsProvider.ts.)
+import { z } from "zod";
+export const GetSystemInfoArgsSchema = z.object({});
+export const ReadClipboardArgsSchema = z.object({});
+export const WriteClipboardArgsSchema = z.object({
+    content: z.string(),
+});
+export const SendNotificationArgsSchema = z.object({
+    title: z.string(),
+    message: z.string(),
+});
+export const OpenFileArgsSchema = z.object({
+    target: z.string().describe("File path or URL"),
+});
+export const PreviewHtmlArgsSchema = z.object({
+    html_content: z.string(),
+    file_name: z.string().optional().describe("Optional filename (default: preview.html)"),
+});

package/dist/web/ddgParse.js

@@ -0,0 +1,51 @@
+// DuckDuckGo HTML parsing helpers — ported verbatim from the Beledarian plugin's
+// web_search implementation (toolsProvider.ts, web_search section) so results match.
+export const decodeHtmlEntities = (value) => value
+    .replace(/"/g, "\"")
+    .replace(/'/g, "'")
+    .replace(/'/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&");
+export const stripHtml = (value) => decodeHtmlEntities(value)
+    .replace(/<[^>]+>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+export const normalizeDuckDuckGoLink = (link) => {
+    const decoded = decodeHtmlEntities(link);
+    const absolute = decoded.startsWith("//")
+        ? `https:${decoded}`
+        : decoded.startsWith("/")
+            ? `https://duckduckgo.com${decoded}`
+            : decoded;
+    try {
+        const parsed = new URL(absolute);
+        const redirect = parsed.searchParams.get("uddg");
+        if (redirect) {
+            return decodeURIComponent(redirect);
+        }
+    }
+    catch {
+        // Return original normalized URL below.
+    }
+    return absolute;
+};
+export const parseDuckDuckGoHtml = (html, provider) => {
+    const parsedResults = [];
+    const titleRegex = /<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let match;
+    while ((match = titleRegex.exec(html)) !== null) {
+        const link = normalizeDuckDuckGoLink(match[1]);
+        const title = stripHtml(match[2]);
+        const nearbyHtml = html.slice(match.index, Math.min(html.length, match.index + 1800));
+        const snippetMatch = nearbyHtml.match(/class="result__snippet"[^>]*>([\s\S]*?)<\/(?:a|div)>/i);
+        const snippet = snippetMatch ? stripHtml(snippetMatch[1]) : "";
+        if (title && link) {
+            parsedResults.push({ title, link, snippet, provider });
+        }
+        if (parsedResults.length >= 10)
+            break;
+    }
+    return parsedResults;
+};

package/dist/web/handler.js

@@ -0,0 +1,286 @@
+import { closeSharedBrowser, getSharedBrowser, } from "../browser/launcher.js";
+import { parseDuckDuckGoHtml, } from "./ddgParse.js";
+// The browser legs (duckduckgo-html / google / bing) launch through the shared
+// browser launcher (browser/launcher.ts): Chrome-for-Testing 142.0.7444.175 via
+// puppeteer-core (pure JS, no browser download). Launch is lazy and provider
+// errors are collected (not fatal), so a missing browser never breaks the
+// non-puppeteer legs. getSharedBrowser/closeSharedBrowser preserve the
+// per-leg close semantics (each leg gets a clean instance).
+const getBrowser = getSharedBrowser;
+export async function handleWebSearch(query, providers) {
+    const results = [];
+    const errors = [];
+    const logs = [];
+    const searchFunctions = {
+        "duckduckgo-api": async (q) => {
+            const ddg = await import("duck-duck-scrape");
+            let attempt = 0;
+            let lastError = null;
+            while (attempt < 2) {
+                try {
+                    const r = await ddg.search(q, { safeSearch: ddg.SafeSearchType.OFF });
+                    if (r.results && r.results.length > 0) {
+                        return r.results.slice(0, 10).map((result) => ({
+                            title: result.title,
+                            link: result.url,
+                            snippet: result.description,
+                            provider: "duckduckgo-api",
+                        }));
+                    }
+                    break;
+                }
+                catch (e) {
+                    lastError = e;
+                    attempt++;
+                    await new Promise((res) => setTimeout(res, 1000));
+                }
+            }
+            if (lastError) {
+                throw lastError;
+            }
+            throw new Error("DuckDuckGo API returned no results");
+        },
+        "duckduckgo-fetch": async (q) => {
+            const response = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(q)}`, {
+                headers: {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+                    "Accept-Language": "en-US,en;q=0.9",
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const html = await response.text();
+            const extracted = parseDuckDuckGoHtml(html, "duckduckgo-fetch");
+            if (extracted.length > 0)
+                return extracted;
+            throw new Error("No results parsed from DuckDuckGo HTML");
+        },
+        "duckduckgo-html": async (q) => {
+            const browser = await getBrowser(); // shared launcher (browser/launcher.ts)
+            try {
+                const page = await browser.newPage();
+                await page.goto(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(q)}`, {
+                    waitUntil: "networkidle2",
+                    timeout: 15000,
+                });
+                const html = await page.content();
+                const extracted = parseDuckDuckGoHtml(html, "duckduckgo-html");
+                if (extracted.length > 0)
+                    return extracted;
+                throw new Error("No results found");
+            }
+            finally {
+                await closeSharedBrowser();
+            }
+        },
+        "google": async (q) => {
+            const browser = await getBrowser();
+            try {
+                const page = await browser.newPage();
+                await page.goto(`https://www.google.com/search?q=${encodeURIComponent(q)}`, {
+                    waitUntil: "networkidle2",
+                    timeout: 15000,
+                });
+                const extracted = await page.evaluate(() => {
+                    const items = document.querySelectorAll("div.g");
+                    const data = [];
+                    for (const item of items) {
+                        const titleEl = item.querySelector("h3");
+                        const linkEl = item.querySelector("a");
+                        const snippetEl = item.querySelector('div[style*="-webkit-line-clamp"]') ||
+                            item.querySelector("div.VwiC3b");
+                        if (titleEl && linkEl) {
+                            data.push({
+                                title: titleEl.innerText,
+                                link: linkEl.getAttribute("href") || "",
+                                snippet: snippetEl ? snippetEl.innerText : "",
+                                provider: "google",
+                            });
+                        }
+                    }
+                    return data;
+                });
+                if (extracted.length > 0)
+                    return extracted.slice(0, 10);
+                throw new Error("No results found");
+            }
+            finally {
+                await closeSharedBrowser();
+            }
+        },
+        "bing": async (q) => {
+            const browser = await getBrowser();
+            try {
+                const page = await browser.newPage();
+                await page.goto(`https://www.bing.com/search?q=${encodeURIComponent(q)}`, {
+                    waitUntil: "networkidle2",
+                    timeout: 15000,
+                });
+                const extracted = await page.evaluate(() => {
+                    const items = document.querySelectorAll("li.b_algo");
+                    const data = [];
+                    for (const item of items) {
+                        const titleEl = item.querySelector("h2 a");
+                        const linkEl = item.querySelector("h2 a");
+                        const snippetEl = item.querySelector("p");
+                        if (titleEl && linkEl) {
+                            data.push({
+                                title: titleEl.innerText,
+                                link: linkEl.getAttribute("href") || "",
+                                snippet: snippetEl ? snippetEl.innerText : "",
+                                provider: "bing",
+                            });
+                        }
+                    }
+                    return data;
+                });
+                if (extracted.length > 0)
+                    return extracted.slice(0, 10);
+                throw new Error("No results found");
+            }
+            finally {
+                await closeSharedBrowser();
+            }
+        },
+    };
+    if (providers && providers.length > 0) {
+        for (const providerKey of providers) {
+            try {
+                logs.push(`[Manual] Attempting ${providerKey}...`);
+                const pResults = await searchFunctions[providerKey](query);
+                results.push(...pResults);
+                logs.push(`[Manual] Success: ${providerKey} found ${pResults.length} results.`);
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                errors.push(`${providerKey}: ${errMsg}`);
+                logs.push(`[Manual] Failed: ${providerKey} - ${errMsg}`);
+            }
+        }
+    }
+    else {
+        const chain = [
+            "duckduckgo-fetch",
+            "duckduckgo-api",
+            "duckduckgo-html",
+            "google",
+            "bing",
+        ];
+        const browserProviders = ["duckduckgo-html", "google", "bing"];
+        let chromeUnavailable = false;
+        for (let i = 0; i < chain.length; i++) {
+            const providerKey = chain[i];
+            if (chromeUnavailable && browserProviders.includes(providerKey)) {
+                logs.push(`[Fallback Chain] Skipping ${providerKey}: Chrome not available on this system.`);
+                continue;
+            }
+            const nextProvider = chain[i + 1];
+            try {
+                logs.push(`[Fallback Chain] Attempting ${providerKey}...`);
+                const pResults = await searchFunctions[providerKey](query);
+                results.push(...pResults);
+                logs.push(`[Fallback Chain] Success: ${providerKey} found ${pResults.length} results. Stopping chain.`);
+                break;
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                errors.push(`${providerKey}: ${errMsg}`);
+                if (/chrome|chromium/i.test(errMsg) && browserProviders.includes(providerKey)) {
+                    chromeUnavailable = true;
+                    logs.push(`[Fallback Chain] Failed: ${providerKey} - Chrome not available. Skipping all browser-based providers.`);
+                }
+                else {
+                    const nextMsg = nextProvider ? `Falling back to ${nextProvider}...` : "No more providers.";
+                    logs.push(`[Fallback Chain] Failed: ${providerKey} - ${errMsg}. ${nextMsg}`);
+                }
+            }
+        }
+    }
+    if (results.length === 0) {
+        return JSON.stringify({
+            error: "All attempted search providers failed.",
+            attempts: errors,
+            trace: logs,
+        });
+    }
+    const seenLinks = new Set();
+    const dedupedResults = results.filter((r) => {
+        const key = r.link.trim();
+        if (!key || seenLinks.has(key))
+            return false;
+        seenLinks.add(key);
+        return true;
+    });
+    return JSON.stringify({
+        results: dedupedResults,
+        meta: {
+            total_found: dedupedResults.length,
+            providers_used: [...new Set(dedupedResults.map((r) => r.provider))],
+            no_api_key_required: true,
+            trace: logs,
+        },
+    });
+}
+export async function handleFetchWebContent(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        let text = await response.text();
+        const result = {
+            url,
+            status: response.status,
+        };
+        const titleMatch = text.match(/<title[^>]*>([^<]+)<\/title>/i);
+        if (titleMatch)
+            result.title = titleMatch[1];
+        const { compile } = await import("html-to-text");
+        const compiledConvert = compile({
+            wordwrap: false,
+            selectors: [
+                { selector: "a", options: { ignoreHref: true } },
+                { selector: "img", format: "skip" },
+            ],
+        });
+        text = compiledConvert(text);
+        result.content =
+            text.substring(0, 40000) + (text.length > 40000 ? " (truncated)" : "");
+        return JSON.stringify(result);
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: `Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}
+export async function handleWikipediaSearch(query, lang = "en") {
+    try {
+        const searchUrl = `https://${lang}.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&format=json`;
+        const searchResponse = await fetch(searchUrl);
+        const searchData = await searchResponse.json();
+        if (!searchData.query || !searchData.query.search || searchData.query.search.length === 0) {
+            return JSON.stringify({ results: "No Wikipedia articles found." });
+        }
+        const results = [];
+        for (const item of searchData.query.search.slice(0, 3)) {
+            // Top 3
+            const pageUrl = `https://${lang}.wikipedia.org/w/api.php?action=query&prop=extracts&exintro&explaintext&pageids=${item.pageid}&format=json`;
+            const pageResponse = await fetch(pageUrl);
+            const pageData = await pageResponse.json();
+            const page = pageData.query.pages[item.pageid];
+            results.push({
+                title: item.title,
+                summary: page.extract.substring(0, 2000) + (page.extract.length > 2000 ? "..." : ""),
+                url: `https://${lang}.wikipedia.org/wiki/${encodeURIComponent(item.title.replace(/ /g, "_"))}`,
+            });
+        }
+        return JSON.stringify({ results });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: `Wikipedia search failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}

package/dist/web/schema.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export const WebSearchArgsSchema = z.object({
+    query: z.string().describe("The search query"),
+    providers: z
+        .array(z.enum(["duckduckgo-api", "duckduckgo-fetch", "duckduckgo-html", "google", "bing"]))
+        .optional()
+        .describe("Optional: List of specific providers. If omitted, fallback chain is: DDG Fetch (no Chrome) -> DDG API -> DDG browser -> Google -> Bing."),
+});
+export const FetchWebContentArgsSchema = z.object({
+    url: z.string().describe("The URL to fetch"),
+});
+export const WikipediaSearchArgsSchema = z.object({
+    query: z.string().describe("The search query"),
+    lang: z
+        .string()
+        .optional()
+        .describe("Language code (default: en)"),
+});

package/package.json

@@ -1,8 +1,19 @@
 {
   "name": "mcp-fs-shell-windows",
-  "version": "0.2.20",
-  "description": "MCP filesystem server: batched file tools + standalone Windows shell tools (extended fork)",
+  "version": "0.2.29",
+  "description": "MCP server with 82 tools: batched filesystem access, standalone Windows shell, and a Beledarian-parity tool set (git, GitHub, system, document, database, web, RAG, browser, sub-agent). Extended fork of mcp-filesystem-extended.",
   "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "filesystem",
+    "windows",
+    "shell",
+    "lm-studio",
+    "claude",
+    "deno",
+    "puppeteer"
+  ],
   "author": "Gerard DeLuca",
   "repository": {
     "type": "git",
@@ -24,21 +35,30 @@
   ],
   "scripts": {
     "build": "tsc && shx chmod +x dist/*.js",
+    "test": "node --test tests/*.test.js",
     "prepare": "npm run build",
     "watch": "tsc --watch"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "0.5.0",
     "diff": "^5.1.0",
+    "duck-duck-scrape": "^2.2.7",
     "glob": "^10.3.10",
+    "html-to-text": "^9.0.5",
+    "mammoth": "^1.12.3",
     "minimatch": "^10.0.1",
+    "node-notifier": "^10.0.1",
+    "pdf-parse": "^2.4.5",
+    "puppeteer-core": "^24.31.0",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5"
   },
   "devDependencies": {
     "@types/diff": "^5.0.9",
+    "@types/html-to-text": "^9.0.4",
     "@types/minimatch": "^5.1.2",
     "@types/node": "^22",
+    "@types/node-notifier": "^8.0.5",
     "shx": "^0.3.4",
     "typescript": "^5.3.3"
   }