Files

247 lines
12 KiB
Python

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