mcp-fs-shell-windows 0.2.19 → 0.2.29

package/dist/server.js

@@ -42,6 +42,32 @@ import { ShellCancelArgsSchema } from "./shell/schema.js";
 import { ShellTerminalArgsSchema } from "./shell/schema.js";
 import { ShellPythonArgsSchema } from "./shell/schema.js";
 import { ShellCwdArgsSchema } from "./shell/schema.js";
+import { RunJavascriptFreeArgsSchema } from "./run_javascript/schema.js";
+import { GitStatusArgsSchema } from "./git/schema.js";
+import { GitDiffArgsSchema } from "./git/schema.js";
+import { GitCommitArgsSchema } from "./git/schema.js";
+import { GitLogArgsSchema } from "./git/schema.js";
+import { GitAddArgsSchema } from "./git/schema.js";
+import { GitCheckoutArgsSchema } from "./git/schema.js";
+import { GhAuthArgsSchema } from "./gh/schema.js";
+import { GhCreateIssueArgsSchema } from "./gh/schema.js";
+import { GhListIssuesArgsSchema } from "./gh/schema.js";
+import { GhViewCommentsArgsSchema } from "./gh/schema.js";
+import { GhCreatePrArgsSchema } from "./gh/schema.js";
+import { GhListPrsArgsSchema } from "./gh/schema.js";
+import { GhViewPrDiffArgsSchema } from "./gh/schema.js";
+import { GhPushArgsSchema } from "./gh/schema.js";
+import { GetSystemInfoArgsSchema } from "./system/schema.js";
+import { ReadClipboardArgsSchema } from "./system/schema.js";
+import { WriteClipboardArgsSchema } from "./system/schema.js";
+import { SendNotificationArgsSchema } from "./system/schema.js";
+import { OpenFileArgsSchema } from "./system/schema.js";
+import { PreviewHtmlArgsSchema } from "./system/schema.js";
+import { ReadDocumentArgsSchema } from "./read_document/schema.js";
+import { QueryDatabaseArgsSchema } from "./query_database/schema.js";
+import { AnalyzeProjectArgsSchema } from "./analyze_project/schema.js";
+import { WebSearchArgsSchema, FetchWebContentArgsSchema, WikipediaSearchArgsSchema, } from "./web/schema.js";
+import { RagLocalFilesArgsSchema, RagWebContentArgsSchema } from "./rag/schema.js";
 // Import all handlers
 import { handleReadFiles } from "./read_files/handler.js";
 import { handleWriteNewFiles } from "./write_new_files/handler.js";
@@ -81,6 +107,38 @@ import { handleShellCancel } from "./shell/handler.js";
 import { handleShellTerminal } from "./shell/handler.js";
 import { handleShellPython } from "./shell/handler.js";
 import { handleShellCwd } from "./shell/handler.js";
+import { handleRunJavascriptFree } from "./run_javascript/handler.js";
+import { handleGitStatus } from "./git/handler.js";
+import { handleGitDiff } from "./git/handler.js";
+import { handleGitCommit } from "./git/handler.js";
+import { handleGitLog } from "./git/handler.js";
+import { handleGitAdd } from "./git/handler.js";
+import { handleGitCheckout } from "./git/handler.js";
+import { handleGhAuth } from "./gh/handler.js";
+import { handleGhCreateIssue } from "./gh/handler.js";
+import { handleGhListIssues } from "./gh/handler.js";
+import { handleGhViewComments } from "./gh/handler.js";
+import { handleGhCreatePr } from "./gh/handler.js";
+import { handleGhListPrs } from "./gh/handler.js";
+import { handleGhViewPrDiff } from "./gh/handler.js";
+import { handleGhPush } from "./gh/handler.js";
+import { handleGetSystemInfo } from "./system/handler.js";
+import { handleReadClipboard } from "./system/handler.js";
+import { handleWriteClipboard } from "./system/handler.js";
+import { handleSendNotification } from "./system/handler.js";
+import { handleOpenFile } from "./system/handler.js";
+import { handlePreviewHtml } from "./system/handler.js";
+import { handleReadDocument } from "./read_document/handler.js";
+import { handleQueryDatabase } from "./query_database/handler.js";
+import { handleAnalyzeProject } from "./analyze_project/handler.js";
+import { handleWebSearch, handleFetchWebContent, handleWikipediaSearch, } from "./web/handler.js";
+import { handleRagLocalFiles, handleRagWebContent } from "./rag/handler.js";
+import { BrowserSessionOpenArgsSchema, BrowserSessionControlArgsSchema, BrowserSessionCloseArgsSchema, BrowserOpenPageArgsSchema, } from "./browser/schema.js";
+import { handleBrowserSessionOpen, handleBrowserSessionControl, handleBrowserSessionClose, handleBrowserOpenPage, } from "./browser/handler.js";
+import { ExecuteCommandArgsSchema, RunInTerminalArgsSchema, RunTestCommandArgsSchema, RunBackgroundCommandArgsSchema, CheckBackgroundCommandArgsSchema, CancelBackgroundCommandArgsSchema, RunPythonArgsSchema, RunJavascriptArgsSchema, SaveMemoryArgsSchema, } from "./compat/schema.js";
+import { handleExecuteCommand, handleRunInTerminal, handleRunTestCommand, handleRunBackgroundCommand, handleCheckBackgroundCommand, handleCancelBackgroundCommand, handleRunPython, handleRunJavascript, handleSaveMemory, } from "./compat/handler.js";
+import { ConsultSecondaryAgentArgsSchema } from "./subagent/schema.js";
+import { handleConsultSecondaryAgent } from "./subagent/handler.js";
 const ToolInputSchema = ToolSchema.shape.inputSchema;
 export class FilesystemServer {
     server;
@@ -89,7 +147,7 @@ export class FilesystemServer {
         this.allowedDirectories = allowedDirectories;
         this.server = new Server({
             name: "secure-filesystem-server",
-            version: "0.2.19",
+            version: "0.2.29",
         }, {
             capabilities: {
                 tools: {},
@@ -467,6 +525,388 @@ export class FilesystemServer {
                             "Only works within allowed directories.",
                         inputSchema: zodToJsonSchema(WaitForFileArgsSchema),
                     },
+                    {
+                        name: "run_javascript_free",
+                        description: "Run a JavaScript/TypeScript code snippet on the Deno runtime with UNRESTRICTED permissions: full filesystem read/write (any drive or UNC path the server user can reach), network access, environment variables, child processes, and arbitrary imports (node:*, npm:*, https:*) - unlike the other run_javascript tools, there is no working-directory sandbox. " +
+                            "The code is written to a temp .ts file and run; returns exit code, stdout, and stderr. " +
+                            "Default 5 s timeout, max 60 s; optional cwd (defaults to the shell_cwd default). " +
+                            "Non-zero exit or timeout returns an error that still includes the captured output. " +
+                            "Requires a Deno binary: $DENO_PATH, <LM Studio home>/.internal/utils/deno(.exe) (found by walking up from the server CWD or the user home), or deno on PATH.",
+                        inputSchema: zodToJsonSchema(RunJavascriptFreeArgsSchema),
+                    },
+                    {
+                        name: "git_status",
+                        description: "Get the current git status of the repository at the server process's current working directory (the directory the server was launched in, e.g. the chat working directory; no path argument). " +
+                            "Returns JSON text: {current (branch name; null for detached HEAD), tracking (upstream branch or null), ahead, behind, isClean, staged: [], notStaged: [], untracked: [], files: [{path, index, working_dir}]}. " +
+                            "If the working directory is not inside a git repository, returns a clear {error} string (not a crash).",
+                        inputSchema: zodToJsonSchema(GitStatusArgsSchema),
+                    },
+                    {
+                        name: "git_diff",
+                        description: "Get the git diff of the repository at the server process's current working directory or specific files. " +
+                            "file_path (optional): path to a specific file to diff, resolved relative to the working directory. " +
+                            "cached (optional): show staged changes only (git diff --cached). " +
+                            "Returns JSON text: {diff} with the unified diff (\"No changes.\" when there is nothing to show), or a clear {error} string if the working directory is not inside a git repository.",
+                        inputSchema: zodToJsonSchema(GitDiffArgsSchema),
+                    },
+                    {
+                        name: "git_commit",
+                        description: "Commit staged changes to the git repository at the server process's current working directory. " +
+                            "Standard git behavior: commits only what is staged (stage first with git_add). " +
+                            "Returns JSON text: {success: true, summary: {changed, insertions, deletions}}, or a clear {error} string (e.g. when nothing is staged).",
+                        inputSchema: zodToJsonSchema(GitCommitArgsSchema),
+                    },
+                    {
+                        name: "git_log",
+                        description: "Get recent git commit history from the repository at the server process's current working directory. " +
+                            "max_count (optional): max number of commits to return (default: 10). " +
+                            "Returns JSON text: {history: ['<hash> <subject> (<author>, <date relative>)', ...]}, newest first, or a clear {error} string (e.g. when the repo has no commits).",
+                        inputSchema: zodToJsonSchema(GitLogArgsSchema),
+                    },
+                    {
+                        name: "git_add",
+                        description: "Stage specific files or all changes for the next commit, in the repository at the server process's current working directory. " +
+                            "paths (optional): specific file paths to stage, resolved relative to the working directory; if omitted, stages all changes (git add .). " +
+                            "Returns JSON text: {success: true, message}, or a clear {error} string.",
+                        inputSchema: zodToJsonSchema(GitAddArgsSchema),
+                    },
+                    {
+                        name: "git_checkout",
+                        description: "Switch to an existing branch, or create and switch to a new one, in the repository at the server process's current working directory. " +
+                            "branch_name: name of the branch to checkout. " +
+                            "create_new (optional, default false): if true, creates the branch if it doesn't exist (like git checkout -b). " +
+                            "Returns JSON text: {success: true, message}, or a clear {error} string (e.g. branch does not exist, or uncommitted changes would be overwritten).",
+                        inputSchema: zodToJsonSchema(GitCheckoutArgsSchema),
+                    },
+                    {
+                        name: "gh_auth",
+                        description: "Check GitHub authentication status. If not authenticated, opens a detached terminal window (cmd /k) for the user to sign in. " +
+                            "Runs `gh auth status`; on failure spawns `cmd.exe /c start ... cmd.exe /k \"<gh> auth login --git-protocol=https & exit\"` detached with ignored stdio, so the window outlives the tool call and stays open for interactive sign-in (the resolved absolute gh path is used, so the window works even when gh is not on the server's PATH). " +
+                            "Returns JSON text: {success: true, message} (\"Already authenticated with GitHub.\" or \"Opened a terminal window for GitHub authentication. Please sign in there.\"), or a clear {error} string (e.g. the gh CLI is not installed).",
+                        inputSchema: zodToJsonSchema(GhAuthArgsSchema),
+                    },
+                    {
+                        name: "gh_create_issue",
+                        description: "Create a new GitHub issue in the repository at the server process's current working directory (no path argument; the repo is resolved from the working directory's git remote, exactly as the reference tools do). " +
+                            "title: the issue title. " +
+                            "body (optional): the issue body — written to a temp file in the working directory and passed via --body-file (always cleaned up). " +
+                            "labels (optional): label names, each added as -l. " +
+                            "Returns JSON text: {success: true, url} with the new issue's URL, or a clear {error} string (e.g. repository not found, not authenticated).",
+                        inputSchema: zodToJsonSchema(GhCreateIssueArgsSchema),
+                    },
+                    {
+                        name: "gh_list_issues",
+                        description: "List issues in the repository at the server process's current working directory. " +
+                            "state (optional, default \"open\"): \"open\" or \"closed\". " +
+                            "labels (optional): filter by label names (each added as -l). " +
+                            "limit (optional, default 10, max 50): maximum number of issues to return. " +
+                            "Returns JSON text: {issues: [{number, title, state, url, labels}]}, an empty array when there are no matches, or a clear {error} string.",
+                        inputSchema: zodToJsonSchema(GhListIssuesArgsSchema),
+                    },
+                    {
+                        name: "gh_view_comments",
+                        description: "View comments on a specific issue or pull request in the repository at the server process's current working directory. " +
+                            "number: the issue or PR number. " +
+                            "type (optional, default \"issue\"): \"issue\" or \"pr\". " +
+                            "Returns JSON text: {comments: [...]} with the GitHub comment objects, or a clear {error} string.",
+                        inputSchema: zodToJsonSchema(GhViewCommentsArgsSchema),
+                    },
+                    {
+                        name: "gh_create_pr",
+                        description: "Create a new pull request in the repository at the server process's current working directory (no path argument; the repo is resolved from the working directory's git remote). " +
+                            "title: the PR title. " +
+                            "head_branch: the branch containing your changes. " +
+                            "base_branch (optional, default \"main\"): the branch to merge into (e.g. main, master). " +
+                            "body (optional): the PR description — written to a temp file in the working directory and passed via --body-file (always cleaned up). " +
+                            "Returns JSON text: {success: true, url} with the new PR's URL, or a clear {error} string (e.g. head branch not found).",
+                        inputSchema: zodToJsonSchema(GhCreatePrArgsSchema),
+                    },
+                    {
+                        name: "gh_list_prs",
+                        description: "List pull requests in the repository at the server process's current working directory. " +
+                            "state (optional, default \"open\"): \"open\" or \"closed\". " +
+                            "limit (optional, default 10, max 50): maximum number of PRs to return. " +
+                            "Returns JSON text: {pull_requests: [{number, title, state, url, headRefName, baseRefName}]}, an empty array when there are no matches, or a clear {error} string.",
+                        inputSchema: zodToJsonSchema(GhListPrsArgsSchema),
+                    },
+                    {
+                        name: "gh_view_pr_diff",
+                        description: "Fetch the diff/patch of a specific pull request in the repository at the server process's current working directory. " +
+                            "number: the PR number. " +
+                            "Returns JSON text: {diff} with the unified diff (truncated to 50,000 characters with a \"... (truncated)\" marker), or a clear {error} string.",
+                        inputSchema: zodToJsonSchema(GhViewPrDiffArgsSchema),
+                    },
+                    {
+                        name: "gh_push",
+                        description: "Push local commits to the remote GitHub repository in the server process's current working directory (git push origin [branch]). " +
+                            "branch (optional): the branch to push; defaults to the current branch. " +
+                            "Returns JSON text: {success: true, message}, or a clear {error} string (e.g. remote not found, no upstream branch, authentication required).",
+                        inputSchema: zodToJsonSchema(GhPushArgsSchema),
+                    },
+                    {
+                        name: "get_system_info",
+                        description: "Get information about the system (OS, CPU, Memory). No parameters. " +
+                            "Returns JSON text: {platform, arch, release, hostname, total_memory, free_memory, cpus, node_version} " +
+                            "(memory in bytes; cpus = number of logical CPUs; node_version = the Node.js version running this server).",
+                        inputSchema: zodToJsonSchema(GetSystemInfoArgsSchema),
+                    },
+                    {
+                        name: "read_clipboard",
+                        description: "Read text content from the system clipboard. No parameters. " +
+                            "On Windows uses `powershell -command Get-Clipboard` (macOS: pbpaste; other: xclip) with a 5-second timeout. " +
+                            "An empty clipboard returns content \"\" (not an error). " +
+                            "Returns JSON text: {content}, or a clear error if the read fails or times out.",
+                        inputSchema: zodToJsonSchema(ReadClipboardArgsSchema),
+                    },
+                    {
+                        name: "write_clipboard",
+                        description: "Write text content to the system clipboard. content: the text to store (UTF-8). " +
+                            "On Windows the content is base64-encoded into the PowerShell command line and Set-Clipboard stores the decoded text, " +
+                            "so quotes, newlines, and Unicode need no escaping. " +
+                            "macOS: pbcopy; other: xclip via stdin. 5-second timeout. " +
+                            "Returns JSON text: {success: true}, or a clear error if the write fails or times out.",
+                        inputSchema: zodToJsonSchema(WriteClipboardArgsSchema),
+                    },
+                    {
+                        name: "send_notification",
+                        description: "Send a system notification to the user (a Windows toast via the bundled snoretoast on this machine; node-notifier backends elsewhere). " +
+                            "title: the notification title. message: the notification body. " +
+                            "Dispatched fire-and-forget (sound: true, wait: false). " +
+                            "Returns JSON text: {success: true, message}.",
+                        inputSchema: zodToJsonSchema(SendNotificationArgsSchema),
+                    },
+                    {
+                        name: "open_file",
+                        description: "Open a file path or http(s) URL in the system's default application (the OS default: e.g. VLC for .mkv/.mp4, Explorer for folders, the default browser for web links). " +
+                            "target: file path or URL. " +
+                            "The Beledarian-named equivalent of launch_file - it delegates to the same internal launch helper: " +
+                            "filesystem targets are subject to the allowed-roots policy and checked for existence; " +
+                            "only http:// and https:// links are launched as URLs (every other scheme is rejected). " +
+                            "Returns JSON text: {success: true, message}, or a clear error (e.g. path does not exist, unsupported URL scheme).",
+                        inputSchema: zodToJsonSchema(OpenFileArgsSchema),
+                    },
+                    {
+                        name: "preview_html",
+                        description: "Render and preview HTML content in the system's default browser. " +
+                            "html_content: the HTML to render. " +
+                            "file_name (optional): name for the temp file (default: a timestamped preview_<ts>.html; " +
+                            "only the final path segment is used - the file always lands in the system temp dir, and an existing file of that name is overwritten). " +
+                            "The temp file is written, launched in the default browser (same detached opener as launch_file), and left on disk. " +
+                            "Returns JSON text: {success: true, path, message} with the temp file path.",
+                        inputSchema: zodToJsonSchema(PreviewHtmlArgsSchema),
+                    },
+                    {
+                        name: "read_document",
+                        description: "Read content from PDF or DOCX files. " +
+                            "PDF via pdf-parse v2 class-based API (new PDFParse({data}), getText/getInfo/destroy) returning JSON text: {content, metadata}; " +
+                            "DOCX via mammoth extractRawText returning {content, messages}. " +
+                            "Unsupported extensions return the error 'Unsupported document format. Use read_file for text files.' " +
+                            "Other failures are wrapped as {error: 'Failed to read document: ...'}. " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(ReadDocumentArgsSchema),
+                    },
+                    {
+                        name: "query_database",
+                        description: "Execute a read-only query on a SQLite database file. " +
+                            "Implemented on Node's built-in node:sqlite (DatabaseSync opened with readOnly: true) - no native dependency. " +
+                            "Write statements (INSERT/UPDATE/DELETE/DROP/ALTER/CREATE/REPLACE) are blocked up-front with the error 'Only SELECT/read queries are allowed for safety.' " +
+                            "Returns JSON text: {results} (array of row objects from prepare().all()), or {error: 'Database query failed: ...'}. " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(QueryDatabaseArgsSchema),
+                    },
+                    {
+                        name: "analyze_project",
+                        description: "Run project-wide analysis (linting) to find errors and warnings. " +
+                            "Operates in the current working directory (the shell_cwd default CWD). " +
+                            "Detection ladder: if package.json has scripts.lint -> 'npm run lint' (type npm-script); " +
+                            "else if eslint is in (dev)dependencies -> 'npx eslint . --format json' (type eslint); " +
+                            "else if any .py file is present (only when package.json is absent/unreadable) -> 'pylint .' (type python-lint). " +
+                            "No detection returns the error 'Could not detect a supported linter (ESLint script or Python).' " +
+                            "Spawns with shell:true and a 60 s timeout; returns JSON text: {tool, type, report} (report = stdout+stderr capped at 10000 chars), or {error}.",
+                        inputSchema: zodToJsonSchema(AnalyzeProjectArgsSchema),
+                    },
+                    {
+                        name: "web_search",
+                        description: "Search the web using multiple providers (DuckDuckGo, Google, Bing). " +
+                            "Uses no-key, no-Chrome providers first, then browser providers as fallback. " +
+                            "Default fallback chain (when providers is omitted): duckduckgo-fetch -> duckduckgo-api -> duckduckgo-html -> google -> bing; the chain stops at the first provider that returns results. " +
+                            "When providers is given, each listed provider is tried in order and errors are collected per provider (not fatal). " +
+                            "Browser-based providers (duckduckgo-html, google, bing) use puppeteer-core with the local Chrome-for-Testing build and are skipped in chain mode once Chrome is detected unavailable. " +
+                            "Returns JSON text: {results: [{title, link, snippet, provider}], meta: {total_found, providers_used, no_api_key_required, trace}} or, when every provider fails, {error: 'All attempted search providers failed.', attempts: [...], trace: [...]}. " +
+                            "Results are deduplicated by link.",
+                        inputSchema: zodToJsonSchema(WebSearchArgsSchema),
+                    },
+                    {
+                        name: "fetch_web_content",
+                        description: "Fetch the clean, text-based content of a webpage URL. " +
+                            "Fetches the URL, extracts the <title> when present, converts the HTML to plain text via html-to-text (wordwrap off, anchor hrefs ignored, images skipped), and truncates the content to 40000 chars (' (truncated)' marker when cut). " +
+                            "Returns JSON text: {url, status, title?, content} or {error: 'Failed to fetch URL: ...'}.",
+                        inputSchema: zodToJsonSchema(FetchWebContentArgsSchema),
+                    },
+                    {
+                        name: "wikipedia_search",
+                        description: "Search Wikipedia for a given query and return page summaries. " +
+                            "Uses the MediaWiki API: list=search (top 3), then prop=extracts exintro explaintext per pageid; each summary is truncated to 2000 chars and each url is built from the page title. " +
+                            "lang (optional): language code, default 'en'. " +
+                            "Returns JSON text: {results: [{title, summary, url}]}, {results: 'No Wikipedia articles found.'}, or {error: 'Wikipedia search failed: ...'}.",
+                        inputSchema: zodToJsonSchema(WikipediaSearchArgsSchema),
+                    },
+                    {
+                        name: "rag_local_files",
+                        description: "Perform RAG (Retrieval-Augmented Generation) on files in a directory. " +
+                            "Recursively scans up to 50 text files under path (default: the server process's working directory), skipping binary extensions (.png/.jpg/.jpeg/.gif/.ico/.exe/.dll/.bin). " +
+                            "file_pattern (optional) restricts the scan to files whose name or full path contains the pattern (e.g. '.ts' or 'src/'). " +
+                            "Files are chunked by paragraph (chunks longer than 20 characters); the query and all chunks are embedded via LM Studio's /v1/embeddings endpoint (bundled nomic-embed-text v1.5; the model id can be overridden with the MCP_RAG_EMBED_MODEL environment variable). " +
+                            "Chunks scoring above cosine similarity 0.4 against the query are kept, sorted by score, and the top 10 are returned. " +
+                            "Returns JSON text: {query, results: [{file, score, content}]} or {error: 'Local RAG failed: ...'}. " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(RagLocalFilesArgsSchema),
+                    },
+                    {
+                        name: "rag_web_content",
+                        description: "Fetch content from a URL, and then use RAG to find and return only the text chunks most relevant to a specific query. " +
+                            "Fetches the URL, converts the HTML to plain text via html-to-text (wordwrap off, anchor hrefs ignored, images skipped), chunks it by paragraph (chunks longer than 20 characters), embeds the query and chunks via LM Studio's /v1/embeddings endpoint (bundled nomic-embed-text v1.5; the model id can be overridden with the MCP_RAG_EMBED_MODEL environment variable), and returns the top 5 chunks sorted by cosine similarity. " +
+                            "Returns JSON text: {url, query, relevant_chunks: [{chunk, score}]} or {error: 'Failed during RAG web search: ...'}.",
+                        inputSchema: zodToJsonSchema(RagWebContentArgsSchema),
+                    },
+                    {
+                        name: "browser_session_open",
+                        description: "Open a persistent browser session (single active page), navigate to URL, and return page text for context. " +
+                            "Launches a headless Chrome-for-Testing instance via puppeteer-core (shared launcher: browser/launcher.ts; also used by web_search's browser legs). " +
+                            "There is ONE active session per server process - re-opening replaces any existing session (closing its browser first). " +
+                            "Navigation waits for networkidle0 with a 30s timeout. " +
+                            "wait_for_selector: optional CSS selector to wait for after navigation (15s timeout). " +
+                            "include_page_text: if true (default), returns full page text content (document.body.innerText) after opening. " +
+                            "Returns JSON text: {success, session_active, url, title, text_content, text_length, message} or {error: 'Failed to open browser session: ...'}.",
+                        inputSchema: zodToJsonSchema(BrowserSessionOpenArgsSchema),
+                    },
+                    {
+                        name: "browser_session_control",
+                        description: "Control the active persistent browser session. " +
+                            "Supports actions, page reading, screenshot capture, and fuzzy finding in-page text/selectors. " +
+                            "actions: array of {type: wait_for_selector | wait | click | type | press | select | hover | scroll | evaluate, selector?, text?, value?, key?, milliseconds?, x?, y?, script?} executed in order. " +
+                            "click: native click with one retry, then DOM fallback (scrollIntoView + element.click); type: triple-clicks to select, clears, then types; evaluate: runs a JS snippet in page context. " +
+                            "Missing required fields produce clear errors (e.g. \"Action 'click' requires 'selector'.\"). " +
+                            "read_page: if true (default), returns page metadata (url + title). Full text is returned only on URL change or when full_read=true. " +
+                            "full_read: if true, forces full page text output even when URL has not changed. " +
+                            "screenshot_path: optional screenshot output path (must be within an allowed directory); full_page_screenshot: capture the full page. " +
+                            "fuzzy_find: fuzzy-find query over in-page content/selectors (interactive + text nodes, deduped, capped at 400 candidates; ranked by text then selector similarity); max_results: max fuzzy results (default 5, max 20). " +
+                            "Returns JSON text: {success, session_active, actions_executed, screenshot_saved, url_changed, url_change_notice, page, fuzzy_find_results} or {error: 'Browser session control failed: ...'}. " +
+                            "Fails with a clear 'No active browser session. Call 'browser_session_open' first.' error when no session is open.",
+                        inputSchema: zodToJsonSchema(BrowserSessionControlArgsSchema),
+                    },
+                    {
+                        name: "browser_session_close",
+                        description: "Close the active persistent browser session. " +
+                            "Tears down the session's Chrome instance; subsequent browser_session_control calls fail with the clear no-session error. " +
+                            "Idempotent: when no session is open it succeeds with session_active=false and message 'No active browser session.'. " +
+                            "Returns JSON text: {success, session_active, message} or {error: 'Failed to close browser session: ...'}.",
+                        inputSchema: zodToJsonSchema(BrowserSessionCloseArgsSchema),
+                    },
+                    {
+                        name: "browser_open_page",
+                        description: "Open a webpage in a headless browser (puppeteer-core), render it once, and return content. " +
+                            "One-shot only; do not use for multi-step navigation. " +
+                            "Stateless: uses its own browser instance (shared launcher: browser/launcher.ts) that is always closed on return, and never touches the persistent browser session. " +
+                            "url: page to load (networkidle0, 30s timeout). " +
+                            "wait_for_selector: CSS selector to wait for before returning (10s timeout). " +
+                            "actions: optional scripted browser steps to run after navigation (same action schema as browser_session_control). " +
+                            "screenshot_path: path to save a screenshot (must be within an allowed directory); full_page_screenshot: capture the full page. " +
+                            "Returns JSON text: {url, title, text_content (max 5000 chars), screenshot_saved, actions_executed, url_changed, url_change_notice} or {error: 'Browser operation failed: ...'}.",
+                        inputSchema: zodToJsonSchema(BrowserOpenPageArgsSchema),
+                    },
+                    {
+                        name: "execute_command",
+                        description: "Beledarian-compatible alias of shell_run (same bounded synchronous semantics, same result shape). " +
+                            "Execute a shell command in the current working directory and return the stdout and stderr output of the command. " +
+                            "You can optionally provide input to be piped to the command's stdin. " +
+                            "IMPORTANT: The host operating system is 'win32' (Windows) - do NOT use 'bash' or 'sh' commands unless you are certain WSL is available; use standard Windows 'cmd' or 'powershell' syntax. " +
+                            "timeout_seconds: default 5, max 60 (Beledarian's 60 s cap; the native shell_run caps at 28 s). " +
+                            "Returns {command, exitCode, stdout, stderr, timedOut, duration_ms, cwd}; non-zero exit or timeout returns an error that still includes the captured output.",
+                        inputSchema: zodToJsonSchema(ExecuteCommandArgsSchema),
+                    },
+                    {
+                        name: "run_in_terminal",
+                        description: "Beledarian-compatible alias of shell_terminal. " +
+                            "Launch a command in a new, separate interactive terminal window. " +
+                            "Use this for scripts that require user interaction (input/output) or to open a shell in a specific directory. " +
+                            "(Currently optimized for Windows.) " +
+                            "Returns the shell_terminal job JSON (including the job id); use cancel_background_command (or shell_cancel) to close the window.",
+                        inputSchema: zodToJsonSchema(RunInTerminalArgsSchema),
+                    },
+                    {
+                        name: "run_test_command",
+                        description: "Beledarian-compatible alias of shell_test. " +
+                            "Execute a test command (like 'npm test') and return the results as {command, exit_code, stdout, stderr, passed}. " +
+                            "Specialized for capturing test output. Never errors on a failing test. Runs with CI=true. " +
+                            "Host is Windows; use cmd.exe syntax. " +
+                            "Bounded to 28 s by the MCP client timeout - for longer suites use run_background_command (shell_start) + check_background_command (shell_check).",
+                        inputSchema: zodToJsonSchema(RunTestCommandArgsSchema),
+                    },
+                    {
+                        name: "run_background_command",
+                        description: "Beledarian-compatible alias of shell_start. " +
+                            "Starts a long-running process in the background. The process is not blocked, allowing you to do other things. " +
+                            "You MUST provide a descriptive name. timeout_hours: optional, default 10, max 10 (auto-kill). " +
+                            "Host is Windows; use cmd.exe syntax. " +
+                            "Returns the shell_start job JSON (including the job id); poll with check_background_command (shell_check) and kill with cancel_background_command (shell_cancel). " +
+                            "Job ids live in this MCP server process's registry (same lifetime as Beledarian's per-process backgroundCommands map - lost when the server restarts).",
+                        inputSchema: zodToJsonSchema(RunBackgroundCommandArgsSchema),
+                    },
+                    {
+                        name: "check_background_command",
+                        description: "Beledarian-compatible alias of shell_check. " +
+                            "Check the status, stdout, and stderr of a running or completed background command started with run_background_command (or run_in_terminal). " +
+                            "Returns {id, name, status, exitCode, duration_seconds, stdout_tail, stderr_tail, logFile}. " +
+                            "Status values: running, completed, error, cancelled, timeout.",
+                        inputSchema: zodToJsonSchema(CheckBackgroundCommandArgsSchema),
+                    },
+                    {
+                        name: "cancel_background_command",
+                        description: "Beledarian-compatible alias of shell_cancel. " +
+                            "Kills a running background command (job from run_background_command or run_in_terminal). " +
+                            "Kills the whole process tree.",
+                        inputSchema: zodToJsonSchema(CancelBackgroundCommandArgsSchema),
+                    },
+                    {
+                        name: "run_python",
+                        description: "Beledarian-compatible alias of shell_python (keeps Beledarian's 60 s cap). " +
+                            "Run a Python code snippet. You cannot import external modules but you have read/write access to the current working directory. " +
+                            "Pass the code you wish to run as a string in the 'python' parameter. " +
+                            "By default, the code will timeout in 5 seconds. You can extend this timeout by setting the 'timeout_seconds' parameter to a higher value in seconds, up to a maximum of 60 seconds. " +
+                            "You will get the stdout and stderr output of the code execution, thus please print the output you wish to return using 'print()'. " +
+                            "Requires system Python on PATH. Optional cwd overrides the default working directory (see shell_cwd). " +
+                            "Returns {exitCode, stdout, stderr, timedOut, duration_ms}; non-zero exit or timeout returns an error that still includes the captured output.",
+                        inputSchema: zodToJsonSchema(RunPythonArgsSchema),
+                    },
+                    {
+                        name: "run_javascript",
+                        description: "Beledarian-compatible alias of the fork's run_javascript - the CONFINED variant (NOT an alias of run_javascript_free). " +
+                            "Run a JavaScript/TypeScript code snippet using deno. You cannot import external modules but you have read/write access to the current working directory. " +
+                            "Pass the code you wish to run as a string in the 'javascript' parameter. " +
+                            "By default, the code will timeout in 5 seconds. You can extend this timeout by setting the 'timeout_seconds' parameter to a higher value in seconds, up to a maximum of 60 seconds. " +
+                            "You will get the stdout and stderr output of the code execution, thus please print the output you wish to return using 'console.log' or 'console.error'. " +
+                            "The snippet runs with Deno permissions --allow-read=. --allow-write=. --no-prompt --deny-net --deny-env --deny-sys --deny-run --deny-ffi; cwd defaults to the shell_cwd default. " +
+                            "Returns {stdout, stderr}; non-zero exit returns an error that includes the stderr. " +
+                            "Requires a Deno binary (same resolution as run_javascript_free).",
+                        inputSchema: zodToJsonSchema(RunJavascriptArgsSchema),
+                    },
+                    {
+                        name: "save_memory",
+                        description: "Save a specific piece of information or fact to long-term memory. " +
+                            "This information will be available in future interactions if memory is enabled. " +
+                            "Use this for user preferences, important facts, or context that should persist. " +
+                            "Standalone tool (no fork equivalent - NOT an alias): appends '- [ISO timestamp] fact' to the memory file, creating it with a '# Long-Term Memory' header if missing. " +
+                            "Memory file path = env MCP_MEMORY_FILE if set, else the reference workspace memory.md (C:\\Users\\Gerar\\.beledarians-llm-toolbox\\workspace\\memory.md) if present, else <cwd>/memory.md. " +
+                            "Unlike Beledarian's there is no enable gate (the fork has no such setting). " +
+                            "Returns {success, message} or {error}.",
+                        inputSchema: zodToJsonSchema(SaveMemoryArgsSchema),
+                    },
+                    {
+                        name: "consult_secondary_agent",
+                        description: "Delegate a task to a secondary agent. IMPORTANT: If the task is 'coding' or 'writing files', the secondary agent will AUTOMATICALLY CREATE AND SAVE the files to the disk. You do NOT need to save them yourself. The tool returns a list of generated files. Trust this list.",
+                        inputSchema: zodToJsonSchema(ConsultSecondaryAgentArgsSchema),
+                    },
                 ],
             };
         });
@@ -869,6 +1309,450 @@ export class FilesystemServer {
                             content: [{ type: "text", text: result }],
                         };
                     }
+                    case "run_javascript_free": {
+                        const parsed = RunJavascriptFreeArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for run_javascript_free: ${parsed.error}`);
+                        }
+                        const result = await handleRunJavascriptFree(parsed.data.javascript, parsed.data.timeout_seconds, parsed.data.cwd);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "git_status": {
+                        const parsed = GitStatusArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for git_status: ${parsed.error}`);
+                        }
+                        const result = await handleGitStatus();
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "git_diff": {
+                        const parsed = GitDiffArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for git_diff: ${parsed.error}`);
+                        }
+                        const result = await handleGitDiff(parsed.data.file_path, parsed.data.cached);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "git_commit": {
+                        const parsed = GitCommitArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for git_commit: ${parsed.error}`);
+                        }
+                        const result = await handleGitCommit(parsed.data.message);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "git_log": {
+                        const parsed = GitLogArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for git_log: ${parsed.error}`);
+                        }
+                        const result = await handleGitLog(parsed.data.max_count);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "git_add": {
+                        const parsed = GitAddArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for git_add: ${parsed.error}`);
+                        }
+                        const result = await handleGitAdd(parsed.data.paths);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "git_checkout": {
+                        const parsed = GitCheckoutArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for git_checkout: ${parsed.error}`);
+                        }
+                        const result = await handleGitCheckout(parsed.data.branch_name, parsed.data.create_new);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "gh_auth": {
+                        const parsed = GhAuthArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for gh_auth: ${parsed.error}`);
+                        }
+                        const result = await handleGhAuth();
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "gh_create_issue": {
+                        const parsed = GhCreateIssueArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for gh_create_issue: ${parsed.error}`);
+                        }
+                        const result = await handleGhCreateIssue(parsed.data.title, parsed.data.body, parsed.data.labels);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "gh_list_issues": {
+                        const parsed = GhListIssuesArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for gh_list_issues: ${parsed.error}`);
+                        }
+                        const result = await handleGhListIssues(parsed.data.state, parsed.data.labels, parsed.data.limit);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "gh_view_comments": {
+                        const parsed = GhViewCommentsArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for gh_view_comments: ${parsed.error}`);
+                        }
+                        const result = await handleGhViewComments(parsed.data.number, parsed.data.type);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "gh_create_pr": {
+                        const parsed = GhCreatePrArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for gh_create_pr: ${parsed.error}`);
+                        }
+                        const result = await handleGhCreatePr(parsed.data.title, parsed.data.body, parsed.data.head_branch, parsed.data.base_branch);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "gh_list_prs": {
+                        const parsed = GhListPrsArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for gh_list_prs: ${parsed.error}`);
+                        }
+                        const result = await handleGhListPrs(parsed.data.state, parsed.data.limit);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "gh_view_pr_diff": {
+                        const parsed = GhViewPrDiffArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for gh_view_pr_diff: ${parsed.error}`);
+                        }
+                        const result = await handleGhViewPrDiff(parsed.data.number);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "gh_push": {
+                        const parsed = GhPushArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for gh_push: ${parsed.error}`);
+                        }
+                        const result = await handleGhPush(parsed.data.branch);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "get_system_info": {
+                        const parsed = GetSystemInfoArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for get_system_info: ${parsed.error}`);
+                        }
+                        const result = await handleGetSystemInfo();
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "read_clipboard": {
+                        const parsed = ReadClipboardArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for read_clipboard: ${parsed.error}`);
+                        }
+                        const result = await handleReadClipboard();
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "write_clipboard": {
+                        const parsed = WriteClipboardArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for write_clipboard: ${parsed.error}`);
+                        }
+                        const result = await handleWriteClipboard(parsed.data.content);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "send_notification": {
+                        const parsed = SendNotificationArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for send_notification: ${parsed.error}`);
+                        }
+                        const result = await handleSendNotification(parsed.data.title, parsed.data.message);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "open_file": {
+                        const parsed = OpenFileArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for open_file: ${parsed.error}`);
+                        }
+                        const result = await handleOpenFile(parsed.data.target, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "preview_html": {
+                        const parsed = PreviewHtmlArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for preview_html: ${parsed.error}`);
+                        }
+                        const result = await handlePreviewHtml(parsed.data.html_content, parsed.data.file_name);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "read_document": {
+                        const parsed = ReadDocumentArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for read_document: ${parsed.error}`);
+                        }
+                        const result = await handleReadDocument(parsed.data.file_path, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "query_database": {
+                        const parsed = QueryDatabaseArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for query_database: ${parsed.error}`);
+                        }
+                        const result = await handleQueryDatabase(parsed.data.db_path, parsed.data.query, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "analyze_project": {
+                        const parsed = AnalyzeProjectArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for analyze_project: ${parsed.error}`);
+                        }
+                        const result = await handleAnalyzeProject();
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "web_search": {
+                        const parsed = WebSearchArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for web_search: ${parsed.error}`);
+                        }
+                        const result = await handleWebSearch(parsed.data.query, parsed.data.providers);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "fetch_web_content": {
+                        const parsed = FetchWebContentArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for fetch_web_content: ${parsed.error}`);
+                        }
+                        const result = await handleFetchWebContent(parsed.data.url);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "wikipedia_search": {
+                        const parsed = WikipediaSearchArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for wikipedia_search: ${parsed.error}`);
+                        }
+                        const result = await handleWikipediaSearch(parsed.data.query, parsed.data.lang);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "rag_local_files": {
+                        const parsed = RagLocalFilesArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for rag_local_files: ${parsed.error}`);
+                        }
+                        const result = await handleRagLocalFiles(parsed.data.query, parsed.data.path, parsed.data.file_pattern, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "rag_web_content": {
+                        const parsed = RagWebContentArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for rag_web_content: ${parsed.error}`);
+                        }
+                        const result = await handleRagWebContent(parsed.data.url, parsed.data.query);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "browser_session_open": {
+                        const parsed = BrowserSessionOpenArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for browser_session_open: ${parsed.error}`);
+                        }
+                        const result = await handleBrowserSessionOpen(parsed.data.url, parsed.data.wait_for_selector, parsed.data.include_page_text);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "browser_session_control": {
+                        const parsed = BrowserSessionControlArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for browser_session_control: ${parsed.error}`);
+                        }
+                        const result = await handleBrowserSessionControl({
+                            actions: parsed.data.actions,
+                            read_page: parsed.data.read_page,
+                            full_read: parsed.data.full_read,
+                            screenshot_path: parsed.data.screenshot_path,
+                            full_page_screenshot: parsed.data.full_page_screenshot,
+                            fuzzy_find: parsed.data.fuzzy_find,
+                            max_results: parsed.data.max_results,
+                        }, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "browser_session_close": {
+                        const parsed = BrowserSessionCloseArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for browser_session_close: ${parsed.error}`);
+                        }
+                        const result = await handleBrowserSessionClose();
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "browser_open_page": {
+                        const parsed = BrowserOpenPageArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for browser_open_page: ${parsed.error}`);
+                        }
+                        const result = await handleBrowserOpenPage({
+                            url: parsed.data.url,
+                            screenshot_path: parsed.data.screenshot_path,
+                            wait_for_selector: parsed.data.wait_for_selector,
+                            full_page_screenshot: parsed.data.full_page_screenshot,
+                            actions: parsed.data.actions,
+                        }, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "execute_command": {
+                        const parsed = ExecuteCommandArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for execute_command: ${parsed.error}`);
+                        }
+                        const result = await handleExecuteCommand(parsed.data.command, parsed.data.input, parsed.data.timeout_seconds);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "run_in_terminal": {
+                        const parsed = RunInTerminalArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for run_in_terminal: ${parsed.error}`);
+                        }
+                        const result = await handleRunInTerminal(parsed.data.command);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "run_test_command": {
+                        const parsed = RunTestCommandArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for run_test_command: ${parsed.error}`);
+                        }
+                        const result = await handleRunTestCommand(parsed.data.command);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "run_background_command": {
+                        const parsed = RunBackgroundCommandArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for run_background_command: ${parsed.error}`);
+                        }
+                        const result = await handleRunBackgroundCommand(parsed.data.command, parsed.data.name, parsed.data.timeout_hours, parsed.data.cwd);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "check_background_command": {
+                        const parsed = CheckBackgroundCommandArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for check_background_command: ${parsed.error}`);
+                        }
+                        const result = await handleCheckBackgroundCommand(parsed.data.id);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "cancel_background_command": {
+                        const parsed = CancelBackgroundCommandArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for cancel_background_command: ${parsed.error}`);
+                        }
+                        const result = await handleCancelBackgroundCommand(parsed.data.id);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "run_python": {
+                        const parsed = RunPythonArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for run_python: ${parsed.error}`);
+                        }
+                        const result = await handleRunPython(parsed.data.python, parsed.data.timeout_seconds, parsed.data.cwd);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "run_javascript": {
+                        const parsed = RunJavascriptArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for run_javascript: ${parsed.error}`);
+                        }
+                        const result = await handleRunJavascript(parsed.data.javascript, parsed.data.timeout_seconds);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "save_memory": {
+                        const parsed = SaveMemoryArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for save_memory: ${parsed.error}`);
+                        }
+                        const result = await handleSaveMemory(parsed.data.fact);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "consult_secondary_agent": {
+                        const parsed = ConsultSecondaryAgentArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for consult_secondary_agent: ${parsed.error}`);
+                        }
+                        const result = await handleConsultSecondaryAgent(parsed.data.task, parsed.data.agent_role, parsed.data.context, parsed.data.allow_tools, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }