loopable / api /tool_groups /apps.py
fsanyoto's picture
Deploy AIOS web (React glide grid + FastAPI slice)
868b75a verified
Raw History Blame
14.6 kB
"""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"}]