file-share-mcp 1.0.14 → 1.0.16

package/README.md

@@ -11,6 +11,11 @@ The agent can list, read, and notify about files. The user can upload, download,
   - `list_shared_files` — List all files available in the shared folder
   - `share_file` — Notify the user that a file is ready to download
   - `preview_file` — Read the content of a `.txt` or `.md` file (max 1 MB)
+  - `write_file` — Write text content to a new file in the shared folder
+  - `copy_file` — Copy a file from the agent workspace into the shared folder
+  - `download_file` — Copy a file from the shared folder to the agent machine (any file type, binary included)
+  - `create_directory` / `delete_directory` — Manage subdirectories
+  - `move_file` — Move or rename a file inside the shared folder
 - **Web GUI** — Upload, download, preview, and delete files from a browser
 - **Zero config** — works out of the box with sensible defaults (`~/.file-share-mcp`)
 - **Proxy-ready** — optional integration with the [file-share-mcp proxy](https://github.com/...)
@@ -112,11 +117,21 @@ By default, all user data is stored in `~/.file-share-mcp/`:
 ~/.file-share-mcp/
 ├── configs.json       # Saved configuration (shared folder path, etc.)
 ├── shared/            # Default shared folder
+│   └── .uploads-tmp/  # Staging area for in-flight GUI uploads (hidden, purged at startup)
 └── logs/
     └── server.log     # Application logs
 ```
 
-This directory survives package updates and reinstalls.
+This directory survives package updates and reinstalls. Both processes (MCP server
+and GUI) log under `<data dir>/logs`, never under the working directory — the cwd of
+an MCP launched by a gateway is not its own and is not necessarily writable.
+
+Uploads are staged in `.uploads-tmp` inside the shared folder rather than in the
+system temp directory, so the final move never crosses a mount boundary. `rename()`
+returns `EXDEV` as soon as it does, even when both sides are on the same filesystem —
+which is the case under systemd `PrivateTmp=yes`, with `/tmp` on tmpfs, or with a
+`TMPDIR` on another volume. A copy-then-rename fallback covers the remaining case
+where `MCP_DATA_DIR` and a custom `shared_folder_path` sit on different volumes.
 
 ---
 

package/dist/gui.js

@@ -4,18 +4,52 @@ import cors from 'cors';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
-import os from 'os';
 import { setupLogging, createLogger, ProxyClient } from '@imenam/mcp-gui-interface';
 import { getConfig, saveConfig } from './utils/config-manager.js';
-import { getSharedFiles, validateSafePath, deleteFile, createDirectory, moveFile, deleteDirectory } from './utils/file-manager.js';
+import { getSharedFiles, validateSafePath, deleteFile, createDirectory, moveFile, deleteDirectory, movePath, UPLOAD_TMP_DIRNAME } from './utils/file-manager.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-setupLogging({ processLabel: 'GUI', logDir: path.join(os.homedir(), '.file-share-mcp', 'logs') });
+setupLogging({ processLabel: 'GUI', logDir: path.join(getConfig().MCP_DATA_DIR, 'logs') });
 const logger = createLogger('GUI');
 const app = express();
 app.use(cors());
 app.use(express.json());
-const upload = multer({ dest: os.tmpdir() });
+// Stage uploads inside the shared folder: the destination always lives there, so
+// the final rename stays within one mount. os.tmpdir() cannot promise that — under
+// systemd PrivateTmp, /tmp is a separate mount and rename() returns EXDEV.
+function getUploadTmpDir() {
+    const { shared_folder_path } = getConfig();
+    const dir = path.join(path.resolve(shared_folder_path), UPLOAD_TMP_DIRNAME);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function purgeUploadTmpDir() {
+    try {
+        const dir = getUploadTmpDir();
+        for (const name of fs.readdirSync(dir)) {
+            try {
+                fs.unlinkSync(path.join(dir, name));
+            }
+            catch { }
+        }
+    }
+    catch (err) {
+        logger.warn(`Could not purge upload staging dir: ${err.message}`);
+    }
+}
+purgeUploadTmpDir();
+const upload = multer({
+    storage: multer.diskStorage({
+        destination: (_req, _file, cb) => {
+            try {
+                cb(null, getUploadTmpDir());
+            }
+            catch (err) {
+                cb(err, '');
+            }
+        },
+    }),
+});
 // Endpoints
 app.get('/proxy/health', (req, res) => {
     res.json({ status: 'healthy' });
@@ -104,7 +138,7 @@ app.post('/api/upload', upload.single('file'), (req, res) => {
         const dir = validateSafePath(targetPath);
         fs.mkdirSync(dir, { recursive: true });
         const dest = path.join(dir, path.basename(req.file.originalname));
-        fs.renameSync(req.file.path, dest);
+        movePath(req.file.path, dest);
         res.json({ message: 'File uploaded successfully', filename: path.basename(req.file.originalname) });
     }
     catch (err) {

package/dist/mcp-server.js

@@ -8,11 +8,13 @@ import { fileURLToPath } from 'url';
 import fs from 'fs';
 import { GuiLauncher, setupLogging, createLogger, reconnectGuiToolDefinition } from '@imenam/mcp-gui-interface';
 import { getConfig } from './utils/config-manager.js';
-import { getSharedFiles, validateSafePath, writeSharedFile, copyToSharedFolder, createDirectory, deleteDirectory, moveFile, } from './utils/file-manager.js';
+import { getSharedFiles, validateSafePath, writeSharedFile, copyToSharedFolder, copyFromSharedFolder, createDirectory, deleteDirectory, moveFile, } from './utils/file-manager.js';
 import { VERSION } from './version.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-setupLogging({ processLabel: 'MASTER' });
+// Always log under MCP_DATA_DIR: the cwd of an MCP launched by a gateway is not
+// ours and is not necessarily writable (the library default is <cwd>/.mcp-gui/logs).
+setupLogging({ processLabel: 'MASTER', logDir: path.join(getConfig().MCP_DATA_DIR, 'logs') });
 const logger = createLogger('MASTER');
 const server = new Server({
     name: 'file-share-mcp',
@@ -133,6 +135,28 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ['source_path'],
                 },
             },
+            {
+                name: 'download_file',
+                description: 'Download a file from the shared folder to the agent workspace (the reverse of copy_file). Works for any file type, including binary ones.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Relative path of the file in the shared folder (e.g. "exports/report.pdf").',
+                        },
+                        destination_path: {
+                            type: 'string',
+                            description: 'ABSOLUTE destination path on the agent machine: either an existing directory (the file keeps its name) or the full target file path. Missing parent directories are created.',
+                        },
+                        overwrite: {
+                            type: 'boolean',
+                            description: 'Replace the destination file if it already exists. Defaults to false.',
+                        },
+                    },
+                    required: ['path', 'destination_path'],
+                },
+            },
             {
                 name: 'create_directory',
                 description: 'Create a new subdirectory inside the shared folder.',
@@ -266,6 +290,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: 'text', text: `File "${copiedName}" copied to shared folder.` }],
                 };
             }
+            case 'download_file': {
+                const { path: relativePath, destination_path, overwrite } = z.object({
+                    path: z.string(),
+                    destination_path: z.string(),
+                    overwrite: z.boolean().optional(),
+                }).parse(args);
+                const written = copyFromSharedFolder(relativePath, destination_path, overwrite ?? false);
+                return {
+                    content: [{ type: 'text', text: `File "${relativePath}" downloaded to "${written}".` }],
+                };
+            }
             case 'create_directory': {
                 const { path: dirPath } = z.object({ path: z.string() }).parse(args);
                 createDirectory(dirPath);

package/dist/utils/file-manager.js

@@ -1,6 +1,9 @@
 import fs from 'fs';
 import path from 'path';
 import { getConfig } from './config-manager.js';
+/** Staging directory for uploads, kept inside the shared folder so the final
+ *  rename never crosses a mount boundary. Hidden from listings. */
+export const UPLOAD_TMP_DIRNAME = '.uploads-tmp';
 export function validateSafePath(relativePath) {
     const { shared_folder_path } = getConfig();
     const resolvedBase = path.resolve(shared_folder_path);
@@ -10,13 +13,52 @@ export function validateSafePath(relativePath) {
     }
     return fullPath;
 }
+const PARTIAL_UPLOAD_RE = /^\..*\.part-\d+-\d+$/;
+function isPartialUpload(name) {
+    return PARTIAL_UPLOAD_RE.test(name);
+}
+/**
+ * Move `srcPath` onto `destPath`, atomically whenever the kernel allows it.
+ *
+ * `rename()` fails with EXDEV as soon as it crosses a mount boundary, even when
+ * both sides live on the same filesystem — which is what happens under systemd
+ * `PrivateTmp=yes`, with `/tmp` on tmpfs, or with a TMPDIR on another volume.
+ * The fallback copies next to the destination first, then renames within that
+ * same directory, so readers never observe a half-written file either way.
+ */
+export function movePath(srcPath, destPath) {
+    try {
+        fs.renameSync(srcPath, destPath);
+        return;
+    }
+    catch (err) {
+        if (err.code !== 'EXDEV')
+            throw err;
+    }
+    const staged = path.join(path.dirname(destPath), `.${path.basename(destPath)}.part-${process.pid}-${Date.now()}`);
+    try {
+        fs.copyFileSync(srcPath, staged);
+        fs.renameSync(staged, destPath);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(staged);
+        }
+        catch { }
+        throw err;
+    }
+    fs.unlinkSync(srcPath);
+}
 export function getSharedFiles(relativePath = '') {
     const dirPath = validateSafePath(relativePath);
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
         return [];
     }
-    return fs.readdirSync(dirPath).map(name => {
+    const hidden = relativePath === '' ? new Set([UPLOAD_TMP_DIRNAME]) : new Set();
+    return fs.readdirSync(dirPath).filter(name => {
+        return !hidden.has(name) && !isPartialUpload(name);
+    }).map(name => {
         const fullPath = path.join(dirPath, name);
         const stats = fs.statSync(fullPath);
         if (stats.isDirectory()) {
@@ -59,6 +101,36 @@ export function copyToSharedFolder(sourcePath, filename, relativePath = '') {
     fs.copyFileSync(sourcePath, path.join(dir, targetFilename));
     return relativePath ? `${relativePath}/${targetFilename}` : targetFilename;
 }
+/**
+ * Copy a file out of the shared folder onto the agent machine.
+ *
+ * `destination` is either a directory (existing, or written with a trailing
+ * separator) — the file then keeps its name — or the full target file path.
+ */
+export function copyFromSharedFolder(relativePath, destination, overwrite = false) {
+    const sourcePath = validateSafePath(relativePath);
+    if (!fs.existsSync(sourcePath)) {
+        throw new Error(`File not found in shared folder: ${relativePath}`);
+    }
+    if (!fs.statSync(sourcePath).isFile()) {
+        throw new Error(`Path is not a file: ${relativePath}`);
+    }
+    if (!path.isAbsolute(destination)) {
+        throw new Error(`Destination must be an absolute path: ${destination}`);
+    }
+    const looksLikeDir = destination.endsWith('/') ||
+        destination.endsWith(path.sep) ||
+        (fs.existsSync(destination) && fs.statSync(destination).isDirectory());
+    const destPath = looksLikeDir
+        ? path.join(destination, path.basename(sourcePath))
+        : destination;
+    if (!overwrite && fs.existsSync(destPath)) {
+        throw new Error(`Destination already exists: ${destPath}. Pass overwrite=true to replace it.`);
+    }
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.copyFileSync(sourcePath, destPath);
+    return destPath;
+}
 export function createDirectory(relativePath) {
     const fullPath = validateSafePath(relativePath);
     fs.mkdirSync(fullPath, { recursive: true });

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.0.14';
+export const VERSION = '1.0.16';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "file-share-mcp",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "MCP server for bidirectional file sharing between AI agents and users, with a built-in web GUI",
   "author": "",
   "license": "ISC",