152 lines
9.3 KiB
JavaScript
152 lines
9.3 KiB
JavaScript
#!/usr/bin/env node
|
|
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
|
|
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
|
|
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
|
|
import { randomBytes, createHash } from 'node:crypto';
|
|
import { readFile, writeFile, rename, chmod } from 'node:fs/promises';
|
|
import { createInterface } from 'node:readline/promises';
|
|
import { stdin, stderr } from 'node:process';
|
|
import { spawn } from 'node:child_process';
|
|
import { resolve } from 'node:path';
|
|
import { startCallback } from './callback.js';
|
|
|
|
const origin = 'https://enercondev.service-now.com';
|
|
const endpoint = process.env.MCP_URL || `${origin}/sncapps/mcp-server/mcp/x_engm3_mcp_stor_0_mcp_story_bridge`;
|
|
const clientId = process.env.OAUTH_CLIENT_ID || 'bde15764d0cb43658c41d31797c28b0e';
|
|
const redirectUri = process.env.OAUTH_REDIRECT_URI || 'http://127.0.0.1:8765/oauth/callback';
|
|
const cache = resolve(process.env.OAUTH_TOKEN_FILE || '.tokens.json');
|
|
const expected = ['rm_story_list', 'rm_story_get', 'rm_story_create', 'rm_story_update'];
|
|
const fallback = { authorization_endpoint: `${origin}/oauth_auth.do`, token_endpoint: `${origin}/oauth_token.do` };
|
|
let tokens, tokenPromise, metadata;
|
|
|
|
async function json(url) {
|
|
const response = await fetch(url, { signal: AbortSignal.timeout(8000), redirect: 'error' });
|
|
if (!response.ok) throw new Error(`HTTP ${response.status}`);
|
|
return response.json();
|
|
}
|
|
async function discover() {
|
|
const u = new URL(endpoint);
|
|
const paths = [`${u.origin}/.well-known/oauth-protected-resource${u.pathname}`, `${u.origin}/.well-known/oauth-protected-resource`];
|
|
for (const url of paths) {
|
|
try {
|
|
const resource = await json(url);
|
|
if (resource.resource && resource.resource.replace(/\/$/, '') !== endpoint.replace(/\/$/, '')) continue;
|
|
for (const issuer of resource.authorization_servers || []) {
|
|
const i = new URL(issuer);
|
|
// Do not send a confidential client secret to a different host based on discovery alone.
|
|
if (i.origin !== origin) continue;
|
|
const as = await json(`${i.origin}/.well-known/oauth-authorization-server${i.pathname === '/' ? '' : i.pathname}`);
|
|
if (new URL(as.token_endpoint).origin !== origin || new URL(as.authorization_endpoint).origin !== origin) continue;
|
|
console.error('OAuth-Discovery erfolgreich.');
|
|
return as;
|
|
}
|
|
} catch { /* try the next route */ }
|
|
}
|
|
console.error('OAuth-Discovery nicht verfügbar; konfigurierte ServiceNow-Endpunkte werden verwendet.');
|
|
return fallback;
|
|
}
|
|
async function saveTokens(value) {
|
|
const tmp = `${cache}.${process.pid}.tmp`;
|
|
await writeFile(tmp, JSON.stringify(value), { mode: 0o600 });
|
|
await chmod(tmp, 0o600);
|
|
await rename(tmp, cache);
|
|
}
|
|
async function exchange(params) {
|
|
const secret = process.env.OAUTH_CLIENT_SECRET || (await readFile(process.env.OAUTH_CLIENT_SECRET_FILE || 'clientsecret', 'utf8')).trim();
|
|
if (!secret) throw new Error('Client-Secret ist leer.');
|
|
const response = await fetch(metadata.token_endpoint, {
|
|
method: 'POST', redirect: 'error', headers: { 'content-type': 'application/x-www-form-urlencoded' },
|
|
body: new URLSearchParams({ ...params, client_id: clientId, client_secret: secret })
|
|
});
|
|
const result = await response.json().catch(() => ({}));
|
|
if (!response.ok || !result.access_token) throw new Error(`Token-Endpunkt: HTTP ${response.status}, ${result.error || 'kein access_token'}`);
|
|
const lifetime = Number(result.expires_in);
|
|
tokens = { ...result, refresh_token: result.refresh_token || (params.grant_type === 'refresh_token' ? tokens?.refresh_token : undefined), expires_at: Date.now() + (Number.isFinite(lifetime) && lifetime > 0 ? lifetime : 1800) * 1000 };
|
|
await saveTokens(tokens);
|
|
}
|
|
async function login() {
|
|
const verifier = randomBytes(32).toString('base64url');
|
|
const state = randomBytes(32).toString('base64url');
|
|
const challenge = createHash('sha256').update(verifier).digest('base64url');
|
|
const url = new URL(metadata.authorization_endpoint);
|
|
url.search = new URLSearchParams({ response_type: 'code', client_id: clientId, redirect_uri: redirectUri, state, code_challenge: challenge, code_challenge_method: 'S256' }).toString();
|
|
const callbackUri = new URL(redirectUri);
|
|
const local = callbackUri.protocol === 'http:' && callbackUri.hostname === '127.0.0.1';
|
|
const listener = local ? await startCallback(redirectUri, state) : null;
|
|
try {
|
|
console.error(`Im Browser anmelden:\n${url}`);
|
|
if (process.env.NO_BROWSER !== '1') { const p = spawn('xdg-open', [url.toString()], { stdio: 'ignore', detached: true }); p.on('error', () => {}); p.unref(); }
|
|
let code;
|
|
if (listener) {
|
|
console.error('Warte auf den lokalen OAuth-Callback (maximal 3 Minuten).');
|
|
code = await listener.result;
|
|
} else {
|
|
console.error('Anschließend die vollständige Weiterleitungs-URL hier einfügen.');
|
|
if (!stdin.isTTY) throw new Error('Interaktiver Login benötigt ein Terminal.');
|
|
const rl = createInterface({ input: stdin, output: stderr });
|
|
let reply;
|
|
try { reply = await rl.question('Weiterleitungs-URL: '); } finally { rl.close(); }
|
|
const callback = new URL(reply.trim());
|
|
if (callback.origin !== callbackUri.origin || callback.pathname !== callbackUri.pathname) throw new Error('Weiterleitungs-URL stimmt nicht mit redirect_uri überein.');
|
|
if (callback.searchParams.get('state') !== state) throw new Error('OAuth-State stimmt nicht überein.');
|
|
if (callback.searchParams.has('error')) throw new Error(`Autorisierung abgelehnt: ${callback.searchParams.get('error')}`);
|
|
code = callback.searchParams.get('code');
|
|
if (!code) throw new Error('Kein Code in der Weiterleitungs-URL.');
|
|
}
|
|
await exchange({ grant_type: 'authorization_code', code, redirect_uri: redirectUri, code_verifier: verifier });
|
|
} finally { listener?.close(); }
|
|
|
|
}
|
|
async function ensureToken(force = false) {
|
|
if (tokenPromise) return tokenPromise;
|
|
tokenPromise = (async () => {
|
|
if (!force && tokens?.access_token && tokens.expires_at > Date.now() + 60000) return;
|
|
if (tokens?.refresh_token) {
|
|
try { await exchange({ grant_type: 'refresh_token', refresh_token: tokens.refresh_token }); return; }
|
|
catch (e) { console.error(`Refresh fehlgeschlagen: ${e.message}. Erneuter Login erforderlich.`); }
|
|
}
|
|
await login();
|
|
})();
|
|
try { await tokenPromise; } finally { tokenPromise = undefined; }
|
|
}
|
|
async function authenticatedFetch(input, init = {}) {
|
|
await ensureToken();
|
|
const send = () => { const headers = new Headers(init.headers); headers.set('Authorization', `Bearer ${tokens.access_token}`); return fetch(input, { ...init, headers, redirect: 'error' }); };
|
|
let response = await send();
|
|
if (response.status === 401) { await response.body?.cancel(); await ensureToken(true); response = await send(); }
|
|
return response;
|
|
}
|
|
async function main() {
|
|
const [command = 'tools', ...args] = process.argv.slice(2);
|
|
if (command === 'help' || command === '--help') { console.log('Aufruf: node client.js tools | list [JSON] | get SYS_ID | create JSON | update SYS_ID JSON | call TOOL JSON\nBeispiel: node client.js list \'{"limit":"5"}\''); return; }
|
|
const parse = (s) => { const o = JSON.parse(s || '{}'); if (!o || Array.isArray(o) || typeof o !== 'object') throw new Error('Argument muss ein JSON-Objekt sein.'); return o; };
|
|
let name, input;
|
|
if (command === 'list') { name = 'rm_story_list'; input = parse(args[0]); }
|
|
else if (command === 'get') { name = 'rm_story_get'; input = { sys_id: args[0] }; }
|
|
else if (command === 'create') { name = 'rm_story_create'; input = parse(args[0]); }
|
|
else if (command === 'update') { name = 'rm_story_update'; input = { ...parse(args[1]), sys_id: args[0] }; }
|
|
else if (command === 'call') { name = args[0]; input = parse(args[1]); if (!expected.includes(name)) throw new Error('Unbekanntes Tool.'); }
|
|
else if (command !== 'tools') throw new Error('Unbekannter Befehl. Siehe help.');
|
|
if ((command === 'get' || command === 'update') && !args[0]) throw new Error('sys_id fehlt.');
|
|
metadata = await discover();
|
|
try { tokens = JSON.parse(await readFile(cache, 'utf8')); } catch (e) { if (e.code !== 'ENOENT') throw new Error(`Token-Datei kann nicht gelesen werden: ${e.message}`); }
|
|
const client = new Client({ name: 'servicenow-story-client', version: '1.0.0' });
|
|
const Transport = process.env.MCP_TRANSPORT === 'sse' ? SSEClientTransport : StreamableHTTPClientTransport;
|
|
const transport = new Transport(new URL(endpoint), { fetch: authenticatedFetch });
|
|
try {
|
|
await client.connect(transport);
|
|
if (command === 'tools') {
|
|
const tools = []; let cursor;
|
|
do { const page = await client.listTools(cursor ? { cursor } : undefined); tools.push(...page.tools); cursor = page.nextCursor; } while (cursor);
|
|
console.log(JSON.stringify(tools, null, 2));
|
|
const names = tools.map(t => t.name);
|
|
if (names.length !== 4 || expected.some(n => !names.includes(n))) { console.error('Warnung: Tool-Liste entspricht nicht den vier erwarteten Tools.'); process.exitCode = 1; }
|
|
} else {
|
|
const result = await client.callTool({ name, arguments: input });
|
|
console.log(JSON.stringify(result, null, 2));
|
|
if (result.isError) process.exitCode = 1;
|
|
}
|
|
} finally { await client.close(); }
|
|
}
|
|
main().catch(error => { console.error(`Fehler: ${error.message}`); process.exitCode = 1; });
|