@wonderwhy-er/desktop-commander 0.2.37 → 0.2.39

package/dist/index-oauth.js

@@ -1,201 +0,0 @@
-#!/usr/bin/env node
-import { FilteredStdioServerTransport } from './custom-stdio.js';
-import { server } from './server.js';
-import { configManager } from './config-manager.js';
-import { runSetup } from './npm-scripts/setup.js';
-import { runUninstall } from './npm-scripts/uninstall.js';
-import { capture } from './utils/capture.js';
-import { logToStderr, logger } from './utils/logger.js';
-import { OAuthHttpServer } from './oauth/server.js';
-async function runServer() {
-    try {
-        // Check if first argument is "setup"
-        if (process.argv[2] === 'setup') {
-            await runSetup();
-            return;
-        }
-        // Check if first argument is "remove"
-        if (process.argv[2] === 'remove') {
-            await runUninstall();
-            return;
-        }
-        // Check for HTTP mode with OAuth
-        const httpMode = process.argv.includes('--http') || process.argv.includes('--oauth');
-        const port = getPortFromArgs() || 8000;
-        if (httpMode) {
-            await runHttpServer(port);
-        }
-        else {
-            await runStdioServer();
-        }
-    }
-    catch (error) {
-        logger.error('Failed to start server:', error);
-        process.exit(1);
-    }
-}
-async function runStdioServer() {
-    logger.info('Loading server.ts');
-    logger.info('Setting up request handlers...');
-    try {
-        logger.info('Loading configuration...');
-        await configManager.loadConfig();
-        logger.info('Configuration loaded successfully');
-        const transport = new FilteredStdioServerTransport();
-        logger.info('Enhanced FilteredStdioServerTransport initialized');
-        logger.info('Connecting server...');
-        await server.connect(transport);
-        logger.info('Server connected successfully');
-    }
-    catch (error) {
-        await capture('error_start_stdio_server', { error });
-        logToStderr('error', `Failed to start stdio server: ${error}`);
-        throw error;
-    }
-}
-async function runHttpServer(port) {
-    logger.info(`Starting HTTP server with OAuth on port ${port}`);
-    try {
-        logger.info('Loading configuration...');
-        await configManager.loadConfig();
-        logger.info('Configuration loaded successfully');
-        // OAuth configuration
-        const baseUrl = `http://localhost:${port}`;
-        const oauthConfig = {
-            enabled: true,
-            clientId: 'desktop-commander-mcp',
-            clientSecret: 'dc-secret-' + Math.random().toString(36).substring(7),
-            redirectUri: `${baseUrl}/callback`,
-            authorizationUrl: `${baseUrl}/authorize`,
-            tokenUrl: `${baseUrl}/token`,
-            scope: 'mcp:access mcp:tools mcp:resources',
-            issuer: baseUrl
-        };
-        // Create MCP handler for HTTP requests
-        const mcpHandler = createMcpHttpHandler();
-        // Create OAuth HTTP server
-        const oauthServer = new OAuthHttpServer(oauthConfig, mcpHandler);
-        oauthServer.listen(port, () => {
-            logger.info(`HTTP server running on port ${port}`);
-            logger.info(`Authorization Server Metadata: ${baseUrl}/.well-known/oauth-authorization-server`);
-            logger.info(`MCP Endpoint: ${baseUrl}/mcp`);
-            logger.info(`SSE Endpoint: ${baseUrl}/sse`);
-            console.log(`\n🚀 DesktopCommanderMCP HTTP Server Started!`);
-            console.log(`📍 Server URL: ${baseUrl}`);
-            console.log(`🔐 OAuth Metadata: ${baseUrl}/.well-known/oauth-authorization-server`);
-            console.log(`🔧 MCP Endpoint: ${baseUrl}/mcp`);
-            console.log(`⚡ SSE Endpoint: ${baseUrl}/sse`);
-            console.log(`\n📝 For Claude Custom Connectors:`);
-            console.log(`   URL: ${baseUrl}/sse`);
-            console.log(`   Authentication: OAuth`);
-        });
-        // Graceful shutdown
-        process.on('SIGINT', () => {
-            logger.info('Received SIGINT, shutting down gracefully...');
-            oauthServer.close(() => {
-                process.exit(0);
-            });
-        });
-    }
-    catch (error) {
-        await capture('error_start_http_server', { error });
-        logToStderr('error', `Failed to start HTTP server: ${error}`);
-        throw error;
-    }
-}
-function createMcpHttpHandler() {
-    return (req, res) => {
-        const url = new URL(req.url, `http://${req.headers.host}`);
-        // Handle SSE endpoint for MCP clients
-        if (url.pathname === '/sse') {
-            handleSSE(req, res);
-            return;
-        }
-        // Handle Streamable HTTP endpoint  
-        if (url.pathname === '/mcp') {
-            handleStreamableHttp(req, res);
-            return;
-        }
-        // Health check
-        if (url.pathname === '/health') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ status: 'ok', service: 'DesktopCommanderMCP' }));
-            return;
-        }
-        // 404 for other paths
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Not found' }));
-    };
-}
-function handleSSE(req, res) {
-    // Set SSE headers
-    res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-        'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Headers': 'Cache-Control'
-    });
-    // SSE implementation would go here
-    // For now, just indicate that SSE is available
-    res.write('event: connected\n');
-    res.write('data: {"type":"connected","message":"DesktopCommanderMCP SSE endpoint"}\n\n');
-    // Keep connection alive
-    const heartbeat = setInterval(() => {
-        res.write('event: heartbeat\n');
-        res.write('data: {"type":"heartbeat","timestamp":' + Date.now() + '}\n\n');
-    }, 30000);
-    req.on('close', () => {
-        clearInterval(heartbeat);
-    });
-}
-function handleStreamableHttp(req, res) {
-    // Handle Streamable HTTP for MCP
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    if (req.method === 'GET') {
-        // Return server info
-        res.end(JSON.stringify({
-            name: 'DesktopCommanderMCP',
-            version: '0.2.13',
-            transport: 'streamable-http',
-            authenticated: !!req.user
-        }));
-        return;
-    }
-    // Handle MCP protocol messages
-    if (req.method === 'POST') {
-        let body = '';
-        req.on('data', chunk => body += chunk.toString());
-        req.on('end', () => {
-            try {
-                const message = JSON.parse(body);
-                // Process MCP message through the server
-                // This would need to be integrated with the existing MCP server
-                res.end(JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: message.id,
-                    result: { message: 'MCP message received' }
-                }));
-            }
-            catch (error) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Invalid JSON' }));
-            }
-        });
-        return;
-    }
-    res.writeHead(405, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: 'Method not allowed' }));
-}
-function getPortFromArgs() {
-    const portIndex = process.argv.findIndex(arg => arg === '--port');
-    if (portIndex !== -1 && process.argv[portIndex + 1]) {
-        return parseInt(process.argv[portIndex + 1], 10);
-    }
-    return null;
-}
-// Run the server
-runServer().catch(error => {
-    console.error('Fatal error:', error);
-    process.exit(1);
-});

package/dist/oauth/auth-middleware.d.ts

@@ -1,20 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import { OAuthManager } from './oauth-manager.js';
-declare global {
-    namespace Express {
-        interface Request {
-            auth?: {
-                username: string;
-                client_id: string;
-                scope: string;
-            };
-        }
-    }
-}
-/**
- * Create authentication middleware for MCP endpoints
- *
- * ChatGPT Workaround: Allow unauthenticated tools/list and initialize requests
- * but require auth for actual tool calls
- */
-export declare function createAuthMiddleware(oauthManager: OAuthManager | null, baseUrl: string, requireAuth: boolean): (req: Request, res: Response, next: NextFunction) => Promise<void | Response<any, Record<string, any>>>;

package/dist/oauth/auth-middleware.js

@@ -1,62 +0,0 @@
-/**
- * Create authentication middleware for MCP endpoints
- *
- * ChatGPT Workaround: Allow unauthenticated tools/list and initialize requests
- * but require auth for actual tool calls
- */
-export function createAuthMiddleware(oauthManager, baseUrl, requireAuth) {
-    return async (req, res, next) => {
-        // Skip auth if disabled
-        if (!requireAuth || !oauthManager) {
-            return next();
-        }
-        // CHATGPT WORKAROUND: Allow unauthenticated discovery requests
-        // ChatGPT needs to see tools before authenticating
-        const method = req.body?.method;
-        if (method === 'initialize' || method === 'tools/list') {
-            console.log(`⚠️  Allowing unauthenticated ${method} for ChatGPT compatibility`);
-            return next();
-        }
-        const auth = req.headers.authorization;
-        // Check for Bearer token
-        if (!auth || !auth.startsWith('Bearer ')) {
-            console.log(`❌ Auth failed: No Bearer token provided for ${method}`);
-            return res.status(401)
-                .set('WWW-Authenticate', `Bearer resource_metadata="${baseUrl}/.well-known/oauth-protected-resource"`)
-                .json({
-                jsonrpc: '2.0',
-                error: {
-                    code: -32001,
-                    message: 'Authorization required',
-                    data: 'Bearer token must be provided in Authorization header'
-                },
-                id: null
-            });
-        }
-        // Extract token
-        const token = auth.substring(7); // Remove "Bearer " prefix
-        // Validate token
-        const validation = oauthManager.validateToken(token);
-        if (!validation.valid) {
-            console.log(`❌ Auth failed: ${validation.error}`);
-            return res.status(401).json({
-                jsonrpc: '2.0',
-                error: {
-                    code: -32001,
-                    message: 'Invalid or expired token',
-                    data: validation.error
-                },
-                id: null
-            });
-        }
-        // Attach user info to request
-        req.auth = {
-            username: validation.username,
-            client_id: validation.client_id,
-            scope: validation.scope
-        };
-        // Log authenticated request
-        console.log(`✅ Authenticated: ${req.auth.username} (${req.auth.client_id})`);
-        next();
-    };
-}

package/dist/oauth/index.d.ts

@@ -1,3 +0,0 @@
-export { OAuthManager } from './oauth-manager.js';
-export { createOAuthRoutes } from './oauth-routes.js';
-export { createAuthMiddleware } from './auth-middleware.js';

package/dist/oauth/index.js

@@ -1,3 +0,0 @@
-export { OAuthManager } from './oauth-manager.js';
-export { createOAuthRoutes } from './oauth-routes.js';
-export { createAuthMiddleware } from './auth-middleware.js';

package/dist/oauth/oauth-manager.d.ts

@@ -1,80 +0,0 @@
-interface JWTPayload {
-    sub: string;
-    client_id: string;
-    scope: string;
-    [key: string]: any;
-}
-interface TokenValidation {
-    valid: boolean;
-    username?: string;
-    client_id?: string;
-    scope?: string;
-    error?: string;
-}
-interface ClientData {
-    client_id: string;
-    client_name: string;
-    redirect_uris: string[];
-    grant_types: string[];
-    response_types: string[];
-}
-interface AuthCodeData {
-    username: string;
-    client_id: string;
-    redirect_uri: string;
-    code_challenge?: string;
-    code_challenge_method?: string;
-    scope: string;
-    expiresAt: number;
-}
-export declare class OAuthManager {
-    private users;
-    private codes;
-    private clients;
-    private privateKey;
-    private publicKey;
-    private baseUrl;
-    constructor(baseUrl: string);
-    /**
-     * Pre-register well-known OAuth clients with fixed IDs
-     * This prevents issues when server restarts and clients still have cached IDs
-     */
-    private preRegisterWellKnownClients;
-    /**
-     * Create a JWT token with the given payload
-     */
-    createJWT(payload: JWTPayload): string;
-    /**
-     * Validate a JWT token
-     */
-    validateToken(token: string): TokenValidation;
-    /**
-     * Register a new OAuth client
-     */
-    registerClient(redirect_uris: string[], client_name?: string): ClientData;
-    /**
-     * Get a client by ID
-     */
-    getClient(clientId: string): ClientData | undefined;
-    /**
-     * List all registered client IDs (for debugging)
-     */
-    listClients(): string;
-    /**
-     * Validate user credentials
-     */
-    validateUser(username: string, password: string): boolean;
-    /**
-     * Create an authorization code
-     */
-    createAuthCode(data: Omit<AuthCodeData, 'expiresAt'>): string;
-    /**
-     * Validate and consume an authorization code
-     */
-    validateAuthCode(code: string, client_id: string, redirect_uri: string, code_verifier?: string): {
-        valid: boolean;
-        data?: AuthCodeData;
-        error?: string;
-    };
-}
-export {};

package/dist/oauth/oauth-manager.js

@@ -1,179 +0,0 @@
-import crypto from 'crypto';
-export class OAuthManager {
-    constructor(baseUrl) {
-        this.users = new Map([['admin', 'password123']]);
-        this.codes = new Map();
-        this.clients = new Map();
-        this.baseUrl = baseUrl;
-        // Generate RSA keys for JWT signing
-        const keys = crypto.generateKeyPairSync('rsa', {
-            modulusLength: 2048,
-            publicKeyEncoding: { type: 'spki', format: 'pem' },
-            privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-        });
-        this.privateKey = keys.privateKey;
-        this.publicKey = keys.publicKey;
-        console.log('🔐 OAuth Manager: JWT Keys generated');
-        // Pre-register well-known clients for common AI tools
-        // This survives server restarts as they use fixed IDs
-        this.preRegisterWellKnownClients();
-    }
-    /**
-     * Pre-register well-known OAuth clients with fixed IDs
-     * This prevents issues when server restarts and clients still have cached IDs
-     */
-    preRegisterWellKnownClients() {
-        // ChatGPT client
-        const chatgptClient = {
-            client_id: 'chatgpt-fixed-client-id',
-            client_name: 'ChatGPT',
-            redirect_uris: [
-                'https://chatgpt.com/connector_platform_oauth_redirect',
-                'https://chat.openai.com/connector_platform_oauth_redirect'
-            ],
-            grant_types: ['authorization_code'],
-            response_types: ['code']
-        };
-        this.clients.set(chatgptClient.client_id, chatgptClient);
-        console.log(`🔐 Pre-registered: ${chatgptClient.client_name} (${chatgptClient.client_id})`);
-        // Claude client
-        const claudeClient = {
-            client_id: 'claude-fixed-client-id',
-            client_name: 'Claude',
-            redirect_uris: [
-                'https://claude.ai/oauth/callback',
-                'http://localhost:3000/callback'
-            ],
-            grant_types: ['authorization_code'],
-            response_types: ['code']
-        };
-        this.clients.set(claudeClient.client_id, claudeClient);
-        console.log(`🔐 Pre-registered: ${claudeClient.client_name} (${claudeClient.client_id})`);
-    }
-    /**
-     * Create a JWT token with the given payload
-     */
-    createJWT(payload) {
-        const header = { alg: 'RS256', typ: 'JWT', kid: 'key-1' };
-        const now = Math.floor(Date.now() / 1000);
-        const claims = {
-            ...payload,
-            iat: now,
-            exp: now + 3600, // 1 hour expiration
-            iss: this.baseUrl,
-            aud: this.baseUrl
-        };
-        const encodedHeader = Buffer.from(JSON.stringify(header)).toString('base64url');
-        const encodedPayload = Buffer.from(JSON.stringify(claims)).toString('base64url');
-        const signature = crypto.sign('sha256', Buffer.from(`${encodedHeader}.${encodedPayload}`), this.privateKey);
-        return `${encodedHeader}.${encodedPayload}.${signature.toString('base64url')}`;
-    }
-    /**
-     * Validate a JWT token
-     */
-    validateToken(token) {
-        try {
-            const parts = token.split('.');
-            if (parts.length !== 3) {
-                return { valid: false, error: 'Invalid token format' };
-            }
-            const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString());
-            // Check expiration
-            if (payload.exp < Math.floor(Date.now() / 1000)) {
-                return { valid: false, error: 'Token expired' };
-            }
-            // Verify signature
-            const signature = parts[2];
-            const data = `${parts[0]}.${parts[1]}`;
-            const valid = crypto.verify('sha256', Buffer.from(data), this.publicKey, Buffer.from(signature, 'base64url'));
-            if (!valid) {
-                return { valid: false, error: 'Invalid signature' };
-            }
-            return {
-                valid: true,
-                username: payload.sub,
-                client_id: payload.client_id,
-                scope: payload.scope
-            };
-        }
-        catch (err) {
-            return { valid: false, error: err instanceof Error ? err.message : 'Unknown error' };
-        }
-    }
-    /**
-     * Register a new OAuth client
-     */
-    registerClient(redirect_uris, client_name) {
-        const clientId = crypto.randomUUID();
-        const client = {
-            client_id: clientId,
-            client_name: client_name || 'MCP Client',
-            redirect_uris,
-            grant_types: ['authorization_code'],
-            response_types: ['code']
-        };
-        this.clients.set(clientId, client);
-        console.log(`🔐 OAuth Manager: Registered client ${clientId} (${client.client_name})`);
-        return client;
-    }
-    /**
-     * Get a client by ID
-     */
-    getClient(clientId) {
-        return this.clients.get(clientId);
-    }
-    /**
-     * List all registered client IDs (for debugging)
-     */
-    listClients() {
-        const ids = Array.from(this.clients.keys());
-        return ids.length > 0 ? ids.join(', ') : 'none';
-    }
-    /**
-     * Validate user credentials
-     */
-    validateUser(username, password) {
-        return this.users.get(username) === password;
-    }
-    /**
-     * Create an authorization code
-     */
-    createAuthCode(data) {
-        const code = crypto.randomBytes(32).toString('base64url');
-        this.codes.set(code, {
-            ...data,
-            expiresAt: Date.now() + 600000 // 10 minutes
-        });
-        console.log(`🔐 OAuth Manager: Created auth code for user ${data.username}`);
-        return code;
-    }
-    /**
-     * Validate and consume an authorization code
-     */
-    validateAuthCode(code, client_id, redirect_uri, code_verifier) {
-        const codeData = this.codes.get(code);
-        if (!codeData) {
-            return { valid: false, error: 'Invalid or expired code' };
-        }
-        if (codeData.expiresAt < Date.now()) {
-            this.codes.delete(code);
-            return { valid: false, error: 'Code expired' };
-        }
-        if (codeData.client_id !== client_id || codeData.redirect_uri !== redirect_uri) {
-            return { valid: false, error: 'Client ID or redirect URI mismatch' };
-        }
-        // PKCE verification
-        if (codeData.code_challenge) {
-            if (!code_verifier) {
-                return { valid: false, error: 'code_verifier required' };
-            }
-            const hash = crypto.createHash('sha256').update(code_verifier).digest('base64url');
-            if (hash !== codeData.code_challenge) {
-                return { valid: false, error: 'Invalid code_verifier' };
-            }
-        }
-        // Delete code after use (one-time use)
-        this.codes.delete(code);
-        return { valid: true, data: codeData };
-    }
-}

package/dist/oauth/oauth-routes.d.ts

@@ -1,3 +0,0 @@
-import { Router } from 'express';
-import { OAuthManager } from './oauth-manager.js';
-export declare function createOAuthRoutes(oauthManager: OAuthManager, baseUrl: string): Router;