@aeolus-fleet/gateway 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://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
+
+       http://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.

package/README.md

@@ -1,3 +1,105 @@
-# Temporary Holding Version
+# Aeolus gateway
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@aeolus-fleet/gateway`: outside MCP servers and clients join an [Aeolus](https://github.com/ThomasHendrickx/aeolus-fleet) fleet as ships, through one gateway beside core. Its design is aeolus-fleet's docs/design/interop/interop.md.
+
+## Run
+
+```sh
+npm install && npm run build
+DATABASE_URL=postgresql://... FLEET_URL=https://fleet.example.com npm start
+```
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `DATABASE_URL` | required | The gateway's own Postgres 16 or newer database, with a direct connection |
+| `FLEET_URL` | required | The fleet's public URL (`http://` or `https://`) |
+| `HOST` | `127.0.0.1` | Interface to listen on |
+| `PORT` | `4200` | Port to listen on |
+| `GATEWAY_PUBLIC_URL` | `http://127.0.0.1:<PORT>` | Where outside MCP clients reach the gateway: the OAuth issuer, with the MCP endpoint at `/mcp` |
+| `GATEWAY_SECRET` | required | At least 32 characters. Keys the ship aliases outside MCP clients see: the same secret keeps every alias across restarts, a new one renames every ship to them |
+| `MCP_WAIT_MAX_MS` | `10000` | How long an outside MCP client's tool call waits for its answer before it is answered its handle; `0` answers the handle at once |
+| `INSTALLATION_TOKEN` | unset | The token a hosting service presents to the installation procedures (at least 32 characters, decision 0021). Unset: they are off and every fleet is served, as a self-hosted gateway needs; set: a fleet is served once switched on |
+| `PAGASAE_URL`, `PAGASAE_CLIENT_ID`, `PAGASAE_CLIENT_SECRET` | unset | pagasae, where people sign in (decision 0054), and the gateway's client there, registered with the redirect URI `<GATEWAY_PUBLIC_URL>/pagasae/callback`. All three or none; unset, nobody signs in, so no MCP client connects (only an account asks for one) |
+| `LOG_LEVEL` | `info` | `fatal`, `error`, `warn`, `info`, `debug`, `trace` or `silent` |
+
+| Command | Does |
+| --- | --- |
+| `aeolus-gateway start` | Reads core's version and exits 1 when core is older than it needs (core 0.27.0 or later), saying both versions; migrates its database; serves |
+| `aeolus-gateway migrate` | Migrates its database, and nothing else. Needs `DATABASE_URL` alone |
+
+`GET /api/version` answers the version it runs, and `GET /api/health` answers `{ "status": "ok" }` while its database answers, else 503.
+
+## Connect
+
+argo commissions the gateway's ship in the console as an app ship (decision 0044: it is software, so its messages state no model), with `fleet:read`, `fleet:commission`, `fleet:on-behalf` and `scopes:declare`, and connects the gateway with it; the gateway registers with the ship's secret, keeps only the crew token, and declares its own scope, `gateway:approve` (decision 0056): any actor the fleet grants it approves outside parties. A fleet that does not take the declaration, as when another ship holds the `gateway` namespace, is refused (CONFLICT). The gateway connects and is switched on whatever network the fleet has (interop I-3): the fleet decides its network. A fleet's outside parties (its outside MCP servers and clients) are a switch, off by default: while off, the gateway approves no party, takes no party's calls and refuses a client party's token at `/mcp` (403). `outsideParties.status` reads it; `outsideParties.set` needs `fleet:network`. Turning it on while the fleet applies no network rules (`fleet.networkRules`, read as the actor) answers PRECONDITION_FAILED with a warning until the call confirms it with `isOpenNetworkConfirmed`.
+
+The API is tRPC at `/trpc`. Its procedures take an actor (decision 0057): argo's or a viewer's console session cookie, checked with the fleet's `console.session`, or any ship's own crew token as a bearer token, for a fleet the gateway is connected to. What an actor may call is the scopes the fleet holds for it, read by the gateway's ship; a change needs `fleet:manage`. `requests.toDecide` and `requests.decide` need `gateway:approve` (decision 0056): every open pending request of the fleet, and a decision on one. Approving names the proxy ship's name, its owner (a person ship) and its scopes, only scopes the approver holds beside `messages:send` and `messages:receive`, and for an outside MCP server its credential and concurrency; the gateway commissions and crews the proxy ship as its own ship, and the fleet refuses a scope the gateway's ship does not hold. The first decision counts. A request is kept 7 days, then expires; a refused proxy ship leaves it pending. The outcome of a request for an outside MCP server is told to each requester with a person ship, as a text message from the gateway's ship: written with the decision or the expiry in one transaction, sent at once, and sent again every minute under the same idempotency key until the fleet stores it. One the fleet refuses is left for the gateway's page. Due requests expire in the same round. When a request opens, the gateway's ship asks its owner (read from the fleet; argo when argo owns it) a question (decision 0038) pointing to the gateway's `/overview`, where any holder of `gateway:approve` decides; it withdraws the question once the request is decided or expired. Both are kept and sent again under the same key until the fleet stores them. `installation.setEnabled`, `installation.get` and `installation.delete` take the installation token in `x-aeolus-installation-token`.
+
+## Parties
+
+argo approves an outside MCP server as a party with `parties.approve` (argo's console session): its name, its Streamable HTTP URL, the credential the gateway calls it with (a static bearer, or OAuth client credentials with their issuer), the owner argo picks for it (a person's ship or argo) and how many calls it takes at once (1 to 10, the most core's pushReceive hands at once; 4 by default). The gateway, as its own ship, commissions the party's app proxy ship of type `mcp-server` with that owner, crews it, and keeps its crew token. argo labels the proxy ship in the console, as any ship, for the network rules to select it. `parties.list` shows each party without its credential or crew token. A proxy ship left awaiting crew (the commission's answer was lost, and its secret with it) takes a new secret from a new starting prompt with `parties.crew`.
+
+The gateway keeps outside credentials and crew tokens as they are in its own database, as squadrons keeps crew tokens: a key on the same server would protect only backups. Guard the database and its backups accordingly.
+
+`parties.state` states the proxy ship anew from the server's `tools/list`: each tool is one capability with its MCP fields and annotations, called with `application/vnd.aeolus.mcp-tool+json; name=<tool>` (the tool arguments as a JSON object) and answered with `application/vnd.aeolus.mcp-result+json; name=<tool>` (the tool result). The summary names the party only, never its URL or credential. `parties.markTool` marks a tool repeatable, or takes the mark off, and states it at once: only argo's mark lets the gateway hand a call that died unanswered again; the server's hints never do.
+
+Commissioning an app ship with a named owner needs core 0.28 (aeolus-fleet#959), and so do the statement's `annotations` and `repeatable` fields (aeolus-fleet#956): core 0.27 refuses a statement that holds them.
+
+## The page of parties
+
+`/parties` is the gateway's own page for argo: the parties with their state, a form to approve an MCP server, and per party the forms to hand over a new secret, state its tools and mark a tool repeatable. The page knows argo by the console session cookie the browser sends, so the gateway must be served where that cookie reaches it (on localhost, any port). A viewer session sees the parties without the forms. Each form calls the API as the session's ship, and the page refuses a form sent from another origin.
+
+## MCP out
+
+From its start, and as soon as a party is crewed, the gateway takes the calls of each crewed party's proxy ship as its crew (interop 5.2). A ship of the fleet calls a tool by sending the proxy ship the tool's input type, `application/vnd.aeolus.mcp-tool+json; name=<tool>`, with the tool arguments as a JSON object. The gateway reports it handed, makes the `tools/call` with the vault's credential, and replies with the result (an error result included) naming the request, then acknowledges and reports it handled. It keeps each call in its database, so a restart replies again and never calls again what may have run.
+
+- A call the server never got (it was unreachable, or refused the credential) is handed again after a wait, and the fleet stops it at the fifth attempt.
+- A call sent with no answer (a broken stream, no answer within 5 minutes) is handed again only when argo marked its tool repeatable. Otherwise the gateway reports it not handled: it may have run, and a human who can check the outside system resends or dismisses it.
+- A party takes at most its concurrency limit of calls at once.
+
+With core 0.27 the not handled report is refused (aeolus-fleet#955): the call is never made again, and its delivery stays handed until argo resends or dismisses it.
+
+## MCP clients sign in
+
+The gateway is an OAuth 2.1 authorization server for outside MCP clients, such as Claude, ChatGPT or Cursor (MCP 2026-07-28):
+
+- `/.well-known/oauth-protected-resource` (RFC 9728) names the gateway as the authorization server of its MCP endpoint, `<GATEWAY_PUBLIC_URL>/mcp`; `/.well-known/oauth-authorization-server` (RFC 8414) states what it serves.
+- A client is pre-registered by argo with `oauth.registerClient` (its name, its redirect URIs, and whether it keeps a secret, answered once), or known by its client metadata document (CIMD): its client id is the https URL of that document. There is no dynamic registration.
+- `/authorize` shows the client and two picks (decision 0056, Q1 a): sign in as yourself, or ask for access for this client. Either sends the person to pagasae to sign in. Only the authorization code flow with PKCE S256 is served, and the `resource` must be the gateway's MCP endpoint (RFC 8707).
+- A person signs in through pagasae (decision 0054). pagasae answers their only fleet, or asks which, and sends them back to `/pagasae/callback`; signed in as themselves, the gateway keeps their account's grant (the account, its fleet, its person ship and pagasae's tokens) and sends their client back with its code, with no approval. The sign-in under way travels sealed in pagasae's `state`, so nothing is stored before the fleet is known. The browser that starts it holds a secret sealed with it, in an HttpOnly cookie sent only to `/pagasae/callback` for its 10 minutes, so no other browser finishes it (login CSRF). A fleet the gateway does not serve is refused. A person's client is served their person ship's tools: `aeolus_inbox` (what waits, by titles only, at most 10), `aeolus_open` (one delivery whole; opening it acknowledges it), `aeolus_answer` (a reply to its sender, then it is handled) and `aeolus_done` (handled with no answer). The gateway makes these calls as the crew of the account's own person ship, with the account's token (decision 0057): it crews the ship once, shared by every client of the person, and crews it again when its lease ended. An account with no person ship is told so, and the fleet is asked nothing. `aeolus_ask_for_server` asks for an outside MCP server by its http or https address, as the account (decision 0056): it opens a pending request, or joins the one pending for the same server, and an approver adds the server with its credential. A server that is a party already is said so. While the fleet's outside parties are off, nobody asks.
+- A person who asks for access for the client asks as their account. A client that is a party already is sent back with its party's code at once. Otherwise the account opens a pending request for the client, or joins the one pending, and its browser waits at `/authorize/waiting`, which reloads itself: approved and its proxy ship crewed, the client gets its party's code; denied or expired, `access_denied`. Closed meanwhile, the next try after a deny or expiry ends with `access_denied` once, and a later try asks anew. The waiting travels sealed in the page's address, and the browser holds the sign-in's secret in an HttpOnly cookie sent only to the waiting page, for the request's 7 days. While the fleet's outside parties are off, nobody asks. Each client party has its own app proxy ship, of type `mcp-client`; every token of a client party names its party, so every fleet call the client makes is its proxy ship's, within its reach; a person's token names their account's grant. `parties.list` shows client parties beside server parties.
+- `/token` takes a code once, within its minute, for an access token (one hour) and a refresh token (30 days). Refreshing rotates the pair; a code or a refresh token used twice revokes what it gave.
+
+Codes and tokens are kept only as hashes, and so are client secrets.
+
+Serve the gateway at its own origin, such as `https://gateway.example.com`, with `GATEWAY_PUBLIC_URL` set to it: RFC 8414 and RFC 9728 put the metadata at the origin's root, and `/authorize` and `/token` are served there.
+
+## MCP clients list and call tools
+
+`<GATEWAY_PUBLIC_URL>/mcp` is the gateway's MCP endpoint (Streamable HTTP, stateless). A call without a token, or with one the gateway did not issue for it, gets 401 with `resource_metadata` naming where to sign in (RFC 9728).
+
+- `tools/list` answers the capabilities of the ships the client's proxy ship may send to now, as the fleet's `discover` answers it: the gateway adds no reach of its own.
+- A tool is named `<alias>__<capability>`. The alias is 8 letters and digits derived from the ship under `GATEWAY_SECRET`: the client never sees a ship's name or id.
+- Its description is the capability's, then the ship's summary. A capability that takes plain text first gets one `text` argument. Every tool takes an optional `aeolus_idempotency_key`.
+- Left out: argo, ships with no statement by their crew, capabilities whose first input type is neither JSON nor plain text or whose input schema is not an object, and tool names over 128 characters.
+- No tool states an output schema: a call may answer a handle, and MCP clients check every answer against it.
+- `tools/call` sends the arguments, without `aeolus_idempotency_key`, as a message from the client's proxy ship to the tool's ship, under the capability's first input type. The client is answered only once the fleet answered the send. The call then waits up to `MCP_WAIT_MAX_MS` for its answer: answered within it, the client gets the answer itself; else `{"handle": "...", "state": "submitted"}` (or `working`). A fleet that refuses the send gets a tool error, and one that cannot be reached gives no reason why.
+- The same `aeolus_idempotency_key` again sends no second message. The send's key is derived from it under `GATEWAY_SECRET`, and the handle from the message, so the client never sees a `msg_` id.
+- `aeolus_result({ handle })` reads the client's own call: `submitted`, `working` once a reply of another type came, its answer once completed, or a tool error once it failed (interop 3.4).
+- MCP Tasks (`io.modelcontextprotocol/tasks`, stated at `server/discover`): a client that declares the extension on its `tools/call` is answered a task in place of the handle, its `taskId` the handle. `tasks/get` reads it: `working` while submitted or working, `completed` with the answer as its `result`, or `failed` once its deadline passed. A task never expires (`ttlMs` null), as the gateway keeps every call. `tasks/cancel` and `tasks/update` are acknowledged and change nothing: a sent call cannot be unsent, and no call asks for input yet.
+- The first reply of the capability's first output type completes it; plain text completes a call to a ship that states no output type. An outside tool's result, as MCP out replies one, is answered as that result.
+- A call fails 10 minutes after it was sent without its answer: the gateway's default while statements state no deadline. A reply after that is kept and changes nothing.
+- Each client party's worker takes the replies of its proxy ship, keeps each on its call, then acknowledges and handles its delivery. With core 0.27 a message to the proxy ship that replies to no call stays unacknowledged, for a later slice's inbox. Ten of them would take every pushReceive answer and keep replies out, until core 0.28's `receiveReply` (aeolus-fleet#953) takes replies by message.
+
+## Develop
+
+```sh
+npm install
+npm run typecheck && npm run lint && npm test
+```
+
+The integration tests need Docker or Podman: they start Postgres in Testcontainers and a real core from the `@aeolus-fleet/core` devDependency.
+
+## Licence
+
+Apache-2.0.

package/dist/adapters/crypto/call-keys.d.ts

@@ -0,0 +1,7 @@
+import type { CallKeys } from '../../core/mcp-in/ports.js';
+/**
+ * Keys as an HMAC under the gateway's secret, of the parts as a JSON array so
+ * no part's colon or comma runs into the next. A client's key is never sent
+ * as it is, and a handle tells nothing of the message id.
+ */
+export declare function createCallKeys(secret: string): CallKeys;

package/dist/adapters/crypto/call-keys.js

@@ -0,0 +1,18 @@
+import { createHmac, randomUUID } from 'node:crypto';
+/** Each derivation under its own label, so a key is never also a handle. */
+const IDEMPOTENCY_LABEL = 'idempotency-key';
+const HANDLE_LABEL = 'handle';
+/**
+ * Keys as an HMAC under the gateway's secret, of the parts as a JSON array so
+ * no part's colon or comma runs into the next. A client's key is never sent
+ * as it is, and a handle tells nothing of the message id.
+ */
+export function createCallKeys(secret) {
+    const derived = (parts) => createHmac('sha256', secret).update(JSON.stringify(parts)).digest('base64url');
+    return {
+        idempotencyKeyOf: ({ fleetId, party, key }) => derived([IDEMPOTENCY_LABEL, fleetId, party, key]),
+        newIdempotencyKey: () => randomUUID(),
+        handleOf: (fleetId, messageId) => derived([HANDLE_LABEL, fleetId, messageId]),
+    };
+}
+//# sourceMappingURL=call-keys.js.map

package/dist/adapters/crypto/call-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-keys.js","sourceRoot":"","sources":["../../../src/adapters/crypto/call-keys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAIrD,4EAA4E;AAC5E,MAAM,iBAAiB,GAAG,iBAAiB,CAAC;AAC5C,MAAM,YAAY,GAAG,QAAQ,CAAC;AAE9B;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc;IAC3C,MAAM,OAAO,GAAG,CAAC,KAAe,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IACpH,OAAO;QACL,gBAAgB,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,iBAAiB,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;QAChG,iBAAiB,EAAE,GAAG,EAAE,CAAC,UAAU,EAAE;QACrC,QAAQ,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;KAC9E,CAAC;AACJ,CAAC"}

package/dist/adapters/crypto/oauth-secrets.d.ts

@@ -0,0 +1,3 @@
+import type { OAuthSecrets } from '../../core/oauth/ports.js';
+/** Secrets drawn from the system's random source, kept as SHA-256 in hex; S256 as RFC 7636 defines it. */
+export declare const oauthSecrets: OAuthSecrets;

package/dist/adapters/crypto/oauth-secrets.js

@@ -0,0 +1,10 @@
+import { createHash, randomBytes } from 'node:crypto';
+/** 256 bits for each code, token and client secret. */
+const SECRET_BYTES = 32;
+/** Secrets drawn from the system's random source, kept as SHA-256 in hex; S256 as RFC 7636 defines it. */
+export const oauthSecrets = {
+    newSecret: () => randomBytes(SECRET_BYTES).toString('base64url'),
+    hashOf: (secret) => createHash('sha256').update(secret).digest('hex'),
+    challengeOf: (verifier) => createHash('sha256').update(verifier, 'ascii').digest('base64url'),
+};
+//# sourceMappingURL=oauth-secrets.js.map

package/dist/adapters/crypto/oauth-secrets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth-secrets.js","sourceRoot":"","sources":["../../../src/adapters/crypto/oauth-secrets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAItD,uDAAuD;AACvD,MAAM,YAAY,GAAG,EAAE,CAAC;AAExB,0GAA0G;AAC1G,MAAM,CAAC,MAAM,YAAY,GAAiB;IACxC,SAAS,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;IAChE,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;IACrE,WAAW,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC;CAC9F,CAAC"}

package/dist/adapters/crypto/request-hasher.d.ts

@@ -0,0 +1,3 @@
+import type { RequestHasher } from '../../core/installation/ports.js';
+/** A request's text as its SHA-256, in hex: what the installation keeps instead of the request. */
+export declare const sha256RequestHasher: RequestHasher;

package/dist/adapters/crypto/request-hasher.js

@@ -0,0 +1,4 @@
+import { createHash } from 'node:crypto';
+/** A request's text as its SHA-256, in hex: what the installation keeps instead of the request. */
+export const sha256RequestHasher = { hash: (text) => createHash('sha256').update(text).digest('hex') };
+//# sourceMappingURL=request-hasher.js.map

package/dist/adapters/crypto/request-hasher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-hasher.js","sourceRoot":"","sources":["../../../src/adapters/crypto/request-hasher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAIzC,mGAAmG;AACnG,MAAM,CAAC,MAAM,mBAAmB,GAAkB,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC"}

package/dist/adapters/crypto/request-ids.d.ts

@@ -0,0 +1,4 @@
+import { createIdGenerator } from '@aeolus-fleet/common';
+import type { RequestIds } from '../../core/requests/ports.js';
+/** New request ids: a common id's time-ordered body under the request prefix. */
+export declare function createRequestIds(options?: Parameters<typeof createIdGenerator>[0]): RequestIds;

package/dist/adapters/crypto/request-ids.js

@@ -0,0 +1,14 @@
+import { createIdGenerator } from '@aeolus-fleet/common';
+/** The prefix common gives a pending request from 0.28.0 (`ID_PREFIXES.request`); until then its time-ordered body is drawn here (aeolus-fleet#991). */
+const REQUEST_PREFIX = 'req_';
+/** New request ids: a common id's time-ordered body under the request prefix. */
+export function createRequestIds(options = {}) {
+    const generate = createIdGenerator(options);
+    return {
+        newRequestId: () => {
+            const id = generate('event');
+            return `${REQUEST_PREFIX}${id.slice(id.indexOf('_') + 1)}`;
+        },
+    };
+}
+//# sourceMappingURL=request-ids.js.map

package/dist/adapters/crypto/request-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-ids.js","sourceRoot":"","sources":["../../../src/adapters/crypto/request-ids.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAIzD,wJAAwJ;AACxJ,MAAM,cAAc,GAAG,MAAM,CAAC;AAE9B,iFAAiF;AACjF,MAAM,UAAU,gBAAgB,CAAC,UAAmD,EAAE;IACpF,MAAM,QAAQ,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAC5C,OAAO;QACL,YAAY,EAAE,GAAG,EAAE;YACjB,MAAM,EAAE,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;YAC7B,OAAO,GAAG,cAAc,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QAC7D,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/crypto/sealer.d.ts

@@ -0,0 +1,14 @@
+/** Seals JSON into URL-safe text, and opens it again; what it opens is unknown until its schema parses it. */
+export interface Sealer {
+    seal(value: unknown): string;
+    open(sealed: string): unknown;
+}
+/**
+ * Seals with AES-256-GCM under a key derived from the gateway's secret and
+ * the label: the sealed text is the nonce, the sealed JSON and its tag,
+ * base64url. Text changed on the way, sealed under another secret or
+ * another label, opens to undefined.
+ */
+export declare function createSealer(secret: string, label: string): Sealer;
+/** The request's parameters that are set, as a sealed request keeps them. */
+export declare function setParameters(request: Readonly<Record<string, string | undefined>>): Record<string, string>;

package/dist/adapters/crypto/sealer.js

@@ -0,0 +1,41 @@
+import { createCipheriv, createDecipheriv, createHmac, randomBytes } from 'node:crypto';
+const CIPHER = 'aes-256-gcm';
+const NONCE_BYTES = 12;
+const TAG_BYTES = 16;
+/**
+ * Seals with AES-256-GCM under a key derived from the gateway's secret and
+ * the label: the sealed text is the nonce, the sealed JSON and its tag,
+ * base64url. Text changed on the way, sealed under another secret or
+ * another label, opens to undefined.
+ */
+export function createSealer(secret, label) {
+    const key = createHmac('sha256', secret).update(label).digest();
+    return {
+        seal: (value) => {
+            const nonce = randomBytes(NONCE_BYTES);
+            const cipher = createCipheriv(CIPHER, key, nonce);
+            const sealed = Buffer.concat([cipher.update(JSON.stringify(value), 'utf8'), cipher.final()]);
+            return Buffer.concat([nonce, sealed, cipher.getAuthTag()]).toString('base64url');
+        },
+        open: (sealed) => {
+            const bytes = Buffer.from(sealed, 'base64url');
+            if (bytes.length <= NONCE_BYTES + TAG_BYTES) {
+                return undefined;
+            }
+            const decipher = createDecipheriv(CIPHER, key, bytes.subarray(0, NONCE_BYTES));
+            decipher.setAuthTag(bytes.subarray(bytes.length - TAG_BYTES));
+            try {
+                const opened = JSON.parse(Buffer.concat([decipher.update(bytes.subarray(NONCE_BYTES, bytes.length - TAG_BYTES)), decipher.final()]).toString('utf8'));
+                return opened;
+            }
+            catch {
+                return undefined;
+            }
+        },
+    };
+}
+/** The request's parameters that are set, as a sealed request keeps them. */
+export function setParameters(request) {
+    return Object.fromEntries(Object.entries(request).filter((entry) => entry[1] !== undefined));
+}
+//# sourceMappingURL=sealer.js.map

package/dist/adapters/crypto/sealer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sealer.js","sourceRoot":"","sources":["../../../src/adapters/crypto/sealer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAExF,MAAM,MAAM,GAAG,aAAa,CAAC;AAC7B,MAAM,WAAW,GAAG,EAAE,CAAC;AACvB,MAAM,SAAS,GAAG,EAAE,CAAC;AAQrB;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,MAAc,EAAE,KAAa;IACxD,MAAM,GAAG,GAAG,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;IAChE,OAAO;QACL,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE;YACd,MAAM,KAAK,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC;YACvC,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YAClD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC7F,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACnF,CAAC;QACD,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE;YACf,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;YAC/C,IAAI,KAAK,CAAC,MAAM,IAAI,WAAW,GAAG,SAAS,EAAE,CAAC;gBAC5C,OAAO,SAAS,CAAC;YACnB,CAAC;YACD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;YAC/E,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;YAC9D,IAAI,CAAC;gBACH,MAAM,MAAM,GAAY,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC/J,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,SAAS,CAAC;YACnB,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,aAAa,CAAC,OAAqD;IACjF,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAA6B,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC;AAC1H,CAAC"}

package/dist/adapters/crypto/ship-aliases.d.ts

@@ -0,0 +1,7 @@
+import type { ShipAliases } from '../../core/mcp-in/ports.js';
+/**
+ * Aliases as an HMAC of the fleet and ship under the gateway's secret: the
+ * same ship has the same alias across restarts, and nobody without the secret
+ * learns its id from it. It starts with a letter, as a tool name may need.
+ */
+export declare function createShipAliases(secret: string): ShipAliases;

package/dist/adapters/crypto/ship-aliases.js

@@ -0,0 +1,19 @@
+import { createHmac } from 'node:crypto';
+const ALIAS_LENGTH = 8;
+const LETTERS = 'abcdefghijklmnopqrstuvwxyz';
+/** Lowercase base32 (RFC 4648's alphabet): 32 divides 256, so each byte draws a character evenly. */
+const BASE32 = `${LETTERS}234567`;
+/**
+ * Aliases as an HMAC of the fleet and ship under the gateway's secret: the
+ * same ship has the same alias across restarts, and nobody without the secret
+ * learns its id from it. It starts with a letter, as a tool name may need.
+ */
+export function createShipAliases(secret) {
+    return {
+        aliasOf: (fleetId, shipId) => {
+            const bytes = createHmac('sha256', secret).update(`${fleetId}:${shipId}`).digest();
+            return [...bytes.subarray(0, ALIAS_LENGTH)].map((byte, index) => (index === 0 ? LETTERS.charAt(byte % LETTERS.length) : BASE32.charAt(byte % BASE32.length))).join('');
+        },
+    };
+}
+//# sourceMappingURL=ship-aliases.js.map

package/dist/adapters/crypto/ship-aliases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ship-aliases.js","sourceRoot":"","sources":["../../../src/adapters/crypto/ship-aliases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAIzC,MAAM,YAAY,GAAG,CAAC,CAAC;AACvB,MAAM,OAAO,GAAG,4BAA4B,CAAC;AAC7C,qGAAqG;AACrG,MAAM,MAAM,GAAG,GAAG,OAAO,QAAQ,CAAC;AAElC;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,OAAO;QACL,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3B,MAAM,KAAK,GAAG,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,GAAG,OAAO,IAAI,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;YACnF,OAAO,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACzK,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/crypto/sign-in-seals.d.ts

@@ -0,0 +1,7 @@
+import type { SignInSeals } from '../../core/sign-in/ports.js';
+/**
+ * Seals a sign-in under way into the state pagasae carries back, under a key
+ * derived from the gateway's secret. A state changed on the way, or sealed
+ * under another secret, opens to nothing.
+ */
+export declare function createSignInSeals(secret: string): SignInSeals;

package/dist/adapters/crypto/sign-in-seals.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { createSealer, setParameters } from './sealer.js';
+/** Its own label, so the sealing key is never also a key the gateway derives elsewhere. */
+const SEAL_LABEL = 'sign-in-seal';
+const sealedSchema = z.object({
+    verifier: z.string(),
+    browserSecret: z.string(),
+    request: z.record(z.string(), z.string()),
+    holder: z.enum(['account', 'party']),
+    expiresAt: z.iso.datetime(),
+});
+/**
+ * Seals a sign-in under way into the state pagasae carries back, under a key
+ * derived from the gateway's secret. A state changed on the way, or sealed
+ * under another secret, opens to nothing.
+ */
+export function createSignInSeals(secret) {
+    const sealer = createSealer(secret, SEAL_LABEL);
+    return {
+        seal: ({ verifier, browserSecret, request, holder, expiresAt }) => sealer.seal({ verifier, browserSecret, request: setParameters(request), holder, expiresAt: expiresAt.toISOString() }),
+        open: (state) => {
+            const signIn = sealedSchema.safeParse(sealer.open(state));
+            return signIn.success ? { ...signIn.data, expiresAt: new Date(signIn.data.expiresAt) } : undefined;
+        },
+    };
+}
+//# sourceMappingURL=sign-in-seals.js.map

package/dist/adapters/crypto/sign-in-seals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-in-seals.js","sourceRoot":"","sources":["../../../src/adapters/crypto/sign-in-seals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE1D,2FAA2F;AAC3F,MAAM,UAAU,GAAG,cAAc,CAAC;AAElC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;IACzC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IACpC,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE;CAC5B,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAChD,OAAO;QACL,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,WAAW,EAAE,EAAE,CAAC;QACxL,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE;YACd,MAAM,MAAM,GAAG,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YAC1D,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QACrG,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/crypto/waiting-seals.d.ts

@@ -0,0 +1,3 @@
+import type { WaitingSeals } from '../../core/requests/ports.js';
+/** Seals a browser's waiting into the waiting page's address, under a key derived from the gateway's secret. */
+export declare function createWaitingSeals(secret: string): WaitingSeals;

package/dist/adapters/crypto/waiting-seals.js

@@ -0,0 +1,24 @@
+import { idSchema } from '@aeolus-fleet/common';
+import { z } from 'zod';
+import { createSealer, setParameters } from './sealer.js';
+/** Its own label, so a sign-in's state never opens as a waiting, nor a waiting as a sign-in. */
+const SEAL_LABEL = 'waiting-seal';
+const sealedSchema = z.object({
+    fleetId: idSchema('fleet'),
+    requestId: z.string(),
+    accountId: z.string(),
+    browserSecret: z.string(),
+    request: z.record(z.string(), z.string()),
+});
+/** Seals a browser's waiting into the waiting page's address, under a key derived from the gateway's secret. */
+export function createWaitingSeals(secret) {
+    const sealer = createSealer(secret, SEAL_LABEL);
+    return {
+        seal: (waiting) => sealer.seal({ ...waiting, request: setParameters(waiting.request) }),
+        open: (sealed) => {
+            const waiting = sealedSchema.safeParse(sealer.open(sealed));
+            return waiting.success ? waiting.data : undefined;
+        },
+    };
+}
+//# sourceMappingURL=waiting-seals.js.map

package/dist/adapters/crypto/waiting-seals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waiting-seals.js","sourceRoot":"","sources":["../../../src/adapters/crypto/waiting-seals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE1D,gGAAgG;AAChG,MAAM,UAAU,GAAG,cAAc,CAAC;AAElC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC;IAC1B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;CAC1C,CAAC,CAAC;AAEH,gHAAgH;AAChH,MAAM,UAAU,kBAAkB,CAAC,MAAc;IAC/C,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAChD,OAAO;QACL,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACvF,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE;YACf,MAAM,OAAO,GAAG,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YAC5D,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;QACpD,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/fleet/console-sessions.d.ts

@@ -0,0 +1,2 @@
+import type { ConsoleSessions } from '../../core/operator/ports.js';
+export declare function createFleetConsoleSessions(fleetUrl: string): ConsoleSessions;

package/dist/adapters/fleet/console-sessions.js

@@ -0,0 +1,23 @@
+/**
+ * Asks the fleet whether a forwarded console session cookie is a signed-in
+ * operator's or a viewer's, with its scopes, with `console.session`
+ * (decisions 0012, 0022 and 0043): the cookie travels from the console's server,
+ * server to server.
+ */
+import { consoleSessionOutputSchema } from '@aeolus-fleet/common';
+import { z } from 'zod';
+import { err, ok } from '../../core/shared/result.js';
+const sessionAnswer = z.object({ result: z.object({ data: consoleSessionOutputSchema }) });
+export function createFleetConsoleSessions(fleetUrl) {
+    return {
+        check: async (cookie) => {
+            const response = await fetch(`${fleetUrl}/trpc/console.session`, { headers: { cookie } });
+            if (!response.ok) {
+                return err({ code: 'UNAUTHORIZED', message: 'No signed-in console session' });
+            }
+            const { fleetId, kind, scopes } = sessionAnswer.parse(await response.json()).result.data;
+            return ok({ fleetId, kind, scopes });
+        },
+    };
+}
+//# sourceMappingURL=console-sessions.js.map