mcp-fs-shell-windows 0.2.19 → 0.2.29

package/dist/compat/handler.js

@@ -0,0 +1,254 @@
+// compat/handler.ts — Beledarian-compatible alias handlers (MCP filesystem fork v0.2.28).
+//
+// Reference: .beledarians-llm-toolbox/dev-src/beledarians-lm-studio-tools/src/toolsProvider.ts.
+// Every handler either delegates to the fork's own tool handler (so behavior and
+// job-registry lifetime are identical) or reuses the fork's shell-layer spawn
+// machinery (runCaptured + cap) with Beledarian's 60 s timeout cap, so existing
+// prompts that pass timeout_seconds up to 60 behave exactly as under Beledarian.
+//
+// Deliberate deviations (documented per the task spec):
+//   * execute_command / run_python / run_javascript keep Beledarian's 60 s cap
+//     (the fork's native shell_* tools cap at 28 s). Same bounded synchronous
+//     semantics, same cmd.exe /d /c verbatim spawn path.
+//   * save_memory has NO enable gate (the fork has no such setting); the memory
+//     file path = env MCP_MEMORY_FILE if set, else the Beledarian workspace
+//     memory.md, created with a '# Long-Term Memory' header if missing.
+//   * run_javascript env = { ...process.env, NO_COLOR: "true" } (Beledarian's
+//     reference passed only NO_COLOR, which strips PATH; spreading process.env
+//     keeps the confined Deno spawn robust and matches run_javascript_free).
+import fsp from "fs/promises";
+import fs from "fs";
+import nodePath from "path";
+import crypto from "crypto";
+import { cap, CAP_OK, CAP_ERR, SHELL_JOBS_DIR, ensureJobsDir, resolveCwd, runCaptured, handleShellTest, handleShellStart, handleShellCheck, handleShellCancel, handleShellTerminal, } from "../shell/handler.js";
+import { resolveDenoPath } from "../run_javascript/handler.js";
+import { COMPAT_SYNC_TIMEOUT_SEC } from "./schema.js";
+// ---------------------------------------------------------------------------
+// execute_command — bounded synchronous execution (alias of shell_run, 60 s cap)
+// Mirrors handleShellRun exactly (cmd.exe /d /c, verbatim, stdin pipe) with
+// Beledarian's 60 s cap and the same result shape: {command, exitCode, stdout,
+// stderr, timedOut, duration_ms, cwd}; non-zero exit / timeout throw with the
+// captured output embedded (callTool turns that into isError content).
+// ---------------------------------------------------------------------------
+export async function handleExecuteCommand(command, input, timeoutSeconds) {
+    const abs = await resolveCwd();
+    const timeout = Math.min(Math.max(timeoutSeconds ?? 5, 0.1), COMPAT_SYNC_TIMEOUT_SEC);
+    const started = Date.now();
+    const r = await runCaptured("cmd.exe", ["/d", "/c", command], {
+        cwd: abs,
+        input,
+        timeoutMs: timeout * 1000,
+        verbatim: true,
+    });
+    const durationMs = Date.now() - started;
+    if (r.spawnError) {
+        throw new Error(`Failed to launch command: ${r.spawnError}`);
+    }
+    if (r.timedOut) {
+        throw new Error(`Process timed out after ${timeout}s.\nSTDOUT:\n${cap(r.stdout, CAP_ERR)}\nSTDERR:\n${cap(r.stderr, CAP_ERR)}`);
+    }
+    if (r.code !== 0) {
+        throw new Error(`Process exited with code ${r.code ?? "unknown"}.\nSTDOUT:\n${cap(r.stdout, CAP_ERR)}\nSTDERR:\n${cap(r.stderr, CAP_ERR)}`);
+    }
+    return JSON.stringify({
+        command,
+        exitCode: 0,
+        stdout: cap(r.stdout, CAP_OK),
+        stderr: cap(r.stderr, CAP_OK),
+        timedOut: false,
+        duration_ms: durationMs,
+        cwd: abs,
+    });
+}
+// ---------------------------------------------------------------------------
+// run_in_terminal — delegates to shell_terminal (visible cmd /k console window).
+// Returns the shell_terminal job JSON (including the job id; kill via
+// shell_cancel / cancel_background_command).
+// ---------------------------------------------------------------------------
+export async function handleRunInTerminal(command) {
+    return handleShellTerminal(command);
+}
+// ---------------------------------------------------------------------------
+// run_test_command — delegates to shell_test ({command, exit_code, stdout,
+// stderr, passed}; never errors on a failing test; CI=true).
+// ---------------------------------------------------------------------------
+export async function handleRunTestCommand(command) {
+    return handleShellTest(command);
+}
+// ---------------------------------------------------------------------------
+// run_background_command — delegates to shell_start. Job ids live in the fork's
+// per-process registry (same lifetime semantics as Beledarian's per-process
+// backgroundCommands Map). name is required (as in Beledarian); timeout_hours
+// defaults to 10 (max 10).
+// ---------------------------------------------------------------------------
+export async function handleRunBackgroundCommand(command, name, timeoutHours, cwd) {
+    return handleShellStart(command, name, timeoutHours, cwd);
+}
+// ---------------------------------------------------------------------------
+// check_background_command — delegates to shell_check.
+// ---------------------------------------------------------------------------
+export async function handleCheckBackgroundCommand(id) {
+    return handleShellCheck(id);
+}
+// ---------------------------------------------------------------------------
+// cancel_background_command — delegates to shell_cancel (kills the whole tree).
+// ---------------------------------------------------------------------------
+export async function handleCancelBackgroundCommand(id) {
+    return handleShellCancel(id);
+}
+// ---------------------------------------------------------------------------
+// run_python — temp .py + system python (alias of shell_python, 60 s cap).
+// Mirrors handleShellPython exactly (temp file in the shell-jobs dir, deleted
+// in finally) with Beledarian's 60 s cap.
+// ---------------------------------------------------------------------------
+export async function handleRunPython(code, timeoutSeconds, cwd) {
+    const abs = await resolveCwd(cwd);
+    await ensureJobsDir();
+    const file = nodePath.join(SHELL_JOBS_DIR, `py-${Date.now().toString(36)}-${crypto.randomBytes(3).toString("hex")}.py`);
+    await fsp.writeFile(file, code, "utf-8");
+    const timeout = Math.min(Math.max(timeoutSeconds ?? 5, 0.1), COMPAT_SYNC_TIMEOUT_SEC);
+    const started = Date.now();
+    try {
+        const r = await runCaptured("python", [file], {
+            cwd: abs,
+            timeoutMs: timeout * 1000,
+        });
+        const durationMs = Date.now() - started;
+        if (r.spawnError) {
+            throw new Error(`Failed to launch python: ${r.spawnError}`);
+        }
+        if (r.timedOut) {
+            throw new Error(`Process timed out after ${timeout}s.\nSTDOUT:\n${cap(r.stdout, CAP_ERR)}\nSTDERR:\n${cap(r.stderr, CAP_ERR)}`);
+        }
+        if (r.code !== 0) {
+            throw new Error(`Process exited with code ${r.code ?? "unknown"}.\nSTDOUT:\n${cap(r.stdout, CAP_ERR)}\nSTDERR:\n${cap(r.stderr, CAP_ERR)}`);
+        }
+        return JSON.stringify({
+            exitCode: 0,
+            stdout: cap(r.stdout, CAP_OK),
+            stderr: cap(r.stderr, CAP_OK),
+            timedOut: false,
+            duration_ms: durationMs,
+        });
+    }
+    finally {
+        await fsp.unlink(file).catch(() => undefined);
+    }
+}
+// ---------------------------------------------------------------------------
+// run_javascript — the CONFINED variant (replicates Beledarian reference
+// L544-610; NOT an alias of run_javascript_free).
+//
+// Temp .ts written in the working directory (Beledarian's pattern, deleted in
+// finally), Deno flags: --allow-read=. --allow-write=. --no-prompt --deny-net
+// --deny-env --deny-sys --deny-run --deny-ffi (net/env/sys/run/ffi denied;
+// no --allow-import, so external module imports are denied — "you cannot import
+// external modules"). cwd defaults to the fork's shell_cwd default. Default
+// timeout 5 s, max 60 s. Returns {stdout, stderr} (trimmed, per the reference).
+// Non-zero exit throws the reference's error text: "Process exited with code N.
+// Stderr: ...". Reuses the fork's Deno binary resolution (resolveDenoPath).
+// ---------------------------------------------------------------------------
+export async function handleRunJavascript(javascript, timeoutSeconds) {
+    const deno = resolveDenoPath();
+    if (!deno) {
+        throw new Error("No Deno runtime found. Set the DENO_PATH environment variable to a deno binary, " +
+            "install deno on PATH, or run this server from inside an LM Studio installation " +
+            "(which bundles deno at <home>/.internal/utils/deno.exe).");
+    }
+    const abs = await resolveCwd();
+    const file = nodePath.join(abs, `temp_script_${Date.now()}.ts`);
+    const timeout = Math.min(Math.max(timeoutSeconds ?? 5, 0.1), COMPAT_SYNC_TIMEOUT_SEC);
+    const started = Date.now();
+    try {
+        await fsp.writeFile(file, javascript, "utf-8");
+        const r = await runCaptured(deno, [
+            "run",
+            "--allow-read=.",
+            "--allow-write=.",
+            "--no-prompt",
+            "--deny-net",
+            "--deny-env",
+            "--deny-sys",
+            "--deny-run",
+            "--deny-ffi",
+            file,
+        ], {
+            cwd: abs,
+            timeoutMs: timeout * 1000,
+            env: { ...process.env, NO_COLOR: "true" },
+        });
+        const durationMs = Date.now() - started;
+        if (r.spawnError) {
+            throw new Error(`Failed to launch deno: ${r.spawnError}`);
+        }
+        if (r.timedOut) {
+            throw new Error(`Process timed out after ${timeout}s.\nSTDOUT:\n${cap(r.stdout, CAP_ERR)}\nSTDERR:\n${cap(r.stderr, CAP_ERR)}`);
+        }
+        if (r.code !== 0) {
+            // Reference error text (toolsProvider.ts L594).
+            throw new Error(`Process exited with code ${r.code ?? "unknown"}. Stderr: ${cap(r.stderr, CAP_ERR)}`);
+        }
+        return JSON.stringify({
+            stdout: r.stdout.trim(),
+            stderr: r.stderr.trim(),
+            duration_ms: durationMs,
+            cwd: abs,
+        });
+    }
+    finally {
+        // Always cleanup temp file, even on error (reference L606-609).
+        await fsp.unlink(file).catch(() => undefined);
+    }
+}
+// ---------------------------------------------------------------------------
+// save_memory — STANDALONE (replicates Beledarian reference L509-542, minus
+// the enable gate — the fork has no such setting).
+//
+// Appends "- [ISO timestamp] fact" to the memory file. Memory file path =
+// env MCP_MEMORY_FILE if set, else the reference machine's workspace
+// memory.md if present, else <cwd>/memory.md. If the file is missing it is
+// created with a '# Long-Term Memory' header.
+// Returns {success, message} on success, {error} on failure.
+// ---------------------------------------------------------------------------
+export function resolveMemoryFile() {
+    const env = process.env.MCP_MEMORY_FILE;
+    if (env && env.trim())
+        return env;
+    // Reference machine's workspace memory.md (kept for back-compat); on other
+    // machines the path does not exist, so fall back to the server's CWD.
+    const legacy = "C:\\Users\\Gerar\\.beledarians-llm-toolbox\\workspace\\memory.md";
+    if (fs.existsSync(legacy))
+        return legacy;
+    return nodePath.join(process.cwd(), "memory.md");
+}
+export async function handleSaveMemory(fact) {
+    const memoryFile = resolveMemoryFile();
+    const timestamp = new Date().toISOString();
+    const entry = `\n- [${timestamp}] ${fact}`;
+    try {
+        // Reference: append; on failure (e.g. missing file) create with header.
+        // On POSIX the reference's append fails for a missing file and the write
+        // path runs; on Windows appendFile would create the file headerless, so we
+        // check existence up front to keep the '# Long-Term Memory' header on all
+        // platforms.
+        let exists = false;
+        try {
+            await fsp.access(memoryFile);
+            exists = true;
+        }
+        catch {
+            exists = false;
+        }
+        if (exists) {
+            await fsp.appendFile(memoryFile, entry, "utf-8");
+            return JSON.stringify({ success: true, message: "Fact saved to memory." });
+        }
+        await fsp.writeFile(memoryFile, "# Long-Term Memory\n" + entry, "utf-8");
+        return JSON.stringify({ success: true, message: "Fact saved to memory (new file created)." });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: `Failed to save memory: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}

package/dist/compat/schema.js

@@ -0,0 +1,97 @@
+// compat/schema.ts — argument schemas for the 9 Beledarian-compatible alias tools.
+// (MCP filesystem fork v0.2.28 — Beledarian-parity project, Stage 5 / task 3.)
+//
+// Purpose: same-named drop-ins for the Beledarian plugin tools so the fork can
+// shadow/replace Beledarian with zero behavior change for existing prompts.
+// Parameter names are kept EXACTLY as Beledarian's (reference:
+// .beledarians-llm-toolbox/dev-src/beledarians-lm-studio-tools/src/toolsProvider.ts),
+// plus the fork's own optional `cwd` where noted.
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Timeout caps.
+//
+// The fork's native shell tools cap at 28 s (SHELL_MAX_TIMEOUT_SEC) to stay under
+// the MCP client's request-kill window. Beledarian's execute_command / run_python
+// / run_javascript all cap at 60 s (verified: the client window is >63 s).
+// To be a zero-behavior-change drop-in, the compat tools keep Beledarian's 60 s cap.
+// ---------------------------------------------------------------------------
+export const COMPAT_SYNC_TIMEOUT_SEC = 60; // execute_command, run_python, run_javascript
+// ---------------------------------------------------------------------------
+// execute_command — compat alias of shell_run (bounded synchronous execution),
+// with Beledarian's 60 s cap. Params match Beledarian exactly:
+//   command, input?, timeout_seconds? (reference toolsProvider.ts L1155-1176).
+// ---------------------------------------------------------------------------
+export const ExecuteCommandArgsSchema = z.object({
+    command: z.string().describe("The shell command to execute (Windows cmd.exe syntax)."),
+    input: z.string().optional().describe("Input text to pipe to the command's stdin."),
+    timeout_seconds: z.number().min(0.1).max(COMPAT_SYNC_TIMEOUT_SEC).optional().describe("Timeout in seconds (default: 5, max: 60)."),
+});
+// ---------------------------------------------------------------------------
+// run_in_terminal — compat alias of shell_terminal (visible console window).
+// Params match Beledarian exactly: command (reference L1317-1332).
+// ---------------------------------------------------------------------------
+export const RunInTerminalArgsSchema = z.object({
+    command: z.string().describe("Command to run in the new terminal window."),
+});
+// ---------------------------------------------------------------------------
+// run_test_command — compat alias of shell_test (test wrapper, CI=true, never
+// errors on a failing test). Params match Beledarian exactly: command
+// (reference L2303-2345).
+// ---------------------------------------------------------------------------
+export const RunTestCommandArgsSchema = z.object({
+    command: z.string().describe("The test command to run (e.g. 'npm test', 'pytest')."),
+});
+// ---------------------------------------------------------------------------
+// run_background_command — compat alias of shell_start (background job).
+// Beledarian: command, timeout_hours (MANDATORY, max 10), name (MANDATORY)
+// (reference L930-1010). Fork variant: name stays REQUIRED (as in Beledarian),
+// timeout_hours gets the fork's default of 10 (max 10), and the fork's cwd
+// override is available.
+// ---------------------------------------------------------------------------
+export const RunBackgroundCommandArgsSchema = z.object({
+    command: z.string().describe("The command to run as a background job (Windows cmd.exe syntax)."),
+    name: z.string().describe("MANDATORY: A short, descriptive name for the background task (e.g. 'Vite Dev Server')."),
+    timeout_hours: z.number().max(10).optional().default(10).describe("Auto-kill the job after this many hours (default 10, max 10)."),
+    cwd: z.string().optional().describe("Working directory override (default: the shell_cwd default)."),
+});
+// ---------------------------------------------------------------------------
+// check_background_command — compat alias of shell_check.
+// Params match Beledarian exactly: id (reference L1013-1033).
+// ---------------------------------------------------------------------------
+export const CheckBackgroundCommandArgsSchema = z.object({
+    id: z.string().describe("Job ID returned by run_background_command or run_in_terminal."),
+});
+// ---------------------------------------------------------------------------
+// cancel_background_command — compat alias of shell_cancel.
+// Params match Beledarian exactly: id (reference L1036-1054).
+// ---------------------------------------------------------------------------
+export const CancelBackgroundCommandArgsSchema = z.object({
+    id: z.string().describe("Job ID returned by run_background_command or run_in_terminal."),
+});
+// ---------------------------------------------------------------------------
+// run_python — compat alias of shell_python (temp .py + system python),
+// with Beledarian's 60 s cap. Beledarian params: python, timeout_seconds?
+// (reference L692-712); the fork's cwd override is available.
+// ---------------------------------------------------------------------------
+export const RunPythonArgsSchema = z.object({
+    python: z.string().describe("Python code to execute (requires system Python on PATH)."),
+    timeout_seconds: z.number().min(0.1).max(COMPAT_SYNC_TIMEOUT_SEC).optional().describe("Timeout in seconds (default: 5, max: 60)."),
+    cwd: z.string().optional().describe("Working directory override (default: the shell_cwd default)."),
+});
+// ---------------------------------------------------------------------------
+// run_javascript — the CONFINED variant (NOT an alias of run_javascript_free).
+// Beledarian params: javascript, timeout_seconds? (reference L612-633, impl
+// L544-610). No cwd param (the reference confines to its working directory,
+// which is the fork's shell_cwd default here).
+// ---------------------------------------------------------------------------
+export const RunJavascriptArgsSchema = z.object({
+    javascript: z.string().describe("JavaScript (or TypeScript) code to execute. Runs as a Deno script confined to the working directory: Deno.* APIs and console.log work; network, env, sys, run, and ffi are denied."),
+    timeout_seconds: z.number().min(0.1).max(COMPAT_SYNC_TIMEOUT_SEC).optional().describe("Timeout in seconds (default: 5, max: 60)."),
+});
+// ---------------------------------------------------------------------------
+// save_memory — STANDALONE (no fork equivalent; not an alias).
+// Beledarian param: fact (reference L509-542).
+// ---------------------------------------------------------------------------
+export const SaveMemoryArgsSchema = z.object({
+    fact: z.string().describe("The specific fact or piece of information to remember."),
+});