#!/usr/bin/env python3 """ServiceNow Story MCP CLI; OAuth authorization code with PKCE and Edge.""" import argparse import asyncio import base64 import hashlib import json import os from pathlib import Path import secrets import shutil import subprocess import sys import tempfile import time from urllib.parse import parse_qs, urlencode, urlparse import httpx from mcp import ClientSession from mcp.client.streamable_http import streamable_http_client from mcp.client.sse import sse_client ORIGIN = 'https://enercondev.service-now.com' MCP_URL = os.getenv('MCP_URL', ORIGIN + '/sncapps/mcp-server/mcp/x_engm3_mcp_stor_0_mcp_story_bridge') CLIENT_ID = os.getenv('OAUTH_CLIENT_ID', 'bde15764d0cb43658c41d31797c28b0e') REDIRECT = os.getenv('OAUTH_REDIRECT_URI', 'http://127.0.0.1:8765/oauth/callback') TOKEN_FILE = Path(os.getenv('OAUTH_TOKEN_FILE', '.tokens.json')).expanduser() EXPECTED = {'rm_story_list', 'rm_story_get', 'rm_story_create', 'rm_story_update'} def edge_open(url): """Launch Edge specifically; never silently substitute another browser.""" configured = os.getenv('EDGE_PATH') candidates = [configured] if configured else (['msedge', 'microsoft-edge', 'microsoft-edge-stable', 'microsoft-edge-beta'] if sys.platform != 'win32' else [ os.path.join(os.environ.get('PROGRAMFILES(X86)', r'C:\Program Files (x86)'), 'Microsoft', 'Edge', 'Application', 'msedge.exe'), os.path.join(os.environ.get('PROGRAMFILES', r'C:\Program Files'), 'Microsoft', 'Edge', 'Application', 'msedge.exe'), 'msedge']) if sys.platform == 'darwin' and not configured: candidates.insert(0, '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge') executable = next((x for x in candidates if x and (shutil.which(x) or Path(x).is_file())), None) if not executable: raise RuntimeError('Microsoft Edge wurde nicht gefunden. Installiere Edge oder setze EDGE_PATH auf die Edge-Programmdatei.') subprocess.Popen([executable, url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True) def save_tokens(tokens): TOKEN_FILE.parent.mkdir(parents=True, exist_ok=True) fd, tmp = tempfile.mkstemp(prefix='.oauth-', dir=TOKEN_FILE.parent) try: if os.name != 'nt': os.fchmod(fd, 0o600) with os.fdopen(fd, 'w', encoding='utf-8') as f: json.dump(tokens, f) os.replace(tmp, TOKEN_FILE) finally: if os.path.exists(tmp): os.unlink(tmp) async def wait_for_callback(state, open_browser, timeout=180): uri = urlparse(REDIRECT) if uri.scheme != 'http' or uri.hostname != '127.0.0.1' or not uri.port or uri.query or uri.fragment: raise ValueError('OAUTH_REDIRECT_URI muss eine HTTP-URL auf 127.0.0.1 mit festem Port sein.') loop = asyncio.get_running_loop() result = loop.create_future() async def handle(reader, writer): try: line = await asyncio.wait_for(reader.readline(), 5) parts = line.decode('ascii', 'replace').split() target = urlparse(parts[1]) if len(parts) >= 2 else None params = parse_qs(target.query) if target else {} if len(parts) < 2 or parts[0] != 'GET' or target.path != uri.path: status, message = '404 Not Found', 'Nicht gefunden.' elif params.get('state', [None])[0] != state: status, message = '400 Bad Request', 'Ungueltiger OAuth-State.' elif params.get('error'): status, message = '400 Bad Request', 'Anmeldung abgelehnt.' if not result.done(): result.set_exception(RuntimeError('OAuth-Autorisierung abgelehnt: ' + params['error'][0])) elif not params.get('code'): status, message = '400 Bad Request', 'Autorisierungscode fehlt.' else: status, message = '200 OK', 'Anmeldung abgeschlossen. Dieses Fenster kann geschlossen werden.' if not result.done(): result.set_result(params['code'][0]) body = message.encode() writer.write(f'HTTP/1.1 {status}\r\nContent-Type: text/plain; charset=utf-8\r\nCache-Control: no-store\r\nContent-Length: {len(body)}\r\nConnection: close\r\n\r\n'.encode() + body) await writer.drain() finally: writer.close() await writer.wait_closed() server = await asyncio.start_server(handle, '127.0.0.1', uri.port) try: open_browser() async with server: return await asyncio.wait_for(result, timeout) finally: server.close() await server.wait_closed() class TokenError(RuntimeError): def __init__(self, status, error): self.status, self.error = status, error super().__init__(f'Token-Endpunkt: HTTP {status}, {error}') class OAuth(httpx.Auth): def __init__(self): self.tokens = {} if TOKEN_FILE.exists(): self.tokens = json.loads(TOKEN_FILE.read_text(encoding='utf-8')) self.metadata = None self.lock = asyncio.Lock() self.http = httpx.AsyncClient(timeout=20, follow_redirects=False) async def close(self): await self.http.aclose() async def discover(self): url = urlparse(MCP_URL) base = f'{url.scheme}://{url.netloc}' for suffix in [url.path, '']: try: r = await self.http.get(base + '/.well-known/oauth-protected-resource' + suffix) r.raise_for_status() resource = r.json() if resource.get('resource', MCP_URL).rstrip('/') != MCP_URL.rstrip('/'): continue for issuer in resource.get('authorization_servers', []): i = urlparse(issuer) if f'{i.scheme}://{i.netloc}' != ORIGIN: continue r = await self.http.get(ORIGIN + '/.well-known/oauth-authorization-server' + (i.path if i.path != '/' else '')) r.raise_for_status() meta = r.json() if all(f'{urlparse(meta[k]).scheme}://{urlparse(meta[k]).netloc}' == ORIGIN for k in ('authorization_endpoint', 'token_endpoint')): print('OAuth-Discovery erfolgreich.', file=sys.stderr) return meta except (httpx.HTTPError, ValueError, KeyError): pass print('OAuth-Discovery fehlgeschlagen; ServiceNow-Endpunkte werden verwendet.', file=sys.stderr) return {'authorization_endpoint': ORIGIN + '/oauth_auth.do', 'token_endpoint': ORIGIN + '/oauth_token.do'} async def exchange(self, fields): secret = os.getenv('OAUTH_CLIENT_SECRET') if not secret: secret = Path(os.getenv('OAUTH_CLIENT_SECRET_FILE', 'clientsecret')).read_text(encoding='utf-8').strip() if not secret: raise RuntimeError('Client-Secret ist leer.') r = await self.http.post(self.metadata['token_endpoint'], data={**fields, 'client_id': CLIENT_ID, 'client_secret': secret}) try: data = r.json() except ValueError: data = {} if r.is_error or not data.get('access_token'): raise TokenError(r.status_code, data.get('error', 'kein access_token')) if fields['grant_type'] == 'refresh_token' and not data.get('refresh_token'): data['refresh_token'] = self.tokens.get('refresh_token') data['expires_at'] = int((time.time() + float(data.get('expires_in', 1800))) * 1000) save_tokens(data) self.tokens = data async def ensure(self, force=False, rejected_token=None): async with self.lock: if self.metadata is None: self.metadata = await self.discover() if force and rejected_token and self.tokens.get('access_token') != rejected_token: return if not force and self.tokens.get('access_token') and self.tokens.get('expires_at', 0) > (time.time() + 60) * 1000: return if self.tokens.get('refresh_token'): try: await self.exchange({'grant_type': 'refresh_token', 'refresh_token': self.tokens['refresh_token']}) return except TokenError as error: if error.error != 'invalid_grant': raise print('Refresh-Token abgelaufen oder widerrufen; erneuter Login erforderlich.', file=sys.stderr) self.tokens = {} verifier = secrets.token_urlsafe(32) state = secrets.token_urlsafe(32) challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).decode().rstrip('=') url = self.metadata['authorization_endpoint'] + '?' + urlencode({'response_type': 'code', 'client_id': CLIENT_ID, 'redirect_uri': REDIRECT, 'state': state, 'code_challenge': challenge, 'code_challenge_method': 'S256'}) print('Microsoft Edge wird für den Login geöffnet; warte auf den lokalen Callback.', file=sys.stderr) code = await wait_for_callback(state, lambda: edge_open(url)) await self.exchange({'grant_type': 'authorization_code', 'code': code, 'redirect_uri': REDIRECT, 'code_verifier': verifier}) async def async_auth_flow(self, request): await self.ensure() token = self.tokens['access_token'] request.headers['Authorization'] = 'Bearer ' + token response = yield request if response.status_code == 401: await response.aread() await self.ensure(force=True, rejected_token=token) request.headers['Authorization'] = 'Bearer ' + self.tokens['access_token'] yield request def object_json(value): try: obj = json.loads(value) except ValueError as e: raise argparse.ArgumentTypeError(str(e)) from e if not isinstance(obj, dict): raise argparse.ArgumentTypeError('JSON-Objekt erforderlich') return obj def parser(): p = argparse.ArgumentParser(description='ServiceNow Story MCP Client') p.add_argument('--transport', choices=('http', 'sse'), default='http') sub = p.add_subparsers(dest='command', required=True) sub.add_parser('tools') listp = sub.add_parser('list'); listp.add_argument('data', nargs='?', type=object_json, default={}) get = sub.add_parser('get'); get.add_argument('sys_id') create = sub.add_parser('create'); create.add_argument('data', type=object_json) update = sub.add_parser('update'); update.add_argument('sys_id'); update.add_argument('data', type=object_json) call = sub.add_parser('call'); call.add_argument('name', choices=sorted(EXPECTED)); call.add_argument('data', nargs='?', type=object_json, default={}) return p def call_args(args): if args.command == 'list': return 'rm_story_list', args.data if args.command == 'get': return 'rm_story_get', {'sys_id': args.sys_id} if args.command == 'create': return 'rm_story_create', {'request_body': args.data} if args.command == 'update': return 'rm_story_update', {'sys_id': args.sys_id, 'request_body': args.data} return args.name, args.data async def run(args): auth = OAuth() try: async with httpx.AsyncClient(auth=auth, timeout=httpx.Timeout(30, read=300), follow_redirects=False) as http: transport = sse_client(MCP_URL, auth=auth) if args.transport == 'sse' else streamable_http_client(MCP_URL, http_client=http) async with transport as streams: async with ClientSession(streams[0], streams[1]) as session: await session.initialize() if args.command == 'tools': tools, cursor = [], None while True: page = await session.list_tools(cursor=cursor) tools.extend(page.tools) cursor = page.nextCursor if not cursor: break print(json.dumps([x.model_dump(mode='json', exclude_none=True) for x in tools], ensure_ascii=False, indent=2)) names = [t.name for t in tools] if len(names) != 4 or set(names) != EXPECTED: print('Warnung: Tool-Liste weicht von den vier erwarteten Tools ab.', file=sys.stderr) return 1 else: name, data = call_args(args) result = await session.call_tool(name, data) print(json.dumps(result.model_dump(mode='json', exclude_none=True), ensure_ascii=False, indent=2)) if result.isError: return 1 return 0 finally: await auth.close() def main(): try: return asyncio.run(run(parser().parse_args())) except (Exception, KeyboardInterrupt) as e: print(f'Fehler: {e}', file=sys.stderr) return 1 if __name__ == '__main__': sys.exit(main())