purmemo-mcp 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "purmemo-mcp",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Official Model Context Protocol (MCP) server for Purmemo - Seamless OAuth authentication for your AI-powered second brain",
   "main": "src/server-oauth.js",
   "type": "module",

package/src/auth/oauth-manager.js

@@ -6,8 +6,13 @@
 import crypto from 'crypto';
 import express from 'express';
 import open from 'open';
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
 import TokenStore from './token-store.js';
 
+const execAsync = promisify(exec);
+
 class OAuthManager {
   constructor(config = {}) {
     this.apiUrl = config.apiUrl || process.env.PUO_MEMO_API_URL || 'https://api.purmemo.ai';
@@ -16,6 +21,142 @@ class OAuthManager {
     this.tokenStore = new TokenStore();
     this.server = null;
     this.pendingAuth = null;
+    this.platform = os.platform();
+  }
+
+  /**
+   * Robust browser opening with multiple fallback strategies
+   * Handles macOS security restrictions and provides user-friendly alternatives
+   */
+  async openBrowserRobustly(url) {
+    console.log(`🌐 Opening OAuth URL...`);
+    
+    const strategies = [
+      () => this.tryOpenPackage(url),
+      () => this.tryDirectCommand(url),
+      () => this.tryAlternativeCommands(url),
+      () => this.tryAppleScript(url),
+      () => this.provideFallbackInstructions(url)
+    ];
+
+    for (let i = 0; i < strategies.length; i++) {
+      try {
+        const result = await strategies[i]();
+        
+        if (result.success) {
+          if (result.requiresManualAction) {
+            // User needs to manually open the URL
+            return { opened: false, manualRequired: true, url };
+          }
+          console.log(`✅ Browser opened successfully`);
+          return { opened: true, manualRequired: false };
+        }
+      } catch (error) {
+        console.log(`Strategy ${i + 1} failed, trying next...`);
+      }
+    }
+
+    return { opened: false, manualRequired: true, url };
+  }
+
+  async tryOpenPackage(url) {
+    try {
+      await open(url, { wait: false });
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      return { success: true };
+    } catch (error) {
+      throw new Error(`open package failed: ${error.message}`);
+    }
+  }
+
+  async tryDirectCommand(url) {
+    try {
+      let command;
+      
+      switch (this.platform) {
+        case 'darwin':
+          command = `open "${url}"`;
+          break;
+        case 'win32':
+          command = `start "" "${url}"`;
+          break;
+        default:
+          command = `xdg-open "${url}"`;
+      }
+
+      await execAsync(command);
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      return { success: true };
+    } catch (error) {
+      throw new Error(`direct command failed: ${error.message}`);
+    }
+  }
+
+  async tryAlternativeCommands(url) {
+    if (this.platform !== 'darwin') {
+      throw new Error('Not macOS');
+    }
+
+    const commands = [
+      `open -a Safari "${url}"`,
+      `open -a "Google Chrome" "${url}"`,
+      `open -a Firefox "${url}"`,
+      `/usr/bin/open "${url}"`
+    ];
+
+    for (const command of commands) {
+      try {
+        await execAsync(command);
+        await new Promise(resolve => setTimeout(resolve, 500));
+        return { success: true };
+      } catch (error) {
+        continue;
+      }
+    }
+    
+    throw new Error('All alternative commands failed');
+  }
+
+  async tryAppleScript(url) {
+    if (this.platform !== 'darwin') {
+      throw new Error('Not macOS');
+    }
+
+    try {
+      const script = `tell application "Safari" to open location "${url}"`;
+      await execAsync(`osascript -e '${script}'`);
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      return { success: true };
+    } catch (error) {
+      throw new Error(`AppleScript failed: ${error.message}`);
+    }
+  }
+
+  async provideFallbackInstructions(url) {
+    console.log('\n' + '━'.repeat(60));
+    console.log('🚨 BROWSER OPENING BLOCKED BY SECURITY');
+    console.log('━'.repeat(60));
+    console.log('');
+    console.log('Please manually copy and paste this URL into your browser:');
+    console.log('');
+    console.log('📋 COPY THIS URL:');
+    console.log('⬇'.repeat(40));
+    console.log(url);
+    console.log('⬆'.repeat(40));
+    console.log('');
+    console.log('📱 QUICK STEPS:');
+    console.log('1. Copy the URL above');
+    console.log('2. Open your browser');
+    console.log('3. Paste and press Enter');
+    console.log('4. Sign in with Google/GitHub');
+    console.log('');
+    console.log('⏰ Waiting for OAuth callback...');
+    console.log('━'.repeat(60));
+
+    return { 
+      success: true, 
+      requiresManualAction: true 
+    };
   }
 
   /**
@@ -106,12 +247,13 @@ class OAuthManager {
     // Start local server for callback
     const authCode = await this.startCallbackServer(state);
     
-    // Open browser for authentication
-    console.log('📱 Opening browser for authentication...');
-    console.log('   If browser doesn\'t open, visit:');
-    console.log(`   ${authUrl.toString()}\n`);
+    // Open browser for authentication with robust fallback
+    const browserResult = await this.openBrowserRobustly(authUrl.toString());
     
-    await open(authUrl.toString());
+    if (!browserResult.opened && browserResult.manualRequired) {
+      // The robust method already displayed instructions
+      console.log(''); // Just add some spacing
+    }
 
     // Wait for callback with auth code
     const code = await authCode;

package/src/server-oauth.js

@@ -364,11 +364,41 @@ async function initialize() {
   console.log('Ready to serve MCP requests\n');
 }
 
-// Start server
-initialize().then(() => {
-  const transport = new StdioServerTransport();
-  server.connect(transport);
+// Handle CLI commands if provided
+async function handleCliCommands() {
+  const args = process.argv.slice(2);
+  if (args.length > 0) {
+    const command = args[0];
+    
+    if (command === 'setup' || command === 'status' || command === 'logout' || command === 'upgrade') {
+      // Delegate to setup script for CLI commands
+      const { execSync } = await import('child_process');
+      const setupPath = new URL('./setup.js', import.meta.url).pathname;
+      
+      try {
+        execSync(`node "${setupPath}" ${args.join(' ')}`, { 
+          stdio: 'inherit',
+          cwd: process.cwd()
+        });
+        process.exit(0);
+      } catch (error) {
+        process.exit(error.status || 1);
+      }
+    }
+  }
+}
+
+// Start server or handle CLI commands
+handleCliCommands().then(() => {
+  // If we get here, it's not a CLI command, so start the MCP server
+  initialize().then(() => {
+    const transport = new StdioServerTransport();
+    server.connect(transport);
+  }).catch(error => {
+    console.error('Failed to initialize:', error);
+    process.exit(1);
+  });
 }).catch(error => {
-  console.error('Failed to initialize:', error);
+  console.error('Failed to handle CLI commands:', error);
   process.exit(1);
 });