lambda-erp 1.1.2__tar.gz → 1.1.4__tar.gz

{lambda_erp-1.1.2 → lambda_erp-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 1.1.2
+Version: 1.1.4
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0

{lambda_erp-1.1.2 → lambda_erp-1.1.4}/api/auth.py

@@ -9,6 +9,7 @@ import uuid
 import secrets
 import hashlib
 from datetime import datetime, timedelta, timezone
+from typing import Literal
 
 import bcrypt
 from jose import jwt, JWTError
@@ -259,12 +260,18 @@ def refresh_auth_principal(principal: dict | None) -> dict | None:
             else owner["role"]
         )
         owner["role"] = effective_role
-        return make_auth_principal(
+        scope_role = principal.get("oauth_scope_role")
+        if scope_role:
+            owner["role"] = min((owner["role"], scope_role), key=_role_rank)
+        refreshed = make_auth_principal(
             owner,
             API_KEY_CREDENTIAL,
             name=principal.get("name") or key.get("session_owner") or owner["name"],
             api_key_id=key["id"],
         )
+        if scope_role:
+            refreshed["oauth_scope_role"] = scope_role
+        return refreshed
 
     user_id = principal.get("user_id") or principal.get("name")
     user = db.get_value(
@@ -981,6 +988,7 @@ class ApiKeyCreate(BaseModel):
     # Optional role CAP. Defaults to the creator's own role; may only be equal
     # or lower — a key can never out-rank its owner.
     role: str | None = None
+    app_type: Literal['claude_code', 'codex', 'other'] = 'other'
 
 
 def _serialize_api_key(row: dict) -> dict:
@@ -997,6 +1005,7 @@ def _serialize_api_key(row: dict) -> dict:
         "created_at": row.get("created_at"),
         "last_used_at": row.get("last_used_at"),
         "revoked": bool(row.get("revoked")),
+        "app_type": row.get("app_type") or "other",
     }
 
 
@@ -1024,7 +1033,7 @@ def list_api_keys(user: dict = Depends(require_interactive_user)):
     db = get_db()
     base = (
         'SELECT k.id, k.name, k.owner, k.role, k.key_prefix, k.created_at, '
-        'k.last_used_at, k.revoked, u.full_name AS owner_full_name, u.email AS owner_email '
+        'k.last_used_at, k.revoked, k.app_type, u.full_name AS owner_full_name, u.email AS owner_email '
         'FROM "Api Key" k LEFT JOIN "User" u ON u.name = k.owner '
     )
     if user["role"] == "admin":
@@ -1068,15 +1077,16 @@ def create_api_key(data: ApiKeyCreate, user: dict = Depends(require_interactive_
     created_at = now()
     db.sql(
         'INSERT INTO "Api Key" '
-        '(id, name, owner, key_hash, key_prefix, role, session_owner, created_at, last_used_at, revoked) '
-        'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0)',
-        [key_id, name, user["name"], key_hash, key_prefix, role, f"api:{user['name']}", created_at, None],
+        '(id, name, owner, key_hash, key_prefix, role, session_owner, created_at, last_used_at, revoked, app_type) '
+        'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?)',
+        [key_id, name, user["name"], key_hash, key_prefix, role, f"api:{user['name']}", created_at, None, data.app_type],
     )
     db.conn.commit()
     row = {
         "id": key_id, "name": name, "owner": user["name"], "role": role, "key_prefix": key_prefix,
         "created_at": created_at, "last_used_at": None, "revoked": 0,
         "owner_full_name": user.get("full_name"), "owner_email": user.get("email"),
+        "app_type": data.app_type,
     }
     result = _serialize_api_key(row)
     result["is_mine"] = True

{lambda_erp-1.1.2 → lambda_erp-1.1.4}/api/main.py

@@ -17,6 +17,7 @@ from lambda_erp.database import setup
 from api.errors import register_exception_handlers
 from api.auth import router as auth_router, COOKIE_NAME, decode_token
 from api.oauth import router as oauth_router
+from api.mcp_oauth import router as mcp_oauth_router, OAuthError, oauth_error_handler
 from api.attachments import router as attachments_router
 from api.chat import chat_websocket, router as chat_router
 from api.routers import admin, documents, masters, reports, setup as setup_router, bank_reconciliation, bank_statements, analytics, accounting, proposals, chat_api, mcp, availability, actions
@@ -101,10 +102,12 @@ app.add_middleware(
 
 # Exception handlers
 register_exception_handlers(app)
+app.add_exception_handler(OAuthError, oauth_error_handler)
 
 # Routers
 app.include_router(auth_router, prefix="/api")
 app.include_router(oauth_router, prefix="/api")
+app.include_router(mcp_oauth_router)
 app.include_router(attachments_router, prefix="/api")
 app.include_router(documents.router, prefix="/api")
 app.include_router(proposals.router, prefix="/api")

lambda_erp-1.1.4/api/mcp_oauth.py

@@ -0,0 +1,423 @@
+"""OAuth authorization-code + S256 PKCE for remote MCP connectors.
+
+Dynamic registration supports public and confidential clients; no client URLs
+are fetched. Grants reuse the per-user Api Key role/revocation model, but have
+no API-key secret. Opaque, hashed OAuth tokens are valid only at this MCP resource.
+"""
+import base64
+import hashlib
+import hmac
+import json
+import os
+import re
+import secrets
+import time
+import uuid
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit, unquote
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi.responses import JSONResponse, RedirectResponse
+from jose import jwt, JWTError
+from pydantic import BaseModel
+
+from api.auth import (ALGORITHM, SECRET_KEY, API_KEY_CREDENTIAL, ROLE_HIERARCHY,
+                      _setting_enabled, require_interactive_user,
+                      refresh_auth_principal)
+from lambda_erp.database import get_db
+from lambda_erp.utils import now
+
+router = APIRouter(tags=['mcp-oauth'])
+SCOPES = {'erp:read': 'viewer', 'erp:write': 'manager', 'erp:admin': 'admin'}
+ACCESS_TTL = 3600
+REFRESH_TTL = 30 * 86400
+RETURN_COOKIE = 'lambda_erp_mcp_return'
+NO_STORE = {'Cache-Control': 'no-store', 'Pragma': 'no-cache'}
+
+
+class OAuthError(Exception):
+    def __init__(self, error, description, status=400):
+        self.error, self.description, self.status = error, description, status
+
+
+async def oauth_error_handler(request, exc):
+    return JSONResponse({'error': exc.error, 'error_description': exc.description},
+                        status_code=exc.status, headers=NO_STORE)
+
+
+def digest(value):
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+def issuer(request):
+    # Set on reverse-proxied deployments if the external origin differs from
+    # Request.base_url. Never derive OAuth metadata from forwarded host headers.
+    return os.environ.get('MCP_PUBLIC_URL', str(request.base_url)).rstrip('/')
+
+
+def resource_url(request):
+    return issuer(request) + '/api/mcp'
+
+
+def challenge_header(request):
+    return {'WWW-Authenticate': f'Bearer resource_metadata="{issuer(request)}/.well-known/oauth-protected-resource/api/mcp"'}
+
+
+def _enabled():
+    if not _setting_enabled(get_db(), 'rest_api_enabled'):
+        raise OAuthError('access_denied', 'An administrator must enable REST API / MCP access first.', 403)
+
+
+def _client(client_id):
+    rows = get_db().sql('SELECT * FROM "MCP OAuth Client" WHERE id = ?', [client_id])
+    if not rows:
+        raise OAuthError('invalid_client', 'Unknown client. Add the connector again.', 401)
+    return rows[0]
+
+
+def _validate_redirect(uri):
+    if not isinstance(uri, str) or len(uri) > 2048 or re.search(r'[\s\\*]', uri):
+        raise OAuthError('invalid_redirect_uri', 'Invalid redirect URI.')
+    try:
+        parts = urlsplit(uri)
+        parts.port  # Validate the port as well as the host.
+    except ValueError:
+        raise OAuthError('invalid_redirect_uri', 'Invalid redirect URI.')
+    if (not parts.hostname or parts.username or parts.password or parts.fragment
+            or parts.scheme not in {'https', 'http'}
+            or (parts.scheme == 'http' and parts.hostname not in {'127.0.0.1', '[::1]', '::1', 'localhost'})):
+        raise OAuthError('invalid_redirect_uri', 'Use HTTPS, or HTTP on a loopback address.')
+    return parts
+
+
+def _redirect_matches(uri, registered):
+    candidate = _validate_redirect(uri)
+    for allowed in registered:
+        if uri == allowed:
+            return True
+        parts = urlsplit(allowed)
+        # RFC 8252 native apps choose an ephemeral loopback listener port.
+        if (parts.scheme == candidate.scheme == 'http' and parts.hostname == candidate.hostname
+                and parts.hostname in {'127.0.0.1', '::1', 'localhost'}
+                and parts.path == candidate.path and parts.query == candidate.query):
+            return True
+    return False
+
+
+def _scope(value):
+    scopes = set((value or 'erp:read').split())
+    if not scopes or not scopes <= SCOPES.keys():
+        raise OAuthError('invalid_scope', 'Supported permissions: erp:read erp:write erp:admin.')
+    return ' '.join(sorted(scopes))
+
+
+def _role(scope):
+    return max((SCOPES[s] for s in scope.split()), key=lambda r: ROLE_HIERARCHY[r])
+
+
+@router.get('/.well-known/oauth-protected-resource')
+@router.get('/.well-known/oauth-protected-resource/api/mcp')
+def protected_resource(request: Request):
+    return JSONResponse({'resource': resource_url(request), 'resource_name': 'Lambda ERP',
+                         'authorization_servers': [issuer(request)], 'scopes_supported': list(SCOPES),
+                         'bearer_methods_supported': ['header']}, headers=NO_STORE)
+
+
+@router.get('/.well-known/oauth-authorization-server')
+def authorization_server(request: Request):
+    base = issuer(request) + '/api/mcp-oauth'
+    return JSONResponse({'issuer': issuer(request), 'authorization_endpoint': base + '/authorize',
+                         'token_endpoint': base + '/token', 'registration_endpoint': base + '/register',
+                         'revocation_endpoint': base + '/revoke', 'scopes_supported': list(SCOPES),
+                         'response_types_supported': ['code'],
+                         'grant_types_supported': ['authorization_code', 'refresh_token'],
+                         'code_challenge_methods_supported': ['S256'],
+                         'token_endpoint_auth_methods_supported': ['none', 'client_secret_post', 'client_secret_basic']},
+                        headers=NO_STORE)
+
+
+@router.get('/api/mcp-oauth/status')
+def connection_status(request: Request, user: dict = Depends(require_interactive_user)):
+    db = get_db()
+    return {'mcp_url': resource_url(request), 'rest_enabled': _setting_enabled(db, 'rest_api_enabled'),
+            'chat_enabled': _setting_enabled(db, 'chat_api_enabled')}
+
+
+@router.post('/api/mcp-oauth/register')
+async def register(request: Request):
+    _enabled()
+    raw = await request.body()
+    if len(raw) > 16384:
+        raise OAuthError('invalid_client_metadata', 'Registration is too large.')
+    try:
+        data = json.loads(raw)
+    except ValueError:
+        raise OAuthError('invalid_client_metadata', 'Expected JSON.')
+    if not isinstance(data, dict):
+        raise OAuthError('invalid_client_metadata', 'Expected an object.')
+    uris = data.get('redirect_uris')
+    if not isinstance(uris, list) or not 1 <= len(uris) <= 10:
+        raise OAuthError('invalid_redirect_uri', 'Supply 1–10 redirect URIs.')
+    for uri in uris:
+        _validate_redirect(uri)
+    method = data.get('token_endpoint_auth_method', 'client_secret_basic')
+    if not isinstance(method, str) or method not in {'none', 'client_secret_post', 'client_secret_basic'}:
+        raise OAuthError('invalid_client_metadata', 'Unsupported client authentication method.')
+    if (data.get('response_types', ['code']) != ['code']
+            or not isinstance(data.get('grant_types', []), list)
+            or any(not isinstance(g, str) for g in data.get('grant_types', []))
+            or not set(data.get('grant_types', ['authorization_code'])) <= {'authorization_code', 'refresh_token'}):
+        raise OAuthError('invalid_client_metadata', 'Only authorization code and refresh grants are supported.')
+    name = data.get('client_name') or 'MCP connector'
+    if not isinstance(name, str) or len(name) > 100:
+        raise OAuthError('invalid_client_metadata', 'Client name must be at most 100 characters.')
+    db = get_db()
+    timestamp = int(time.time())
+    # Bound unauthenticated registration growth without relying on process-local
+    # counters (the same service can run on several replicas).
+    if db.sql('SELECT COUNT(*) AS n FROM "MCP OAuth Client" WHERE created_at > ?', [timestamp - 3600])[0]['n'] >= 1000:
+        raise OAuthError('temporarily_unavailable', 'Registration limit reached. Try again later.', 429)
+    client_id, secret = secrets.token_urlsafe(24), secrets.token_urlsafe(32)
+    with db.atomic():
+        db.sql('INSERT INTO "MCP OAuth Client" (id,name,redirect_uris,auth_method,secret_hash,created_at) VALUES (?,?,?,?,?,?)',
+               [client_id, name, json.dumps(uris), method, digest(secret) if method != 'none' else None, timestamp])
+    result = {'client_id': client_id, 'client_id_issued_at': timestamp, 'client_name': name,
+              'redirect_uris': uris, 'token_endpoint_auth_method': method,
+              'grant_types': ['authorization_code', 'refresh_token'], 'response_types': ['code']}
+    if method != 'none':
+        result.update(client_secret=secret, client_secret_expires_at=0)
+    return JSONResponse(result, status_code=201, headers=NO_STORE)
+
+
+@router.get('/api/mcp-oauth/authorize')
+def authorize(request: Request):
+    _enabled()
+    p = dict(request.query_params)
+    if any(len(request.query_params.getlist(k)) != 1 for k in p) or len(str(request.url)) > 10000:
+        raise OAuthError('invalid_request', 'Invalid authorization parameters.')
+    client = _client(p.get('client_id'))
+    if not _redirect_matches(p.get('redirect_uri'), json.loads(client['redirect_uris'])):
+        raise OAuthError('invalid_request', 'Redirect URI does not match the registered client.')
+    if p.get('response_type') != 'code':
+        raise OAuthError('unsupported_response_type', 'Use response_type=code.')
+    if p.get('code_challenge_method') != 'S256' or not re.fullmatch(r'[A-Za-z0-9_-]{43}', p.get('code_challenge', '')):
+        raise OAuthError('invalid_request', 'S256 PKCE is required.')
+    if p.get('resource', resource_url(request)) != resource_url(request):
+        raise OAuthError('invalid_target', 'Unknown MCP resource.')
+    p['resource'] = resource_url(request)
+    p['scope'] = _scope(p.get('scope'))
+    request_id = secrets.token_hex(32)
+    db = get_db()
+    with db.atomic():
+        db.sql('DELETE FROM "MCP OAuth Request" WHERE expires_at < ?', [int(time.time())])
+        db.sql('INSERT INTO "MCP OAuth Request" (id,params,expires_at) VALUES (?,?,?)',
+               [request_id, json.dumps(p), int(time.time()) + 600])
+    response = RedirectResponse('/connect/authorize?request=' + request_id, status_code=303, headers=NO_STORE)
+    https = issuer(request).startswith('https://')
+    # Apple's social sign-in returns with a cross-site form POST.
+    response.set_cookie(RETURN_COOKIE, request_id, max_age=600, httponly=True,
+                        secure=https, samesite='none' if https else 'lax', path='/api/auth')
+    return response
+
+
+def _pending(request_id):
+    rows = get_db().sql('SELECT * FROM "MCP OAuth Request" WHERE id = ? AND consumed = 0 AND expires_at > ?',
+                        [request_id, int(time.time())])
+    if not rows:
+        raise OAuthError('invalid_request', 'This connection request has expired. Start again in your app.')
+    return json.loads(rows[0]['params'])
+
+
+@router.get('/api/mcp-oauth/consent')
+def consent(request: Request, request_id: str, user: dict = Depends(require_interactive_user)):
+    _enabled()
+    p = _pending(request_id)
+    client = _client(p['client_id'])
+    # This signed CSRF token binds approval to the logged-in user and request.
+    csrf = jwt.encode({'sub': user['name'], 'rid': request_id, 'aud': 'mcp-consent',
+                       'exp': int(time.time()) + 600}, SECRET_KEY, algorithm=ALGORITHM)
+    maximum = min(ROLE_HIERARCHY[user['role']], ROLE_HIERARCHY[_role(p['scope'])])
+    return JSONResponse({'client_name': client['name'], 'redirect_uri': p['redirect_uri'],
+                         'roles': [r for r in ('viewer', 'manager', 'admin') if ROLE_HIERARCHY[r] <= maximum],
+                         'csrf_token': csrf}, headers=NO_STORE)
+
+
+class ConsentDecision(BaseModel):
+    request_id: str
+    csrf_token: str
+    allow: bool
+    role: str = 'viewer'
+
+
+@router.post('/api/mcp-oauth/consent')
+def approve(data: ConsentDecision, request: Request, user: dict = Depends(require_interactive_user)):
+    _enabled()
+    origin = request.headers.get('origin')
+    if origin and origin != issuer(request):
+        raise OAuthError('access_denied', 'Invalid request origin.', 403)
+    try:
+        claims = jwt.decode(data.csrf_token, SECRET_KEY, algorithms=[ALGORITHM], audience='mcp-consent')
+        if claims['sub'] != user['name'] or claims['rid'] != data.request_id:
+            raise ValueError()
+    except (JWTError, KeyError, ValueError):
+        raise OAuthError('access_denied', 'Approval expired. Reload this page.', 403)
+    p = _pending(data.request_id)
+    client = _client(p['client_id'])
+    if data.allow and (data.role not in SCOPES.values() or ROLE_HIERARCHY[data.role] > min(ROLE_HIERARCHY[user['role']], ROLE_HIERARCHY[_role(p['scope'])])):
+        raise OAuthError('invalid_scope', 'The app cannot exceed your role or its requested access.')
+    query = {'state': p['state']} if 'state' in p else {}
+    db = get_db()
+    with db.atomic():
+        claimed = db.sql('UPDATE "MCP OAuth Request" SET consumed = 1 WHERE id = ? AND consumed = 0 AND expires_at > ? RETURNING id',
+                         [data.request_id, int(time.time())])
+        if not claimed:
+            raise OAuthError('invalid_request', 'This approval has already been used or expired.')
+        if data.allow:
+            key_id, code = str(uuid.uuid4()), secrets.token_urlsafe(32)
+            scope = ' '.join(s for s in p['scope'].split() if ROLE_HIERARCHY[SCOPES[s]] <= ROLE_HIERARCHY[data.role]) or 'erp:read'
+            db.sql('INSERT INTO "Api Key" (id,name,owner,key_prefix,role,session_owner,created_at,app_type) VALUES (?,?,?,?,?,?,?,?)',
+                   [key_id, client['name'], user['name'], 'OAuth', data.role, f"api:{user['name']}", now(), 'oauth'])
+            db.sql('INSERT INTO "MCP OAuth Code" (hash,client_id,key_id,redirect_uri,challenge,resource,scope,expires_at) VALUES (?,?,?,?,?,?,?,?)',
+                   [digest(code), client['id'], key_id, p['redirect_uri'], p['code_challenge'], p['resource'], scope, int(time.time()) + 120])
+            query['code'] = code
+        else:
+            query['error'] = 'access_denied'
+    parts = urlsplit(p['redirect_uri'])
+    redirect = urlunsplit(parts._replace(query=urlencode(parse_qsl(parts.query) + list(query.items()))))
+    response = JSONResponse({'redirect_uri': redirect}, headers=NO_STORE)
+    response.delete_cookie(RETURN_COOKIE, path='/api/auth')
+    return response
+
+
+def _authenticate_client(request, form):
+    client_id, secret = form.get('client_id'), form.get('client_secret', '')
+    header = request.headers.get('authorization', '')
+    basic = header.lower().startswith('basic ')
+    if basic:
+        try:
+            cid, secret = base64.b64decode(header[6:], validate=True).decode().split(':', 1)
+            cid, secret = unquote(cid), unquote(secret)
+        except (ValueError, UnicodeError):
+            raise OAuthError('invalid_client', 'Invalid client authentication.', 401)
+        if client_id and client_id != cid:
+            raise OAuthError('invalid_client', 'Conflicting client IDs.', 401)
+        client_id = cid
+    client = _client(client_id)
+    method = client['auth_method']
+    if (method == 'client_secret_basic' and not basic) or (method == 'client_secret_post' and basic):
+        raise OAuthError('invalid_client', 'Use the registered authentication method.', 401)
+    if method != 'none' and not hmac.compare_digest(digest(secret), client['secret_hash']):
+        raise OAuthError('invalid_client', 'Invalid client authentication.', 401)
+    return client
+
+
+async def _token_form(request):
+    if len(await request.body()) > 16384:
+        raise OAuthError('invalid_request', 'Token request is too large.')
+    form = await request.form()
+    if any(len(form.getlist(k)) != 1 for k in form) or any(not isinstance(v, str) or len(v) > 4096 for v in form.values()):
+        raise OAuthError('invalid_request', 'Invalid token parameters.')
+    return form
+
+
+def _grant_user(key_id):
+    principal = refresh_auth_principal({'credential_type': API_KEY_CREDENTIAL, 'api_key_id': key_id})
+    if not principal or principal['role'] == 'public_manager':
+        raise OAuthError('invalid_grant', 'Connection revoked or account no longer available.')
+    return principal
+
+
+def _issue_tokens(db, grant):
+    access, refresh = 'erp_oauth_' + secrets.token_urlsafe(32), secrets.token_urlsafe(48)
+    for token, kind, ttl in ((access, 'access', ACCESS_TTL), (refresh, 'refresh', REFRESH_TTL)):
+        db.sql('INSERT INTO "MCP OAuth Token" (hash,kind,client_id,key_id,resource,scope,expires_at) VALUES (?,?,?,?,?,?,?)',
+               [digest(token), kind, grant['client_id'], grant['key_id'], grant['resource'], grant['scope'], int(time.time()) + ttl])
+    return {'access_token': access, 'token_type': 'Bearer', 'expires_in': ACCESS_TTL,
+            'refresh_token': refresh, 'scope': grant['scope']}
+
+
+@router.post('/api/mcp-oauth/token')
+async def token_endpoint(request: Request):
+    _enabled()
+    form = await _token_form(request)
+    client = _authenticate_client(request, form)
+    kind = form.get('grant_type')
+    if kind not in {'authorization_code', 'refresh_token'}:
+        raise OAuthError('unsupported_grant_type', 'Use authorization_code or refresh_token.')
+    db = get_db()
+    table = 'MCP OAuth Code' if kind == 'authorization_code' else 'MCP OAuth Token'
+    token_hash = digest(form.get('code' if kind == 'authorization_code' else 'refresh_token', ''))
+    rows = db.sql(f'SELECT * FROM "{table}" WHERE hash = ? AND client_id = ?', [token_hash, client['id']])
+    if not rows or rows[0]['expires_at'] <= time.time():
+        raise OAuthError('invalid_grant', 'Invalid or expired credential.')
+    grant = rows[0]
+    if grant['resource'] != resource_url(request) or form.get('resource', grant['resource']) != grant['resource']:
+        raise OAuthError('invalid_target', 'Token is bound to a different MCP resource.')
+    if kind == 'authorization_code':
+        verifier = form.get('code_verifier', '')
+        challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).decode().rstrip('=')
+        if (not re.fullmatch(r'[A-Za-z0-9._~-]{43,128}', verifier)
+                or not hmac.compare_digest(challenge, grant['challenge'])
+                or form.get('redirect_uri') != grant['redirect_uri']):
+            raise OAuthError('invalid_grant', 'Invalid PKCE verifier or redirect URI.')
+    elif grant['kind'] != 'refresh':
+        raise OAuthError('invalid_grant', 'Expected a refresh token.')
+    if grant['consumed']:
+        # A replayed refresh token invalidates the entire grant/token family.
+        if kind == 'refresh_token':
+            with db.atomic():
+                db.sql('UPDATE "Api Key" SET revoked = 1 WHERE id = ?', [grant['key_id']])
+        raise OAuthError('invalid_grant', 'Credential already used. Connect again.')
+    _grant_user(grant['key_id'])
+    if form.get('scope'):
+        narrowed = _scope(form['scope'])
+        if not set(narrowed.split()) <= set(grant['scope'].split()):
+            raise OAuthError('invalid_scope', 'Refresh cannot expand permissions.')
+        grant['scope'] = narrowed
+    with db.atomic():
+        claimed = db.sql(f'UPDATE "{table}" SET consumed = 1 WHERE hash = ? AND consumed = 0 AND expires_at > ? RETURNING hash',
+                         [token_hash, int(time.time())])
+        if claimed:
+            result = _issue_tokens(db, grant)
+        else:
+            # A second worker may have consumed the same refresh token after
+            # our initial read. Commit family revocation before returning error.
+            if kind == 'refresh_token':
+                db.sql('UPDATE "Api Key" SET revoked = 1 WHERE id = ?', [grant['key_id']])
+            result = None
+    if result is None:
+        raise OAuthError('invalid_grant', 'Credential already used or expired.')
+    return JSONResponse(result, headers=NO_STORE)
+
+
+def authenticate_access_token(request, token):
+    _enabled()
+    rows = get_db().sql('SELECT * FROM "MCP OAuth Token" WHERE hash = ? AND kind = ? AND expires_at > ?',
+                        [digest(token), 'access', int(time.time())])
+    if not rows or rows[0]['resource'] != resource_url(request):
+        raise HTTPException(401, 'Invalid or expired OAuth access token', headers=challenge_header(request))
+    grant = rows[0]
+    try:
+        user = _grant_user(grant['key_id'])
+    except OAuthError:
+        raise HTTPException(401, 'OAuth connection revoked', headers=challenge_header(request))
+    user['role'] = min((user['role'], _role(grant['scope'])), key=lambda r: ROLE_HIERARCHY[r])
+    user['oauth_scope_role'] = _role(grant['scope'])
+    # Return a user principal, not the isolated programmatic chat identity.
+    user['name'] = user['user_id']
+    db = get_db()
+    with db.atomic():
+        db.sql('UPDATE "Api Key" SET last_used_at = ? WHERE id = ?', [now(), grant['key_id']])
+    return user
+
+
+@router.post('/api/mcp-oauth/revoke')
+async def revoke_token(request: Request):
+    form = await _token_form(request)
+    client = _authenticate_client(request, form)
+    rows = get_db().sql('SELECT key_id FROM "MCP OAuth Token" WHERE hash = ? AND client_id = ?',
+                        [digest(form.get('token', '')), client['id']])
+    if rows:
+        db = get_db()
+        with db.atomic():
+            db.sql('UPDATE "Api Key" SET revoked = 1 WHERE id = ?', [rows[0]['key_id']])
+    return JSONResponse({}, headers=NO_STORE)

{lambda_erp-1.1.2 → lambda_erp-1.1.4}/api/oauth.py

@@ -29,6 +29,7 @@ import uuid
 import hmac
 import hashlib
 import secrets as _secrets
+import re
 
 import httpx
 from jose import jwt, JWTError
@@ -474,7 +475,10 @@ async def _read_callback_params(request: Request) -> dict:
 
 def _login_redirect(request: Request, user_name: str, flow_id: str | None = None) -> RedirectResponse:
     token = create_access_token(user_name)
-    resp = RedirectResponse(url="/", status_code=303)
+    mcp_request = request.cookies.get('lambda_erp_mcp_return', '')
+    target = '/connect/authorize?request=' + mcp_request if re.fullmatch(r'[a-f0-9]{64}', mcp_request) else '/'
+    resp = RedirectResponse(url=target, status_code=303)
+    resp.delete_cookie('lambda_erp_mcp_return', path='/api/auth')
     set_auth_cookie(request, resp, token)
     if flow_id:
         _clear_flow_cookie(resp, flow_id)

{lambda_erp-1.1.2 → lambda_erp-1.1.4}/api/routers/mcp.py

@@ -4,9 +4,9 @@ LLM agents (Claude, Codex, …) over MCP's Streamable HTTP transport.
 Reuses everything the chat already has, so there's almost no new logic:
   * schemas   — build_tools() (the live, plugin-widened tool list).
   * execution — the same TOOL_HANDLERS (which run validate()).
-  * auth      — get_current_user: a Bearer API key acts AS its user at the key's
-                role, exactly like the REST API, gated by the same
-                `rest_api_enabled` Settings flag. No separate MCP credential.
+  * auth      — Bearer API keys or resource-bound OAuth tokens, acting as their
+                owner with a live role cap. Both use `rest_api_enabled`.
+                Ambient session cookies are never MCP credentials.
 
 Because the tool schemas come from the live registries, a plugin that registers
 doctypes/masters (e.g. the internal CRM's lead/contact/activity) is exposed here
@@ -16,12 +16,15 @@ Transport: a single POST /api/mcp speaking JSON-RPC 2.0 (request → JSON result
 notifications → 202, no body). That's the minimum a tool-only server needs.
 """
 import json
+import os
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import JSONResponse, Response
 
 from lambda_erp import get_app_version
-from api.auth import get_current_user
+from api.auth import _lookup_api_key, _setting_enabled, make_auth_principal, API_KEY_CREDENTIAL
+from api.mcp_oauth import authenticate_access_token, challenge_header, issuer
+from lambda_erp.database import get_db
 from api import services
 from api import chat as chat_mod
 from api.chat import TOOL_HANDLERS, build_tools
@@ -30,6 +33,7 @@ from api.tool_permissions import tool_allowed
 router = APIRouter(tags=["mcp"])
 
 PROTOCOL_VERSION = "2025-06-18"
+SUPPORTED_PROTOCOL_VERSIONS = frozenset({'2025-03-26', PROTOCOL_VERSION})
 
 # Chat-session-only tools have no meaning without a chat session — keep them out
 # of the MCP surface (an MCP client owns its own context).
@@ -44,18 +48,35 @@ _EXCLUDE = {
     "apply_company_setup",
 }
 
+_READ_ONLY = {
+    'list_documents', 'get_document_fields', 'get_document', 'get_master_fields',
+    'search_masters', 'get_report', 'get_current_time', 'query_dataset',
+    'preview_bank_statement_attachments', 'list_bank_reconciliation_queue',
+    'suggest_bank_reconciliation',
+}
+
 
 def _allowed(name: str, role) -> bool:
     return name not in _EXCLUDE and tool_allowed(name, role)
 
 
 def _require_caller(request: Request) -> dict:
-    """A valid Bearer API key is mandatory for MCP — no cookie/public fallback.
-    get_current_user then validates the key and applies `rest_api_enabled`."""
+    """MCP accepts API keys and OAuth tokens, never ambient browser cookies."""
     auth = request.headers.get("authorization", "")
     if not auth.lower().startswith("bearer "):
-        raise HTTPException(status_code=401, detail="MCP requires a Bearer API key")
-    return get_current_user(request)
+        raise HTTPException(status_code=401, detail="Connect your account or supply a Bearer API key", headers=challenge_header(request))
+    token = auth[7:].strip()
+    if token.startswith('erp_oauth_'):
+        return authenticate_access_token(request, token)
+    db = get_db()
+    if not _setting_enabled(db, 'rest_api_enabled'):
+        raise HTTPException(403, 'REST API / MCP access is disabled')
+    try:
+        key, owner, role = _lookup_api_key(db, token)
+    except HTTPException as exc:
+        raise HTTPException(exc.status_code, exc.detail, headers=challenge_header(request))
+    owner = dict(owner, role=role)
+    return make_auth_principal(owner, API_KEY_CREDENTIAL, api_key_id=key['id'])
 
 
 def _tools(role) -> list:
@@ -68,6 +89,16 @@ def _tools(role) -> list:
             "name": fn["name"],
             "description": fn.get("description", ""),
             "inputSchema": fn.get("parameters") or {"type": "object", "properties": {}},
+            "annotations": {
+                "readOnlyHint": fn['name'] in _READ_ONLY,
+                # Unknown extension actions are conservatively treated as writes.
+                "destructiveHint": fn['name'] not in _READ_ONLY | {'generate_document_pdf'},
+                "openWorldHint": fn['name'] in services.REGISTERED_ACTIONS,
+            },
+            "securitySchemes": [{"type": "oauth2", "scopes": [
+                'erp:read' if tool_allowed(fn['name'], 'viewer') else
+                'erp:write' if tool_allowed(fn['name'], 'manager') else 'erp:admin'
+            ]}],
         })
     return out
 
@@ -116,6 +147,10 @@ def _rpc_error(mid, code: int, message: str) -> dict:
 def _handle(msg: dict, user: dict):
     """Handle one JSON-RPC message. Returns a response dict, or None for a
     notification (no `id`)."""
+    if msg.get('jsonrpc') != '2.0' or not isinstance(msg.get('method'), str):
+        return _rpc_error(msg.get('id'), -32600, 'Invalid Request')
+    if 'params' in msg and not isinstance(msg['params'], dict):
+        return _rpc_error(msg.get('id'), -32602, 'Expected object parameters')
     method = msg.get("method")
     mid = msg.get("id")
     is_notification = "id" not in msg
@@ -124,8 +159,12 @@ def _handle(msg: dict, user: dict):
         return None if is_notification else {"jsonrpc": "2.0", "id": mid, "result": payload}
 
     if method == "initialize":
+        requested_version = (msg.get('params') or {}).get('protocolVersion', PROTOCOL_VERSION)
+        if not isinstance(requested_version, str):
+            return _rpc_error(mid, -32602, 'Expected a string protocolVersion')
         return result({
-            "protocolVersion": PROTOCOL_VERSION,
+            "protocolVersion": (requested_version if requested_version in SUPPORTED_PROTOCOL_VERSIONS
+                                else PROTOCOL_VERSION),
             "capabilities": {"tools": {"listChanged": False}},
             "serverInfo": {"name": "lambda-erp", "version": get_app_version()},
         })
@@ -156,13 +195,28 @@ def _handle(msg: dict, user: dict):
 
 @router.post("/mcp")
 async def mcp_endpoint(request: Request):
+    origin = request.headers.get('origin')
+    allowed_origins = {issuer(request), *os.environ.get('MCP_ALLOWED_ORIGINS', '').split(',')}
+    if origin and origin not in allowed_origins:
+        raise HTTPException(403, 'Invalid Origin')
+    # Authentication discovery must work before the client has negotiated an
+    # MCP version. Otherwise a newer connector gets 400 instead of the 401
+    # challenge that tells it how to sign in.
     user = _require_caller(request)
     try:
         body = await request.json()
     except Exception:
         return JSONResponse(_rpc_error(None, -32700, "Parse error"), status_code=400)
 
-    # JSON-RPC batch (a list) or a single message.
+    # Keep legacy batch support, but reject malformed messages rather than 500.
+    if not isinstance(body, (dict, list)) or (isinstance(body, list) and (not body or any(not isinstance(m, dict) for m in body))):
+        return JSONResponse(_rpc_error(None, -32600, "Invalid Request"), status_code=400)
+    # initialize negotiates the revision in its JSON-RPC payload. The version
+    # header is enforced on subsequent calls, after the client has our answer.
+    initializing = isinstance(body, dict) and body.get('method') == 'initialize'
+    version = request.headers.get('mcp-protocol-version')
+    if not initializing and version and version not in SUPPORTED_PROTOCOL_VERSIONS:
+        raise HTTPException(400, 'Unsupported MCP protocol version')
     if isinstance(body, list):
         responses = [r for r in (_handle(m, user) for m in body) if r is not None]
         return JSONResponse(responses) if responses else Response(status_code=202)
@@ -170,3 +224,9 @@ async def mcp_endpoint(request: Request):
     if resp is None:
         return Response(status_code=202)
     return JSONResponse(resp)
+
+
+@router.get('/mcp')
+def mcp_no_stream():
+    # A stateless JSON transport does not offer a server-initiated SSE stream.
+    return Response(status_code=405, headers={'Allow': 'POST'})

{lambda_erp-1.1.2 → lambda_erp-1.1.4}/frontend/src/api/client.ts

@@ -57,7 +57,7 @@ export async function request<T>(path: string, options?: RequestInit): Promise<T
       throw new ApiError(401, "Session expired");
     }
     const body = await res.json().catch(() => ({ detail: res.statusText }));
-    throw new ApiError(res.status, formatErrorDetail(body.detail));
+    throw new ApiError(res.status, formatErrorDetail(body.detail || body.error_description));
   }
   return res.json();
 }
@@ -74,7 +74,7 @@ async function multipartRequest<T>(path: string, form: FormData): Promise<T> {
       throw new ApiError(401, "Session expired");
     }
     const body = await res.json().catch(() => ({ detail: res.statusText }));
-    throw new ApiError(res.status, formatErrorDetail(body.detail));
+    throw new ApiError(res.status, formatErrorDetail(body.detail || body.error_description));
   }
   return res.json() as Promise<T>;
 }
@@ -746,17 +746,21 @@ export const api = {
   getMySettings: () => request<Record<string, string>>("/auth/my-settings"),
   updateMySettings: (data: Record<string, string>) =>
     request<Record<string, string>>("/auth/my-settings", { method: "PUT", body: JSON.stringify(data) }),
+  getConnectionStatus: () => request<{ mcp_url: string; rest_enabled: boolean; chat_enabled: boolean }>("/mcp-oauth/status"),
+  getMcpConsent: (requestId: string) => request<{ client_name: string; redirect_uri: string; roles: string[]; csrf_token: string }>(`/mcp-oauth/consent?request_id=${encodeURIComponent(requestId)}`),
+  approveMcp: (request_id: string, csrf_token: string, allow: boolean, role: string) =>
+    request<{ redirect_uri: string }>("/mcp-oauth/consent", { method: "POST", body: JSON.stringify({ request_id, csrf_token, allow, role }) }),
   getApiKeys: () =>
     request<Array<{
       id: string; name: string; user?: string; role: string; key_prefix: string;
-      created_at?: string; last_used_at?: string | null; revoked: boolean;
+      created_at?: string; last_used_at?: string | null; revoked: boolean; app_type?: string;
       owner_full_name?: string | null; owner_email?: string | null; is_mine?: boolean;
     }>>("/auth/api-keys"),
-  createApiKey: (name: string, role: string) =>
+  createApiKey: (name: string, role: string, app_type: "claude_code" | "codex" | "other" = "other") =>
     request<{
       id: string; name: string; user?: string; role: string; key_prefix: string; token: string;
       owner_full_name?: string | null; owner_email?: string | null; is_mine?: boolean;
-    }>("/auth/api-keys", { method: "POST", body: JSON.stringify({ name, role }) }),
+    }>("/auth/api-keys", { method: "POST", body: JSON.stringify({ name, role, app_type }) }),
   revokeApiKey: (id: string) =>
     request<{ id: string; revoked: boolean }>(
       `/auth/api-keys/${encodeURIComponent(id)}/revoke`, { method: "POST" }),

{lambda_erp-1.1.2 → lambda_erp-1.1.4}/lambda_erp/database.py

@@ -1695,6 +1695,25 @@ class Database:
                 revoked INTEGER DEFAULT 0
             )""",
 
+            """CREATE TABLE IF NOT EXISTS "MCP OAuth Client" (
+                id TEXT PRIMARY KEY, name TEXT NOT NULL, redirect_uris TEXT NOT NULL,
+                auth_method TEXT NOT NULL, secret_hash TEXT, created_at INTEGER NOT NULL
+            )""",
+            """CREATE TABLE IF NOT EXISTS "MCP OAuth Request" (
+                id TEXT PRIMARY KEY, params TEXT NOT NULL, expires_at INTEGER NOT NULL,
+                consumed INTEGER DEFAULT 0
+            )""",
+            """CREATE TABLE IF NOT EXISTS "MCP OAuth Code" (
+                hash TEXT PRIMARY KEY, client_id TEXT NOT NULL, key_id TEXT NOT NULL,
+                redirect_uri TEXT NOT NULL, challenge TEXT NOT NULL, resource TEXT NOT NULL,
+                scope TEXT NOT NULL, expires_at INTEGER NOT NULL, consumed INTEGER DEFAULT 0
+            )""",
+            """CREATE TABLE IF NOT EXISTS "MCP OAuth Token" (
+                hash TEXT PRIMARY KEY, kind TEXT NOT NULL, client_id TEXT NOT NULL,
+                key_id TEXT NOT NULL, resource TEXT NOT NULL, scope TEXT NOT NULL,
+                expires_at INTEGER NOT NULL, consumed INTEGER DEFAULT 0
+            )""",
+
             # Exchange rates for multi-currency. A lookup carries forward the
             # most recent rate on/before a transaction's date; the rate is then
             # snapshotted onto the document, so editing this table never changes
@@ -2855,6 +2874,10 @@ def _m038_customer_website(db: "Database") -> None:
     db.ensure_column("Customer", "website", "TEXT")
 
 
+def _m039_connection_app_type(db: "Database") -> None:
+    db.ensure_column("Api Key", "app_type", "TEXT DEFAULT 'other'")
+
+
 Database.MIGRATIONS = [
     (1, "chat_message_session_id", _m001_chat_message_session_id),
     (2, "chat_session_user_id", _m002_chat_session_user_id),
@@ -2894,6 +2917,7 @@ Database.MIGRATIONS = [
     (36, "external_identity_integrity", _m036_external_identity_integrity),
     (37, "pricing_record_lifecycle", _m037_pricing_record_lifecycle),
     (38, "customer_website", _m038_customer_website),
+    (39, "connection_app_type", _m039_connection_app_type),
 ]
 
 

{lambda_erp-1.1.2 → lambda_erp-1.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "1.1.2"
+version = "1.1.4"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "Apache-2.0"