@meldocio/mcp-stdio-proxy 1.0.7 → 1.0.10

package/lib/auth.js

@@ -0,0 +1,142 @@
+const axios = require('axios');
+const https = require('https');
+const { readCredentials, writeCredentials, isTokenExpiredOrExpiringSoon, isTokenExpired } = require('./credentials');
+const { getApiUrl } = require('./constants');
+
+/**
+ * Get access token with priority:
+ * 1. MELDOC_ACCESS_TOKEN (environment variable)
+ * 2. credentials.json (user session, with refresh if needed)
+ * 3. MELDOC_MCP_TOKEN (integration token)
+ * @returns {Promise<{token: string, type: 'env'|'user_session'|'integration'|null}>}
+ */
+async function getAccessToken() {
+  // Priority 1: MELDOC_ACCESS_TOKEN environment variable
+  if (process.env.MELDOC_ACCESS_TOKEN) {
+    return {
+      token: process.env.MELDOC_ACCESS_TOKEN,
+      type: 'env'
+    };
+  }
+  
+  // Priority 2: credentials.json (user session)
+  const credentials = readCredentials();
+  if (credentials && credentials.type === 'user_session') {
+    // Check if token needs refresh
+    if (isTokenExpiredOrExpiringSoon(credentials)) {
+      try {
+        const refreshed = await refreshToken(credentials);
+        if (refreshed) {
+          return {
+            token: refreshed.tokens.accessToken,
+            type: 'user_session'
+          };
+        }
+      } catch (error) {
+        // Refresh failed - credentials might be invalid
+        // Return null to fall back to next priority
+      }
+    } else {
+      return {
+        token: credentials.tokens.accessToken,
+        type: 'user_session'
+      };
+    }
+  }
+  
+  // Priority 3: MELDOC_MCP_TOKEN (integration token)
+  if (process.env.MELDOC_MCP_TOKEN) {
+    return {
+      token: process.env.MELDOC_MCP_TOKEN,
+      type: 'integration'
+    };
+  }
+  
+  // No token found
+  return null;
+}
+
+/**
+ * Refresh access token using refresh token
+ * @param {Object} credentials - Current credentials object
+ * @returns {Promise<Object|null>} Updated credentials or null if refresh failed
+ */
+async function refreshToken(credentials) {
+  if (!credentials || !credentials.tokens || !credentials.tokens.refreshToken) {
+    return null;
+  }
+  
+  const apiBaseUrl = credentials.apiBaseUrl || getApiUrl();
+  
+  try {
+    const response = await axios.post(`${apiBaseUrl}/api/auth/refresh`, {
+      refreshToken: credentials.tokens.refreshToken
+    }, {
+      timeout: 10000,
+      httpsAgent: new https.Agent({ keepAlive: true })
+    });
+    
+    // Update credentials with new tokens
+    const updatedCredentials = {
+      ...credentials,
+      tokens: {
+        accessToken: response.data.accessToken,
+        accessExpiresAt: response.data.expiresAt,
+        refreshToken: response.data.refreshToken || credentials.tokens.refreshToken
+      },
+      updatedAt: new Date().toISOString()
+    };
+    
+    writeCredentials(updatedCredentials);
+    return updatedCredentials;
+  } catch (error) {
+    // Refresh failed - delete credentials
+    const { deleteCredentials } = require('./credentials');
+    deleteCredentials();
+    return null;
+  }
+}
+
+/**
+ * Check if user is authenticated
+ * @returns {Promise<boolean>} True if authenticated
+ */
+async function isAuthenticated() {
+  const tokenInfo = await getAccessToken();
+  return tokenInfo !== null;
+}
+
+/**
+ * Get auth status information
+ * @returns {Promise<Object|null>} Auth status with user info or null if not authenticated
+ */
+async function getAuthStatus() {
+  const tokenInfo = await getAccessToken();
+  if (!tokenInfo) {
+    return null;
+  }
+  
+  if (tokenInfo.type === 'user_session') {
+    const credentials = readCredentials();
+    if (credentials && credentials.user) {
+      return {
+        authenticated: true,
+        type: 'user_session',
+        user: credentials.user,
+        expiresAt: credentials.tokens?.accessExpiresAt || null
+      };
+    }
+  }
+  
+  return {
+    authenticated: true,
+    type: tokenInfo.type
+  };
+}
+
+module.exports = {
+  getAccessToken,
+  refreshToken,
+  isAuthenticated,
+  getAuthStatus
+};

package/lib/config.js

@@ -0,0 +1,68 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_PATH = path.join(os.homedir(), '.meldoc', 'config.json');
+
+/**
+ * Read config from ~/.meldoc/config.json
+ * @returns {Object|null} Config object or null if file doesn't exist
+ */
+function readConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return null;
+    }
+    const content = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Write config to ~/.meldoc/config.json
+ * Sets file permissions to 0644 (read for all, write for owner)
+ * @param {Object} config - Config object
+ */
+function writeConfig(config) {
+  const dir = path.dirname(CONFIG_PATH);
+  
+  // Create .meldoc directory if it doesn't exist
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+  
+  // Write config file
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', {
+    encoding: 'utf8',
+    mode: 0o644 // 0644 - read for all, write for owner
+  });
+}
+
+/**
+ * Get workspace alias from config
+ * @returns {string|null} Workspace alias or null
+ */
+function getWorkspaceAlias() {
+  const config = readConfig();
+  return config?.workspaceAlias || null;
+}
+
+/**
+ * Set workspace alias in config
+ * @param {string} alias - Workspace alias
+ */
+function setWorkspaceAlias(alias) {
+  const config = readConfig() || {};
+  config.workspaceAlias = alias;
+  writeConfig(config);
+}
+
+module.exports = {
+  readConfig,
+  writeConfig,
+  getWorkspaceAlias,
+  setWorkspaceAlias,
+  CONFIG_PATH
+};

package/lib/constants.js

@@ -0,0 +1,31 @@
+/**
+ * Default configuration constants
+ * Production values used when environment variables are not set
+ */
+
+// Production API URL
+const DEFAULT_API_URL = 'https://api.meldoc.io';
+
+// Production App URL (frontend)
+const DEFAULT_APP_URL = 'https://app.meldoc.io';
+
+/**
+ * Get API URL from environment or use production default
+ */
+function getApiUrl() {
+  return process.env.MELDOC_API_URL || DEFAULT_API_URL;
+}
+
+/**
+ * Get App URL from environment or use production default
+ */
+function getAppUrl() {
+  return process.env.MELDOC_APP_URL || DEFAULT_APP_URL;
+}
+
+module.exports = {
+  DEFAULT_API_URL,
+  DEFAULT_APP_URL,
+  getApiUrl,
+  getAppUrl
+};

package/lib/credentials.js

@@ -0,0 +1,96 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CREDENTIALS_PATH = path.join(os.homedir(), '.meldoc', 'credentials.json');
+
+/**
+ * Read credentials from ~/.meldoc/credentials.json
+ * @returns {Object|null} Credentials object or null if file doesn't exist
+ */
+function readCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_PATH)) {
+      return null;
+    }
+    const content = fs.readFileSync(CREDENTIALS_PATH, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Write credentials to ~/.meldoc/credentials.json
+ * Sets file permissions to 0600 (read/write only for owner)
+ * @param {Object} credentials - Credentials object
+ */
+function writeCredentials(credentials) {
+  const dir = path.dirname(CREDENTIALS_PATH);
+  
+  // Create .meldoc directory if it doesn't exist
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+  
+  // Write credentials file
+  fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2) + '\n', {
+    encoding: 'utf8',
+    mode: 0o600 // 0600 - read/write only for owner
+  });
+}
+
+/**
+ * Delete credentials file
+ */
+function deleteCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_PATH)) {
+      fs.unlinkSync(CREDENTIALS_PATH);
+    }
+  } catch (error) {
+    // Ignore errors
+  }
+}
+
+/**
+ * Check if access token is expired or expires soon (within 5 minutes)
+ * @param {Object} credentials - Credentials object
+ * @returns {boolean} True if token is expired or expires soon
+ */
+function isTokenExpiredOrExpiringSoon(credentials) {
+  if (!credentials || !credentials.tokens || !credentials.tokens.accessExpiresAt) {
+    return true;
+  }
+  
+  const expiresAt = new Date(credentials.tokens.accessExpiresAt);
+  const now = new Date();
+  const fiveMinutes = 5 * 60 * 1000; // 5 minutes in milliseconds
+  
+  return expiresAt.getTime() <= (now.getTime() + fiveMinutes);
+}
+
+/**
+ * Check if access token is expired
+ * @param {Object} credentials - Credentials object
+ * @returns {boolean} True if token is expired
+ */
+function isTokenExpired(credentials) {
+  if (!credentials || !credentials.tokens || !credentials.tokens.accessExpiresAt) {
+    return true;
+  }
+  
+  const expiresAt = new Date(credentials.tokens.accessExpiresAt);
+  const now = new Date();
+  
+  return expiresAt.getTime() <= now.getTime();
+}
+
+module.exports = {
+  readCredentials,
+  writeCredentials,
+  deleteCredentials,
+  isTokenExpiredOrExpiringSoon,
+  isTokenExpired,
+  CREDENTIALS_PATH
+};

package/lib/device-flow.js

@@ -0,0 +1,263 @@
+const axios = require('axios');
+const https = require('https');
+const { writeCredentials } = require('./credentials');
+const { getApiUrl, getAppUrl } = require('./constants');
+const logger = require('./logger');
+
+/**
+ * Start device flow authentication
+ * @param {string} apiBaseUrl - API base URL
+ * @returns {Promise<Object>} Device flow response with deviceCode, userCode, verificationUrl, expiresIn, interval
+ */
+async function startDeviceFlow(apiBaseUrl = null) {
+  const url = apiBaseUrl || getApiUrl();
+  try {
+    // Server may expect snake_case, but we'll send camelCase and let server handle it
+    const response = await axios.post(`${url}/api/auth/device/start`, {
+      client: 'mcp-stdio-proxy',
+      client_version: '1.0.0'
+    }, {
+      timeout: 10000,
+      httpsAgent: new https.Agent({ keepAlive: true })
+    });
+    
+    const data = response.data;
+    
+    // Normalize response: support both camelCase and snake_case
+    const normalized = {
+      deviceCode: data.deviceCode || data.device_code,
+      userCode: data.userCode || data.user_code,
+      verificationUrl: data.verificationUrl || data.verification_url,
+      expiresIn: data.expiresIn || data.expires_in,
+      interval: data.interval
+    };
+    
+    // Validate response
+    if (!normalized.deviceCode || !normalized.userCode || !normalized.verificationUrl) {
+      throw new Error(`Invalid response from server: missing required fields. Response: ${JSON.stringify(data)}`);
+    }
+    
+    if (!normalized.expiresIn || !normalized.interval) {
+      throw new Error(`Invalid response from server: missing expiresIn or interval. Response: ${JSON.stringify(data)}`);
+    }
+    
+    return normalized;
+  } catch (error) {
+    if (error.response) {
+      // Server responded with error status
+      const status = error.response.status;
+      const errorData = error.response.data;
+      const errorMessage = errorData?.error?.message || errorData?.message || `HTTP ${status}: ${error.response.statusText}`;
+      throw new Error(`Device flow start failed: ${errorMessage}`);
+    } else if (error.request) {
+      // Request was made but no response received
+      throw new Error(`Device flow start failed: No response from server at ${url}`);
+    } else {
+      // Other errors
+      throw new Error(`Device flow start failed: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Poll device flow for approval
+ * @param {string} deviceCode - Device code from startDeviceFlow
+ * @param {string} apiBaseUrl - API base URL
+ * @returns {Promise<Object>} Poll response with status and tokens if approved
+ */
+async function pollDeviceFlow(deviceCode, apiBaseUrl = null) {
+  const url = apiBaseUrl || getApiUrl();
+  try {
+    // Server expects snake_case: device_code
+    const response = await axios.post(`${url}/api/auth/device/poll`, {
+      device_code: deviceCode
+    }, {
+      timeout: 10000,
+      httpsAgent: new https.Agent({ keepAlive: true })
+    });
+    
+    const data = response.data;
+    
+    // Debug logging - only log if LOG_LEVEL is DEBUG
+    if (process.env.LOG_LEVEL === 'DEBUG') {
+      logger.debug(`Poll response keys: ${Object.keys(data).join(', ')}`);
+      logger.debug(`Poll response: ${JSON.stringify(data, null, 2)}`);
+    }
+    
+    // Validate response has status field
+    if (!data.status) {
+      throw new Error(`Invalid poll response: missing status field. Response: ${JSON.stringify(data)}`);
+    }
+    
+    // Check if data is nested in auth_response (server format)
+    const authData = data.auth_response || data.authResponse || data;
+    
+    // refresh_token can be in root or in auth_response
+    const refreshToken = data.refresh_token || data.refreshToken || 
+                        authData.refreshToken || authData.refresh_token || null;
+    
+    // Normalize response: support both camelCase and snake_case
+    // Check all possible field name variations
+    const normalized = {
+      status: data.status,
+      accessToken: authData.accessToken || authData.access_token || null,
+      expiresAt: authData.expiresAt || authData.expires_at || null,
+      refreshToken: refreshToken,
+      user: authData.user || null
+    };
+    
+    // Debug logging - only log if LOG_LEVEL is DEBUG
+    if (process.env.LOG_LEVEL === 'DEBUG') {
+      logger.debug(`Normalized response: ${JSON.stringify({
+        ...normalized,
+        accessToken: normalized.accessToken ? '[REDACTED]' : null
+      }, null, 2)}`);
+    }
+    
+    // Validate normalized response for approved status
+    if (normalized.status === 'approved' && !normalized.accessToken) {
+      throw new Error(`Invalid approved response: missing accessToken. Raw response: ${JSON.stringify(data)}, Normalized: ${JSON.stringify(normalized)}`);
+    }
+    
+    return normalized;
+  } catch (error) {
+    if (error.response) {
+      // Server responded with error status
+      const status = error.response.status;
+      const errorData = error.response.data;
+      const errorMessage = errorData?.error?.message || errorData?.message || `HTTP ${status}: ${error.response.statusText}`;
+      throw new Error(`Device flow poll failed: ${errorMessage}`);
+    } else if (error.request) {
+      // Request was made but no response received
+      throw new Error(`Device flow poll failed: No response from server at ${url}`);
+    } else {
+      // Other errors (including our validation errors)
+      throw error;
+    }
+  }
+}
+
+/**
+ * Perform device flow login
+ * @param {Function} onCodeDisplay - Callback to display code to user (url, code)
+ * @param {Function} onStatusChange - Optional callback for status changes
+ * @param {string} apiBaseUrl - API base URL
+ * @returns {Promise<Object>} Credentials object
+ */
+async function deviceFlowLogin(onCodeDisplay, onStatusChange = null, apiBaseUrl = null, appUrl = null) {
+  const url = apiBaseUrl || getApiUrl();
+  const frontendUrl = appUrl || getAppUrl();
+  
+  // Step 1: Start device flow (already normalized in startDeviceFlow)
+  const startResponse = await startDeviceFlow(url);
+  const { deviceCode, userCode, verificationUrl, expiresIn, interval } = startResponse;
+  
+  // Step 2: Display code to user
+  // Use verificationUrl from server, but replace base URL if MELDOC_APP_URL is set
+  let displayUrl = verificationUrl;
+  
+  // Check if verificationUrl already contains code in query parameter
+  let urlHasCode = false;
+  try {
+    const urlObj = new URL(verificationUrl);
+    if (urlObj.searchParams.has('code')) {
+      urlHasCode = true;
+    }
+  } catch (e) {
+    // URL parsing failed, continue
+  }
+  
+  if (process.env.MELDOC_APP_URL || appUrl) {
+    // Replace the base URL in verificationUrl with the configured app URL
+    try {
+      const urlObj = new URL(verificationUrl);
+      const appUrlObj = new URL(frontendUrl);
+      // Keep the path and query from verificationUrl, but use app URL origin
+      displayUrl = `${appUrlObj.origin}${urlObj.pathname}${urlObj.search}`;
+    } catch (e) {
+      // If URL parsing fails, use verificationUrl as is
+      displayUrl = verificationUrl;
+    }
+  }
+  
+  // If URL doesn't have code, add it as path parameter
+  let fullUrl = displayUrl;
+  if (!urlHasCode) {
+    // Add code as path parameter (format: /device/CODE)
+    if (displayUrl.endsWith('/')) {
+      fullUrl = `${displayUrl}${userCode}`;
+    } else {
+      fullUrl = `${displayUrl}/${userCode}`;
+    }
+  }
+  
+  onCodeDisplay(fullUrl, userCode);
+  
+  // Step 3: Poll for approval
+  const startTime = Date.now();
+  const expiresAt = startTime + (expiresIn * 1000);
+  
+  while (Date.now() < expiresAt) {
+    await new Promise(resolve => setTimeout(resolve, interval * 1000));
+    
+    const pollResponse = await pollDeviceFlow(deviceCode, url);
+    
+    if (pollResponse.status === 'approved') {
+      // Validate that we have required fields
+      if (!pollResponse.accessToken) {
+        throw new Error(`Invalid poll response: missing accessToken. Response: ${JSON.stringify(pollResponse)}`);
+      }
+      
+      // Step 4: Save credentials
+      // Note: refreshToken is optional - if server doesn't provide it, auto-refresh won't work
+      const credentials = {
+        type: 'user_session',
+        apiBaseUrl: url,
+        user: pollResponse.user,
+        tokens: {
+          accessToken: pollResponse.accessToken,
+          accessExpiresAt: pollResponse.expiresAt || new Date(Date.now() + 3600000).toISOString(), // Default 1 hour if missing
+          refreshToken: pollResponse.refreshToken || null // Optional - server may not provide refreshToken
+        },
+        updatedAt: new Date().toISOString()
+      };
+      
+      // Note: refreshToken is optional, but if provided, auto-refresh will work
+      
+      // Debug logging
+      if (process.env.LOG_LEVEL === 'DEBUG') {
+        logger.debug(`Saving credentials: ${JSON.stringify({
+          ...credentials,
+          tokens: { ...credentials.tokens, accessToken: credentials.tokens.accessToken ? '[REDACTED]' : null }
+        }, null, 2)}`);
+      }
+      
+      writeCredentials(credentials);
+      
+      if (onStatusChange) {
+        onStatusChange('approved');
+      }
+      
+      return credentials;
+    } else if (pollResponse.status === 'denied') {
+      if (onStatusChange) {
+        onStatusChange('denied');
+      }
+      throw new Error('Login denied by user');
+    } else if (pollResponse.status === 'expired') {
+      if (onStatusChange) {
+        onStatusChange('expired');
+      }
+      throw new Error('Device code expired');
+    }
+    // status === 'pending' - continue polling
+  }
+  
+  throw new Error('Device code expired');
+}
+
+module.exports = {
+  startDeviceFlow,
+  pollDeviceFlow,
+  deviceFlowLogin
+};

package/lib/logger.js

@@ -0,0 +1,105 @@
+const chalk = require('chalk');
+
+/**
+ * Beautiful console logger with colors and emojis
+ */
+const logger = {
+  /**
+   * Success message (green)
+   */
+  success: (message) => {
+    console.log(chalk.green('✓'), chalk.greenBright(message));
+  },
+
+  /**
+   * Error message (red)
+   */
+  error: (message) => {
+    console.error(chalk.red('✗'), chalk.redBright(message));
+  },
+
+  /**
+   * Warning message (yellow)
+   */
+  warn: (message) => {
+    console.warn(chalk.yellow('⚠'), chalk.yellowBright(message));
+  },
+
+  /**
+   * Info message (blue)
+   */
+  info: (message) => {
+    console.log(chalk.blue('ℹ'), chalk.blueBright(message));
+  },
+
+  /**
+   * Debug message (gray)
+   */
+  debug: (message) => {
+    console.error(chalk.gray('🔍'), chalk.gray(message));
+  },
+
+  /**
+   * Log message with custom prefix
+   */
+  log: (message) => {
+    console.log(message);
+  },
+
+  /**
+   * Highlighted text (cyan)
+   */
+  highlight: (text) => {
+    return chalk.cyan.bold(text);
+  },
+
+  /**
+   * URL formatting
+   */
+  url: (url) => {
+    return chalk.cyan.underline(url);
+  },
+
+  /**
+   * Code formatting
+   */
+  code: (code) => {
+    return chalk.bgGray.white.bold(` ${code} `);
+  },
+
+  /**
+   * Label formatting
+   */
+  label: (label) => {
+    return chalk.gray(label);
+  },
+
+  /**
+   * Value formatting
+   */
+  value: (value) => {
+    return chalk.white.bold(value);
+  },
+
+  /**
+   * Section header
+   */
+  section: (title) => {
+    console.log('\n' + chalk.bold.cyan('━'.repeat(50)));
+    console.log(chalk.bold.cyan('  ' + title));
+    console.log(chalk.bold.cyan('━'.repeat(50)) + '\n');
+  },
+
+  /**
+   * List item
+   */
+  item: (text, value = null) => {
+    if (value !== null) {
+      console.log(chalk.gray('  •'), chalk.white(text), chalk.gray('→'), logger.value(value));
+    } else {
+      console.log(chalk.gray('  •'), chalk.white(text));
+    }
+  }
+};
+
+module.exports = logger;

package/lib/workspace.js

@@ -0,0 +1,76 @@
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const { getWorkspaceAlias: getConfigWorkspaceAlias } = require('./config');
+
+/**
+ * Find .meldoc.yml file in current directory or parent directories
+ * @param {string} startDir - Starting directory
+ * @returns {string|null} Path to .meldoc.yml or null if not found
+ */
+function findRepoConfig(startDir = process.cwd()) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  
+  while (currentDir !== root) {
+    const configPath = path.join(currentDir, '.meldoc.yml');
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  
+  return null;
+}
+
+/**
+ * Read workspace alias from .meldoc.yml
+ * @param {string} configPath - Path to .meldoc.yml
+ * @returns {string|null} Workspace alias or null
+ */
+function readRepoConfig(configPath) {
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    const config = yaml.load(content);
+    return config?.context?.workspace || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Resolve workspace alias for request
+ * Priority:
+ * 1. Repo config (.meldoc.yml) - optional, can be skipped
+ * 2. Global config (~/.meldoc/config.json)
+ * 3. No header (let server choose automatically)
+ * @param {boolean} useRepoConfig - Whether to check repo config (optional)
+ * @returns {string|null} Workspace alias or null
+ */
+function resolveWorkspaceAlias(useRepoConfig = true) {
+  // Step 1: Repo config (optional)
+  if (useRepoConfig) {
+    const repoConfigPath = findRepoConfig();
+    if (repoConfigPath) {
+      const repoWorkspace = readRepoConfig(repoConfigPath);
+      if (repoWorkspace) {
+        return repoWorkspace;
+      }
+    }
+  }
+  
+  // Step 2: Global config
+  const configWorkspace = getConfigWorkspaceAlias();
+  if (configWorkspace) {
+    return configWorkspace;
+  }
+  
+  // Step 3: No workspace alias
+  return null;
+}
+
+module.exports = {
+  findRepoConfig,
+  readRepoConfig,
+  resolveWorkspaceAlias
+};

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@meldocio/mcp-stdio-proxy",
-  "version": "1.0.7",
+  "version": "1.0.10",
   "description": "MCP stdio proxy for meldoc - connects Claude Desktop to meldoc MCP API",
   "bin": {
     "meldoc-mcp": "bin/meldoc-mcp-proxy.js"
   },
   "files": [
     "bin/**",
+    "lib/**",
     "README.md",
     "LICENSE"
   ],
@@ -32,6 +33,8 @@
   },
   "homepage": "https://github.com/meldoc/mcp-stdio-proxy#readme",
   "dependencies": {
-    "axios": "^1.6.0"
+    "axios": "^1.6.0",
+    "chalk": "^4.1.2",
+    "js-yaml": "^4.1.1"
   }
 }