@meldocio/mcp-stdio-proxy 1.0.5 → 1.0.6

package/bin/cli.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+
+const { deviceFlowLogin } = require('../lib/device-flow');
+const { readCredentials, deleteCredentials } = require('../lib/credentials');
+const { getAuthStatus } = require('../lib/auth');
+const { setWorkspaceAlias, getWorkspaceAlias } = require('../lib/config');
+const { getAccessToken } = require('../lib/auth');
+const { getApiUrl, getAppUrl } = require('../lib/constants');
+const axios = require('axios');
+const https = require('https');
+const chalk = require('chalk');
+const logger = require('../lib/logger');
+
+const API_URL = getApiUrl();
+const APP_URL = getAppUrl();
+
+// Support localhost testing
+if (process.env.MELDOC_API_URL) {
+  logger.debug(`Using API URL: ${process.env.MELDOC_API_URL}`);
+}
+if (process.env.MELDOC_APP_URL) {
+  logger.debug(`Using App URL: ${process.env.MELDOC_APP_URL}`);
+}
+
+/**
+ * Handle auth login command
+ */
+async function handleAuthLogin() {
+  try {
+    logger.section('🔐 Authentication');
+    await deviceFlowLogin(
+      (url, code) => {
+        console.log('\n' + logger.label('Visit this URL:'));
+        console.log('  ' + logger.url(url));
+        console.log('\n' + logger.label('Enter this code:'));
+        console.log('  ' + logger.code(code) + '\n');
+        logger.info('Waiting for authentication...');
+      },
+      (status) => {
+        if (status === 'denied') {
+          logger.error('Login denied by user');
+          process.exit(1);
+        } else if (status === 'expired') {
+          logger.error('Authentication code expired');
+          process.exit(1);
+        }
+      },
+      API_URL,
+      APP_URL
+    );
+    logger.success('Login successful!');
+    process.exit(0);
+  } catch (error) {
+    logger.error(`Login failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle auth status command
+ */
+async function handleAuthStatus() {
+  const status = await getAuthStatus();
+  if (!status || !status.authenticated) {
+    logger.error('Not authenticated');
+    console.log('\n' + logger.label('To authenticate, run:'));
+    console.log('  ' + logger.highlight('npx @meldoc/mcp auth login') + '\n');
+    process.exit(1);
+  }
+  
+  logger.section('🔑 Authentication Status');
+  
+  if (status.type === 'user_session' && status.user) {
+    logger.item('Email', logger.value(status.user.email));
+    if (status.expiresAt) {
+      logger.item('Token expires', logger.value(new Date(status.expiresAt).toLocaleString()));
+    }
+  } else {
+    logger.item('Type', logger.value(status.type));
+  }
+  
+  console.log();
+  process.exit(0);
+}
+
+/**
+ * Handle auth logout command
+ */
+async function handleAuthLogout() {
+  deleteCredentials();
+  logger.success('Logged out successfully');
+  process.exit(0);
+}
+
+/**
+ * Handle config set-workspace command
+ */
+function handleConfigSetWorkspace(alias) {
+  if (!alias) {
+    logger.error('Workspace alias is required');
+    console.log('\n' + logger.label('Usage:'));
+    console.log('  ' + logger.highlight('npx @meldoc/mcp config set-workspace <alias>') + '\n');
+    process.exit(1);
+  }
+  
+  try {
+    setWorkspaceAlias(alias);
+    logger.success(`Workspace set to: ${logger.highlight(alias)}`);
+    process.exit(0);
+  } catch (error) {
+    logger.error(`Failed to set workspace: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle config get-workspace command
+ */
+function handleConfigGetWorkspace() {
+  const alias = getWorkspaceAlias();
+  if (alias) {
+    console.log(logger.highlight(alias));
+  }
+  process.exit(0);
+}
+
+/**
+ * Handle config list-workspaces command
+ */
+async function handleConfigListWorkspaces() {
+  try {
+    const tokenInfo = await getAccessToken();
+    if (!tokenInfo) {
+      logger.error('Not authenticated');
+      console.log('\n' + logger.label('To authenticate, run:'));
+      console.log('  ' + logger.highlight('npx @meldoc/mcp auth login') + '\n');
+      process.exit(1);
+    }
+    
+    // Call MCP tool meldoc.list_workspaces via POST /mcp/v1/rpc
+    const response = await axios.post(`${API_URL}/mcp/v1/rpc`, {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: {
+        name: 'meldoc.list_workspaces',
+        arguments: {}
+      }
+    }, {
+      headers: {
+        'Authorization': `Bearer ${tokenInfo.token}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 10000,
+      httpsAgent: new https.Agent({ keepAlive: true })
+    });
+    
+    if (response.data.error) {
+      logger.error(`Error: ${response.data.error.message}`);
+      process.exit(1);
+    }
+    
+    const workspaces = response.data.result?.workspaces || [];
+    if (workspaces.length === 0) {
+      logger.info('No workspaces available');
+      process.exit(0);
+    }
+    
+    logger.section('📁 Available Workspaces');
+    for (const ws of workspaces) {
+      const role = ws.role || 'member';
+      const roleColor = role === 'owner' ? chalk.red : role === 'admin' ? chalk.yellow : chalk.gray;
+      logger.item(
+        `${logger.highlight(ws.alias)} ${chalk.gray('(' + ws.name + ')')}`,
+        roleColor(`[${role}]`)
+      );
+    }
+    console.log();
+    
+    process.exit(0);
+  } catch (error) {
+    if (error.response?.data?.error) {
+      const errorData = error.response.data.error;
+      if (errorData.code === 'AUTH_REQUIRED' || errorData.data?.code === 'AUTH_REQUIRED') {
+        logger.error('Not authenticated');
+        console.log('\n' + logger.label('To authenticate, run:'));
+        console.log('  ' + logger.highlight('npx @meldoc/mcp auth login') + '\n');
+        process.exit(1);
+      }
+      logger.error(`Error: ${errorData.message || error.message}`);
+    } else {
+      logger.error(`Error: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle help command
+ */
+function handleHelp() {
+  console.log('\n' + logger.section('📖 Meldoc MCP CLI Help'));
+  console.log();
+  
+  console.log(logger.label('Available Commands:'));
+  console.log();
+  
+  console.log('  ' + logger.highlight('auth login'));
+  console.log('    Authenticate with Meldoc using device flow');
+  console.log();
+  
+  console.log('  ' + logger.highlight('auth status'));
+  console.log('    Check authentication status');
+  console.log();
+  
+  console.log('  ' + logger.highlight('auth logout'));
+  console.log('    Log out and clear credentials');
+  console.log();
+  
+  console.log('  ' + logger.highlight('config set-workspace <alias>'));
+  console.log('    Set the active workspace alias');
+  console.log();
+  
+  console.log('  ' + logger.highlight('config get-workspace'));
+  console.log('    Get the current workspace alias');
+  console.log();
+  
+  console.log('  ' + logger.highlight('config list-workspaces'));
+  console.log('    List all available workspaces');
+  console.log();
+  
+  console.log('  ' + logger.highlight('help'));
+  console.log('    Show this help message');
+  console.log();
+  
+  console.log(logger.label('Examples:'));
+  console.log('  ' + logger.highlight('npx @meldoc/mcp auth login'));
+  console.log('  ' + logger.highlight('npx @meldoc/mcp config set-workspace my-workspace'));
+  console.log('  ' + logger.highlight('npx @meldoc/mcp config list-workspaces'));
+  console.log();
+  
+  process.exit(0);
+}
+
+/**
+ * Show usage hints when no arguments provided
+ */
+function showUsageHints() {
+  console.log('\n' + logger.section('🔧 Meldoc MCP CLI'));
+  console.log();
+  console.log(logger.label('Available commands:'));
+  console.log('  ' + logger.highlight('auth login') + '        - Authenticate with Meldoc');
+  console.log('  ' + logger.highlight('auth status') + '       - Check authentication status');
+  console.log('  ' + logger.highlight('auth logout') + '       - Log out');
+  console.log('  ' + logger.highlight('config set-workspace') + ' - Set workspace alias');
+  console.log('  ' + logger.highlight('config get-workspace') + ' - Get current workspace');
+  console.log('  ' + logger.highlight('config list-workspaces') + ' - List workspaces');
+  console.log('  ' + logger.highlight('help') + '              - Show detailed help');
+  console.log();
+  console.log(logger.label('For more information, run:'));
+  console.log('  ' + logger.highlight('npx @meldoc/mcp help') + '\n');
+  process.exit(0);
+}
+
+/**
+ * Main CLI handler
+ */
+function main() {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0) {
+    // No arguments - show usage hints
+    showUsageHints();
+    return;
+  }
+  
+  const command = args[0];
+  const subcommand = args[1];
+  const value = args[2];
+  
+  if (command === 'help' || command === '--help' || command === '-h') {
+    handleHelp();
+  } else if (command === 'auth') {
+    if (subcommand === 'login') {
+      handleAuthLogin();
+    } else if (subcommand === 'status') {
+      handleAuthStatus();
+    } else if (subcommand === 'logout') {
+      handleAuthLogout();
+    } else {
+      logger.error(`Unknown auth command: ${subcommand}`);
+      console.log('\n' + logger.label('Usage:'));
+      console.log('  ' + logger.highlight('npx @meldoc/mcp auth <login|status|logout>') + '\n');
+      process.exit(1);
+    }
+  } else if (command === 'config') {
+    if (subcommand === 'set-workspace') {
+      handleConfigSetWorkspace(value);
+    } else if (subcommand === 'get-workspace') {
+      handleConfigGetWorkspace();
+    } else if (subcommand === 'list-workspaces') {
+      handleConfigListWorkspaces();
+    } else {
+      logger.error(`Unknown config command: ${subcommand}`);
+      console.log('\n' + logger.label('Usage:'));
+      console.log('  ' + logger.highlight('npx @meldoc/mcp config <set-workspace|get-workspace|list-workspaces>') + '\n');
+      process.exit(1);
+    }
+  } else {
+    // Unknown command - might be for main proxy
+    // Return control to main proxy handler
+    return;
+  }
+}
+
+// Run main when this file is required (called from main proxy)
+// main() will handle commands and exit, so this is safe to call
+main();
+
+module.exports = {
+  handleAuthLogin,
+  handleAuthStatus,
+  handleAuthLogout,
+  handleConfigSetWorkspace,
+  handleConfigGetWorkspace,
+  handleConfigListWorkspaces
+};

package/bin/meldoc-mcp-proxy.js

@@ -5,6 +5,16 @@ const https = require('https');
 const { URL } = require('url');
 const path = require('path');
 const fs = require('fs');
+const chalk = require('chalk');
+
+// Check for CLI commands first
+const args = process.argv.slice(2);
+if (args.length > 0 && (args[0] === 'auth' || args[0] === 'config')) {
+  // Handle CLI commands - cli.js will handle and exit
+  require('./cli');
+  // cli.js should have exited, but if not, exit here
+  process.exit(0);
+}
 
 // Get package info - try multiple paths for different installation scenarios
 let pkg;
@@ -49,39 +59,14 @@ const LOG_LEVELS = {
   DEBUG: 3
 };
 
-// Get token from environment or config file
-// Priority: 1) MELDOC_TOKEN env var, 2) ~/.meldoc/config.json
-function getToken() {
-  // First, try environment variable (recommended)
-  if (process.env.MELDOC_TOKEN) {
-    return process.env.MELDOC_TOKEN;
-  }
-  
-  // Fallback: try MELDOC_MCP_TOKEN for backward compatibility
-  if (process.env.MELDOC_MCP_TOKEN) {
-    return process.env.MELDOC_MCP_TOKEN;
-  }
-  
-  // Then, try config file
-  try {
-    const os = require('os');
-    const configPath = path.join(os.homedir(), '.meldoc', 'config.json');
-    if (fs.existsSync(configPath)) {
-      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      if (config.token) {
-        return config.token;
-      }
-    }
-  } catch (e) {
-    // Silently ignore config file errors
-  }
-  
-  return null;
-}
+// Import new auth and workspace modules
+const { getAccessToken, getAuthStatus } = require('../lib/auth');
+const { resolveWorkspaceAlias } = require('../lib/workspace');
+const { getApiUrl } = require('../lib/constants');
+const { setWorkspaceAlias, getWorkspaceAlias } = require('../lib/config');
 
 // Configuration
-const token = getToken();
-const apiUrl = process.env.MELDOC_API_URL || 'https://api.meldoc.io';
+const apiUrl = getApiUrl();
 const rpcEndpoint = `${apiUrl}/mcp/v1/rpc`;
 const REQUEST_TIMEOUT = 25000; // 25 seconds (less than Claude Desktop's 30s timeout)
 const LOG_LEVEL = getLogLevel(process.env.LOG_LEVEL || 'ERROR');
@@ -92,13 +77,37 @@ function getLogLevel(level) {
   return LOG_LEVELS[upper] !== undefined ? LOG_LEVELS[upper] : LOG_LEVELS.ERROR;
 }
 
-// Logging function - all logs go to stderr
+// Logging function - all logs go to stderr with beautiful colors
 function log(level, message, ...args) {
   if (LOG_LEVEL >= level) {
-    const prefix = `[${Object.keys(LOG_LEVELS)[level]}]`;
-    process.stderr.write(`${prefix} ${message}\n`);
+    const levelName = Object.keys(LOG_LEVELS)[level];
+    let prefix, colorFn;
+    
+    switch (level) {
+      case LOG_LEVELS.ERROR:
+        prefix = chalk.red('✗ [ERROR]');
+        colorFn = chalk.redBright;
+        break;
+      case LOG_LEVELS.WARN:
+        prefix = chalk.yellow('⚠ [WARN]');
+        colorFn = chalk.yellowBright;
+        break;
+      case LOG_LEVELS.INFO:
+        prefix = chalk.blue('ℹ [INFO]');
+        colorFn = chalk.blueBright;
+        break;
+      case LOG_LEVELS.DEBUG:
+        prefix = chalk.gray('🔍 [DEBUG]');
+        colorFn = chalk.gray;
+        break;
+      default:
+        prefix = `[${levelName}]`;
+        colorFn = (text) => text;
+    }
+    
+    process.stderr.write(`${prefix} ${colorFn(message)}\n`);
     if (args.length > 0 && LOG_LEVEL >= LOG_LEVELS.DEBUG) {
-      process.stderr.write(JSON.stringify(args, null, 2) + '\n');
+      process.stderr.write(chalk.gray(JSON.stringify(args, null, 2)) + '\n');
     }
   }
 }
@@ -212,6 +221,7 @@ function validateRequest(request) {
 
 /**
  * Handle a JSON-RPC request
+ * This function MUST always send a response for requests with id (except notifications)
  */
 async function handleRequest(request) {
   // Handle null/undefined requests
@@ -219,28 +229,47 @@ async function handleRequest(request) {
     return;
   }
   
-  // Handle batch requests (array of requests)
+  // Wrap in try-catch to ensure we always handle errors gracefully
+  try {
+    // Handle batch requests (array of requests)
   if (Array.isArray(request)) {
     // Process batch requests sequentially
     for (const req of request) {
       if (req) {
-        // Check if this is a protocol method that should be handled locally
-        const method = req.method;
-        if (method === 'initialize') {
-          handleInitialize(req);
-        } else if (method === 'initialized' || method === 'notifications/initialized') {
-          // Notification - no response needed
-          continue;
-        } else if (method === 'notifications/cancelled') {
-          // Notification - no response needed
-          continue;
-        } else if (method === 'ping') {
-          handlePing(req);
-        } else if (method === 'resources/list') {
-          handleResourcesList(req);
-        } else {
-          // Forward to backend
-          await processSingleRequest(req);
+        try {
+          // Check if this is a protocol method that should be handled locally
+          const method = req.method;
+          if (method === 'initialize') {
+            handleInitialize(req);
+          } else if (method === 'initialized' || method === 'notifications/initialized') {
+            // Notification - no response needed
+            continue;
+          } else if (method === 'notifications/cancelled') {
+            // Notification - no response needed
+            continue;
+          } else if (method === 'ping') {
+            handlePing(req);
+          } else if (method === 'resources/list') {
+            handleResourcesList(req);
+          } else if (method === 'tools/list') {
+            handleToolsList(req);
+          } else if (method === 'tools/call') {
+            await handleToolsCall(req);
+          } else {
+            // Forward to backend
+            await processSingleRequest(req);
+          }
+        } catch (error) {
+          // Catch any errors in batch request processing
+          log(LOG_LEVELS.ERROR, `Error processing batch request: ${error.message || 'Unknown error'}`);
+          log(LOG_LEVELS.DEBUG, `Error stack: ${error.stack || 'No stack trace'}`);
+          // Send error response if request has id
+          if (req && req.id !== undefined && req.id !== null) {
+            sendError(req.id, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, 
+                      `Error processing request: ${error.message || 'Unknown error'}`, {
+                        code: 'INTERNAL_ERROR'
+                      });
+          }
         }
       }
     }
@@ -272,10 +301,31 @@ async function handleRequest(request) {
     // Return empty resources list (resources not supported yet)
     handleResourcesList(request);
     return;
+  } else if (method === 'tools/list') {
+    // Return static list of tools (never proxy to backend)
+    handleToolsList(request);
+    return;
+  } else if (method === 'tools/call') {
+    // Handle tools/call - check if it's a local tool first
+    await handleToolsCall(request);
+    return;
   }
   
-  // All other methods (tools/*, etc.) are forwarded to backend
+  // All other methods are forwarded to backend
   await processSingleRequest(request);
+  } catch (error) {
+    // Catch any completely unexpected errors in handleRequest
+    log(LOG_LEVELS.ERROR, `Unexpected error in handleRequest: ${error.message || 'Unknown error'}`);
+    log(LOG_LEVELS.DEBUG, `Error stack: ${error.stack || 'No stack trace'}`);
+    
+    // Only send error if request has id (not for notifications)
+    if (request && request.id !== undefined && request.id !== null) {
+      sendError(request.id, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, 
+                `Internal error: ${error.message || 'Unknown error'}`, {
+                  code: 'INTERNAL_ERROR'
+                });
+    }
+  }
 }
 
 /**
@@ -341,15 +391,427 @@ function handleResourcesList(request) {
   }
 }
 
+/**
+ * Get static list of all available tools
+ * This is always returned locally, never proxied to backend
+ */
+function getToolsList() {
+  return [
+    {
+      name: 'docs_list',
+      description: 'List documents in workspace/project. For public tokens, only shows published public documents.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' },
+          projectId: { type: 'string', description: 'UUID of the project to list documents from' },
+          cursor: { type: 'string', description: 'Pagination cursor' },
+          limit: { type: 'integer', description: 'Maximum number of documents to return (default: 50, max: 100)' }
+        }
+      }
+    },
+    {
+      name: 'docs_get',
+      description: 'Get a specific document by ID or path. For public tokens, allows access to public and unlisted documents.',
+      inputSchema: {
+        type: 'object',
+        required: ['docId'],
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' },
+          docId: { type: 'string', description: 'UUID of the document (alias: id)' },
+          id: { type: 'string', description: 'UUID of the document (alias for docId)' },
+          path: { type: 'string', description: 'Path of the document (not yet implemented)' }
+        }
+      }
+    },
+    {
+      name: 'docs_tree',
+      description: 'Get the document tree structure for a project. For public tokens, only includes published public documents.',
+      inputSchema: {
+        type: 'object',
+        required: ['projectId'],
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' },
+          projectId: { type: 'string', description: 'UUID of the project' },
+          project_alias: { type: 'string', description: 'Alias of the project (alternative to projectId)' }
+        }
+      }
+    },
+    {
+      name: 'docs_search',
+      description: 'Search documents by text query. For public tokens, only searches published public documents.',
+      inputSchema: {
+        type: 'object',
+        required: ['query'],
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' },
+          query: { type: 'string', description: 'Search query text' },
+          projectId: { type: 'string', description: 'UUID of the project to search in' },
+          limit: { type: 'integer', description: 'Maximum number of results (default: 20, max: 50)' }
+        }
+      }
+    },
+    {
+      name: 'docs_update',
+      description: 'Update a document\'s content and/or metadata. Requires update permission (internal tokens only).',
+      inputSchema: {
+        type: 'object',
+        required: ['docId'],
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' },
+          docId: { type: 'string', description: 'UUID of the document to update' },
+          contentMd: { type: 'string', description: 'New markdown content for the document (optional, can update individual fields without content)' },
+          title: { type: 'string', description: 'New title for the document' },
+          alias: { type: 'string', description: 'New alias for the document' },
+          parentAlias: { type: 'string', description: 'Alias of the parent document (set to empty string to remove parent)' },
+          workflow: { type: 'string', enum: ['published', 'draft'], description: 'Workflow status: \'published\' or \'draft\'' },
+          visibility: { type: 'string', enum: ['visible', 'hidden'], description: 'Visibility: \'visible\' or \'hidden\'' },
+          exposure: { type: 'string', enum: ['private', 'unlisted', 'public', 'inherit'], description: 'Exposure level: \'private\', \'unlisted\', \'public\', or \'inherit\'' },
+          expectedUpdatedAt: { type: 'string', description: 'Expected updatedAt timestamp for optimistic locking (RFC3339 format)' }
+        }
+      }
+    },
+    {
+      name: 'docs_create',
+      description: 'Create a new document. Requires create permission (internal tokens only).',
+      inputSchema: {
+        type: 'object',
+        required: ['projectId', 'title', 'contentMd'],
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' },
+          projectId: { type: 'string', description: 'UUID of the project to create the document in' },
+          title: { type: 'string', description: 'Title of the document' },
+          contentMd: { type: 'string', description: 'Markdown content for the document' },
+          alias: { type: 'string', description: 'Alias for the document (will be auto-generated from title if not provided)' },
+          parentAlias: { type: 'string', description: 'Alias of the parent document' }
+        }
+      }
+    },
+    {
+      name: 'docs_delete',
+      description: 'Delete a document. Requires delete permission (internal tokens only).',
+      inputSchema: {
+        type: 'object',
+        required: ['docId'],
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' },
+          docId: { type: 'string', description: 'UUID of the document to delete' }
+        }
+      }
+    },
+    {
+      name: 'docs_links',
+      description: 'Get all outgoing links from a document (links that point from this document to other documents).',
+      inputSchema: {
+        type: 'object',
+        required: ['docId'],
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' },
+          docId: { type: 'string', description: 'UUID of the document' }
+        }
+      }
+    },
+    {
+      name: 'docs_backlinks',
+      description: 'Get all backlinks to a document (links from other documents that point to this document).',
+      inputSchema: {
+        type: 'object',
+        required: ['docId'],
+        properties: {
+          docId: { type: 'string', description: 'UUID of the document' }
+        }
+      }
+    },
+    {
+      name: 'projects_list',
+      description: 'List projects accessible by this token. For public tokens, only shows public projects.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' }
+        }
+      }
+    },
+    {
+      name: 'server_info',
+      description: 'Get information about this MCP server\'s configuration, capabilities, and accessible projects.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          workspaceAlias: { type: 'string', description: 'Workspace alias (auto-selected if user has only one workspace)' },
+          workspaceId: { type: 'string', description: 'Workspace UUID (auto-selected if user has only one workspace)' }
+        }
+      }
+    },
+    {
+      name: 'list_workspaces',
+      description: 'List all workspaces accessible by the current user or integration token. For integration tokens, returns the workspace from token scope. Works without workspace header via /mcp/v1/rpc endpoint.',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    },
+    {
+      name: 'get_workspace',
+      description: 'Get the current workspace alias from repo config or global config. Reads workspaceAlias from configuration files.',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    },
+    {
+      name: 'set_workspace',
+      description: 'Set the workspace alias in global config (~/.meldoc/config.json). This workspace will be used automatically if user has multiple workspaces.',
+      inputSchema: {
+        type: 'object',
+        required: ['alias'],
+        properties: {
+          alias: { type: 'string', description: 'Workspace alias to set' }
+        }
+      }
+    },
+    {
+      name: 'auth_status',
+      description: 'Check authentication status. Returns whether user is logged in and authentication details.',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    },
+    {
+      name: 'auth_login_instructions',
+      description: 'Get instructions for logging in. Returns the command to run for authentication.',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    }
+  ];
+}
+
+/**
+ * Handle tools/list method
+ * Always returns static list locally, never proxies to backend
+ * This function MUST always succeed and return a response
+ */
+function handleToolsList(request) {
+  try {
+    const tools = getToolsList();
+    
+    // Log tool names for debugging
+    const toolNames = tools.map(t => t.name).join(', ');
+    log(LOG_LEVELS.INFO, `Returning ${tools.length} tools locally: ${toolNames}`);
+    
+    const response = {
+      jsonrpc: '2.0',
+      id: request.id,
+      result: {
+        tools: tools
+      }
+    };
+    
+    // Always send response, even if there's an error writing
+    try {
+      const responseStr = JSON.stringify(response);
+      process.stdout.write(responseStr + '\n');
+      if (process.stdout.isTTY) {
+        process.stdout.flush();
+      }
+      log(LOG_LEVELS.DEBUG, `Sent tools/list response (${responseStr.length} bytes)`);
+    } catch (writeError) {
+      // If stdout write fails, log but don't throw - we've already logged the response
+      log(LOG_LEVELS.ERROR, `Failed to write tools/list response: ${writeError.message}`);
+    }
+  } catch (error) {
+    // This should never happen, but if it does, send error response
+    log(LOG_LEVELS.ERROR, `Unexpected error in handleToolsList: ${error.message || 'Unknown error'}`);
+    log(LOG_LEVELS.DEBUG, `Error stack: ${error.stack || 'No stack trace'}`);
+    
+    // Send error response
+    sendError(request.id, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, 
+              `Failed to get tools list: ${error.message || 'Unknown error'}`, {
+                code: 'INTERNAL_ERROR'
+              });
+  }
+}
+
+/**
+ * Handle tools/call method
+ * Checks if it's a local tool first, otherwise forwards to backend
+ */
+async function handleToolsCall(request) {
+  try {
+    const toolName = request.params?.name;
+    const arguments_ = request.params?.arguments || {};
+    
+    log(LOG_LEVELS.DEBUG, `handleToolsCall: toolName=${toolName}`);
+    
+    // Handle local tools
+    if (toolName === 'set_workspace') {
+      const alias = arguments_.alias;
+      if (!alias || typeof alias !== 'string') {
+        sendError(request.id, JSON_RPC_ERROR_CODES.INVALID_PARAMS, 'alias parameter is required and must be a string');
+        return;
+      }
+      
+      try {
+        setWorkspaceAlias(alias);
+        const response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result: {
+            content: [
+              {
+                type: 'text',
+                text: `Workspace alias set to: ${alias}`
+              }
+            ]
+          }
+        };
+        process.stdout.write(JSON.stringify(response) + '\n');
+        if (process.stdout.isTTY) {
+          process.stdout.flush();
+        }
+      } catch (error) {
+        sendError(request.id, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Failed to set workspace alias: ${error.message}`);
+      }
+      return;
+    }
+  
+    if (toolName === 'get_workspace') {
+      try {
+        const workspaceAlias = getWorkspaceAlias();
+        const response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result: {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  workspaceAlias: workspaceAlias || null,
+                  source: workspaceAlias ? 'config' : 'not_found',
+                  message: workspaceAlias ? `Current workspace: ${workspaceAlias}` : 'No workspace set in config'
+                }, null, 2)
+              }
+            ]
+          }
+        };
+        process.stdout.write(JSON.stringify(response) + '\n');
+        if (process.stdout.isTTY) {
+          process.stdout.flush();
+        }
+      } catch (error) {
+        sendError(request.id, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Failed to get workspace: ${error.message}`);
+      }
+      return;
+    }
+  
+  if (toolName === 'auth_status') {
+    try {
+      const authStatus = await getAuthStatus();
+      if (!authStatus) {
+        const response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result: {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  authenticated: false,
+                  message: 'Not authenticated. Run: npx @meldoc/mcp@latest auth login'
+                }, null, 2)
+              }
+            ]
+          }
+        };
+        process.stdout.write(JSON.stringify(response) + '\n');
+        if (process.stdout.isTTY) {
+          process.stdout.flush();
+        }
+        return;
+      }
+      
+      const response = {
+        jsonrpc: '2.0',
+        id: request.id,
+        result: {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(authStatus, null, 2)
+            }
+          ]
+        }
+      };
+      process.stdout.write(JSON.stringify(response) + '\n');
+      if (process.stdout.isTTY) {
+        process.stdout.flush();
+      }
+    } catch (error) {
+      sendError(request.id, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Failed to get auth status: ${error.message}`);
+    }
+    return;
+  }
+  
+  if (toolName === 'auth_login_instructions') {
+    const response = {
+      jsonrpc: '2.0',
+      id: request.id,
+      result: {
+        content: [
+          {
+            type: 'text',
+            text: 'To authenticate, run the following command:\n\nnpx @meldoc/mcp@latest auth login'
+          }
+        ]
+      }
+    };
+    process.stdout.write(JSON.stringify(response) + '\n');
+    if (process.stdout.isTTY) {
+      process.stdout.flush();
+    }
+    return;
+  }
+  
+  // All other tools are forwarded to backend
+  log(LOG_LEVELS.DEBUG, `Forwarding tool ${toolName} to backend (not a local tool)`);
+  await processSingleRequest(request);
+  } catch (error) {
+    // Catch any unexpected errors in handleToolsCall
+    log(LOG_LEVELS.ERROR, `Unexpected error in handleToolsCall: ${error.message || 'Unknown error'}`);
+    log(LOG_LEVELS.DEBUG, `Error stack: ${error.stack || 'No stack trace'}`);
+    sendError(request.id, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, 
+              `Internal error in tool handler: ${error.message || 'Unknown error'}`, {
+                code: 'INTERNAL_ERROR',
+                toolName: request.params?.name
+              });
+  }
+}
+
 /**
  * Process a single JSON-RPC request
  * Forwards the request to the backend MCP API
  */
 async function processSingleRequest(request) {
-  // Check token before making request
-  if (!token) {
+  // Get access token with priority and auto-refresh
+  const tokenInfo = await getAccessToken();
+  if (!tokenInfo) {
     sendError(request.id, CUSTOM_ERROR_CODES.AUTH_REQUIRED, 
-              'Meldoc token not found. Set MELDOC_TOKEN environment variable or run: meldoc auth login');
+              'Meldoc token not found. Set MELDOC_ACCESS_TOKEN environment variable or run: npx @meldoc/mcp@latest auth login', {
+                code: 'AUTH_REQUIRED',
+                hint: 'Use meldoc.auth_login_instructions tool to get login command'
+              });
     return;
   }
   
@@ -362,19 +824,61 @@ async function processSingleRequest(request) {
     
     log(LOG_LEVELS.DEBUG, `Forwarding request: ${request.method || 'unknown'}`);
     
+    // Prepare headers
+    const headers = {
+      'Authorization': `Bearer ${tokenInfo.token}`,
+      'Content-Type': 'application/json',
+      'User-Agent': `${pkg.name}/${pkg.version}`
+    };
+    
+    // For tools/call: special handling
+    if (request.method === 'tools/call') {
+      const toolName = request.params?.name;
+      
+      // For list_workspaces: NEVER add workspace header
+      // This tool should work without workspace header
+      // Backend middleware should handle this specially
+      if (toolName === 'list_workspaces') {
+        log(LOG_LEVELS.DEBUG, `Skipping workspace header for ${toolName} tool`);
+        // Explicitly don't add workspace header - this tool must work without it
+        // Do nothing - headers will not include X-Meldoc-Workspace
+      } else {
+        // For other tools/call: don't add workspace header automatically
+        // Backend will auto-select if user has only one workspace
+        // If multiple workspaces, backend will return WORKSPACE_REQUIRED error
+        log(LOG_LEVELS.DEBUG, `Tool ${toolName} - not adding workspace header automatically`);
+      }
+    } else {
+      // For other methods: add workspace header if available (for backward compatibility)
+      const workspaceAlias = resolveWorkspaceAlias(true);
+      if (workspaceAlias) {
+        headers['X-Meldoc-Workspace'] = workspaceAlias;
+        log(LOG_LEVELS.DEBUG, `Added workspace header: ${workspaceAlias}`);
+      }
+    }
+    
+    log(LOG_LEVELS.DEBUG, `Making request to ${rpcEndpoint}, method: ${request.method || 'unknown'}, headers: ${JSON.stringify(Object.keys(headers))}`);
+    
     // Make HTTP request to MCP API
+    log(LOG_LEVELS.DEBUG, `POST ${rpcEndpoint} with body: ${JSON.stringify({
+      method: requestWithJsonRpc.method,
+      params: requestWithJsonRpc.params ? {
+        name: requestWithJsonRpc.params.name,
+        arguments: requestWithJsonRpc.params.arguments
+      } : undefined
+    })}`);
+    
     const response = await axios.post(rpcEndpoint, requestWithJsonRpc, {
-      headers: {
-        'Authorization': `Bearer ${token}`,
-        'Content-Type': 'application/json',
-        'User-Agent': `${pkg.name}/${pkg.version}`
-      },
+      headers,
       timeout: REQUEST_TIMEOUT,
       validateStatus: (status) => status < 500, // Don't throw on 4xx errors
       // Keep connection alive for better performance
       httpsAgent: new https.Agent({ keepAlive: true, keepAliveMsecs: 1000 })
     });
     
+    log(LOG_LEVELS.DEBUG, `Response status: ${response.status}, data keys: ${JSON.stringify(Object.keys(response.data || {}))}`);
+    log(LOG_LEVELS.DEBUG, `Full response data: ${JSON.stringify(response.data)}`);
+    
     // Handle successful response
     if (response.status >= 200 && response.status < 300) {
       const responseData = response.data;
@@ -389,18 +893,168 @@ async function processSingleRequest(request) {
         }
       }
       
-      // Ensure stdout is flushed immediately
+      // Check for WORKSPACE_REQUIRED error
+      if (responseData.error) {
+        const errorCode = responseData.error.code;
+        const errorMessage = responseData.error.message || '';
+        const errorData = responseData.error.data || {};
+        
+        // Get tool name from request (check both original and modified request)
+        const toolName = request.params?.name || requestWithJsonRpc.params?.name;
+        
+        log(LOG_LEVELS.DEBUG, `Error response: code=${errorCode} (type: ${typeof errorCode}), message="${errorMessage}", toolName=${toolName}, errorData=${JSON.stringify(errorData)}`);
+        log(LOG_LEVELS.DEBUG, `Full error response: ${JSON.stringify(responseData.error)}`);
+        
+        // Check if error message contains "Multiple workspaces available" (backend may return this with different error codes)
+        // Backend may return code as number (-32000) or string ('WORKSPACE_REQUIRED')
+        const errorMsgStr = String(errorMessage || '');
+        const hasWorkspaceMessage = errorMsgStr.includes('Multiple workspaces available') || 
+                                    errorMsgStr.includes('Specify workspace');
+        
+        const isWorkspaceRequired = errorCode === 'WORKSPACE_REQUIRED' || 
+                                   errorData.code === 'WORKSPACE_REQUIRED' ||
+                                   (errorCode === JSON_RPC_ERROR_CODES.SERVER_ERROR && hasWorkspaceMessage);
+        
+        log(LOG_LEVELS.DEBUG, `Workspace check: isWorkspaceRequired=${isWorkspaceRequired}, hasWorkspaceMessage=${hasWorkspaceMessage}, errorMsgStr="${errorMsgStr}"`);
+        
+        if (isWorkspaceRequired) {
+          log(LOG_LEVELS.DEBUG, `Detected WORKSPACE_REQUIRED error for tool: ${toolName}`);
+          
+          // Special handling for tools that should work without workspace
+          if (toolName === 'list_workspaces') {
+            // This is a backend issue - this tool should work without workspace header
+            // But we can still provide helpful message
+            const message = `Backend requires workspace selection even for ${toolName}. Please set a default workspace using set_workspace tool first, or contact support if this persists.`;
+            sendError(request.id, JSON_RPC_ERROR_CODES.SERVER_ERROR, message, {
+              code: 'WORKSPACE_REQUIRED',
+              hint: 'Try setting a default workspace first using set_workspace tool, or specify workspaceAlias/workspaceId in the tool call arguments.'
+            });
+            return;
+          }
+          
+          const message = 'Multiple workspaces available. Use list_workspaces tool to get list, then use set_workspace to set default workspace, or specify workspaceAlias or workspaceId parameter in tool call.';
+          sendError(request.id, JSON_RPC_ERROR_CODES.SERVER_ERROR, message, {
+            code: 'WORKSPACE_REQUIRED',
+            hint: 'Use list_workspaces tool to get available workspaces, then use set_workspace to set default, or specify workspaceAlias or workspaceId in tool call.'
+          });
+          return;
+        }
+        
+        // Check for AUTH_REQUIRED error
+        if (errorCode === 'AUTH_REQUIRED' || errorData.code === 'AUTH_REQUIRED') {
+          const message = 'Authentication required. Run: npx @meldoc/mcp@latest auth login';
+          sendError(request.id, CUSTOM_ERROR_CODES.AUTH_REQUIRED, message, {
+            code: 'AUTH_REQUIRED',
+            hint: 'Use auth_login_instructions tool to get login command'
+          });
+          return;
+        }
+        
+        // If error was not handled above, forward it as-is
+        log(LOG_LEVELS.DEBUG, `Forwarding unhandled error: ${JSON.stringify(responseData.error)}`);
+        // Forward the error response as-is
+        process.stdout.write(JSON.stringify(responseData) + '\n');
+        if (process.stdout.isTTY) {
+          process.stdout.flush();
+        }
+        return;
+      }
+      
+      // If there's an error that we handled, we already sent a response, so return
+      if (responseData.error) {
+        return;
+      }
+      
+      // Success response - ensure stdout is flushed immediately
       process.stdout.write(JSON.stringify(responseData) + '\n');
       // Flush stdout to ensure data is sent immediately
       if (process.stdout.isTTY) {
         process.stdout.flush();
       }
     } else {
-      // HTTP error status
-      const errorMessage = response.data?.error?.message || 
-                          response.data?.message || 
+      // HTTP error status (400, 401, 404, etc.)
+      log(LOG_LEVELS.DEBUG, `HTTP error status ${response.status}, full response: ${JSON.stringify(response.data)}`);
+      
+      // Try to extract error information from different possible formats
+      // Format 1: JSON-RPC error format { error: { code, message, data } }
+      // Format 2: Direct error format { code, message, details, error }
+      // Format 3: Simple error format { message }
+      
+      const responseData = response.data || {};
+      const errorMessage = responseData.error?.message || 
+                          responseData.message || 
                           `HTTP ${response.status}: ${response.statusText}`;
-      sendError(request.id, JSON_RPC_ERROR_CODES.SERVER_ERROR, errorMessage);
+      
+      // Check for WORKSPACE_REQUIRED in various places
+      const errorData = responseData.error?.data || responseData.details || {};
+      const errorMsg = responseData.error?.message || responseData.message || '';
+      const errorCode = responseData.error?.code || responseData.code;
+      
+      log(LOG_LEVELS.DEBUG, `HTTP error details: errorCode=${errorCode}, errorMsg="${errorMsg}", errorData=${JSON.stringify(errorData)}`);
+      
+      const isWorkspaceRequired = errorCode === 'WORKSPACE_REQUIRED' ||
+                                  errorData.code === 'WORKSPACE_REQUIRED' || 
+                                  errorMsg.includes('Multiple workspaces available') ||
+                                  errorMsg.includes('Specify workspace') ||
+                                  errorMsg.includes('workspace selection') ||
+                                  errorMsg.includes('workspace slug') ||
+                                  errorMsg.includes('workspaceId') ||
+                                  errorMsg.includes('workspaceAlias');
+      
+      if (isWorkspaceRequired) {
+        // Get tool name from request
+        const toolName = request.params?.name;
+        
+        log(LOG_LEVELS.DEBUG, `Detected WORKSPACE_REQUIRED for tool: ${toolName}`);
+        
+        // Special handling for tools that should work without workspace
+        if (toolName === 'list_workspaces') {
+          // For this tool, backend should not require workspace
+          // Log the actual backend error for debugging
+          log(LOG_LEVELS.WARN, `Backend returned workspace requirement for ${toolName} tool. Backend error: ${errorMsg}`);
+          const message = `Backend requires workspace selection even for ${toolName}. This may indicate a backend configuration issue. Backend error: ${errorMsg}`;
+          sendError(request.id, JSON_RPC_ERROR_CODES.SERVER_ERROR, message, {
+            code: 'WORKSPACE_REQUIRED',
+            hint: 'This tool should work without workspace. Please contact support or check backend configuration.',
+            backendError: errorMsg,
+            backendCode: errorCode
+          });
+          return;
+        }
+        
+        const message = 'Multiple workspaces available. Use list_workspaces tool to get list, then use set_workspace to set default workspace, or specify workspaceAlias or workspaceId parameter in tool call.';
+        sendError(request.id, JSON_RPC_ERROR_CODES.SERVER_ERROR, message, {
+          code: 'WORKSPACE_REQUIRED',
+          hint: 'Use list_workspaces tool to get available workspaces, then use set_workspace to set default, or specify workspaceAlias or workspaceId in tool call.'
+        });
+        return;
+      }
+      
+      // Check for AUTH_REQUIRED
+      if (errorCode === 'AUTH_REQUIRED' || errorData.code === 'AUTH_REQUIRED') {
+        const message = 'Authentication required. Run: npx @meldoc/mcp@latest auth login';
+        sendError(request.id, CUSTOM_ERROR_CODES.AUTH_REQUIRED, message, {
+          code: 'AUTH_REQUIRED',
+          hint: 'Use auth_login_instructions tool to get login command'
+        });
+        return;
+      }
+      
+      // Forward the error as-is, but ensure JSON-RPC format
+      // If response is already in JSON-RPC format, forward it
+      if (responseData.jsonrpc && responseData.error) {
+        process.stdout.write(JSON.stringify(responseData) + '\n');
+        if (process.stdout.isTTY) {
+          process.stdout.flush();
+        }
+      } else {
+        // Convert to JSON-RPC format
+        sendError(request.id, JSON_RPC_ERROR_CODES.SERVER_ERROR, errorMessage, {
+          status: response.status,
+          code: errorCode,
+          details: errorData
+        });
+      }
     }
   } catch (error) {
     // Handle different types of errors
@@ -421,10 +1075,48 @@ async function processSingleRequest(request) {
         errorCode = CUSTOM_ERROR_CODES.RATE_LIMIT;
       }
       
+      // Check for WORKSPACE_REQUIRED
+      const errorDataCode = errorData?.error?.code || errorData?.code;
+      const errorMsgText = errorData?.error?.message || errorData?.message || errorMessage || '';
+      const isWorkspaceRequired = errorDataCode === 'WORKSPACE_REQUIRED' || 
+                                  errorMsgText.includes('Multiple workspaces available');
+      
+      if (isWorkspaceRequired) {
+        // Get tool name from request
+        const toolName = request.params?.name;
+        
+        // Special handling for tools that should work without workspace
+        if (toolName === 'list_workspaces') {
+          const message = `Backend requires workspace selection even for ${toolName}. Please set a default workspace using set_workspace tool first, or contact support if this persists.`;
+          sendError(request.id, JSON_RPC_ERROR_CODES.SERVER_ERROR, message, {
+            code: 'WORKSPACE_REQUIRED',
+            hint: 'Try setting a default workspace first using set_workspace tool, or specify workspaceAlias/workspaceId in the tool call arguments.'
+          });
+          return;
+        }
+        
+        const message = 'Multiple workspaces available. Use list_workspaces tool to get list, then use set_workspace to set default workspace, or specify workspaceAlias or workspaceId parameter in tool call.';
+        sendError(request.id, JSON_RPC_ERROR_CODES.SERVER_ERROR, message, {
+          code: 'WORKSPACE_REQUIRED',
+          hint: 'Use list_workspaces tool to get available workspaces, then use set_workspace to set default, or specify workspaceAlias or workspaceId in tool call.'
+        });
+        return;
+      }
+      
+      // Check for AUTH_REQUIRED
+      if (errorDataCode === 'AUTH_REQUIRED') {
+        const message = 'Authentication required. Run: npx @meldoc/mcp@latest auth login';
+        sendError(request.id, CUSTOM_ERROR_CODES.AUTH_REQUIRED, message, {
+          code: 'AUTH_REQUIRED',
+          hint: 'Use auth_login_instructions tool to get login command'
+        });
+        return;
+      }
+      
       log(LOG_LEVELS.WARN, `HTTP error ${status}: ${errorMessage}`);
       sendError(request.id, errorCode, errorMessage, {
         status,
-        code: errorData?.error?.code || `HTTP_${status}`
+        code: errorData?.error?.code || errorDataCode || `HTTP_${status}`
       });
     } else if (error.request) {
       // Request was made but no response received
@@ -443,6 +1135,7 @@ async function processSingleRequest(request) {
     } else {
       // Other errors
       log(LOG_LEVELS.ERROR, `Internal error: ${error.message || 'Unknown error'}`);
+      log(LOG_LEVELS.DEBUG, `Error stack: ${error.stack || 'No stack trace'}`);
       sendError(request.id, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, 
                 `Internal error: ${error.message || 'Unknown error'}`, {
                   code: 'INTERNAL_ERROR'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meldocio/mcp-stdio-proxy",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "MCP stdio proxy for meldoc - connects Claude Desktop to meldoc MCP API",
   "bin": {
     "meldoc-mcp": "bin/meldoc-mcp-proxy.js"