247 lines
12 KiB
Python
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())
|