@cat-factory/gatekeeper-worker 0.4.3 → 0.5.0

package/dist/os/resource-core.js

@@ -0,0 +1,155 @@
+// What a bound resource DOES, separated from the Durable Object it lives in.
+//
+// The split is not ceremony. A Durable Object can only be constructed by workerd from a real
+// `DurableObjectState`, and the props-imbued class this Gatekeeper hands the workspace is opaque by
+// design (the workspace instantiates it, through machinery that is its own). So a suite that could
+// only reach this behaviour through the object would be reduced to asserting that a class was
+// returned. Everything worth getting wrong lives here instead, where it is ordinary code with
+// ordinary dependencies, and `resource.ts` is the shell that supplies `ctx.props` and holds one of
+// these for the object's lifetime.
+//
+// Holding ONE per object is what the action ledger needs: the workspace settles an action by
+// calling `applyAction` on the resource, so a core rebuilt per call would lose the pending action
+// the decision is about.
+import { GatekeeperError } from '../errors.js';
+import { Gatekeeper } from '../gatekeeper.js';
+import { actionKindOf } from './descriptions.js';
+import { ActionLedger, queueGovernance } from './queue.js';
+import { renderTierSessionTypes, SESSION_INTERFACE_NAME } from './session-types.js';
+/** One bound resource: the session it opens, its types, and the action lifecycle behind it. */
+export class ResourceCore {
+    #env;
+    #policy;
+    #props;
+    #ledger = new ActionLedger();
+    constructor(env, policy, props) {
+        this.#env = env;
+        this.#policy = policy;
+        this.#props = props;
+    }
+    async describe() {
+        const tier = this.#tier();
+        return {
+            url: this.#gatekeeper().deployment,
+            title: 'cat-factory workspace',
+            snippet: `File work, start runs and answer what they park on, at policy tier '${tier.name}': ` +
+                `${tier.description}`,
+            suggestedBindingName: 'catFactory',
+            tsType: SESSION_INTERFACE_NAME,
+        };
+    }
+    /**
+     * The session's own types, rendered for the tier this account holds.
+     *
+     * Tier-specific rather than a copy of the vendor's, because this is the one the contract points a
+     * caller at: `ResourceDescription.tsType` must name an export of THIS method's output, and a
+     * session carries exactly its granted operations.
+     */
+    async getTypeScriptTypes() {
+        return renderTierSessionTypes(this.#tier());
+    }
+    /**
+     * Open a governed session.
+     *
+     * The queue is not optional and not a decoration: every operation the returned object carries
+     * funnels through the one `invoke` closure, which submits actions to this queue and authorizes
+     * observations against it. The tier policy underneath is the FLOOR, so an operation the policy
+     * never granted is absent from the object rather than something the queue has to refuse.
+     *
+     * The queue passed here is OWNED by the session that comes back: it is released, along with
+     * every action that session left undecided, when the session is disposed. A caller reaching this
+     * over RPC therefore hands in a reference of its own rather than the parameter it received (see
+     * `resource.ts`), because the parameter's lifetime ends when this call returns and the session's
+     * does not.
+     */
+    async startSession(approvalQueue) {
+        const gatekeeper = this.#gatekeeper();
+        const accountId = this.#props.accountId;
+        return gatekeeper.capabilityForAccount(accountId, queueGovernance({
+            queue: approvalQueue,
+            ledger: this.#ledger.openSession(),
+            subject: {
+                accountId,
+                tier: gatekeeper.tierForAccount(accountId).name,
+                deployment: gatekeeper.deployment,
+            },
+        }));
+    }
+    /**
+     * How many submitted actions this object is still holding, across every live session.
+     *
+     * Exposed for the same reason the ledger counts them: the ONE unbounded thing about a long-lived
+     * resource object is this set, and a count that does not fall back to zero when the sessions are
+     * gone is the leak rather than a slow day.
+     */
+    get pendingActionCount() {
+        return this.#ledger.pendingCount;
+    }
+    /**
+     * The action kinds this Gatekeeper may auto-apply, if the user opted into the kind.
+     *
+     * Derived from the same table and the same consequence reading `describeAction` stamps onto each
+     * submission, so a pre-approval UI listing kinds before any action exists and the `autoApprovable`
+     * flag on an action that has been submitted cannot disagree.
+     *
+     * TODAY THIS IS EMPTY, and that is the honest answer rather than a gap. The public surface
+     * annotates a consequence only where the stakes are real money or a merged pull request, so every
+     * other mutation is unannotated, and the table's documented reading of an unannotated mutation is
+     * that it is destructive. Offering those for unattended auto-approval would mean inverting that
+     * default here, which is precisely the misreading `resolveConsequence` exists to stop. If the
+     * surface ever states that a write is safe, it appears here with no further decision.
+     */
+    async getAutoApprovableActions() {
+        return this.#tier()
+            .granted.filter((binding) => !binding.readOnly)
+            .filter((binding) => (binding.consequence?.destructive ?? true) === false)
+            .map(actionKindOf);
+    }
+    /** The workspace approved an action: perform it, and hand the result to the waiting call. */
+    async applyAction(action) {
+        await this.#ledger.apply(action);
+    }
+    /** The workspace rejected an action: the waiting call throws and nothing is performed. */
+    async rejectAction(action) {
+        this.#ledger.reject(action);
+    }
+    /**
+     * Reverting is not something this Gatekeeper can do, which every action it submits already states
+     * (`implementsRevert: false`).
+     *
+     * It answers rather than throwing because the caller is the workspace UI on behalf of a person who
+     * wants their change undone: a message naming what they have to do themselves is the useful
+     * answer, where an exception would surface as a failed revert they might retry.
+     */
+    async revertAction(_action) {
+        return {
+            message: 'This Gatekeeper cannot revert a cat-factory operation. A started run is stopped from the ' +
+                'board or with `tasks_stop`; a merged pull request is reverted in the repository, not here.',
+            canRetry: false,
+        };
+    }
+    /**
+     * Sharing this resource's observations onward is REFUSED, which blocks the share.
+     *
+     * The contract asks the gatekeeper to verify that the new viewer could directly read everything
+     * historically observed through it. This Gatekeeper cannot answer that: it keeps no observation
+     * log, and the plausible rule (the observer's own tier reaches every operation that produced the
+     * observed data) needs a tier for a viewer this deployment's policy has never named. A share
+     * blocked loudly beats an observation leaked quietly, so the refusal stands until there is a rule
+     * worth writing down.
+     */
+    async addObserver(id, _user) {
+        throw new GatekeeperError('sharing_refused', `This Gatekeeper cannot verify that '${id}' may see everything already read through this ` +
+            'resource, so it refuses the share. Give them their own connected account instead: their ' +
+            "tier is then resolved from this deployment's own policy.");
+    }
+    /** Idempotent by contract: nothing was ever added, so there is nothing to forget. */
+    async removeObserver(_id) { }
+    #gatekeeper() {
+        return Gatekeeper.create(this.#env, this.#policy);
+    }
+    #tier() {
+        return this.#gatekeeper().tierForAccount(this.#props.accountId);
+    }
+}
+//# sourceMappingURL=resource-core.js.map

package/dist/os/resource-core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-core.js","sourceRoot":"","sources":["../../src/os/resource-core.ts"],"names":[],"mappings":"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"}

package/dist/os/resource.d.ts

@@ -0,0 +1,16 @@
+import type { GatekeeperEnv } from '../env.js';
+import type { GatekeeperPolicy } from '../policy/compile.js';
+import type { ResourceObject } from './protocol.js';
+import { type ResourceProps } from './resource-core.js';
+export type { ResourceProps } from './resource-core.js';
+/**
+ * Build the resource Durable Object class over a deployment's policy.
+ *
+ * A factory rather than a class, for the reason `createGatekeeperWorker` is one: the policy is the
+ * deployment's and arrives as an argument, so a class that imported one would own the file the
+ * operator is supposed to write.
+ */
+export declare function createGatekeeperResource(options: {
+    policy: GatekeeperPolicy;
+}): new (ctx: DurableObjectState<ResourceProps>, env: GatekeeperEnv) => ResourceObject;
+//# sourceMappingURL=resource.d.ts.map

package/dist/os/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../src/os/resource.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC5D,OAAO,KAAK,EAAkD,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnG,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAErE,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAChD,MAAM,EAAE,gBAAgB,CAAA;CACzB,GAAG,KAAK,GAAG,EAAE,kBAAkB,CAAC,aAAa,CAAC,EAAE,GAAG,EAAE,aAAa,KAAK,cAAc,CA+CrF"}

package/dist/os/resource.js

@@ -0,0 +1,64 @@
+// The per-resource object the workspace binds: a Durable Object serving one paired cat-factory
+// workspace to one account.
+//
+// WHAT A RESOURCE IS, decided here and recorded in the initiative tracker: the PAIRED cat-factory
+// WORKSPACE, named by a URLPattern over the deployment origin. It follows from the credential
+// rather than being a modelling preference. This Worker holds one provisioning key, a cat-factory
+// key is scoped to exactly one workspace, and `STATE` is already keyed on the deployment origin for
+// the same reason. So one Gatekeeper Worker serves one resource, and an OS deployment that wants
+// two workspaces runs two Gatekeepers with two bindings, which is also the only arrangement in
+// which the two workspaces' credentials sit in different secret stores.
+//
+// Everything below is a FACADE. The policy compilation, the key broker, the durable state and the
+// approval answerers are the same single implementation the `/rpc` door reaches; what differs is
+// the door, and the governance that door brings with it. This file is the SHELL: it supplies
+// `ctx.props` and holds one `ResourceCore`, which is where the behaviour lives.
+import { DurableObject } from 'cloudflare:workers';
+import { holdQueue } from './queue.js';
+import { ResourceCore } from './resource-core.js';
+/**
+ * Build the resource Durable Object class over a deployment's policy.
+ *
+ * A factory rather than a class, for the reason `createGatekeeperWorker` is one: the policy is the
+ * deployment's and arrives as an argument, so a class that imported one would own the file the
+ * operator is supposed to write.
+ */
+export function createGatekeeperResource(options) {
+    const { policy } = options;
+    return class CatFactoryResource extends DurableObject {
+        // ONE core for the object's lifetime, because the action ledger inside it is what a later
+        // `applyAction` settles: a core rebuilt per call would have forgotten the action the decision
+        // is about. Field initializers run after the base constructor, so `ctx` and `env` are set.
+        #core = new ResourceCore(this.env, policy, this.ctx.props);
+        async describe() {
+            return this.#core.describe();
+        }
+        async getTypeScriptTypes() {
+            return this.#core.getTypeScriptTypes();
+        }
+        // The one method where being the SHELL is not delegation: this is where the RPC boundary is,
+        // so this is where the queue's lifetime is taken over from the call that carried it in.
+        async startSession(approvalQueue) {
+            return this.#core.startSession(holdQueue(approvalQueue));
+        }
+        async getAutoApprovableActions() {
+            return this.#core.getAutoApprovableActions();
+        }
+        async applyAction(action) {
+            return this.#core.applyAction(action);
+        }
+        async rejectAction(action) {
+            return this.#core.rejectAction(action);
+        }
+        async revertAction(action) {
+            return this.#core.revertAction(action);
+        }
+        async addObserver(id, user) {
+            return this.#core.addObserver(id, user);
+        }
+        async removeObserver(id) {
+            return this.#core.removeObserver(id);
+        }
+    };
+}
+//# sourceMappingURL=resource.js.map

package/dist/os/resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.js","sourceRoot":"","sources":["../../src/os/resource.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,4BAA4B;AAC5B,EAAE;AACF,kGAAkG;AAClG,8FAA8F;AAC9F,kGAAkG;AAClG,oGAAoG;AACpG,iGAAiG;AACjG,+FAA+F;AAC/F,wEAAwE;AACxE,EAAE;AACF,kGAAkG;AAClG,iGAAiG;AACjG,6FAA6F;AAC7F,gFAAgF;AAEhF,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAIlD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,EAAE,YAAY,EAAsB,MAAM,oBAAoB,CAAA;AAIrE;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAExC;IACC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAA;IAE1B,OAAO,MAAM,kBAAmB,SAAQ,aAA2C;QACjF,0FAA0F;QAC1F,8FAA8F;QAC9F,2FAA2F;QAClF,KAAK,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAEnE,KAAK,CAAC,QAAQ;YACZ,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAA;QAC9B,CAAC;QAED,KAAK,CAAC,kBAAkB;YACtB,OAAO,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAA;QACxC,CAAC;QAED,6FAA6F;QAC7F,wFAAwF;QACxF,KAAK,CAAC,YAAY,CAAC,aAA4B;YAC7C,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAA;QAC1D,CAAC;QAED,KAAK,CAAC,wBAAwB;YAC5B,OAAO,IAAI,CAAC,KAAK,CAAC,wBAAwB,EAAE,CAAA;QAC9C,CAAC;QAED,KAAK,CAAC,WAAW,CAAC,MAAc;YAC9B,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;QACvC,CAAC;QAED,KAAK,CAAC,YAAY,CAAC,MAAc;YAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAA;QACxC,CAAC;QAED,KAAK,CAAC,YAAY,CAAC,MAAc;YAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAA;QACxC,CAAC;QAED,KAAK,CAAC,WAAW,CAAC,EAAU,EAAE,IAAa;YACzC,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;QACzC,CAAC;QAED,KAAK,CAAC,cAAc,CAAC,EAAU;YAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC,CAAA;QACtC,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/os/resources.d.ts

@@ -0,0 +1,11 @@
+import type { SupportedResource } from './protocol.js';
+/**
+ * The single resource: the paired cat-factory workspace, named by a pattern over its origin.
+ *
+ * The pattern is anchored on the deployment's ORIGIN with a wildcard path, which is what makes a
+ * board URL a person pastes (`https://cat-factory.example.com/w/…`) bind to this Gatekeeper. It is
+ * not `grantable`: there is nothing to grant separately, because the account's access is the
+ * provisioning key this Worker already holds.
+ */
+export declare function supportedResourceFor(deployment: string): SupportedResource;
+//# sourceMappingURL=resources.d.ts.map

package/dist/os/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/os/resources.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAEtD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,CAW1E"}

package/dist/os/resources.js

@@ -0,0 +1,26 @@
+// What this Gatekeeper serves, as the workspace's own resource vocabulary.
+//
+// One function, in a file of its own, because three callers need the SAME answer and a second
+// spelling of the URL pattern would be a resource an account advertises and a bind cannot match:
+// the vendor lists it, the account lists it and matches a URL against it, and the resource object
+// describes itself with it.
+/**
+ * The single resource: the paired cat-factory workspace, named by a pattern over its origin.
+ *
+ * The pattern is anchored on the deployment's ORIGIN with a wildcard path, which is what makes a
+ * board URL a person pastes (`https://cat-factory.example.com/w/…`) bind to this Gatekeeper. It is
+ * not `grantable`: there is nothing to grant separately, because the account's access is the
+ * provisioning key this Worker already holds.
+ */
+export function supportedResourceFor(deployment) {
+    const origin = new URL(deployment).origin;
+    return {
+        urlPattern: `${origin}/*`,
+        title: 'cat-factory workspace',
+        description: 'The cat-factory workspace this Gatekeeper is paired with: file tasks, start runs, watch ' +
+            'them, and answer the decisions they park on. One Gatekeeper serves one workspace, because ' +
+            'the provisioning key it holds is scoped to one.',
+        grantable: false,
+    };
+}
+//# sourceMappingURL=resources.js.map

package/dist/os/resources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.js","sourceRoot":"","sources":["../../src/os/resources.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,EAAE;AACF,8FAA8F;AAC9F,iGAAiG;AACjG,kGAAkG;AAClG,4BAA4B;AAI5B;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAAC,UAAkB;IACrD,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC,MAAM,CAAA;IACzC,OAAO;QACL,UAAU,EAAE,GAAG,MAAM,IAAI;QACzB,KAAK,EAAE,uBAAuB;QAC9B,WAAW,EACT,0FAA0F;YAC1F,4FAA4F;YAC5F,iDAAiD;QACnD,SAAS,EAAE,KAAK;KACjB,CAAA;AACH,CAAC"}

package/dist/os/session-types.d.ts

@@ -0,0 +1,6 @@
+import type { CompiledTier } from '../policy/compile.js';
+/** The type name a resource declares as its `tsType`, and the interface the `.d.ts` exports. */
+export declare const SESSION_INTERFACE_NAME = "CatFactoryWorkspace";
+/** Render the session `.d.ts` for one compiled tier. */
+export declare function renderTierSessionTypes(tier: CompiledTier): string;
+//# sourceMappingURL=session-types.d.ts.map

package/dist/os/session-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-types.d.ts","sourceRoot":"","sources":["../../src/os/session-types.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,gGAAgG;AAChG,eAAO,MAAM,sBAAsB,wBAAwB,CAAA;AA2D3D,wDAAwD;AACxD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAUjE"}

package/dist/os/session-types.js

@@ -0,0 +1,82 @@
+// The `.d.ts` a session serves through `getTypeScriptTypes()`, composed for one tier.
+//
+// The per-operation signatures are GENERATED (`@cat-factory/gatekeeper-bindings`'s
+// `SESSION_METHOD_SIGNATURES`, rendered by `pnpm gen:sdk` from the same spec the bindings table
+// comes from), so the types an agent codes against cannot describe a surface the deployment does
+// not serve. What is composed here is the tier's own subset plus the reserved methods, because a
+// session carries exactly what its policy granted: a file naming the whole surface would promise
+// methods the object does not have.
+//
+// The reserved methods are written out here rather than generated because they are this package's,
+// not the deployment's: they exist at exactly the same version as this file.
+import { renderSessionTypes } from '@cat-factory/gatekeeper-bindings';
+/** The type name a resource declares as its `tsType`, and the interface the `.d.ts` exports. */
+export const SESSION_INTERFACE_NAME = 'CatFactoryWorkspace';
+/**
+ * The methods every session carries whatever its policy: who the caller is, what they hold, what
+ * they do not, and the approval inbox.
+ *
+ * `withheld()` is the one worth reading twice. An agent that cannot tell "your policy hides this"
+ * from "no policy could grant this" from "ask for it another way" reports the wrong one to whoever
+ * has to fix it, which is why it is on the object rather than in a document.
+ */
+const RESERVED_MEMBERS = [
+    `  /** Who this session acts as, and the policy tier that account resolved to. */
+  tier(): Promise<{ actorId: string; tier: string; description: string; keyScope: string }>
+`,
+    `  /**
+   * Every operation this session carries, with the scope floor and consequence of each.
+   */
+  bindings(): Promise<
+    {
+      name: string
+      summary: string
+      minScope: string
+      readOnly: boolean
+      destructive: boolean
+      idempotent: boolean
+      pathParams: readonly string[]
+      queryParams: readonly { name: string; required: boolean }[]
+      hasBody: boolean
+    }[]
+  >
+`,
+    `  /**
+   * Every operation this session does NOT carry, and why: \`not_in_policy\` and
+   * \`denied_by_policy\` are your operator's decision, \`above_key_scope\` needs a higher tier,
+   * and \`not_relayable\` cannot cross a session call at all (ask for it another way).
+   */
+  withheld(): Promise<{ name: string; reason: string; detail: string }[]>
+`,
+    `  /** The approval cards the paired deployment has raised and this Gatekeeper still holds open. */
+  approvals_list(): Promise<unknown[]>
+`,
+    `  /**
+   * What a card's run is ACTUALLY parked on now, with the verbs each park takes and whether this
+   * session holds the operation behind it. The card is a pointer; the run is the truth.
+   */
+  approvals_inspect(cardId: string): Promise<unknown>
+`,
+    `  /**
+   * Answer a park. Three outcomes are distinguishable and all three matter: \`answered\` (the run
+   * is unparked), \`recorded\` (your vote counted, the quorum is unmet, the run is still parked)
+   * and \`stale\` (the run moved on).
+   */
+  approvals_answer(cardId: string, input: unknown): Promise<unknown>
+`,
+    `  /** Every run this Gatekeeper has been pushed lifecycle events for. */
+  runs_watched(): Promise<unknown[]>
+`,
+];
+/** Render the session `.d.ts` for one compiled tier. */
+export function renderTierSessionTypes(tier) {
+    return renderSessionTypes({
+        interfaceName: SESSION_INTERFACE_NAME,
+        bindings: tier.granted.map((binding) => binding.name),
+        extraMembers: RESERVED_MEMBERS,
+        preamble: `// The session for policy tier \`${tier.name}\`: ${tier.description}\n` +
+            `// Calls are made with a per-account API key at scope \`${tier.keyScope}\`, and every one of\n` +
+            "// them passes through this workspace's approval queue.",
+    });
+}
+//# sourceMappingURL=session-types.js.map

package/dist/os/session-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-types.js","sourceRoot":"","sources":["../../src/os/session-types.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,EAAE;AACF,mFAAmF;AACnF,gGAAgG;AAChG,iGAAiG;AACjG,iGAAiG;AACjG,iGAAiG;AACjG,oCAAoC;AACpC,EAAE;AACF,mGAAmG;AACnG,6EAA6E;AAE7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AAGrE,gGAAgG;AAChG,MAAM,CAAC,MAAM,sBAAsB,GAAG,qBAAqB,CAAA;AAE3D;;;;;;;GAOG;AACH,MAAM,gBAAgB,GAAsB;IAC1C;;CAED;IACC;;;;;;;;;;;;;;;;CAgBD;IACC;;;;;;CAMD;IACC;;CAED;IACC;;;;;CAKD;IACC;;;;;;CAMD;IACC;;CAED;CACA,CAAA;AAED,wDAAwD;AACxD,MAAM,UAAU,sBAAsB,CAAC,IAAkB;IACvD,OAAO,kBAAkB,CAAC;QACxB,aAAa,EAAE,sBAAsB;QACrC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;QACrD,YAAY,EAAE,gBAAgB;QAC9B,QAAQ,EACN,oCAAoC,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,WAAW,IAAI;YACxE,2DAA2D,IAAI,CAAC,QAAQ,wBAAwB;YAChG,yDAAyD;KAC5D,CAAC,CAAA;AACJ,CAAC"}

package/dist/os/vendor.d.ts

@@ -0,0 +1,14 @@
+import type { GatekeeperEnv } from '../env.js';
+import type { GatekeeperPolicy } from '../policy/compile.js';
+import type { VendorEntrypoint } from './protocol.js';
+/**
+ * Build the vendor entrypoint class over a deployment's policy.
+ *
+ * The deployment exports the result under the name the OS pins:
+ *
+ *     export const GatekeeperVendor = createGatekeeperVendor({ policy: POLICY })
+ */
+export declare function createGatekeeperVendor(options: {
+    policy: GatekeeperPolicy;
+}): new (ctx: ExecutionContext, env: GatekeeperEnv) => VendorEntrypoint;
+//# sourceMappingURL=vendor.d.ts.map

package/dist/os/vendor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor.d.ts","sourceRoot":"","sources":["../../src/os/vendor.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAG5D,OAAO,KAAK,EAAwC,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAe3F;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAC9C,MAAM,EAAE,gBAAgB,CAAA;CACzB,GAAG,KAAK,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,aAAa,KAAK,gBAAgB,CA4DtE"}

package/dist/os/vendor.js

@@ -0,0 +1,95 @@
+// The entrypoint a Cloudflare OS deployment discovers this Worker through.
+//
+// The workspace scans its own environment for `GATEKEEPER_*` SERVICE BINDINGS and treats each as a
+// vendor, reaching the bound Worker's `GatekeeperVendor` entrypoint over native Workers RPC. That
+// is a different door from `/rpc`, and the difference that matters is the authorization:
+//
+//   - On this path, HOLDING THE BINDING IS THE AUTHORIZATION. A service binding is configuration
+//     only the OS deployment's operator can write, and the call never traverses the internet.
+//     There is no shared token in the published model and none is asked for here; adding one would
+//     be a second secret to rotate that protects nothing the binding does not already.
+//   - `/rpc` stays bearer-gated by `OS_SHARED_TOKEN`, because a Worker with a route attached is
+//     reachable by anyone who finds it. Nothing about that door changes: it is what a non-OS
+//     consumer speaks, and the promise that this Worker is not Cloudflare-OS-only rests on it.
+//
+// Everything the vendor answers is a PROJECTION of the operation table or of the policy compiled
+// against it. Nothing here is transcribed, so a surface change cannot leave the description of it
+// behind.
+import { WorkerEntrypoint } from 'cloudflare:workers';
+import { Gatekeeper } from '../gatekeeper.js';
+import { loopbackExport } from './exports.js';
+import { supportedResourceFor } from './resources.js';
+import { renderTierSessionTypes } from './session-types.js';
+/**
+ * A fresh account id.
+ *
+ * Random rather than derived: the vendor is handed nothing to derive one FROM (`createAccount()`
+ * takes no arguments by design, so that a public method cannot be used to look an existing account
+ * up), and a guessable id would be one an agent could name in place of its own.
+ */
+function mintAccountId() {
+    return `acct_${crypto.randomUUID().replaceAll('-', '')}`;
+}
+/**
+ * Build the vendor entrypoint class over a deployment's policy.
+ *
+ * The deployment exports the result under the name the OS pins:
+ *
+ *     export const GatekeeperVendor = createGatekeeperVendor({ policy: POLICY })
+ */
+export function createGatekeeperVendor(options) {
+    const { policy } = options;
+    return class GatekeeperVendor extends WorkerEntrypoint {
+        #gatekeeper() {
+            return Gatekeeper.create(this.env, policy);
+        }
+        async describe() {
+            const deployment = this.#gatekeeper().deployment;
+            return {
+                displayName: 'cat-factory',
+                url: deployment,
+                tagline: 'Ship software with managed agents.',
+                description: 'File work onto a cat-factory board, start a pipeline run, watch it, and answer what it ' +
+                    'parks on. Calls are made with a per-account API key this Gatekeeper mints and holds; ' +
+                    'no agent ever sees a credential.',
+                // This vendor cannot authenticate anyone for sign-in: there is no per-user OAuth on the
+                // cat-factory side, so no provider-verified email exists to be one.
+                providesAuth: false,
+                // It CAN mint an account with no flow, which is the contract's own escape hatch for
+                // exactly this case. See `account.ts` for what that does and does not buy.
+                autoProvisionsAccount: true,
+            };
+        }
+        async getSupportedResources(_options) {
+            return [supportedResourceFor(this.#gatekeeper().deployment)];
+        }
+        /**
+         * The session types, rendered for the tier an auto-provisioned account will get.
+         *
+         * That is `autoProvisionedTier`, never `defaultTier`: the two are different knobs answering
+         * different questions (`policy/compile.ts` holds why), and this door only ever mints accounts.
+         * The tier is resolved WITHOUT an account, because there is none yet and inventing one to
+         * resolve through would make the refusal name an `acct_…` id no operator could find. The
+         * authoritative copy for a bound session is the resource's own `getTypeScriptTypes()`, which
+         * knows the tier the account actually resolved to and is the one `ResourceDescription.tsType`
+         * points at.
+         */
+        async getTypeScriptTypes() {
+            return renderTierSessionTypes(this.#gatekeeper().tierForNewAccount());
+        }
+        /**
+         * Mint a new connected account.
+         *
+         * Deliberately creating-only and identity-free, which is what makes it safe on a public
+         * interface: it cannot look an existing account up, so holding the binding buys the ability to
+         * make an account and never the ability to reach somebody else's.
+         */
+        async createAccount() {
+            const props = { accountId: mintAccountId() };
+            // Resolved before the account is handed back, so a deployment missing the export is refused
+            // at the call that would have created the account rather than at the first use of it.
+            return loopbackExport(this.ctx.exports, 'account', props);
+        }
+    };
+}
+//# sourceMappingURL=vendor.js.map

package/dist/os/vendor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor.js","sourceRoot":"","sources":["../../src/os/vendor.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,EAAE;AACF,mGAAmG;AACnG,kGAAkG;AAClG,yFAAyF;AACzF,EAAE;AACF,iGAAiG;AACjG,8FAA8F;AAC9F,mGAAmG;AACnG,uFAAuF;AACvF,gGAAgG;AAChG,6FAA6F;AAC7F,+FAA+F;AAC/F,EAAE;AACF,iGAAiG;AACjG,kGAAkG;AAClG,UAAU;AAEV,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAErD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAG7C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAE3D;;;;;;GAMG;AACH,SAAS,aAAa;IACpB,OAAO,QAAQ,MAAM,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAA;AAC1D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAEtC;IACC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAA;IAE1B,OAAO,MAAM,gBAAiB,SAAQ,gBAA+B;QACnE,WAAW;YACT,OAAO,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;QAC5C,CAAC;QAED,KAAK,CAAC,QAAQ;YACZ,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAA;YAChD,OAAO;gBACL,WAAW,EAAE,aAAa;gBAC1B,GAAG,EAAE,UAAU;gBACf,OAAO,EAAE,oCAAoC;gBAC7C,WAAW,EACT,yFAAyF;oBACzF,uFAAuF;oBACvF,kCAAkC;gBACpC,wFAAwF;gBACxF,oEAAoE;gBACpE,YAAY,EAAE,KAAK;gBACnB,oFAAoF;gBACpF,2EAA2E;gBAC3E,qBAAqB,EAAE,IAAI;aAC5B,CAAA;QACH,CAAC;QAED,KAAK,CAAC,qBAAqB,CAAC,QAA8B;YACxD,OAAO,CAAC,oBAAoB,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,CAAC,CAAA;QAC9D,CAAC;QAED;;;;;;;;;;WAUG;QACH,KAAK,CAAC,kBAAkB;YACtB,OAAO,sBAAsB,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,iBAAiB,EAAE,CAAC,CAAA;QACvE,CAAC;QAED;;;;;;WAMG;QACH,KAAK,CAAC,aAAa;YACjB,MAAM,KAAK,GAAiB,EAAE,SAAS,EAAE,aAAa,EAAE,EAAE,CAAA;YAC1D,4FAA4F;YAC5F,sFAAsF;YACtF,OAAO,cAAc,CAAU,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,CAAA;QACpE,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/policy/compile.d.ts

@@ -25,6 +25,25 @@ export interface TierPolicy {
 export interface GatekeeperPolicy {
     /** The tier an actor with no explicit grant is given. Name `null` to refuse unknown actors. */
     defaultTier: string | null;
+    /**
+     * The tier an AUTO-PROVISIONED account gets: the Cloudflare OS entrypoint's own default.
+     *
+     * A second knob rather than a reuse of `defaultTier`, because the two doors establish identity
+     * differently and an operator's answer about one is not their answer about the other.
+     * `defaultTier` is about a person the OS names on a `connect({ actorId })` call, so a deployment
+     * can keep a roster and refuse strangers. An account minted through `createAccount()` has no name
+     * to put on a roster: the contract's auto-provisioning flow carries no identity by design, so
+     * `grants` can never match one and every such account falls to this.
+     *
+     * Absent or `null` REFUSES, and it does not inherit from `defaultTier`. Inheriting would widen
+     * silently in whichever direction the deployment did not mean: a roster deployment would hand a
+     * tier to every account the workspace mints, or turning on OS discovery would quietly give every
+     * unrostered `/rpc` caller one. Naming a tier here is what turns Cloudflare OS discovery on.
+     *
+     * An account still resolves through `grants` first, so an operator who wants ONE account raised
+     * reads its id off the account's own `describe()` (`uniqueName`) and grants that id directly.
+     */
+    autoProvisionedTier?: string | null;
     tiers: Record<string, TierPolicy>;
     /** OS user identity (whatever the OS authenticates) to tier name. */
     grants: Record<string, string>;
@@ -54,6 +73,7 @@ export interface CompiledTier {
 /** The policy, resolved once and read per request. */
 export interface CompiledPolicy {
     defaultTier: string | null;
+    autoProvisionedTier: string | null;
     tiers: ReadonlyMap<string, CompiledTier>;
     grants: ReadonlyMap<string, string>;
 }
@@ -70,6 +90,24 @@ export declare function compilePolicy(policy: GatekeeperPolicy): CompiledPolicy;
  * ask for a better one.
  */
 export declare function tierForActor(policy: CompiledPolicy, actorId: string): CompiledTier | null;
+/**
+ * The tier EVERY auto-provisioned account falls to, resolved without an account to ask about.
+ *
+ * Asked on its own because the vendor is questioned before any account exists: the session types
+ * it publishes are the ones a not-yet-created account will get. Answering that by minting a
+ * throwaway id and letting it miss `grants` produces the same tier and a refusal naming an id that
+ * exists nowhere in the operator's config, which is the wrong sentence for the one reader who has
+ * to act on it.
+ */
+export declare function autoProvisionedTier(policy: CompiledPolicy): CompiledTier | null;
+/**
+ * The tier one auto-provisioned Cloudflare OS account holds, or a refusal.
+ *
+ * `grants` is consulted FIRST and by the account's own minted id, which is the whole affordance an
+ * operator has for raising one account above the rest: nothing else about such an account is
+ * nameable, because nothing about it was named when it was created.
+ */
+export declare function tierForAccount(policy: CompiledPolicy, accountId: string): CompiledTier | null;
 /**
  * What the OS needs to run its own approval governance over a call: the consequence the platform
  * annotates, with the cautious default already applied.

package/dist/policy/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/policy/compile.ts"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACpB,MAAM,kCAAkC,CAAA;AAGzC;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAA;IACnB,sEAAsE;IACtE,QAAQ,EAAE,cAAc,CAAA;IACxB,4EAA4E;IAC5E,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,CAAA;IAC9B,mFAAmF;IACnF,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACxB;;;OAGG;IACH,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACzB;AAED,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACjC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B;AAED,kEAAkE;AAClE,MAAM,MAAM,cAAc,GACtB,eAAe,GACf,kBAAkB,GAClB,iBAAiB,GACjB,eAAe,CAAA;AAEnB,oDAAoD;AACpD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,cAAc,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,cAAc,CAAA;IACxB,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAA;IACrC;;;;OAIG;IACH,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAA;IACpC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CACxB;AAED,sDAAsD;AACtD,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;IACxC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AA2HD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,cAAc,CAqBtE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAIzF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,cAAc,CAAA;IACxB,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,EAAE,OAAO,CAAA;IACpB,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAA;IAC5C,OAAO,EAAE,OAAO,CAAA;CACjB,CAaA"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/policy/compile.ts"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACpB,MAAM,kCAAkC,CAAA;AAGzC;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAA;IACnB,sEAAsE;IACtE,QAAQ,EAAE,cAAc,CAAA;IACxB,4EAA4E;IAC5E,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,CAAA;IAC9B,mFAAmF;IACnF,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACxB;;;OAGG;IACH,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACzB;AAED,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B;;;;;;;;;;;;;;;;;OAiBG;IACH,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACjC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B;AAED,kEAAkE;AAClE,MAAM,MAAM,cAAc,GACtB,eAAe,GACf,kBAAkB,GAClB,iBAAiB,GACjB,eAAe,CAAA;AAEnB,oDAAoD;AACpD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,cAAc,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,cAAc,CAAA;IACxB,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAA;IACrC;;;;OAIG;IACH,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAA;IACpC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CACxB;AAED,sDAAsD;AACtD,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;IACxC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AA2HD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,cAAc,CAgCtE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAIzF;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,YAAY,GAAG,IAAI,CAG/E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAI7F;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,cAAc,CAAA;IACxB,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,EAAE,OAAO,CAAA;IACpB,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAA;IAC5C,OAAO,EAAE,OAAO,CAAA;CACjB,CAaA"}