mcp-fs-shell-windows 0.2.6 → 0.2.18

package/dist/write_bytes/handler.js

@@ -0,0 +1,49 @@
+import fs from "fs/promises";
+import { validatePath } from "../helpers/path.js";
+// Strict base64: groups of 4, with valid padding at the end.
+const BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$/;
+export async function handleWriteBytes(filePath, offset, dataBase64, extend, allowedDirectories) {
+    const validPath = await validatePath(filePath, allowedDirectories);
+    let stats;
+    try {
+        stats = await fs.stat(validPath);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            throw new Error(`File does not exist (write_bytes requires an existing file, no implicit create): ${filePath}`);
+        }
+        throw error;
+    }
+    if (!stats.isFile()) {
+        throw new Error(`Not a file: ${filePath}`);
+    }
+    const size = stats.size;
+    if (!BASE64_RE.test(dataBase64)) {
+        throw new Error(`Invalid base64 in dataBase64: ${JSON.stringify(dataBase64.slice(0, 80))}`);
+    }
+    const data = Buffer.from(dataBase64, "base64");
+    const end = offset + data.length;
+    const handle = await fs.open(validPath, "r+");
+    try {
+        if (end > size) {
+            if (!extend) {
+                throw new Error(`Write would extend file past EOF: offset ${offset} + ${data.length} bytes = ${end} > file size ${size}; use extend=true to grow the file`);
+            }
+            await handle.truncate(end);
+        }
+        const { bytesWritten } = await handle.write(data, 0, data.length, offset);
+        if (bytesWritten !== data.length) {
+            throw new Error(`Short write: expected ${data.length} bytes at offset ${offset}, wrote ${bytesWritten}`);
+        }
+    }
+    finally {
+        await handle.close();
+    }
+    return JSON.stringify({
+        path: filePath,
+        offset,
+        bytesWritten: data.length,
+        size: Math.max(size, end),
+    });
+}

package/dist/write_bytes/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const WriteBytesArgsSchema = z.object({
+    path: z.string().describe("Path to the file to write (must already exist - no implicit create)"),
+    offset: z.number().int().min(0).describe("Byte offset at which to write (0-indexed)"),
+    dataBase64: z.string().describe("Base64-encoded bytes to write. Must be valid base64 (strict)."),
+    extend: z.boolean().optional().default(false).describe("If true, grow the file when the write ends past EOF, zero-filling any gap between the old size and the offset. Default: false (write past EOF is an error)."),
+});

package/dist/write_new_files/handler.js

@@ -1,6 +1,7 @@
 import fs from "fs/promises";
 import path from "path";
-import { validatePath, ensureDirectoryExists } from "../helpers/path.js";
+import { validatePath, ensureDirectoryExists, stripLongPathAll } from "../helpers/path.js";
+import { encodeText } from "../helpers/encoding.js";
 export async function handleWriteNewFiles(files, allowedDirectories) {
     const results = [];
     const errors = [];
@@ -30,12 +31,14 @@ export async function handleWriteNewFiles(files, allowedDirectories) {
                 await fs.writeFile(validPath, Buffer.from(file.content, "base64"));
             }
             else {
-                await fs.writeFile(validPath, file.content, "utf-8");
+                // textEncoding defaults to utf8 (byte-identical to the old behavior);
+                // base64 above already handled the raw-bytes case.
+                await fs.writeFile(validPath, encodeText(file.content, file.textEncoding ?? "utf8"));
             }
             results.push(`Successfully wrote to ${file.path}${file.overwrite ? " (overwritten)" : ""}`);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorMessage = stripLongPathAll(error instanceof Error ? error.message : String(error));
             errors.push(`Failed to write file ${file.path}: ${errorMessage}`);
         }
     }));

package/dist/write_new_files/schema.js

@@ -5,5 +5,6 @@ export const WriteNewFilesArgsSchema = z.object({
         content: z.string().describe("Content to write to the file (UTF-8 text, or base64 when encoding is \"base64\")"),
         overwrite: z.boolean().optional().default(false).describe("Replace the file if it already exists. Default: false (fail if it exists)."),
         encoding: z.enum(["utf8", "base64"]).optional().default("utf8").describe("Content encoding. Use \"base64\" for binary files."),
+        textEncoding: z.enum(["utf8", "utf16le", "utf16be", "cp1252"]).optional().describe("Text encoding for text content: 'utf8' (default), 'utf16le' or 'utf16be' (a BOM is written), or 'cp1252' (no BOM). Ignored when encoding is \"base64\" (raw bytes win)."),
     })).describe("Array of files to write"),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-fs-shell-windows",
-  "version": "0.2.6",
+  "version": "0.2.18",
   "description": "MCP filesystem server: batched file tools + standalone Windows shell tools (extended fork)",
   "license": "MIT",
   "author": "Gerard DeLuca",