"""App actions through the registry and the shared confirmation path.""" import base64 import copy import hashlib import json from core import external_tools, perm_scope, sheets import application_registry as applications from app_guide import BRIEF from loopy_catalog_tools import _schema as catalog_pdf_schema from loopy_catalog_tools import build_schema as catalog_build_schema from . import legacy_action def _admit(ctx, *, write=False): session = ctx.session reason = perm_scope.ai_apps_refusal(session.user, session.runtime) if reason: raise sheets.SheetRefusal("ai_apps_off", reason) if write: from routes_external import _assert_write_scope _assert_write_scope(session, "apps") return session def _access(ctx, databases, *, strict=False): from routes_assets import application_access_context from routes_external import _assert_database_scope for database in databases: _assert_database_scope(ctx.session, database) return application_access_context(ctx.session, databases, strict=strict) def _fields(ctx, databases): return {database: ctx.describe_database(database)["fields"] for database in databases} def _attribution(session): from routes_external import _trusted_activity_via external = (session.claims or {}).get("external") is True return {"via": _trusted_activity_via(session), "on_behalf_of": session.uname, "origin_door": "mcp" if external else "loopy"} def _refuse(exc): from routes_assets import _application_error _application_error(exc) def templates(ctx, args): _admit(ctx) return {"templates": applications.template_contracts()} def _catalog_link(app): if app.get("templateKind") == "catalog": from loopy_links import application_link databases = app.get("compatibleDatabases") or [] app["deepLink"] = application_link(app["id"], databases[0] if databases else None) return app def list_apps(ctx, args): session = _admit(ctx) from core import external_access from routes_external import _key_scope scope = _key_scope(session)[1] databases = {database for app in applications.load(session.runtime)["applications"].values() if applications._listed(app, session.uname) for database in app.get("compatibleDatabases") or [] if external_access.database_allowed(scope, database)} try: allowed, _ = _access(ctx, sorted(databases)) return {"applications": [_catalog_link(app) for app in applications.list_apps( session.runtime, session.uname, session.admin, allowed_databases=allowed)]} except (applications.ApplicationError, PermissionError) as exc: _refuse(exc) def catalog_pdf(ctx, args): session = _admit(ctx) import catalog_store import loopy_catalog_tools # The stored record admits its actual App source and credential scope. catalog_store._record(session, args["catalog_id"]) return loopy_catalog_tools.catalog_pdf(session, args) def catalog_build(ctx, args): _admit(ctx, write=True) from loopy_catalog_tools import catalog_build as build return build(ctx, args) def _read(ctx, app_id): session = _admit(ctx) app = applications.load(session.runtime)["applications"].get(app_id) if (not app or app.get("retired") is True or not applications.may_read(app, session.uname, session.admin)): raise applications.ApplicationError("application does not exist") databases = app.get("compatibleDatabases") or [] allowed, _ = _access(ctx, databases) if applications._is_finance(app): if not applications._account_wall(session.runtime, session.user)(applications._finance_permission(app)): raise applications.ApplicationError("application does not exist") elif databases and not allowed: raise applications.ApplicationError("application does not exist") return app, allowed def get(ctx, args): try: app, allowed = _read(ctx, args["app_id"]) result = applications._public(app, ctx.session.uname, ctx.session.admin, allowed_databases=allowed) if app["type"] == "code": result["config"]["display"]["html"] = app["config"]["display"]["html"] return {"application": _catalog_link(result)} except (applications.ApplicationError, PermissionError) as exc: _refuse(exc) def apply_template(ctx, args): session = _admit(ctx, write=True) try: payload = copy.deepcopy(args) if payload["templateKind"] not in {row["kind"] for row in applications.template_contracts()}: raise applications.ApplicationError("Choose a template from apps.templates.") share = payload.pop("share", None) source = payload.get("sourceDatabase") databases = [source] if source else [] allowed, records = _access(ctx, databases, strict=True) payload.setdefault("navPlacement", {"section": "app", "order": 0}) attribution = _attribution(session) result = applications.create( session.runtime, session.tenant, session.uname, payload, allowed_databases=allowed, semantic_records=records, field_contracts=_fields(ctx, allowed), **attribution) if share is not None: result = applications.mutate( session.runtime, result["id"], session.uname, session.admin, {"share": share}, allowed_databases=allowed, semantic_records=records, field_contracts=_fields(ctx, allowed), **attribution) return _result(result) except (applications.ApplicationError, PermissionError) as exc: _refuse(exc) def _result(app): result = {"application": _catalog_link(app)} if app.get("shareApproval"): result["warnings"] = [app["shareApproval"]["message"]] return result def save_code(ctx, args): session = _admit(ctx, write=True) try: payload = {key: copy.deepcopy(args[key]) for key in ("name", "compatibleDatabases", "share") if key in args} payload["config"] = {"schemaVersion": 1, "display": {"mode": "code", "html": args["html"]}} attribution = _attribution(session) app_id = args.get("app_id") if app_id: current, allowed = _read(ctx, app_id) if current["type"] != "code": raise applications.ApplicationError("Choose a code App to update.") proposed = payload.get("compatibleDatabases", current.get("compatibleDatabases") or []) proposed_allowed, records = _access(ctx, proposed, strict=True) result = applications.mutate( session.runtime, app_id, session.uname, session.admin, payload, allowed_databases=allowed | proposed_allowed, semantic_records=records, **attribution) else: share = payload.pop("share", None) payload.update(type="code") payload.setdefault("compatibleDatabases", []) allowed, records = _access(ctx, payload["compatibleDatabases"], strict=True) result = applications.create( session.runtime, session.tenant, session.uname, payload, allowed_databases=allowed, semantic_records=records, **attribution) if share is not None: result = applications.mutate( session.runtime, result["id"], session.uname, session.admin, {"share": share}, allowed_databases=allowed, **attribution) return _result(result) except (applications.ApplicationError, PermissionError) as exc: _refuse(exc) def guide(ctx, args): _admit(ctx) import app_guide return app_guide.read(args.get("section")) def preview_documents(documents): """Project code bodies to a bounded excerpt before the host computes its diff.""" projected = copy.deepcopy(documents) pair = projected.get(applications._KEY) if pair: for side in ("before", "after"): if not isinstance(pair[side], dict): continue pair[side] = applications._clean_doc(pair[side]) for app in pair[side]["applications"].values(): if app.get("type") == "code": html = app["config"]["display"].pop("html") app["config"]["display"].update( htmlBytes=len(html.encode("utf-8")), htmlSha256=hashlib.sha256(html.encode("utf-8")).hexdigest(), firstLines="\n".join(html.split("\n")[:5])[:500]) return projected def pending_arguments(arguments, *, encode): """Encode the pending code body for JSONB and restore it before confirmation.""" result = copy.deepcopy(arguments) if result.get("action") == "save_code": args = result["arguments"] if encode and isinstance(args.get("html"), str): args["html"] = {"encoding": "utf8-base64-v1", "data": base64.b64encode(args["html"].encode("utf-8")).decode("ascii")} elif not encode and isinstance(args.get("html"), dict): encoded = args["html"] if set(encoded) != {"encoding", "data"} or encoded["encoding"] != "utf8-base64-v1": raise ValueError("The pending App body cannot be read.") args["html"] = base64.b64decode(encoded["data"], validate=True).decode("utf-8") return result def code_transport_fits(value, limit): """Allow JSON escaping overhead while bounding the HTML and all other arguments.""" if not isinstance(value, dict): return False document = copy.deepcopy(value) args = document.get("arguments") if document.get("tool") == "apps" else document if not isinstance(args, dict) or args.get("action") != "save_code": return False body = args.get("arguments") if not isinstance(body, dict): return False html = body.get("html") if isinstance(html, dict): html = pending_arguments(args, encode=False)["arguments"]["html"] if not isinstance(html, str) or len(html.encode("utf-8")) > applications._MAX_DISPLAY_BYTES: return False body["html"] = "" return len(json.dumps(document, ensure_ascii=True, allow_nan=False).encode("utf-8")) <= limit def loopy(session, args): """Serve the Assistant's App group through the same preview and read dispatcher.""" from routes_external import _dispatch_mcp reply = _dispatch_mcp({"jsonrpc": "2.0", "id": "loopy-apps", "method": "tools/call", "params": {"name": "apps", "arguments": args}}, session) return json.loads(reply["result"]["content"][0]["text"]) def loopy_confirm(session, args): """Apply an agreed Assistant App preview through confirm_change.""" from routes_external import _dispatch_mcp, _read_confirmation_token payload = _read_confirmation_token(args.get("confirmation_token"), session=session) if payload.get("tool") != "apps" or payload["arguments"].get("action") not in ("apply_template", "save_code", "catalog_build"): raise sheets.SheetRefusal("confirmation_not_write", "Choose an App preview to confirm.") reply = _dispatch_mcp({"jsonrpc": "2.0", "id": "loopy-apps-confirm", "method": "tools/call", "params": {"name": "confirm_change", "arguments": args}}, session) return json.loads(reply["result"]["content"][0]["text"]) def _schema(properties, required=()): return {"type": "object", "properties": properties, "required": list(required), "additionalProperties": False} def _action(handler, properties, required=(), *, read=True, description=None): schema = _schema(properties, required) if description is not None: schema["description"] = description return {"read": read, "destructive": False, "confirm": not read, "schema": schema, "handler": handler} _TEXT = {"type": "string", "minLength": 1} _INTENT = {"type": "string", "minLength": 1, "maxLength": 500} _SHARE = _schema({"mode": {"enum": ["private", "users", "tenant"]}, "users": {"type": "array", "items": _TEXT}}, ("mode",)) LOOPY_SCHEMA = _schema({"action": {"type": "string"}, "arguments": {"type": "object"}, "intent": copy.deepcopy(_INTENT)}, ("action",)) if hasattr(external_tools, "ABOUT_SCHEMA"): LOOPY_SCHEMA["properties"]["about"] = copy.deepcopy(external_tools.ABOUT_SCHEMA) _CONFIRM_SCHEMA = copy.deepcopy(external_tools.TOOLS["confirm_change"]["inputSchema"]) _CONFIRM_SCHEMA["properties"]["intent"] = copy.deepcopy(_INTENT) GROUP = { "name": "apps", "title": "Apps", "guide": BRIEF, "actions": { "upsert": legacy_action("app_upsert"), "delete": legacy_action("app_delete", destructive=True), "templates": _action(templates, {}), "list": _action(list_apps, {}), "catalog_pdf": {"read": True, "destructive": False, "confirm": False, "schema": catalog_pdf_schema(), "handler": catalog_pdf}, "catalog_build": {"read": False, "destructive": False, "confirm": True, "buildKind": "app", "schema": catalog_build_schema(), "handler": catalog_build}, "apply_template": _action(apply_template, { "name": _TEXT, "templateKind": _TEXT, "sourceDatabase": _TEXT, "fieldMap": {"type": "object"}, "config": {"type": "object"}, "navPlacement": _schema({"section": {"enum": ["app"]}, "order": {"type": "integer"}}, ("section", "order")), "share": _SHARE, }, ("name", "templateKind"), read=False), "save_code": _action(save_code, { "app_id": _TEXT, "name": _TEXT, "html": {"type": "string"}, "compatibleDatabases": {"type": "array", "items": _TEXT}, "share": _SHARE, }, ("name", "html"), read=False, description=BRIEF), "get": _action(get, {"app_id": _TEXT}, ("app_id",)), "guide": _action(guide, {"section": _TEXT}), }, } # The Assistant callback returns a preview. Only confirm_change applies its product write. TOOLS = [{"name": "apps", "schema": {**LOOPY_SCHEMA, "description": GROUP["guide"]}, "fn": loopy, "effect": "read"}, {"name": "apps_confirm", "schema": { **_CONFIRM_SCHEMA, "description": "Call confirm_change only for an App preview the person agreed to. Use its confirmation_token."}, "fn": loopy_confirm, "effect": "write"}]