#!/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; });