file-share-mcp 1.0.2 → 1.0.5

package/dist/gui.js

@@ -4,50 +4,42 @@ import cors from 'cors';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
+import os from 'os';
 import axios from 'axios';
 import { setupLogging } from './utils/logger.js';
 import { getConfig, saveConfig } from './utils/config-manager.js';
-import { getSharedFiles, validateSafePath, deleteFile } from './utils/file-manager.js';
+import { getSharedFiles, validateSafePath, deleteFile, createDirectory, moveFile, deleteDirectory } from './utils/file-manager.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 setupLogging('GUI');
 const app = express();
 app.use(cors());
 app.use(express.json());
-// Protect stdout - setupLogging already redirects console.log/error
-// but we want to be sure no other library writes to stdout.
-// Multer configuration for file uploads
-const storage = multer.diskStorage({
-    destination: (req, file, cb) => {
-        const config = getConfig();
-        if (!fs.existsSync(config.shared_folder_path)) {
-            fs.mkdirSync(config.shared_folder_path, { recursive: true });
-        }
-        cb(null, config.shared_folder_path);
-    },
-    filename: (req, file, cb) => {
-        cb(null, file.originalname);
-    }
-});
-const upload = multer({ storage });
+const upload = multer({ dest: os.tmpdir() });
 // Endpoints
 app.get('/proxy/health', (req, res) => {
     res.json({ status: 'healthy' });
 });
 app.get('/api/files', (req, res) => {
     try {
-        const files = getSharedFiles();
-        res.json(files);
+        const relativePath = req.query.path || '';
+        const entries = getSharedFiles(relativePath);
+        res.json(entries);
     }
     catch (error) {
         res.status(500).json({ error: error.message });
     }
 });
-app.get('/api/download/:filename', (req, res) => {
+app.get('/api/download', async (req, res) => {
     try {
-        const safePath = validateSafePath(req.params.filename);
-        if (fs.existsSync(safePath)) {
-            res.download(safePath);
+        const relativePath = req.query.path || '';
+        const safePath = validateSafePath(relativePath);
+        if (fs.existsSync(safePath) && fs.statSync(safePath).isFile()) {
+            res.download(safePath, path.basename(safePath), (err) => {
+                if (err && !res.headersSent) {
+                    res.status(500).send('Download failed');
+                }
+            });
         }
         else {
             res.status(404).send('File not found');
@@ -57,9 +49,10 @@ app.get('/api/download/:filename', (req, res) => {
         res.status(400).send(error.message);
     }
 });
-app.delete('/api/files/:filename', (req, res) => {
+app.delete('/api/files', (req, res) => {
     try {
-        deleteFile(req.params.filename);
+        const relativePath = req.query.path || '';
+        deleteFile(relativePath);
         res.json({ message: 'File deleted successfully' });
     }
     catch (error) {
@@ -68,13 +61,14 @@ app.delete('/api/files/:filename', (req, res) => {
 });
 const PREVIEWABLE_EXTENSIONS = ['.txt', '.md'];
 const PREVIEW_MAX_SIZE = 1024 * 1024; // 1 MB
-app.get('/api/preview/:filename', (req, res) => {
+app.get('/api/preview', (req, res) => {
     try {
-        const ext = path.extname(req.params.filename).toLowerCase();
+        const relativePath = req.query.path || '';
+        const ext = path.extname(relativePath).toLowerCase();
         if (!PREVIEWABLE_EXTENSIONS.includes(ext)) {
             return res.status(400).json({ error: 'Preview not supported for this file type' });
         }
-        const safePath = validateSafePath(req.params.filename);
+        const safePath = validateSafePath(relativePath);
         if (!fs.existsSync(safePath)) {
             return res.status(404).json({ error: 'File not found' });
         }
@@ -90,11 +84,56 @@ app.get('/api/preview/:filename', (req, res) => {
     }
 });
 app.post('/api/upload', upload.single('file'), (req, res) => {
-    if (req.file) {
-        res.json({ message: 'File uploaded successfully', filename: req.file.filename });
+    if (!req.file)
+        return res.status(400).json({ error: 'No file uploaded' });
+    const targetPath = req.body.targetPath || '';
+    try {
+        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);
+        res.json({ message: 'File uploaded successfully', filename: path.basename(req.file.originalname) });
     }
-    else {
-        res.status(400).json({ error: 'No file uploaded' });
+    catch (err) {
+        try {
+            fs.unlinkSync(req.file.path);
+        }
+        catch { }
+        res.status(400).json({ error: err.message });
+    }
+});
+app.delete('/api/folder', (req, res) => {
+    try {
+        const relativePath = req.query.path || '';
+        deleteDirectory(relativePath);
+        res.json({ message: 'Directory deleted successfully' });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+app.post('/api/mkdir', (req, res) => {
+    try {
+        const { path: dirPath } = req.body;
+        if (!dirPath)
+            return res.status(400).json({ error: 'path is required' });
+        createDirectory(dirPath);
+        res.json({ message: 'Directory created successfully' });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+app.post('/api/move', (req, res) => {
+    try {
+        const { from, to } = req.body;
+        if (!from || !to)
+            return res.status(400).json({ error: 'from and to are required' });
+        moveFile(from, to);
+        res.json({ message: 'File moved successfully' });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
     }
 });
 app.get('/api/config', (req, res) => {
@@ -155,7 +194,6 @@ async function registerWithProxy() {
     if (!config.PROXY_URL || !config.PROXY_APP_PATH)
         return null;
     try {
-        // Check if proxy is up
         await axios.get(`${config.PROXY_URL}/proxy/health`, { timeout: 2000 });
         const response = await axios.post(`${config.PROXY_URL}/proxy/register`, {
             path: config.PROXY_APP_PATH,

package/dist/mcp-server.js

@@ -9,7 +9,7 @@ import { fileURLToPath } from 'url';
 import fs from 'fs';
 import { setupLogging } from './utils/logger.js';
 import { getConfig } from './utils/config-manager.js';
-import { getSharedFiles, validateSafePath, writeSharedFile, copyToSharedFolder } from './utils/file-manager.js';
+import { getSharedFiles, validateSafePath, writeSharedFile, copyToSharedFolder, createDirectory, deleteDirectory, moveFile, } from './utils/file-manager.js';
 import { VERSION } from './version.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -99,10 +99,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 name: 'list_shared_files',
-                description: 'List all files currently available in the shared folder.',
+                description: 'List files and directories in the shared folder. Use the optional path parameter to navigate into a subdirectory.',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Relative path of the subdirectory to list (e.g. "docs/reports"). Defaults to the root shared folder.',
+                        },
+                    },
                 },
             },
             {
@@ -125,12 +130,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        filename: {
+                        path: {
                             type: 'string',
-                            description: 'The name of the file to preview (filename only, not the full path).',
+                            description: 'Relative path to the file in the shared folder (e.g. "docs/notes.md").',
                         },
                     },
-                    required: ['filename'],
+                    required: ['path'],
                 },
             },
             {
@@ -147,6 +152,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             type: 'string',
                             description: 'Text content to write into the file.',
                         },
+                        path: {
+                            type: 'string',
+                            description: 'Target subdirectory relative to the shared folder (e.g. "docs/reports"). The directory is created if it does not exist.',
+                        },
                     },
                     required: ['filename', 'content'],
                 },
@@ -165,10 +174,60 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             type: 'string',
                             description: 'Optional target filename in the shared folder. Defaults to the source file basename.',
                         },
+                        path: {
+                            type: 'string',
+                            description: 'Target subdirectory relative to the shared folder (e.g. "exports"). The directory is created if it does not exist.',
+                        },
                     },
                     required: ['source_path'],
                 },
             },
+            {
+                name: 'create_directory',
+                description: 'Create a new subdirectory inside the shared folder.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Relative path of the directory to create (e.g. "docs/reports"). Parent directories are created automatically.',
+                        },
+                    },
+                    required: ['path'],
+                },
+            },
+            {
+                name: 'delete_directory',
+                description: 'Delete an empty subdirectory from the shared folder. Fails if the directory contains files or subdirectories.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Relative path of the directory to delete (e.g. "docs/drafts").',
+                        },
+                    },
+                    required: ['path'],
+                },
+            },
+            {
+                name: 'move_file',
+                description: 'Move or rename a file within the shared folder.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        from: {
+                            type: 'string',
+                            description: 'Relative path of the source file (e.g. "report.md" or "docs/draft.md").',
+                        },
+                        to: {
+                            type: 'string',
+                            description: 'Relative path of the destination (e.g. "archive/report.md").',
+                        },
+                    },
+                    required: ['from', 'to'],
+                },
+            },
         ],
     };
 });
@@ -183,15 +242,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'list_shared_files': {
-                const files = getSharedFiles();
-                if (files.length === 0) {
+                const { path: relativePath } = z.object({ path: z.string().optional() }).parse(args);
+                const entries = getSharedFiles(relativePath ?? '');
+                if (entries.length === 0) {
+                    const location = relativePath ? `"${relativePath}"` : 'the shared folder';
                     return {
-                        content: [{ type: 'text', text: 'The shared folder is empty.' }],
+                        content: [{ type: 'text', text: `${location} is empty.` }],
                     };
                 }
-                const fileList = files.map(f => `- ${f.name} (${(f.size / 1024).toFixed(2)} KB)`).join('\n');
+                const dirs = entries.filter(e => e.type === 'directory').map(e => `📁 ${e.name}/`);
+                const files = entries.filter(e => e.type === 'file').map(e => `📄 ${e.name} (${((e.size ?? 0) / 1024).toFixed(2)} KB)`);
+                const list = [...dirs, ...files].join('\n');
+                const location = relativePath ? `"${relativePath}"` : 'shared folder';
                 return {
-                    content: [{ type: 'text', text: `Files in shared folder:\n${fileList}` }],
+                    content: [{ type: 'text', text: `Contents of ${location}:\n${list}` }],
                 };
             }
             case 'share_file': {
@@ -201,18 +265,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'preview_file': {
-                const { filename } = z.object({ filename: z.string() }).parse(args);
-                const ext = path.extname(filename).toLowerCase();
+                const { path: relativePath } = z.object({ path: z.string() }).parse(args);
+                const ext = path.extname(relativePath).toLowerCase();
                 if (!['.txt', '.md'].includes(ext)) {
                     return {
                         content: [{ type: 'text', text: `Error: Preview is only supported for .txt and .md files.` }],
                         isError: true,
                     };
                 }
-                const safePath = validateSafePath(filename);
+                const safePath = validateSafePath(relativePath);
                 if (!fs.existsSync(safePath)) {
                     return {
-                        content: [{ type: 'text', text: `Error: File "${filename}" not found in shared folder.` }],
+                        content: [{ type: 'text', text: `Error: File "${relativePath}" not found in shared folder.` }],
                         isError: true,
                     };
                 }
@@ -229,25 +293,48 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'write_file': {
-                const { filename, content } = z.object({
+                const { filename, content, path: relativePath } = z.object({
                     filename: z.string(),
                     content: z.string(),
+                    path: z.string().optional(),
                 }).parse(args);
-                const dest = writeSharedFile(filename, content);
+                const dest = writeSharedFile(filename, content, relativePath ?? '');
                 return {
-                    content: [{ type: 'text', text: `File "${path.basename(dest)}" written to shared folder.` }],
+                    content: [{ type: 'text', text: `File "${path.basename(dest)}" written to shared folder${relativePath ? ` (${relativePath})` : ''}.` }],
                 };
             }
             case 'copy_file': {
-                const { source_path, filename } = z.object({
+                const { source_path, filename, path: relativePath } = z.object({
                     source_path: z.string(),
                     filename: z.string().optional(),
+                    path: z.string().optional(),
                 }).parse(args);
-                const copiedName = copyToSharedFolder(source_path, filename);
+                const copiedName = copyToSharedFolder(source_path, filename, relativePath ?? '');
                 return {
                     content: [{ type: 'text', text: `File "${copiedName}" copied to shared folder.` }],
                 };
             }
+            case 'create_directory': {
+                const { path: dirPath } = z.object({ path: z.string() }).parse(args);
+                createDirectory(dirPath);
+                return {
+                    content: [{ type: 'text', text: `Directory "${dirPath}" created successfully.` }],
+                };
+            }
+            case 'delete_directory': {
+                const { path: dirPath } = z.object({ path: z.string() }).parse(args);
+                deleteDirectory(dirPath);
+                return {
+                    content: [{ type: 'text', text: `Directory "${dirPath}" deleted successfully.` }],
+                };
+            }
+            case 'move_file': {
+                const { from, to } = z.object({ from: z.string(), to: z.string() }).parse(args);
+                moveFile(from, to);
+                return {
+                    content: [{ type: 'text', text: `File moved from "${from}" to "${to}".` }],
+                };
+            }
             default:
                 throw new Error(`Tool not found: ${name}`);
         }

package/dist/utils/file-manager.js

@@ -1,54 +1,83 @@
 import fs from 'fs';
 import path from 'path';
 import { getConfig } from './config-manager.js';
-export function getSharedFiles() {
+export function validateSafePath(relativePath) {
     const { shared_folder_path } = getConfig();
-    if (!fs.existsSync(shared_folder_path)) {
-        fs.mkdirSync(shared_folder_path, { recursive: true });
+    const resolvedBase = path.resolve(shared_folder_path);
+    const fullPath = path.resolve(shared_folder_path, relativePath);
+    if (fullPath !== resolvedBase && !fullPath.startsWith(resolvedBase + path.sep)) {
+        throw new Error('Path traversal detected');
+    }
+    return fullPath;
+}
+export function getSharedFiles(relativePath = '') {
+    const dirPath = validateSafePath(relativePath);
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
         return [];
     }
-    return fs.readdirSync(shared_folder_path).filter(file => {
-        const filePath = path.join(shared_folder_path, file);
-        return fs.statSync(filePath).isFile();
-    }).map(file => {
-        const filePath = path.join(shared_folder_path, file);
-        const stats = fs.statSync(filePath);
+    return fs.readdirSync(dirPath).map(name => {
+        const fullPath = path.join(dirPath, name);
+        const stats = fs.statSync(fullPath);
+        if (stats.isDirectory()) {
+            return { name, type: 'directory', mtime: stats.mtime };
+        }
         return {
-            name: file,
+            name,
+            type: 'file',
             size: stats.size,
             mtime: stats.mtime,
-            extension: path.extname(file).toLowerCase(),
+            extension: path.extname(name).toLowerCase(),
         };
+    }).sort((a, b) => {
+        if (a.type !== b.type)
+            return a.type === 'directory' ? -1 : 1;
+        return a.name.localeCompare(b.name);
     });
 }
-export function validateSafePath(filename) {
-    const { shared_folder_path } = getConfig();
-    const safeName = path.basename(filename);
-    const fullPath = path.join(shared_folder_path, safeName);
-    // Extra safety check
-    if (!fullPath.startsWith(path.resolve(shared_folder_path))) {
-        throw new Error('Path traversal detected');
-    }
-    return fullPath;
-}
-export function deleteFile(filename) {
-    const fullPath = validateSafePath(filename);
+export function deleteFile(relativePath) {
+    const fullPath = validateSafePath(relativePath);
     if (fs.existsSync(fullPath)) {
         fs.unlinkSync(fullPath);
     }
 }
-export function writeSharedFile(filename, content) {
-    const dest = validateSafePath(filename);
+export function writeSharedFile(filename, content, relativePath = '') {
+    const dir = validateSafePath(relativePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const dest = path.join(dir, path.basename(filename));
     fs.writeFileSync(dest, content, 'utf-8');
     return dest;
 }
-export function copyToSharedFolder(sourcePath, filename) {
-    const targetFilename = filename ?? path.basename(sourcePath);
+export function copyToSharedFolder(sourcePath, filename, relativePath = '') {
+    const targetFilename = filename ? path.basename(filename) : path.basename(sourcePath);
     const stats = fs.statSync(sourcePath);
     if (!stats.isFile()) {
         throw new Error(`Source path is not a file: ${sourcePath}`);
     }
-    const dest = validateSafePath(targetFilename);
-    fs.copyFileSync(sourcePath, dest);
-    return targetFilename;
+    const dir = validateSafePath(relativePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.copyFileSync(sourcePath, path.join(dir, targetFilename));
+    return relativePath ? `${relativePath}/${targetFilename}` : targetFilename;
+}
+export function createDirectory(relativePath) {
+    const fullPath = validateSafePath(relativePath);
+    fs.mkdirSync(fullPath, { recursive: true });
+}
+export function deleteDirectory(relativePath) {
+    const fullPath = validateSafePath(relativePath);
+    if (!fs.existsSync(fullPath))
+        throw new Error('Directory not found');
+    const contents = fs.readdirSync(fullPath);
+    if (contents.length > 0)
+        throw new Error('Directory is not empty');
+    fs.rmdirSync(fullPath);
+}
+export function moveFile(fromRelative, toRelative) {
+    const fromPath = validateSafePath(fromRelative);
+    const toPath = validateSafePath(toRelative);
+    if (!fs.existsSync(fromPath)) {
+        throw new Error(`File not found: ${fromRelative}`);
+    }
+    fs.mkdirSync(path.dirname(toPath), { recursive: true });
+    fs.renameSync(fromPath, toPath);
 }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.0.2';
+export const VERSION = '1.0.5';

package/package.json

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