file-share-mcp 1.0.6 → 1.0.8

package/dist/gui.js

@@ -5,13 +5,13 @@ 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 { 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';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-setupLogging('GUI');
+setupLogging({ processLabel: 'GUI', logDir: path.join(os.homedir(), '.file-share-mcp', 'logs') });
+const logger = createLogger('GUI');
 const app = express();
 app.use(cors());
 app.use(express.json());
@@ -34,27 +34,31 @@ app.get('/api/download', async (req, res) => {
     const relativePath = req.query.path || '';
     try {
         const safePath = validateSafePath(relativePath);
-        console.log(`[download] path="${relativePath}" → safePath="${safePath}"`);
-        if (fs.existsSync(safePath) && fs.statSync(safePath).isFile()) {
-            res.download(safePath, path.basename(safePath), (err) => {
-                if (err) {
-                    console.error(`[download] Stream error for "${safePath}":`, err);
-                    if (!res.headersSent) {
-                        res.status(500).send(`Stream error: ${err.message}`);
-                    }
-                }
-                else {
-                    console.log(`[download] Completed: "${safePath}"`);
-                }
-            });
-        }
-        else {
-            console.warn(`[download] Not found or not a file: "${safePath}"`);
+        logger.info(`[download] path="${relativePath}" → safePath="${safePath}"`);
+        if (!fs.existsSync(safePath) || !fs.statSync(safePath).isFile()) {
+            logger.info(`[download] Not found or not a file: "${safePath}"`);
             res.status(404).send(`File not found: ${relativePath}`);
+            return;
         }
+        const filename = path.basename(safePath);
+        const { size } = fs.statSync(safePath);
+        res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(filename)}"`);
+        res.setHeader('Content-Type', 'application/octet-stream');
+        res.setHeader('Content-Length', size);
+        const stream = fs.createReadStream(safePath);
+        stream.on('error', (err) => {
+            logger.error(`[download] Stream error for "${safePath}": ${err.message}`);
+            if (!res.headersSent) {
+                res.status(500).send(`Stream error: ${err.message}`);
+            }
+        });
+        stream.on('end', () => {
+            logger.info(`[download] Completed: "${safePath}"`);
+        });
+        stream.pipe(res);
     }
     catch (error) {
-        console.error(`[download] Validation error for "${relativePath}":`, error);
+        logger.error(`[download] Validation error for "${relativePath}": ${error.message}`);
         res.status(400).send(`Invalid path: ${error.message}`);
     }
 });
@@ -199,84 +203,49 @@ app.get(/^(?!\/api\/|\/proxy\/)/, (req, res) => {
 });
 // Proxy registration & server startup
 const config = getConfig();
-async function registerWithProxy() {
-    if (!config.PROXY_URL || !config.PROXY_APP_PATH)
-        return null;
-    try {
-        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,
-            name: config.PROXY_APP_NAME
-        }, { timeout: 2000 });
-        const assignedPort = response.data.port;
-        console.log(`Successfully registered with proxy at ${config.PROXY_URL}${config.PROXY_APP_PATH} (port ${assignedPort})`);
-        return assignedPort;
-    }
-    catch (error) {
-        console.error(`Failed to register with proxy: ${error.message}`);
-        return null;
-    }
-}
-async function unregisterFromProxy() {
-    if (!config.PROXY_URL || !config.PROXY_APP_PATH)
-        return;
-    try {
-        await axios.delete(`${config.PROXY_URL}/proxy/unregister`, {
-            data: { path: config.PROXY_APP_PATH },
-            timeout: 2000
-        });
-        console.log(`Unregistered from proxy`);
-    }
-    catch (error) {
-        // Ignore error on shutdown
-    }
-}
+const proxyClient = config.PROXY_URL ? new ProxyClient(config.PROXY_URL) : null;
 let server;
 async function startServer() {
-    let port;
-    if (config.PROXY_URL) {
-        const assignedPort = await registerWithProxy();
-        if (assignedPort) {
-            port = assignedPort;
-        }
-        else {
-            console.error(`Could not register with proxy. Falling back to standalone mode on port ${config.GUI_PORT}.`);
-            port = config.GUI_PORT;
+    let port = config.GUI_PORT;
+    if (proxyClient && config.PROXY_APP_PATH) {
+        const result = await proxyClient.register({ path: config.PROXY_APP_PATH, name: config.PROXY_APP_NAME }, config.GUI_PORT);
+        port = result.port;
+        if (!result.success) {
+            logger.warn(`Could not register with proxy. Falling back to standalone mode on port ${port}.`);
         }
     }
-    else {
-        port = config.GUI_PORT;
-    }
     server = app.listen(port, () => {
-        console.log(`GUI API server listening on port ${port}`);
+        logger.info(`GUI API server listening on port ${port}`);
     });
     server.on('error', (err) => {
         if (err.code === 'EADDRINUSE') {
-            console.error(`PORT CONFLICT: Port ${port} is already in use.`);
+            logger.error(`PORT CONFLICT: Port ${port} is already in use. Another GUI instance is running.`);
+            process.exit(0);
         }
     });
 }
 startServer();
 // IPC and signals
 process.on('message', async (msg) => {
-    if (msg === 'STOP') {
-        console.log('GUI received STOP signal');
-        await unregisterFromProxy();
+    const type = typeof msg === 'string' ? msg : msg?.type;
+    if (type === 'STOP') {
+        logger.info('GUI received STOP signal');
+        await proxyClient?.unregister();
         server?.close(() => process.exit(0));
     }
 });
 process.on('error', (err) => {
     if (err.code === 'ERR_IPC_CHANNEL_CLOSED') {
-        console.error('[IPC] Channel closed (expected on disconnect).');
+        logger.error('[IPC] Channel closed (expected on disconnect).');
         return;
     }
-    console.error(`[Process] Error: ${err.message}`);
+    logger.error(`[Process] Error: ${err.message}`);
 });
 process.on('disconnect', () => {
-    console.error('Disconnected from parent, exiting.');
+    logger.error('Disconnected from parent, exiting.');
     process.exit(0);
 });
 process.on('SIGTERM', async () => {
-    await unregisterFromProxy();
+    await proxyClient?.unregister();
     process.exit(0);
 });

package/dist/mcp-server.js

@@ -3,17 +3,17 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import { fork } from 'child_process';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
-import { setupLogging } from './utils/logger.js';
+import { GuiLauncher, setupLogging, createLogger } 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 { VERSION } from './version.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-setupLogging('MASTER');
+setupLogging({ processLabel: 'MASTER' });
+const logger = createLogger('MASTER');
 const server = new Server({
     name: 'file-share-mcp',
     version: VERSION,
@@ -22,68 +22,18 @@ const server = new Server({
         tools: {},
     },
 });
-let guiProcess = null;
-/**
- * Envoi IPC robuste — vérifie que le canal est connecté avant d'envoyer
- */
-function safeSend(proc, message) {
-    if (proc && typeof proc.send === 'function' && proc.connected) {
-        try {
-            return proc.send(message);
+const gui = new GuiLauncher({
+    guiPath: path.join(__dirname, 'gui.js'),
+    onMessage: (msg) => {
+        if (msg.type === 'RESTART') {
+            logger.info('GUI requested restart...');
+            gui.start();
         }
-        catch (err) {
-            console.error(`[IPC] Failed to send message: ${err.message}`);
-            return false;
+        else if (msg.type === 'STOP') {
+            logger.info('GUI requested stop...');
+            gui.cleanup().then(() => process.exit(0));
         }
-    }
-    return false;
-}
-function startGui() {
-    if (guiProcess) {
-        guiProcess.kill();
-    }
-    const guiPath = path.join(__dirname, 'gui.js');
-    guiProcess = fork(guiPath, [], {
-        stdio: ['ignore', 'pipe', 'inherit', 'ipc'],
-        env: { ...process.env }
-    });
-    // Redirect GUI stdout to stderr to protect JSON-RPC
-    guiProcess.stdout?.on('data', (data) => {
-        process.stderr.write(data);
-    });
-    guiProcess.on('message', (message) => {
-        if (message === 'RESTART') {
-            console.log('GUI requested restart...');
-            startGui();
-        }
-        else if (message === 'STOP') {
-            console.log('GUI requested stop...');
-            cleanup().then(() => process.exit(0));
-        }
-    });
-    guiProcess.on('exit', (code) => {
-        if (code !== 0 && code !== null) {
-            console.error(`GUI process exited with code ${code}. Restarting...`);
-            setTimeout(startGui, 2000);
-        }
-    });
-}
-async function cleanup() {
-    console.log('Cleaning up...');
-    if (guiProcess) {
-        safeSend(guiProcess, 'STOP');
-        // Give it a moment to stop gracefully
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        guiProcess.kill();
-    }
-}
-process.on('SIGINT', async () => {
-    await cleanup();
-    process.exit(0);
-});
-process.on('SIGTERM', async () => {
-    await cleanup();
-    process.exit(0);
+    },
 });
 // Tool Definitions
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -349,8 +299,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.log('File Share MCP Server started');
-    startGui();
+    logger.info('File Share MCP Server started');
+    gui.start();
 }
 main().catch((error) => {
     console.error('Fatal error in main():', error);

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.0.6';
+export const VERSION = '1.0.8';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "file-share-mcp",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "MCP server for bidirectional file sharing between AI agents and users, with a built-in web GUI",
   "author": "",
   "license": "ISC",
@@ -37,6 +37,7 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
+    "@imenam/mcp-gui-interface": "file:../mcp-gui-interface",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "axios": "^1.13.5",
     "cors": "^2.8.6",