open-action-consent 0.2.0__tar.gz

open_action_consent-0.2.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

open_action_consent-0.2.0/NOTICE

@@ -0,0 +1,5 @@
+Open Action Consent (OAC)
+Copyright 2026 Ishan Srivastava
+
+Code, schemas and test vectors: Apache License 2.0 (LICENSE).
+Specification text: CC BY 4.0 (LICENSE-SPEC).

open_action_consent-0.2.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: open-action-consent
+Version: 0.2.0
+Summary: Open Action Consent: a verifiable yes for actions AI agents take for people. Core SDK plus MCP, browser, approval page, OpenAI Agents and LangGraph integrations.
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Ishan2036924/open-action-consent
+Project-URL: Specification, https://github.com/Ishan2036924/open-action-consent/blob/main/spec/oac-v0.1.md
+Keywords: ai-agents,consent,mcp,agent-payments,jws,open-standard
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: cryptography>=42
+Provides-Extra: mcp
+Requires-Dist: mcp<3,>=2.3; extra == "mcp"
+Provides-Extra: browser
+Requires-Dist: mcp<3,>=2.3; extra == "browser"
+Requires-Dist: playwright>=1.50; extra == "browser"
+Provides-Extra: approver
+Requires-Dist: starlette>=0.40; extra == "approver"
+Requires-Dist: uvicorn>=0.30; extra == "approver"
+Provides-Extra: openai-agents
+Requires-Dist: openai-agents<0.30,>=0.24; extra == "openai-agents"
+Provides-Extra: langgraph
+Requires-Dist: langgraph<2,>=1.2; extra == "langgraph"
+Provides-Extra: all
+Requires-Dist: mcp<3,>=2.3; extra == "all"
+Requires-Dist: playwright>=1.50; extra == "all"
+Requires-Dist: starlette>=0.40; extra == "all"
+Requires-Dist: uvicorn>=0.30; extra == "all"
+Requires-Dist: openai-agents<0.30,>=0.24; extra == "all"
+Requires-Dist: langgraph<2,>=1.2; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: anyio>=4; extra == "test"
+Dynamic: license-file
+
+# open-action-consent (Python)
+
+**A verifiable "yes" for things AI agents do for people.** Before an agent sends, books, pays or deletes, the tool
+shows a Preview of exactly what will happen; the person signs a Consent over it; the action runs only if the signature
+and the limits check out; a signed Receipt says what ran and how to undo it.
+Spec and source: <https://github.com/Ishan2036924/open-action-consent>
+
+## Everything in this one package
+
+| Part | Install | Use | Guide |
+|---|---|---|---|
+| Core: previews, consents, mandates, receipts, undo, status lists, key discovery, `Gate` | `pip install open-action-consent` | `import oac` | [README](https://github.com/Ishan2036924/open-action-consent#readme) |
+| MCP servers (official MCP Python SDK, protocol 2026-07-28) | `pip install "open-action-consent[mcp]"` | `from oac.mcp import OACExtension` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/mcp-python.md) |
+| Gated Browser (stops before every final click) | `pip install "open-action-consent[browser]"` then `playwright install chromium` | `oac-gated-browser` or `from oac.browser import build_server` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/gated-browser.md) |
+| Approval page (the person's key stays in their browser) | `pip install "open-action-consent[approver]"` | `from oac.approver import Approver` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/approver.md) |
+| OpenAI Agents SDK | `pip install "open-action-consent[openai-agents]"` | `from oac.openai_agents import oac_tool` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/openai-agents.md) |
+| LangGraph | `pip install "open-action-consent[langgraph]"` | `from oac.langgraph import gated` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/langgraph.md) |
+| All of the above | `pip install "open-action-consent[all]"` | | |
+
+The core needs only `cryptography`. Each part pulls in its framework only when you install that option; importing a
+part without it tells you exactly what to install. JavaScript/TypeScript: `npm install open-action-consent`.
+
+Tests: `python -m pytest -q` (from this folder); conformance: `PYTHONPATH=src python -m oac.conformance ../../vectors`.
+License: Apache-2.0 (code), CC BY 4.0 (spec text).

open_action_consent-0.2.0/README.md

@@ -0,0 +1,24 @@
+# open-action-consent (Python)
+
+**A verifiable "yes" for things AI agents do for people.** Before an agent sends, books, pays or deletes, the tool
+shows a Preview of exactly what will happen; the person signs a Consent over it; the action runs only if the signature
+and the limits check out; a signed Receipt says what ran and how to undo it.
+Spec and source: <https://github.com/Ishan2036924/open-action-consent>
+
+## Everything in this one package
+
+| Part | Install | Use | Guide |
+|---|---|---|---|
+| Core: previews, consents, mandates, receipts, undo, status lists, key discovery, `Gate` | `pip install open-action-consent` | `import oac` | [README](https://github.com/Ishan2036924/open-action-consent#readme) |
+| MCP servers (official MCP Python SDK, protocol 2026-07-28) | `pip install "open-action-consent[mcp]"` | `from oac.mcp import OACExtension` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/mcp-python.md) |
+| Gated Browser (stops before every final click) | `pip install "open-action-consent[browser]"` then `playwright install chromium` | `oac-gated-browser` or `from oac.browser import build_server` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/gated-browser.md) |
+| Approval page (the person's key stays in their browser) | `pip install "open-action-consent[approver]"` | `from oac.approver import Approver` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/approver.md) |
+| OpenAI Agents SDK | `pip install "open-action-consent[openai-agents]"` | `from oac.openai_agents import oac_tool` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/openai-agents.md) |
+| LangGraph | `pip install "open-action-consent[langgraph]"` | `from oac.langgraph import gated` | [guide](https://github.com/Ishan2036924/open-action-consent/blob/main/guides/langgraph.md) |
+| All of the above | `pip install "open-action-consent[all]"` | | |
+
+The core needs only `cryptography`. Each part pulls in its framework only when you install that option; importing a
+part without it tells you exactly what to install. JavaScript/TypeScript: `npm install open-action-consent`.
+
+Tests: `python -m pytest -q` (from this folder); conformance: `PYTHONPATH=src python -m oac.conformance ../../vectors`.
+License: Apache-2.0 (code), CC BY 4.0 (spec text).

open_action_consent-0.2.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "open-action-consent"
+version = "0.2.0"
+description = "Open Action Consent: a verifiable yes for actions AI agents take for people. Core SDK plus MCP, browser, approval page, OpenAI Agents and LangGraph integrations."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+keywords = ["ai-agents", "consent", "mcp", "agent-payments", "jws", "open-standard"]
+dependencies = ["cryptography>=42"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Topic :: Security :: Cryptography",
+  "Topic :: Software Development :: Libraries",
+]
+
+[project.optional-dependencies]
+mcp = ["mcp>=2.3,<3"]
+browser = ["mcp>=2.3,<3", "playwright>=1.50"]
+approver = ["starlette>=0.40", "uvicorn>=0.30"]
+openai-agents = ["openai-agents>=0.24,<0.30"]
+langgraph = ["langgraph>=1.2,<2"]
+all = ["mcp>=2.3,<3", "playwright>=1.50", "starlette>=0.40", "uvicorn>=0.30", "openai-agents>=0.24,<0.30", "langgraph>=1.2,<2"]
+test = ["pytest>=8", "anyio>=4"]
+
+[project.scripts]
+oac-gated-browser = "oac.browser.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/Ishan2036924/open-action-consent"
+Specification = "https://github.com/Ishan2036924/open-action-consent/blob/main/spec/oac-v0.1.md"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+oac = ["approver/page.js"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

open_action_consent-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

open_action_consent-0.2.0/src/oac/__init__.py

@@ -0,0 +1,41 @@
+"""OAC (Open Action Consent) v0.1 reference SDK: previews, signed consents, mandates, receipts and undo for actions
+agents take for people. Spec: spec/oac-v0.1.md."""
+
+from oac.consent import MemoryNonces, make_consent, verify_consent
+from oac.errors import CODES, OACError
+from oac.jcs import canonical, parse
+from oac.jws import KeySet, SigningKey, digest, generate, sign, token_digest, verify
+from oac.mandate import check_mandate, loosens, make_mandate
+from oac.preview import action_digest, build_preview, check_binding
+from oac.receipts import make_receipt, verify_chain
+from oac.tiers import tier_for
+from oac.undo import check_undo, make_undo
+
+__version__ = "0.2.0"
+__all__ = [
+    "CODES",
+    "KeySet",
+    "MemoryNonces",
+    "OACError",
+    "SigningKey",
+    "action_digest",
+    "build_preview",
+    "canonical",
+    "check_binding",
+    "check_mandate",
+    "check_undo",
+    "digest",
+    "generate",
+    "loosens",
+    "make_consent",
+    "make_mandate",
+    "make_receipt",
+    "make_undo",
+    "parse",
+    "sign",
+    "tier_for",
+    "token_digest",
+    "verify",
+    "verify_chain",
+    "verify_consent",
+]

open_action_consent-0.2.0/src/oac/approver/__init__.py

@@ -0,0 +1,146 @@
+"""OAC Approver: a small self-hostable approval page where a person approves (or declines) an agent's action.
+
+The person's key never leaves their browser: it is a non-extractable WebCrypto P-256 key (OAC `signer.kind`
+"device"), created at enrolment with a one-time code. The page shows the Preview (summary, every field and detail,
+whether it can be undone, the cancellation policy), and on Approve the browser itself signs the Consent JWS and posts
+it here; the Approver checks it and hands it to the executor through `deliver`. It also publishes the person's
+public keys as issuer metadata (spec 3.5) so executors can find them.
+
+    from oac.approver import Approver
+
+    approver = Approver(issuer="https://approve.example", person="person:1",
+                        previews=lambda preview_id: executor.preview(preview_id),
+                        deliver=lambda token: executor.accept_consent(token))
+    app = approver.app()   # a Starlette app; serve it with uvicorn behind HTTPS
+
+0.1 limits: one person per Approver; in-memory state; no payment references in Consents (a pay action needs the
+rail's reference, which this page does not collect yet).
+"""
+
+from __future__ import annotations
+
+import hmac
+import secrets
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit
+
+try:
+    from starlette.applications import Starlette
+    from starlette.requests import Request
+    from starlette.responses import HTMLResponse, JSONResponse, Response
+    from starlette.routing import Route
+except ImportError as e:  # the optional dependency is not installed
+    raise ImportError('oac.approver needs Starlette: pip install "open-action-consent[approver]"') from e
+
+from oac import KeySet, OACError, digest, shapes, verify
+from oac.discovery import metadata_url
+
+PAGE_JS = (Path(__file__).parent / "page.js").read_text()
+CSP = "default-src 'none'; script-src 'self'; connect-src 'self'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'"
+STYLE = ("body{font:16px -apple-system,Segoe UI,sans-serif;max-width:560px;margin:40px auto;padding:0 16px;color:#111}"
+         "td{padding:6px 10px;border-bottom:1px solid #eee;vertical-align:top}button{font-size:16px;padding:10px 18px;margin-right:8px}"
+         "#status{margin-top:16px;color:#374151}")
+
+
+def _page(title: str, body: str, start: str) -> HTMLResponse:
+    html = (f"<!doctype html><html><head><meta charset=utf-8><meta name=viewport content='width=device-width'>"
+            f"<title>{title}</title><style>{STYLE}</style></head><body>{body}<p id=status></p>"
+            f"<script src='page.js'></script><script src='start-{start}.js'></script></body></html>")
+    return HTMLResponse(html, headers={"Content-Security-Policy": CSP, "X-Frame-Options": "DENY", "Referrer-Policy": "no-referrer",
+                                        "Cache-Control": "no-store"})
+
+
+class Approver:
+    def __init__(self, *, issuer: str, person: str, previews: Callable[[str], Mapping[str, Any] | None],
+                 deliver: Callable[[str], bool], enrollment_code: str | None = None) -> None:
+        self.issuer, self.person, self._previews, self._deliver = issuer, person, previews, deliver
+        self.enrollment_code = enrollment_code or secrets.token_urlsafe(9)
+        self._code_used = False
+        self.keys: list[dict[str, Any]] = []
+        self.declined: list[str] = []
+        self.well_known_path = urlsplit(metadata_url(issuer)).path
+
+    def metadata(self) -> dict[str, Any]:
+        return {"oac": "0.1", "type": "issuer-metadata", "issuer": self.issuer, "keys": list(self.keys)}
+
+    def keyset(self) -> KeySet:
+        return KeySet({self.issuer: self.keys})
+
+    def _same_origin(self, request: Request) -> bool:
+        origin = request.headers.get("origin")
+        return origin is not None and origin == f"{request.url.scheme}://{request.url.netloc}"
+
+    def app(self) -> Starlette:
+        async def js(request: Request) -> Response:
+            return Response(PAGE_JS, media_type="text/javascript", headers={"Cache-Control": "no-store"})
+
+        async def start_enroll(request: Request) -> Response:
+            return Response("document.getElementById('go').onclick = enroll;", media_type="text/javascript")
+
+        async def start_consent(request: Request) -> Response:
+            return Response("showPreview();", media_type="text/javascript")
+
+        async def enroll_page(request: Request) -> HTMLResponse:
+            return _page("Enrol this browser", "<h1>Enrol this browser</h1><p>Enter the one-time code from the server.</p>"
+                         "<input id=code autocomplete=off> <button id=go>Enrol</button>", "enroll")
+
+        async def consent_page(request: Request) -> HTMLResponse:
+            return _page("Approve an action", "<h1>An agent asks to act for you</h1><p id=summary></p><table id=fields></table>"
+                         "<p id=buttons hidden><button id=approve>Approve</button><button id=decline>Decline</button></p>",
+                         "consent")
+
+        async def api_enroll(request: Request) -> JSONResponse:
+            if not self._same_origin(request):
+                return JSONResponse({"error": "wrong origin"}, status_code=403)
+            body = await request.json()
+            if self._code_used or not hmac.compare_digest(str(body.get("code", "")), self.enrollment_code):
+                return JSONResponse({"error": "That code is not valid."}, status_code=403)
+            jwk = body.get("jwk", {})
+            try:
+                if not isinstance(jwk, dict) or set(jwk) != {"kty", "crv", "x", "y"} or jwk["kty"] != "EC" or jwk["crv"] != "P-256":
+                    raise OACError("malformed", "a P-256 public key")
+                shapes.check(jwk, shapes.JWK_FIELDS, "jwk")
+                KeySet({self.issuer: [jwk]})  # computes the thumbprint, refuses a key already bound elsewhere
+            except OACError:
+                return JSONResponse({"error": "That is not a valid public key."}, status_code=400)
+            self._code_used = True
+            self.keys.append(dict(jwk))
+            return JSONResponse({"ok": True})
+
+        async def api_preview(request: Request) -> JSONResponse:
+            p = self._previews(request.query_params.get("r", ""))
+            if p is None or p.get("sub") != self.person:
+                return JSONResponse({"error": "unknown"}, status_code=404)
+            return JSONResponse({"preview": p, "issuer": self.issuer, "person": self.person}, headers={"Cache-Control": "no-store"})
+
+        async def api_consent(request: Request) -> JSONResponse:
+            if not self._same_origin(request):
+                return JSONResponse({"error": "wrong origin"}, status_code=403)
+            token = (await request.json()).get("token", "")
+            try:
+                p = verify(token, self.keyset(), "oac-consent+jws")
+                shapes.consent(p)
+                if p["sub"] != self.person or p["signer"]["kind"] != "device":
+                    raise OACError("malformed", "not this person's device consent")
+            except OACError as e:
+                return JSONResponse({"error": f"Not accepted ({e.code})."}, status_code=400)
+            return JSONResponse({"ok": True}) if self._deliver(token) else JSONResponse({"error": "The agent did not accept it."}, status_code=409)
+
+        async def api_decline(request: Request) -> JSONResponse:
+            if not self._same_origin(request):
+                return JSONResponse({"error": "wrong origin"}, status_code=403)
+            self.declined.append(str((await request.json()).get("r", "")))
+            return JSONResponse({"ok": True})
+
+        async def well_known(request: Request) -> JSONResponse:
+            return JSONResponse(self.metadata())
+
+        return Starlette(routes=[
+            Route("/page.js", js), Route("/start-enroll.js", start_enroll), Route("/start-consent.js", start_consent),
+            Route("/enroll", enroll_page), Route("/consent", consent_page),
+            Route("/api/enroll", api_enroll, methods=["POST"]), Route("/api/preview", api_preview),
+            Route("/api/consent", api_consent, methods=["POST"]), Route("/api/decline", api_decline, methods=["POST"]),
+            Route(self.well_known_path, well_known),
+        ])

open_action_consent-0.2.0/src/oac/approver/page.js

@@ -0,0 +1,88 @@
+// OAC Approver page script. The person's key is a non-extractable WebCrypto P-256 key kept in this browser
+// (IndexedDB); the server never sees it. Canonical JSON (RFC 8785, integers only) and JWS here must match the SDKs
+// byte for byte; tests verify browser-made tokens with the Python SDK.
+const N = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n;
+const enc = new TextEncoder();
+const b64u = (bytes) => btoa(String.fromCharCode(...new Uint8Array(bytes))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+function canonical(v) {
+  if (v === null) return "null";
+  if (v === true) return "true";
+  if (v === false) return "false";
+  if (typeof v === "number") { if (!Number.isSafeInteger(v)) throw new Error("integers only"); return String(v === 0 ? 0 : v); }
+  if (typeof v === "string") return JSON.stringify(v);
+  if (Array.isArray(v)) return "[" + v.map(canonical).join(",") + "]";
+  return "{" + Object.keys(v).sort().map((k) => JSON.stringify(k) + ":" + canonical(v[k])).join(",") + "}";
+}
+async function sha(text) { return new Uint8Array(await crypto.subtle.digest("SHA-256", enc.encode(text))); }
+async function digest(value) { return "sha-256:" + b64u(await sha(canonical(value))); }
+function db() {
+  return new Promise((ok, bad) => {
+    const r = indexedDB.open("oac-approver", 1);
+    r.onupgradeneeded = () => r.result.createObjectStore("keys");
+    r.onsuccess = () => ok(r.result); r.onerror = () => bad(r.error);
+  });
+}
+async function store(op, key, value) {
+  const d = await db();
+  return new Promise((ok, bad) => {
+    const tx = d.transaction("keys", op === "get" ? "readonly" : "readwrite"), s = tx.objectStore("keys");
+    const r = op === "get" ? s.get(key) : s.put(value, key);
+    r.onsuccess = () => ok(r.result); r.onerror = () => bad(r.error);
+  });
+}
+async function thumbprint(jwk) { return b64u(await sha(canonical({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y }))); }
+async function signJws(payload, typ) {
+  const k = await store("get", "device");
+  if (!k) throw new Error("This browser is not enrolled yet. Open /enroll first.");
+  const head = b64u(enc.encode(canonical({ alg: "ES256", kid: k.kid, typ })));
+  const body = b64u(enc.encode(canonical(payload)));
+  const sig = new Uint8Array(await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, k.pair.privateKey, enc.encode(head + "." + body)));
+  let s = BigInt("0x" + [...sig.slice(32)].map((b) => b.toString(16).padStart(2, "0")).join(""));
+  if (s > N / 2n) s = N - s; // low-S: one payload, one signature (spec 3.3)
+  const sBytes = s.toString(16).padStart(64, "0").match(/../g).map((h) => parseInt(h, 16));
+  return head + "." + body + "." + b64u(new Uint8Array([...sig.slice(0, 32), ...sBytes]));
+}
+const post = (path, body) => fetch(path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) }).then(async (r) => ({ ok: r.ok, body: await r.json() }));
+const el = (id) => document.getElementById(id);
+function say(text) { el("status").textContent = text; }
+
+async function enroll() {
+  const pair = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, false, ["sign", "verify"]);
+  const pub = await crypto.subtle.exportKey("jwk", pair.publicKey);
+  const jwk = { kty: "EC", crv: "P-256", x: pub.x, y: pub.y };
+  const r = await post("api/enroll", { code: el("code").value, jwk });
+  if (!r.ok) return say(r.body.error || "Enrolment refused.");
+  await store("put", "device", { pair, kid: await thumbprint(jwk) });
+  say("This browser can now approve actions.");
+}
+
+function row(table, label, value) {
+  const tr = table.insertRow(); tr.insertCell().textContent = label; tr.insertCell().textContent = typeof value === "string" ? value : JSON.stringify(value);
+}
+
+async function showPreview() {
+  const id = new URLSearchParams(location.search).get("r");
+  const r = await fetch("api/preview?r=" + encodeURIComponent(id || ""));
+  if (!r.ok) return say("This request is unknown or has expired.");
+  const { preview, issuer, person } = await r.json();
+  el("summary").textContent = preview.summary;
+  const t = el("fields");
+  for (const [k, v] of Object.entries(preview.fields)) row(t, k, v);
+  for (const [k, v] of Object.entries(preview.details || {})) row(t, k + " (detail)", v);
+  row(t, "can be undone", preview.undo.kind === "none" ? "NO: this cannot be undone" : preview.undo.kind);
+  if (preview.cancel_policy) row(t, "cancellation", preview.cancel_policy.text);
+  row(t, "who asks", preview.executor);
+  el("buttons").hidden = false;
+  el("approve").onclick = async () => {
+    const now = Math.floor(Date.now() / 1000);
+    const jti = b64u(crypto.getRandomValues(new Uint8Array(18)));
+    const consent = { oac: "0.1", type: "consent", iss: issuer, sub: person, aud: preview.executor, jti, iat: now, exp: now + 300,
+      items: [{ preview: await digest(preview), action: preview.action }], signer: { kind: "device" } };
+    try {
+      const res = await post("api/consent", { token: await signJws(consent, "oac-consent+jws") });
+      say(res.ok ? "Approved. You can close this page." : res.body.error || "Not accepted.");
+    } catch (e) { say(String(e.message || e)); }
+    el("buttons").hidden = true;
+  };
+  el("decline").onclick = async () => { await post("api/decline", { r: id }); say("Declined. Nothing will run."); el("buttons").hidden = true; };
+}