@cotal-ai/core 0.170.0 → 0.171.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/agent-endpoint.d.ts +146 -5
- package/dist/agent-endpoint.d.ts.map +1 -1
- package/dist/agent-endpoint.js +69 -12
- package/dist/agent-endpoint.js.map +1 -1
- package/dist/connector-setup.d.ts +2 -0
- package/dist/connector-setup.d.ts.map +1 -1
- package/dist/endpoint-action.d.ts +2 -2
- package/dist/endpoint-action.js +6 -7
- package/dist/endpoint-action.js.map +1 -1
- package/dist/endpoint-boot-memberships.d.ts +71 -0
- package/dist/endpoint-boot-memberships.d.ts.map +1 -0
- package/dist/endpoint-boot-memberships.js +119 -0
- package/dist/endpoint-boot-memberships.js.map +1 -0
- package/dist/endpoint-journal.d.ts.map +1 -1
- package/dist/endpoint-journal.js +14 -6
- package/dist/endpoint-journal.js.map +1 -1
- package/dist/endpoint-provisioning.d.ts +73 -0
- package/dist/endpoint-provisioning.d.ts.map +1 -0
- package/dist/endpoint-provisioning.js +122 -0
- package/dist/endpoint-provisioning.js.map +1 -0
- package/dist/endpoint.d.ts +10 -33
- package/dist/endpoint.d.ts.map +1 -1
- package/dist/endpoint.js +44 -150
- package/dist/endpoint.js.map +1 -1
- package/dist/provision-permission-builders.d.ts +356 -0
- package/dist/provision-permission-builders.d.ts.map +1 -0
- package/dist/provision-permission-builders.js +1383 -0
- package/dist/provision-permission-builders.js.map +1 -0
- package/dist/provision-permissions.d.ts +2 -47
- package/dist/provision-permissions.d.ts.map +1 -1
- package/dist/provision-permissions.js +9 -1378
- package/dist/provision-permissions.js.map +1 -1
- package/package.json +1 -1
|
@@ -0,0 +1,356 @@
|
|
|
1
|
+
import { type DeprovisionTarget } from "./subjects.js";
|
|
2
|
+
import { type EpCaller } from "./endpoint-subjects.js";
|
|
3
|
+
import { type ListingBinding } from "./issued-authority.js";
|
|
4
|
+
import type { MintOpts, MintPrincipal } from "./provision-jwt.js";
|
|
5
|
+
/** One seat's manager control view. It carries no agent messaging or delivery surface, and every
|
|
6
|
+
* manager request, including describe, is pinned to one exact registered instance. */
|
|
7
|
+
export declare function managerCallerPermissions(space: string, pr: MintPrincipal, opts: MintOpts): Record<string, unknown>;
|
|
8
|
+
/** The long-lived SUPERVISOR permission set — the always-on manager daemon
|
|
9
|
+
* (`manager.ts` `this.ep`), carved down from the former allow-all `manager`. Its breadth is
|
|
10
|
+
* STANDING, so tightening it removes the always-on DM/DLV body-read AND the stream-admin tamper
|
|
11
|
+
* from the one connection that never goes away. It holds the manager bucket's `lease.*` instance keys
|
|
12
|
+
* and the per-space renewal lease key, its own presence key + the roster watch, the ONE delivery-admin
|
|
13
|
+
* call (request + bounded reply subtree), the manager-plane liveness serve + reply rows, and a
|
|
14
|
+
* read-only point read of the delivery lease row — and nothing else. It serves no manager control:
|
|
15
|
+
* that is the v0.4 `service` endpoint, served on a SEPARATE connection under its own
|
|
16
|
+
* `endpoint-serve` credential. Provisioning (DM/DLV/TASK consumer-create + ACL
|
|
17
|
+
* writes) moves to the EPHEMERAL `provisioner` (opened per-spawn); destructive history-purge moves to the
|
|
18
|
+
* EPHEMERAL `purger`. So the supervisor holds NO chat/inst/svc publish (it never posts — only
|
|
19
|
+
* `setActivity`, a presence write), NO DM/DLV read of any kind (no consumer-create, no native sub), NO
|
|
20
|
+
* stream CREATE/DELETE/PURGE/UPDATE, NO channel-registry access (the daemon sets `watchChannels:false`).
|
|
21
|
+
* `$JS` is an ENUMERATED allow-list — exactly the presence-watch + lease-KV verbs — never `$JS.>`. A
|
|
22
|
+
* leaked supervisor cred can hold the lease and read the public roster; it cannot read a DM, forge an
|
|
23
|
+
* actor, provision, purge, or tamper with a stream. */
|
|
24
|
+
export declare function supervisorPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
25
|
+
/** The long-lived REMOTE MANAGER base credential. This is intentionally smaller than the local
|
|
26
|
+
* supervisor+provisioner union: it registers only its own manager presence, holds only its own
|
|
27
|
+
* manager-instance lease key, and may provision only lifecycle-keyed resources under its derived
|
|
28
|
+
* owner. Endpoint registration, contract publication and serving use separate instance-pinned
|
|
29
|
+
* credentials returned by the same typed host protocol. Per-agent provisioning deliberately does
|
|
30
|
+
* NOT ride this credential: NATS consumer names are single tokens, so a broker grant cannot safely
|
|
31
|
+
* express a prefix wildcard inside `dm_<owner>-<actor>-<uid>`. That operation stays on the host's
|
|
32
|
+
* authenticated provisioning protocol, where the requested descendant is fresh-validated before
|
|
33
|
+
* an exact one-shot grant is used. */
|
|
34
|
+
export declare function remoteManagerPermissions(space: string, pr: MintPrincipal, pin: {
|
|
35
|
+
instanceId: string;
|
|
36
|
+
owner: string;
|
|
37
|
+
actor: string;
|
|
38
|
+
}): Record<string, unknown>;
|
|
39
|
+
/** The human-CLI OPERATOR permission set — the ephemeral key the headless
|
|
40
|
+
* client commands mint (`cotal send dm|msg|ask`, `cotal dm`, `personas list --running`, via
|
|
41
|
+
* `openTransient`). It does exactly what those do: POST as itself (chat/DM/anycast — self-scoped, can
|
|
42
|
+
* never forge another actor), and READ the public roster (presence) + the channel registry to resolve a
|
|
43
|
+
* name→id and a channel's delivery class. Much narrower than the old broad `manager`: NO serve-control,
|
|
44
|
+
* NO DM/DLV body read, NO chat-history read, NO stream CREATE/DELETE/PURGE, NO ACL write, NO lease, NO
|
|
45
|
+
* provisioning. A leaked operator cred can post as itself and read the roster — the same surface as the
|
|
46
|
+
* human who ran the command. (The interactive `cotal join` console — chat read + own-DM receive — is a
|
|
47
|
+
* separate, fuller surface, deferred: it needs the unprovisioned-console DM self-create fixed first.) */
|
|
48
|
+
export declare function operatorPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
49
|
+
/** Connect-only PROBE — the liveness/auth preflight (`preflight.ts preflightTarget`, minted on
|
|
50
|
+
* ~every CLI command that resolves a mesh). `probeConnect` opens a connection to prove the broker is up
|
|
51
|
+
* and the creds are accepted, then closes it — it performs NO pub/sub. So the tightest possible grant:
|
|
52
|
+
* deny ALL publish, subscribe only to the own reply inbox. A leaked probe cred can open a socket and do
|
|
53
|
+
* nothing else. (Was the broad `manager` cred — minted on nearly every command, the worst over-grant.) */
|
|
54
|
+
export declare function probePermissions(pr: MintPrincipal): Record<string, unknown>;
|
|
55
|
+
/** CHANNEL-WRITER — edits the channel registry ONLY: `cotal channels set/default` and the
|
|
56
|
+
* `spawn -f` new-channel seed (`seedChannelRegistry`). It VALUE-writes `$KV.<channelBucket>` (a channel's
|
|
57
|
+
* config key) and read-before-writes it. NO stream data, NO other bucket, NO chat/DM — a leaked
|
|
58
|
+
* channel-writer can only rewrite channel config, never post, read a body, or tear a stream down. */
|
|
59
|
+
export declare function channelWriterPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
60
|
+
/** CHANNEL-PURGER — the `cotal web` dashboard's ONLY write path: delete a channel
|
|
61
|
+
* (`clearChannel` = filtered `STREAM.PURGE.CHAT` to drop the channel's messages + a `$KV.<channelBucket>`
|
|
62
|
+
* key delete). Pre-minted once by `web` so the account signing seed falls out of scope; the dashboard's
|
|
63
|
+
* READ side runs on the separate read-only `admin` cred. = channel-writer + the scoped CHAT purge. */
|
|
64
|
+
export declare function channelPurgerPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
65
|
+
/** TEARDOWN — `cotal down -f` space teardown. The space-wide cred that keeps `STREAM.DELETE` (the
|
|
66
|
+
* tamper verb). `down -f` is multi-step: `connectProbe` (presence-watch + channel-registry read)
|
|
67
|
+
* → invoke the manager's `ps` + any-mode `despawn` over the ep rails to politely stop the managed
|
|
68
|
+
* agents → `readMembership` (the membership-feed read that keeps an owned channel another member
|
|
69
|
+
* still uses) → `deleteChannels`
|
|
70
|
+
* (channel-registry key delete + CHAT purge) → `deleteSpace` (STREAM.DELETE every owned stream/bucket).
|
|
71
|
+
* So it reads state, CALLS admin control, deletes channels, and deletes streams — but NEVER reads a
|
|
72
|
+
* DM/DLV body, posts chat, or forges. Isolated here so no standing operator/provisioner/supervisor cred
|
|
73
|
+
* can delete a stream; a leaked teardown can wipe a space you own + stop its agents (that IS its job),
|
|
74
|
+
* nothing else. Minted ephemerally per teardown from the local trust material (same-checkout `down -f`). */
|
|
75
|
+
export declare function teardownPermissions(space: string, pr: MintPrincipal, transferStreams: string[]): Record<string, unknown>;
|
|
76
|
+
/** MEMBERSHIP-STORE-RECREATE — explicit conversion of the derived membership feed from File to
|
|
77
|
+
* Memory. The credential can inspect and delete exactly that one stream. It cannot create the
|
|
78
|
+
* replacement, read membership values, or touch another stream; the ordinary short-lived
|
|
79
|
+
* provisioner creates and verifies the empty Memory replacement after deletion. */
|
|
80
|
+
export declare function membershipStoreRecreatePermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
81
|
+
/** ISSUED-STORE-RECREATE — `cotal up --recreate-issued-stores`, and an embedder's call of
|
|
82
|
+
* `removeIssuedStoresBeforeRetention`: back up, then delete, the two issued-authority stores of ONE
|
|
83
|
+
* space that predate bounded retention. Exactly `STREAM.INFO`, `STREAM.SNAPSHOT` and
|
|
84
|
+
* `STREAM.DELETE` on those two streams, the snapshot's delivery inside its own inbox, and the
|
|
85
|
+
* snapshot ACK subjects of those two streams ({@link snapshotAckGrant}). Nothing reads a row,
|
|
86
|
+
* writes a store or reaches another stream. */
|
|
87
|
+
export declare function issuedStoreRecreatePermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
88
|
+
/** CONTROL-CALLER (ep rails only) — the operator's lifecycle commands
|
|
89
|
+
* (`cotal ps/start/stop/attach`, `manager/commands.ts`). It invokes the manager's v0.4 service
|
|
90
|
+
* endpoint and reads the bounded reply on the ep reply rail. That is ALL — no `$JS`, no `$KV`,
|
|
91
|
+
* no chat/DM: it forges nothing, reads no body.
|
|
92
|
+
*
|
|
93
|
+
* The tiers stay SPLIT because the BROKER grant is load-bearing: an any-mode
|
|
94
|
+
* despawn/attach row *is* cross-agent reach — the manager maps mode `any` to its admin
|
|
95
|
+
* authorization path, so which ROWS an instrument holds is the tier boundary. Therefore:
|
|
96
|
+
* • `control-caller-privileged` (ps/start) holds the manager reads + untargeted `spawn` +
|
|
97
|
+
* `define-persona` — structurally barred from cross-agent ops (no any-mode row). This is the
|
|
98
|
+
* high-frequency path; it never needs admin reach.
|
|
99
|
+
* • `control-caller-admin` (stop/attach) adds the any-mode despawn/attach rows + the
|
|
100
|
+
* `manager.admin` family — it genuinely needs cross-agent reach. Its containment is the
|
|
101
|
+
* broker gating the any-mode rows + the cred being ephemeral (mint → one request →
|
|
102
|
+
* disconnect, from the local signing seed); on a user mesh the manager's serve-time ledger
|
|
103
|
+
* re-check sits on top. */
|
|
104
|
+
export declare function controlCallerPermissions(space: string, pr: MintPrincipal, epTier: "privileged" | "admin", opts?: MintOpts): Record<string, unknown>;
|
|
105
|
+
/** The ep caller a mint pins: the triple, plus the issued generation when the mint is an
|
|
106
|
+
* issuance (SPEC 13.15). One place decides the rail so a credential's request rows, its reply
|
|
107
|
+
* read, and its describe row all land on the same one. */
|
|
108
|
+
export declare function issuedCallerFor(triple: EpCaller, opts: MintOpts): EpCaller;
|
|
109
|
+
/** The rows a listing generation adds to a legacy-rail credential (SPEC 13.15, "Listing
|
|
110
|
+
* issuance"): the registry's `endpoints` request publish and its reply subscribe on `ep.v1`, and
|
|
111
|
+
* the per-key read of the generation's accepted row. Exactly these: one caller value emits one
|
|
112
|
+
* rail, so these are the only `ep.v1` rows such a credential holds. */
|
|
113
|
+
export declare function listingGrantRows(space: string, caller: EpCaller, listing: ListingBinding): {
|
|
114
|
+
pub: string[];
|
|
115
|
+
sub: string[];
|
|
116
|
+
};
|
|
117
|
+
/** ENDPOINT-SERVE (v0.4, SPEC §13.9 "Serve grants") — the per-instance serve credential:
|
|
118
|
+
* EXACTLY the instance's registered rails and nothing else. Subscribe: the queue-qualified
|
|
119
|
+
* class rail, the plain scatter rail, and the own-instance rail for the FULL registered
|
|
120
|
+
* command set plus the derived `describe`, and the own epoch-pinned timer-fire subjects;
|
|
121
|
+
* publish: the epoch-pinned egress (reply / `epe` events / `ept` schedule requests / `epr`
|
|
122
|
+
* record-write ingress) plus, from the branded snapshot only, the §13.9 bind rows: the shared
|
|
123
|
+
* `eff_<e>` effects bind iff the surface is journal-class and each owned `pool_<e>_<pool>`
|
|
124
|
+
* bind (bind-only + `$JS.API.INFO`; an ephemeral-only poolless endpoint emits none). No agent
|
|
125
|
+
* baseline of any kind — no chat/DM/anycast/presence/ctl, no broad `$JS.>`. The value MUST be the
|
|
126
|
+
* branded ARTIFACT `authorizeServeGrant` returned, and its mint context binds: same space, and
|
|
127
|
+
* the minted principal is the registered owner. This builds the ROWS; the RELEASE fence is the
|
|
128
|
+
* durable issuance-gate CAS `mintCreds` runs (SPEC §13.1) — a raw/copied/diverging value or a
|
|
129
|
+
* foreign space/principal refuses here, and a stale incarnation loses the gate CAS. */
|
|
130
|
+
export declare function endpointServePermissions(space: string, pr: MintPrincipal, opts: MintOpts): Record<string, unknown>;
|
|
131
|
+
/** DEPLOYER — the `cotal spawn -f` manifest-deploy authority. `spawn -f` drives ONE
|
|
132
|
+
* `connectProbe` endpoint that both READS live state (roster/presence watch, channel registry,
|
|
133
|
+
* membership feed, manager-singleton lease) AND invokes the running manager's `launch` + `ps`
|
|
134
|
+
* readiness over the v0.4 ep rails. Those interleave on one connection, so a strict 3-connection
|
|
135
|
+
* split would only refactor `live.ts` for marginal gain; `deployer` is that one coherent,
|
|
136
|
+
* ephemeral deploy cred. It is the SOLE profile that combines reads + admin-control — NOT a template a
|
|
137
|
+
* 4th command should reach for (revisit the connection split before adding a second such caller).
|
|
138
|
+
*
|
|
139
|
+
* Boundaries (all enforced by omission / default-deny): NO self-post (`chat`/`inst`/`svc`), NO `$JS.>`,
|
|
140
|
+
* NO `STREAM.DELETE`/`PURGE`/`UPDATE`, NO DM/DLV/TASK `CONSUMER.CREATE` (no body-read surface), NO `$KV`
|
|
141
|
+
* writes (channel seeding rides a SEPARATE `channel-writer` cred). It holds the admin INSTRUMENT ep
|
|
142
|
+
* set (any-mode despawn/attach + the manager.admin family + reads) because manifest launch/ps
|
|
143
|
+
* genuinely need cross-agent reach — and that IS real power: the manager's any-mode authz is
|
|
144
|
+
* subject-gated (the any-mode ep row is mintable only under operator policy), so holding it lets it
|
|
145
|
+
* stop/attach/launch ANY agent. The BROKER gating that row is the boundary. Containment is therefore
|
|
146
|
+
* the LIFETIME, not a manager re-check: minted from LOCAL same-checkout auth for one `spawn -f`,
|
|
147
|
+
* memory-only, dropped after deploy. If it is ever persisted, handed to user-supplied `--creds`, or
|
|
148
|
+
* reused as a general "read + admin" cred, revisit. */
|
|
149
|
+
export declare function deployerPermissions(space: string, pr: MintPrincipal, epTier?: "privileged" | "admin", opts?: MintOpts): Record<string, unknown>;
|
|
150
|
+
/** The ephemeral PURGER permission set — minted per-purge inside the daemon's
|
|
151
|
+
* `opPurge` and `cotal history clear`. Isolates the DESTRUCTIVE history-purge grant
|
|
152
|
+
* (`STREAM.PURGE.CHAT` + `STREAM.PURGE.DM`) off the always-on supervisor: `--dms` purges the DM stream,
|
|
153
|
+
* exactly the grant the supervisor must not hold. It PURGES but never READS — no DM/chat consumer, no
|
|
154
|
+
* `MSG.GET` — so a leaked purger can drop history but cannot read a body. Short-lived (one purge call). */
|
|
155
|
+
export declare function purgerPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
156
|
+
/** The ephemeral PROVISIONER permission set — the onboarding authority,
|
|
157
|
+
* carved off the long-lived manager. Minted short-lived for per-spawn provisioning (pre-create each
|
|
158
|
+
* agent's bind-only DM/DLV/TASK durables + record its read ACL via `commitAcl`) — the daemon opens it per
|
|
159
|
+
* spawn (`manager.ts withProvisioner`). It is ALSO the cred that creates the space's streams + KV buckets
|
|
160
|
+
* and seeds the channel registry via `setupSpaceStreams` (exercised by the manager-split smoke) — and
|
|
161
|
+
* `cotal up`'s ephemeral setup cred (`up.ts authSetup`) now mints THIS profile, not the broad `manager`.
|
|
162
|
+
* NEVER minted for an agent — `cotal mint` whitelists
|
|
163
|
+
* agent/observer/admin only, like `manager`/`delivery`.
|
|
164
|
+
*
|
|
165
|
+
* This profile HOLDS the DM/DLV `CONSUMER.CREATE` push-consumer surface — the irreducible onboarding
|
|
166
|
+
* power (the create-time `deliver_subject` of a push consumer is not ACL-constrained, so whoever can
|
|
167
|
+
* create a DM/DLV consumer can stream the bodies). That is exactly why it is split OFF the always-on
|
|
168
|
+
* supervisor and made EPHEMERAL: the daemon opens a provisioner connection per spawn and drains it
|
|
169
|
+
* immediately, so the surface exists only for the provisioning window, not as a standing target. The
|
|
170
|
+
* cred is MEMORY-ONLY (never written to `.cotal`) and carries a short profile-default `exp`.
|
|
171
|
+
*
|
|
172
|
+
* `$JS` is an ENUMERATED allow-list, never `$JS.>`: STREAM.CREATE + INFO for the space streams/buckets,
|
|
173
|
+
* DM/DLV/TASK consumer CREATE/DURABLE.CREATE/INFO — and deliberately NO `MSG.NEXT`/`MSG.GET`/`ACK` on
|
|
174
|
+
* DM/DLV (it creates the bind-only mailbox but never reads it), and NO STREAM.DELETE/PURGE/MSG.DELETE
|
|
175
|
+
* (it provisions, it does not tear down). STREAM.UPDATE is held on EXACTLY thirteen streams and no others:
|
|
176
|
+
* the three TTL'd KV buckets (presence + the two leases, #286: an existing bucket's `max_age` cannot be
|
|
177
|
+
* fixed by `kvm.create`, so reconciling a pre-TTL deployment requires updating it), the four hardened
|
|
178
|
+
* authority stores (records, issued, accepted, admission), each updated once at creation, and the
|
|
179
|
+
* membership KV and artifact Object Store, whose legacy `max_bytes` values setup reconciles to -1 (the
|
|
180
|
+
* reservation a positive cap holds against the broker's `max_file_store` is what stopped a tenth space
|
|
181
|
+
* from being provisioned; `Objm.create` cannot fix an existing bucket's cap either), and the CHAT,
|
|
182
|
+
* INBOX, DLV and DM streams, whose history limits `cotal history limit` writes (`setHistoryLimit`).
|
|
183
|
+
* Stated positively on purpose: this docblock previously read "NO …/UPDATE", which was already untrue of
|
|
184
|
+
* the records stream and became untrue of the buckets, and a comment that denies a credential's real
|
|
185
|
+
* power is worse than none — it is the document a reader trusts instead of checking. KV value-writes are
|
|
186
|
+
* scoped to exactly the two
|
|
187
|
+
* registries provisioning touches: the read-ACL bucket (`commitAcl`) and the channel registry (seed). */
|
|
188
|
+
export declare function provisionerPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
189
|
+
/** The ISSUER permission set (SPEC 13.15): value-writes on the evidence store (evidence, attempt,
|
|
190
|
+
* source index: create-only and CAS rows, keyed by generation) and on the accepted-row store
|
|
191
|
+
* (create-only, keyed by the client's token); `STREAM.INFO` on both, the bind-time shape check;
|
|
192
|
+
* the leader-served point read on the evidence store; and the ordered `keys()` walk a source
|
|
193
|
+
* retirement enumerates the reverse index with.
|
|
194
|
+
* NAMED RESIDUAL (the contract's section 8): this profile holds a write and a raw read on ONE
|
|
195
|
+
* stream, the pairing no peer-held profile may hold, so it is never issuable to a peer. */
|
|
196
|
+
export declare function issuerPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
197
|
+
/** The REGISTRY READER permission set (SPEC 13.20). The evidence store's `STREAM.MSG.GET` is
|
|
198
|
+
* stream-scoped because the key rides the request body: NAMED RESIDUAL, the holder can read every
|
|
199
|
+
* recorded ceiling in the space, so this credential is never a peer's. The records reads are the
|
|
200
|
+
* key list and the per-key `svc` spec/status Direct Get, no stream-wide read; contract artifacts
|
|
201
|
+
* ride the agent's subject-scoped fetch row. No write of any shape. */
|
|
202
|
+
export declare function registryReaderPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
203
|
+
/** The RUN ADMITTER permission set (SPEC 14.8): exactly ONE run's admission record and
|
|
204
|
+
* revocation marker on the admission store (both create-only), plus the leader-served read the
|
|
205
|
+
* create-before-read and the marker's own re-read ride. No other run's keys, no other store. */
|
|
206
|
+
export declare function runAdmitterPermissions(space: string, pr: MintPrincipal, pin: NonNullable<MintOpts["runAdmitter"]>): Record<string, unknown>;
|
|
207
|
+
/** The ephemeral, LIFECYCLE-PINNED §13.1 state-write permission set for the STATIC manager's
|
|
208
|
+
* lifecycle executor. One credential per lifecycle OPERATION (activation, terminal,
|
|
209
|
+
* renewal ledger append): every grant names exactly ONE incarnation's keys — the alias head,
|
|
210
|
+
* the uid reservation, the manager slot row, the issuance gate, and the `cred.<uid>.>` ledger
|
|
211
|
+
* family — so a leaked executor cred can move one incarnation's state machine and nothing else.
|
|
212
|
+
*
|
|
213
|
+
* Reads: records reads ride the keyed Direct Get form (the key is ON the subject, so the read
|
|
214
|
+
* grant stays key-pinned); the auth store is leader-served (`allow_direct=false`), so its reads
|
|
215
|
+
* are body-selected `STREAM.MSG.GET` — stream-scoped, NOT key-scoped (the requested key rides
|
|
216
|
+
* the PAYLOAD, which a subject grant cannot see). NAMED RESIDUAL: for its one-shot lifetime the
|
|
217
|
+
* executor can READ (never write) other rows in the auth store. */
|
|
218
|
+
export declare function lifecycleExecutorPermissions(space: string, pr: MintPrincipal, pin: {
|
|
219
|
+
owner: string;
|
|
220
|
+
actor: string;
|
|
221
|
+
lifecycleUid: string;
|
|
222
|
+
alias: string;
|
|
223
|
+
}): Record<string, unknown>;
|
|
224
|
+
/** The SELF-MEDIATED goal-writer profile (spawn-as-action): exactly
|
|
225
|
+
* {@link goalWriterGrants} for ITS endpoint — the goal bind + terminal facts, the goal-record KV
|
|
226
|
+
* writes, and the leader-served fencing reads — plus the connection-scoped reply inbox. Disjoint
|
|
227
|
+
* from the endpoint's serve credential: a serve connection carries none of these rows, so it
|
|
228
|
+
* is broker-denied every goal write. */
|
|
229
|
+
export declare function goalWriterPermissions(space: string, pr: MintPrincipal, pin: {
|
|
230
|
+
endpoint: string;
|
|
231
|
+
}): Record<string, unknown>;
|
|
232
|
+
/** The console/CLI per-session CALLER rows: RAILS-ONLY for ONE §13.6 session — pub the
|
|
233
|
+
* session's epoch-pinned `in` rail, sub its `out` rail plus the caller's own reply inbox, and
|
|
234
|
+
* NOTHING else. Deliberately NO KV, NO JetStream API, NO store: the caller drives the terminal over
|
|
235
|
+
* the two core-only eps subjects and never reads the session ledger, so there is no subject-blind
|
|
236
|
+
* store read to widen (SPEC §13.9). The endpoint+sessionId+epoch pin the EXACT pair, so a cred for
|
|
237
|
+
* session A authorizes nothing of session B (no wildcard). `epsSubject` validates every token, so a
|
|
238
|
+
* malformed coordinate refuses at the mint rather than emitting a broadened subject. */
|
|
239
|
+
export declare function sessionCallerPermissions(space: string, pr: MintPrincipal, pin: {
|
|
240
|
+
endpoint: string;
|
|
241
|
+
sessionId: string;
|
|
242
|
+
epoch: number;
|
|
243
|
+
} | undefined): Record<string, unknown>;
|
|
244
|
+
/** The own-DM reader rows (#4189): CONSUMER.INFO and MSG.NEXT on the principal's own
|
|
245
|
+
* lifecycle-keyed `dm_` durable, its `$JS.ACK` subtree, and the connection inbox. Nothing else:
|
|
246
|
+
* no publish of any message, no CONSUMER.CREATE (the durable is provisioned, never created), no
|
|
247
|
+
* `$JS.API.INFO`, no STREAM.INFO, no presence, channel, CHAT or `dlv_` row. It is exactly what
|
|
248
|
+
* `EndpointOptions.dmOnly` sends. */
|
|
249
|
+
export declare function dmReaderPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
250
|
+
/** The manager's per-session SERVING rows: the EXACT mirror of
|
|
251
|
+
* {@link sessionCallerPermissions} with the directions swapped — sub the ONE session's epoch-pinned
|
|
252
|
+
* `in` rail (caller→serving), pub its `out` rail (serving→caller), plus the connection-scoped reply
|
|
253
|
+
* inbox, and NOTHING else. Same asymmetry §13.6 states: "the caller publishes `in` and subscribes
|
|
254
|
+
* `out`; the serving instance the reverse".
|
|
255
|
+
*
|
|
256
|
+
* Deliberately NO KV and NO JetStream API — not even the session ledger. The serving side drives
|
|
257
|
+
* bytes; the ledger is the standing `session-ledger` credential's, on a different connection. That
|
|
258
|
+
* separation is what lets this credential be one-shot and die with its session while the durable
|
|
259
|
+
* revocation authority outlives it (§13.6).
|
|
260
|
+
*
|
|
261
|
+
* This REPLACES a standing writer that held `eps.<endpoint>.*.<epoch>.{in,out}` and so could read
|
|
262
|
+
* and write every live session's bytes at its epoch. The pin makes a credential for session A
|
|
263
|
+
* authorize nothing of session B, and `epsSubject` validates every token, so a malformed
|
|
264
|
+
* coordinate refuses at the mint rather than emitting a broadened subject. */
|
|
265
|
+
export declare function sessionServingPermissions(space: string, pr: MintPrincipal, pin: {
|
|
266
|
+
endpoint: string;
|
|
267
|
+
sessionId: string;
|
|
268
|
+
epoch: number;
|
|
269
|
+
} | undefined): Record<string, unknown>;
|
|
270
|
+
/** The manager's SESSION-LEDGER rows: the DEDICATED sessions-bucket rows and nothing
|
|
271
|
+
* else — no session rail of any shape. Needs no pin: the grant carries no endpoint, epoch, or
|
|
272
|
+
* session component, because §13.6's durable revocation authority is per-space, not per-session
|
|
273
|
+
* (it must still be able to resolve and revoke a row after the endpoint that served it is gone).
|
|
274
|
+
* {@link sessionLedgerGrants} carries the row rationale, the §13.9 subject-blindness confinement,
|
|
275
|
+
* and the named `session.*` breadth residual. */
|
|
276
|
+
export declare function sessionLedgerPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
277
|
+
/** The ephemeral, ENDPOINT-INSTANCE-PINNED endpoint-serve executor permission set:
|
|
278
|
+
* the manager mints this per registration/serve-mint op and drives the endpoint
|
|
279
|
+
* registration barrier's `epgate` CAS + the mint fence's `epcred` stage/revoke THROUGH it — never
|
|
280
|
+
* its standing seed/supervisor connection. Every
|
|
281
|
+
* WRITE is key-pinned to exactly ONE (endpoint, instanceId): the gate `epgate.<ep>.<iid>`, its
|
|
282
|
+
* serving ledger family `epcred.<ep>.<iid>.>`, and the registration's two records keys (the
|
|
283
|
+
* instance's `svc` spec + the endpoint's governance head — `registerServiceInstance` drives the
|
|
284
|
+
* slot-take/promote over this same connection). A leaked/mis-constructed executor can move exactly
|
|
285
|
+
* one endpoint instance's serve state and nothing else. The auth store is `allow_direct=false`, so
|
|
286
|
+
* reads are leader-served `STREAM.MSG.GET` (stream-scoped, NOT key-scoped — the key rides the
|
|
287
|
+
* payload); enumeration of the epcred family rides an ordered `keys()` consumer. NAMED RESIDUAL:
|
|
288
|
+
* for its one-shot lifetime the executor can READ (never write) other auth rows — endpoint/
|
|
289
|
+
* credential metadata, no bearer bytes; every WRITE stays key-pinned. */
|
|
290
|
+
export declare function endpointServeExecutorPermissions(space: string, pr: MintPrincipal, pin: {
|
|
291
|
+
endpoint: string;
|
|
292
|
+
instanceId: string;
|
|
293
|
+
}): Record<string, unknown>;
|
|
294
|
+
/** The ephemeral, TARGET-PINNED DEPROVISIONER permission set — the teardown counterpart
|
|
295
|
+
* to {@link provisionerPermissions}, minted per departed agent inside the manager's `deprovision` tail
|
|
296
|
+
* (`withProvisioner`-style: a fresh scoped cred per teardown is cheap). It deletes exactly the
|
|
297
|
+
* dev/static principal footprint the provisioner created for ONE agent: that agent's two bind-only
|
|
298
|
+
* durables (`dm_local-<actor>`, `dlv_local-<actor>`) and its read-ACL row — pinned BY NAME to the target
|
|
299
|
+
* actor under {@link DEV_OWNER}, so a leaked deprovisioner cred can tear down that one already-dead
|
|
300
|
+
* agent and NOTHING else.
|
|
301
|
+
*
|
|
302
|
+
* Deliberately NOT granted (least-privilege / correctness): the role-SHARED `svc_<role>` TASK durable
|
|
303
|
+
* (one consumer for ALL agents of a role — deleting it on one agent's exit would break its siblings; it
|
|
304
|
+
* lives until space teardown), any peer's `dm_`/`dlv_`/ACL (the grants are target-name-pinned, never
|
|
305
|
+
* `.>`), any MSG.NEXT/MSG.GET/ACK (it deletes mailboxes, never reads a body), and any STREAM
|
|
306
|
+
* DELETE/PURGE (it removes per-agent consumers, never a stream). The `chathist_<id>` history consumers
|
|
307
|
+
* need no grant here — they are ephemeral (`mem_storage`, 30s inactive threshold) and agent-deleted
|
|
308
|
+
* after each read, so they self-clean on the agent's disconnect.
|
|
309
|
+
*
|
|
310
|
+
* Blast radius of a leaked cred (minted for target T): it can delete T's `dm_local-<T>`/`dlv_local-<T>`
|
|
311
|
+
* durables + purge T's ACL row — a denial-of-DELIVERY for T (broken DM/DLV bind + the reader DEFERs on
|
|
312
|
+
* the absent ACL) if fired while T is still alive. It CANNOT read T's bodies, impersonate T, reach any peer, or
|
|
313
|
+
* delete a stream — and it is ephemeral (one per-exit teardown, minted then dropped). Contained and
|
|
314
|
+
* recoverable (re-provision T). */
|
|
315
|
+
export declare function deprovisionerPermissions(space: string, pr: MintPrincipal, deprovisionTarget: DeprovisionTarget): Record<string, unknown>;
|
|
316
|
+
/** The scoped `delivery` daemon permission set (server-side Plane-3 infra; NEVER allow-all, never
|
|
317
|
+
* minted for an agent — `cotal mint` excludes it, like `manager`). Least-privilege: exactly what the
|
|
318
|
+
* fan-out writer + trusted reader + activation catch-up + membership/ACL reads + members-KV writes +
|
|
319
|
+
* the lease + the `ctl.delivery` control service touch. `sub.allow` is the per-identity inbox (all JS
|
|
320
|
+
* pull delivery / KV-watch / request replies land there) PLUS the `ctl.delivery` control subtree it
|
|
321
|
+
* serves; ALL stream/KV reads ride the JS API (publishes), so there is NO native `chat`/`dinbox`/`dlv`
|
|
322
|
+
* subscription — a leaked cred can't natively sniff the mixed pre-auth store. Honest blast radius
|
|
323
|
+
* (delivery-daemon.mdx): it can write any owner's `dlv` (the post-auth store agents trust); the future
|
|
324
|
+
* fan-out/reader cred split bounds that. */
|
|
325
|
+
export declare function deliveryPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
326
|
+
/** The scoped DATA-account `membership-rw` permission set (the graph feed's conn B; NEVER allow-all,
|
|
327
|
+
* never minted for an agent — `cotal mint` excludes it, like `manager`/`delivery`). Least-privilege:
|
|
328
|
+
* READ the members registry (the durable arm of the merge) + READ/WRITE the one derived membership
|
|
329
|
+
* bucket, and nothing else. It holds NO chat/DM/anycast/ctl grant and never touches `$SYS` (account
|
|
330
|
+
* isolation keeps the system-account CONNZ read on the SEPARATE conn-A cred). A leaked conn-B cred can
|
|
331
|
+
* read durable-membership records and forge the feed — bounded to "dashboard integrity" by the
|
|
332
|
+
* display-only invariant; it reads no message bodies and admins nothing. */
|
|
333
|
+
export declare function membershipRwPermissions(space: string, pr: MintPrincipal): Record<string, unknown>;
|
|
334
|
+
/** The scoped SYSTEM-account `membership-observer` permission set (the graph feed's conn A). An EXPLICIT
|
|
335
|
+
* block is MANDATORY: a system-account user with NO permissions block defaults to ALLOW-ALL = full
|
|
336
|
+
* `$SYS` = broker admin (verified — pre-flight spike + docs). Least-privilege allowlist:
|
|
337
|
+
* - **pub:** the account-scoped CONNZ request subject ONLY (not server-wide `PING.CONNZ`, not
|
|
338
|
+
* `REQ.SERVER.*`/`REQ.CLAIMS.*`).
|
|
339
|
+
* - **sub:** the scoped reply inbox (`<MEMBERSHIP_INBOX_PREFIX>.>`) + this ONE account's
|
|
340
|
+
* CONNECT/DISCONNECT events (re-poll triggers) — never `$SYS.ACCOUNT.*.…` (cross-tenant) nor
|
|
341
|
+
* `$SYS.ACCOUNT.<id>.>` (pulls in SUBSZ/JSZ/purge).
|
|
342
|
+
* No `$SYS.>` deny that would shadow the allows (deny-beats-allow). A leaked conn-A cred enumerates THIS
|
|
343
|
+
* account's connections (silent readers + nkeys) and can forge the feed; it reads no bodies, touches no
|
|
344
|
+
* other account, and admins no server. */
|
|
345
|
+
export declare function membershipObserverPermissions(accountId: string): Record<string, unknown>;
|
|
346
|
+
/** The KICK-ONLY connection-evictor permission set — a SYSTEM-account user that can do
|
|
347
|
+
* exactly ONE thing: `$SYS.REQ.SERVER.*.KICK` (disconnect a live client by cid). It CANNOT read
|
|
348
|
+
* CONNZ (discovery stays on the separate observer cred — never one broad sys user that both
|
|
349
|
+
* enumerates and kills), touch any other `$SYS` verb, or reach another account's data. A leaked
|
|
350
|
+
* evictor cred can DoS live connections on this broker (KICK is not account-scoped — the honest
|
|
351
|
+
* blast radius), which is why it is a HIGH-POWER standing credential: minted only at `up`,
|
|
352
|
+
* rate-limited + audited by its one caller (the delivery daemon), and its cid/server-id inputs come
|
|
353
|
+
* only from the observer's own CONNZ scan, never a user-facing API. Wildcard `*` over server id
|
|
354
|
+
* because a cluster's server ids aren't known at mint time; the scan pins the exact id per KICK. */
|
|
355
|
+
export declare function connectionEvictorPermissions(): Record<string, unknown>;
|
|
356
|
+
//# sourceMappingURL=provision-permission-builders.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"provision-permission-builders.d.ts","sourceRoot":"","sources":["../src/provision-permission-builders.ts"],"names":[],"mappings":"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"}
|