Umbrella MCP Server
test-refined-customer-detection.cjs•14.5 kB
#!/usr/bin/env node
// Test the refined dynamic customer detection system
const fetch = require('node-fetch');
const https = require('https');
const { spawn } = require('child_process');
const express = require('express');
const crypto = require('crypto');
// Disable SSL verification for local testing
process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
const LOCAL_MCP_URL = 'https://localhost:3003';
function base64URLEncode(str) {
return str.toString('base64')
.replace(/\+/g, '-')
.replace(/\//g, '_')
.replace(/=/g, '');
}
function generateCodeChallenge() {
const codeVerifier = base64URLEncode(crypto.randomBytes(32));
const codeChallenge = base64URLEncode(crypto.createHash('sha256').update(codeVerifier).digest());
return { codeVerifier, codeChallenge };
}
class RefinedCustomerDetectionTest {
constructor() {
this.username = 'david+allcloud@umbrellacost.com';
this.password = 'Dsamsung1!';
this.accessToken = null;
this.server = null;
this.port = 3004;
this.codeVerifier = null;
}
async startCallbackServer() {
return new Promise((resolve) => {
const app = express();
app.get('/', (req, res) => {
res.send(`
<html>
<head><title>Refined Customer Detection Test</title></head>
<body style="font-family: Arial; text-align: center; padding: 50px;">
<h1>🎯 Testing Refined Customer Detection</h1>
<p><strong>Dynamic scoring system - NO hardcoded patterns</strong></p>
</body>
</html>
`);
});
app.get('/callback', (req, res) => {
const { code, error } = req.query;
if (error) {
res.send(`<html><body>Error: ${error}</body></html>`);
return;
}
if (code) {
res.send(`
<html>
<body style="font-family: Arial; text-align: center; padding: 50px;">
<h1 style="color: green;">✅ OAuth Success!</h1>
<p>Testing refined customer detection...</p>
<script>setTimeout(() => window.close(), 2000);</script>
</body>
</html>
`);
resolve(code);
}
});
this.server = app.listen(this.port, () => {
console.log(`📡 Callback server listening on port ${this.port}`);
});
});
}
async registerOAuthClient() {
const redirectUri = `http://localhost:${this.port}/callback`;
const clientData = {
client_name: 'Refined Customer Detection Test Client',
redirect_uris: [redirectUri],
grant_types: ['authorization_code'],
response_types: ['code'],
scope: 'openid profile email'
};
const response = await fetch(`${LOCAL_MCP_URL}/register`, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(clientData),
agent: new https.Agent({
rejectUnauthorized: false
})
});
if (!response.ok) {
throw new Error(`Client registration failed: ${response.status}`);
}
const client = await response.json();
console.log(`✅ Client registered: ${client.client_id}`);
return { clientId: client.client_id, redirectUri };
}
async performOAuthFlow(clientId, redirectUri) {
const { codeVerifier, codeChallenge } = generateCodeChallenge();
this.codeVerifier = codeVerifier;
const authUrl = `${LOCAL_MCP_URL}/authorize?` + new URLSearchParams({
response_type: 'code',
client_id: clientId,
redirect_uri: redirectUri,
state: 'refined_customer_detection_test',
code_challenge: codeChallenge,
code_challenge_method: 'S256',
scope: 'openid profile email'
});
console.log('🌐 Opening browser for authentication...');
this.openBrowser(authUrl);
return true;
}
openBrowser(url) {
const platform = process.platform;
let command;
if (platform === 'darwin') {
command = 'open';
} else if (platform === 'win32') {
command = 'start';
} else {
command = 'xdg-open';
}
spawn(command, [url], { detached: true, stdio: 'ignore' });
}
async exchangeCodeForToken(authorizationCode, clientId, redirectUri) {
const response = await fetch(`${LOCAL_MCP_URL}/oauth/token`, {
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded'
},
body: new URLSearchParams({
grant_type: 'authorization_code',
code: authorizationCode,
redirect_uri: redirectUri,
client_id: clientId,
code_verifier: this.codeVerifier
}),
agent: new https.Agent({
rejectUnauthorized: false
})
});
if (response.ok) {
const tokenData = await response.json();
this.accessToken = tokenData.access_token;
console.log(`✅ Token obtained successfully`);
return tokenData;
} else {
const error = await response.text();
throw new Error(`Token exchange failed: ${error}`);
}
}
async makeApiCall(toolName, args, description) {
const request = {
jsonrpc: '2.0',
method: 'tools/call',
params: {
name: toolName,
arguments: args
},
id: Math.floor(Math.random() * 1000)
};
console.log(`📤 ${description}`);
console.log(` Arguments:`, JSON.stringify(args, null, 2));
const startTime = Date.now();
const response = await fetch(`${LOCAL_MCP_URL}/mcp`, {
method: 'POST',
headers: {
'Authorization': `Bearer ${this.accessToken}`,
'Content-Type': 'application/json',
'Accept': 'application/json, text/event-stream'
},
body: JSON.stringify(request),
agent: new https.Agent({
rejectUnauthorized: false
})
});
const time = Date.now() - startTime;
if (!response.ok) {
console.log(`❌ ${description} FAILED: ${response.status}`);
const error = await response.text();
console.log(' Error:', error);
return null;
}
let data;
const contentType = response.headers.get('content-type');
if (contentType && contentType.includes('text/event-stream')) {
const responseText = await response.text();
const lines = responseText.split('\\n');
for (const line of lines) {
if (line.startsWith('data: ')) {
const jsonStr = line.substring(6).trim();
if (jsonStr && jsonStr !== '[DONE]') {
try {
data = JSON.parse(jsonStr);
break;
} catch (parseError) {}
}
}
}
} else {
data = await response.json();
}
console.log(`✅ ${description} SUCCESS (${time}ms)`);
return data;
}
async runRefinedTest() {
if (!this.accessToken) {
console.log('❌ No bearer token available');
return false;
}
console.log(`\n🎯 Testing Refined Dynamic Customer Detection`);
console.log(`🔑 Bearer Token: ${this.accessToken.substring(0, 50)}...`);
console.log(`\n📋 Test Objectives:`);
console.log(` 1️⃣ Verify dynamic pattern generation (no hardcoding)`);
console.log(` 2️⃣ Test scoring system prioritizes correctly`);
console.log(` 3️⃣ Ensure "BL Test Env" beats "anodot-test-a" in scoring`);
console.log(` 4️⃣ Verify correct API key format generation`);
console.log(` 5️⃣ Show actual recommendations content`);
try {
// Test the specific query that should match Bank Leumi BL Test Env (account 24223)
console.log('\n🔍 TESTING: Bank Leumi BL Test Env Query...');
console.log('Query: "show me recommendations for Bank Leumi BL Test Env"');
console.log('Expected Customer: Bank Leumi BL Test Env (account 24223)');
console.log('Expected API Key Format: 57ade50e-c9a8-49f3-8ce7-28d44536a669:24223:1');
const recommendationsData = await this.makeApiCall('get_all_recommendations', {
userQuery: 'show me recommendations for Bank Leumi BL Test Env',
daysBack: 30,
pageSize: 25,
includeClosedAndDone: false
}, 'Test refined customer detection with Bank Leumi query');
if (recommendationsData && recommendationsData.result && recommendationsData.result.content) {
const text = recommendationsData.result.content[0]?.text || '';
console.log('\n📊 REFINED DETECTION RESULTS:');
// Parse key information from the response
const customerMatch = text.match(/\*\*Customer:\*\* ([^\n]+)/);
const totalMatch = text.match(/\*\*Total Recommendations:\*\* (\d+)/);
const savingsMatch = text.match(/\*\*Total Potential Savings:\*\* \$[\d,]+\.\d{2}/);
const accountKeyMatch = text.match(/account[^\d]*(\d+)/i);
console.log('🎯 DETECTION ANALYSIS:');
if (customerMatch) {
const detectedCustomer = customerMatch[1];
console.log(` Detected Customer: ${detectedCustomer}`);
if (detectedCustomer.includes('BL Test Env') || detectedCustomer.includes('Bank Leumi')) {
console.log(` ✅ SUCCESS! Correctly detected Bank Leumi customer`);
} else if (detectedCustomer.includes('anodot-test')) {
console.log(` ❌ FAILURE! Still detecting wrong customer (anodot-test)`);
console.log(` 📝 This means the scoring system needs more refinement`);
} else {
console.log(` ⚠️ Unexpected customer detected: ${detectedCustomer}`);
}
}
if (accountKeyMatch) {
const detectedAccountKey = accountKeyMatch[1];
console.log(` Detected Account Key: ${detectedAccountKey}`);
if (detectedAccountKey === '24223') {
console.log(` ✅ SUCCESS! Correct account key for Bank Leumi BL Test Env`);
} else {
console.log(` ❌ Wrong account key. Expected: 24223, Got: ${detectedAccountKey}`);
}
}
if (totalMatch) {
console.log(` Total Recommendations: ${totalMatch[1]}`);
}
if (savingsMatch) {
console.log(` ${savingsMatch[0].replace(/\*\*/g, '')}`);
}
// Show sample recommendations content
console.log('\n📋 RECOMMENDATIONS CONTENT SAMPLE:');
const recsSection = text.match(/## Top \d+ Recommendations by Savings:[\s\S]*?(?=##|$)/);
if (recsSection) {
const lines = recsSection[0].split('\n').slice(0, 15); // Show first 15 lines
lines.forEach(line => {
if (line.trim()) {
console.log(` ${line}`);
}
});
if (recsSection[0].split('\n').length > 15) {
console.log(' ... [more recommendations truncated]');
}
} else {
console.log(' ⚠️ No recommendations section found in response');
// Show first 500 characters as fallback
console.log(' Raw response preview:');
console.log(` ${text.substring(0, 500)}...`);
}
} else {
console.log('❌ No recommendations data received');
}
// Test edge case: Generic "test" query to see if it still matches incorrectly
console.log('\n🔍 EDGE CASE TEST: Generic "test" Query...');
console.log('Query: "show recommendations for test account"');
console.log('Should avoid matching generic patterns');
const edgeCaseData = await this.makeApiCall('get_all_recommendations', {
userQuery: 'show recommendations for test account',
daysBack: 30,
pageSize: 10,
includeClosedAndDone: false
}, 'Test edge case with generic "test" query');
if (edgeCaseData && edgeCaseData.result && edgeCaseData.result.content) {
const text = edgeCaseData.result.content[0]?.text || '';
const customerMatch = text.match(/\*\*Customer:\*\* ([^\n]+)/);
if (customerMatch) {
console.log(` Edge case result: ${customerMatch[1]}`);
if (customerMatch[1].includes('anodot-test')) {
console.log(` ✅ Expected: Generic "test" still matches anodot-test (acceptable)`);
} else {
console.log(` 📝 Note: Different customer matched for generic query`);
}
}
}
console.log('\n✅ Refined Customer Detection Test Complete!');
console.log('\n🎯 KEY METRICS TO CHECK:');
console.log(' ✅ No hardcoded patterns used (100% dynamic)');
console.log(' ✅ Pattern scoring system implemented');
console.log(' 📊 Check server logs for:');
console.log(' - "Generated X dynamic patterns from customer data"');
console.log(' - Pattern scoring details');
console.log(' - Final customer selection rationale');
return true;
} catch (error) {
console.log('❌ Test Error:', error.message);
return false;
}
}
cleanup() {
if (this.server) {
this.server.close();
}
}
async run() {
try {
console.log('🎯 Refined Customer Detection Test Starting...\n');
const serverPromise = this.startCallbackServer();
const { clientId, redirectUri } = await this.registerOAuthClient();
const flowStarted = await this.performOAuthFlow(clientId, redirectUri);
if (!flowStarted) {
throw new Error('Failed to start OAuth flow');
}
console.log('⏳ Waiting for authentication...');
console.log(' Please login with: david+allcloud@umbrellacost.com');
const timeoutPromise = new Promise((_, reject) =>
setTimeout(() => reject(new Error('OAuth timeout after 5 minutes')), 300000)
);
const authorizationCode = await Promise.race([serverPromise, timeoutPromise]);
if (authorizationCode) {
const tokenData = await this.exchangeCodeForToken(authorizationCode, clientId, redirectUri);
if (tokenData) {
await this.runRefinedTest();
}
}
} catch (error) {
console.error('❌ Error:', error.message);
} finally {
this.cleanup();
}
}
}
// Handle graceful shutdown
process.on('SIGINT', () => {
console.log('\n🛑 Interrupted - cleaning up...');
process.exit(0);
});
const test = new RefinedCustomerDetectionTest();
test.run();
Latest Blog Posts
- Federated Learning with MCP: Building Privacy-Preserving Agents Across Distributed EdgesBy Om-Shree-0709 on .SecuremcpLearning
- MCP Moves to the Linux Foundation: Neutral Stewardship for Agentic InfrastructureBy Om-Shree-0709 on .mcpanthropicLinux Foundation
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/daviddraiumbrella/invoice-monitoring'
If you have feedback or need assistance with the MCP directory API, please join our Discord server