permdock 0.1.0 → 0.2.0

package/dist/jwt/index.d.ts

@@ -1,7 +1,7 @@
-import { Et as TokenVerifier, J as AuthEvent, Tt as TokenSigner, hr as Subject, mr as Principal, nt as JwtClaims, wt as TokenFailureCause } from "../policy-CInmNGkM.js";
-import { a as JsonWebKeySet, c as JwtJwks, d as MappedSubject, i as JoseTokenVerifierOptions, l as JwtPrincipal, n as DpopProofResult, o as JwtAlgorithm, r as JoseTokenSignerOptions, s as JwtClaimPaths, t as DiscoveryInput, u as JwtSubjectOptions } from "../types-bva3i4Gf.js";
-import { a as ReplayStore } from "../types-i4BAOvdb.js";
-import { i as LinkPolicy, o as LinkPrincipal, t as Capability } from "../capability-BDG_nkxt.js";
+import { Ft as TokenVerifier, Nr as Principal, Nt as TokenFailureCause, Pr as Subject, Pt as TokenSigner, ct as JwtClaims, et as AuthEvent } from "../policy-CFZAr_Al.js";
+import { a as JsonWebKeySet, c as JwtJwks, d as MappedSubject, g as ReplayStore, i as JoseTokenVerifierOptions, l as JwtPrincipal, n as DpopProofResult, o as JwtAlgorithm, r as JoseTokenSignerOptions, s as JwtClaimPaths, t as DiscoveryInput, u as JwtSubjectOptions } from "../types-9AWO9EGt.js";
+import { i as LinkPolicy, o as LinkPrincipal, t as Capability } from "../capability-Dq43tT1u.js";
+import { t as memoryReplayStore } from "../replay-sqBGMnNs.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/jwt/capability.d.ts
 /** `on('auth')` causes: a verification failure, or one of the three capability checks. */
@@ -69,7 +69,11 @@ type CiOidcPrincipal = Principal & {
 export declare function subjectFromCiOidc(token: string | undefined | null, options: CiOidcSubjectOptions): Promise<Subject<CiOidcPrincipal> | Subject>;
 //#endregion
 //#region src/jwt/dpop.d.ts
-export declare function verifyDpopProof(request: Request, claims: JwtClaims, accessToken?: string): Promise<DpopProofResult>;
+type DpopProofOptions = {
+  /** Rejects a proof whose `jti` this key already used within the 60-second window. */
+  readonly replay?: ReplayStore;
+};
+export declare function verifyDpopProof(request: Request, claims: JwtClaims, accessToken?: string, options?: DpopProofOptions): Promise<DpopProofResult>;
 //#endregion
 //#region src/jwt/introspection.d.ts
 export declare function subjectFromIntrospection(response: unknown, options?: JwtSubjectOptions): MappedSubject;
@@ -84,4 +88,4 @@ export declare function createJwtSubjectResolver(options: JwtSubjectOptions): (t
 //#region src/jwt/verifier.d.ts
 export declare function joseTokenVerifier(options: JoseTokenVerifierOptions): TokenVerifier;
 //#endregion
-export type { CapabilityFailureCause, CapabilitySubjectOptions, CiOidcPrincipal, CiOidcProvider, CiOidcSubjectOptions, DiscoveryInput, DpopProofResult, JoseTokenSignerOptions, JoseTokenVerifierOptions, JsonWebKeySet, JwtAlgorithm, JwtClaimPaths, JwtJwks, JwtPrincipal, JwtSubjectOptions, MappedSubject };
+export { type CapabilityFailureCause, type CapabilitySubjectOptions, type CiOidcPrincipal, type CiOidcProvider, type CiOidcSubjectOptions, type DiscoveryInput, type DpopProofOptions, type DpopProofResult, type JoseTokenSignerOptions, type JoseTokenVerifierOptions, type JsonWebKeySet, type JwtAlgorithm, type JwtClaimPaths, type JwtJwks, type JwtPrincipal, type JwtSubjectOptions, type MappedSubject, type ReplayStore, memoryReplayStore };

package/dist/jwt/index.js

@@ -1,11 +1,12 @@
 import { t as compact } from "../compact-y6vfu2_f.js";
-import { n as freezeDeep } from "../freeze-y1_jQL4v.js";
+import { n as freezeDeep } from "../freeze-CrU8nQeX.js";
 import { n as sha256, t as bytesToBase64Url } from "../sha256-BO0swRXL.js";
 import { t as anonymousSubject } from "../subject-C6dLxqHU.js";
-import { i as linkPolicyViolation, o as parseCapability, s as redeemerAllows, t as capabilitySubject } from "../capability-B68OFnZx.js";
-import { a as decodeHeader, i as issuerFromDiscovery, n as assertSubjectConfig, o as normalizeTyp, r as fail, t as joseTokenVerifier } from "../verifier-B90agnhl.js";
+import { i as linkPolicyViolation, o as parseCapability, s as redeemerAllows, t as capabilitySubject } from "../capability-4qPdO9gk.js";
+import { a as decodeHeader, i as issuerFromDiscovery, n as assertSubjectConfig, o as normalizeTyp, r as fail, t as joseTokenVerifier } from "../verifier-BxBo6I44.js";
 import { t as loadJose } from "../load-jose-BL6LH4bL.js";
-import { n as mapClaimsToSubject, r as validateCustomClaims, t as acceptMismatch } from "../map-claims-B_6I1Rn-.js";
+import { n as mapClaimsToSubject, r as validateCustomClaims, t as acceptMismatch } from "../map-claims-Z4QZOiFF.js";
+import { t as memoryReplayStore } from "../replay-BsOyTrdV.js";
 //#region src/jwt/capability.ts
 function emit(options, reason, cause, token) {
 	if (options.onAuth === void 0) return;
@@ -237,15 +238,23 @@ const PRIVATE_MEMBERS = [
 function headerOf(request) {
 	return request.headers.get("DPoP") ?? request.headers.get("dpop");
 }
-function requestUrl(request) {
-	const url = new URL(request.url);
+function withoutQuery(value) {
+	if (typeof value !== "string" || !URL.canParse(value)) return null;
+	const url = new URL(value);
+	url.search = "";
 	url.hash = "";
 	return url.href;
 }
-function verifyDpopProof(request, claims, accessToken) {
-	return verify(request, claims, accessToken);
+async function claimJti(replay, key, expiresAt) {
+	if (replay.claim !== void 0) return replay.claim(key, expiresAt);
+	if (await replay.seen(key)) return false;
+	await replay.remember(key, expiresAt);
+	return true;
+}
+function verifyDpopProof(request, claims, accessToken, options = {}) {
+	return verify(request, claims, accessToken, options);
 }
-async function verify(request, claims, accessToken) {
+async function verify(request, claims, accessToken, options) {
 	const proof = headerOf(request);
 	if (proof === null || proof.length === 0) return {
 		ok: false,
@@ -273,13 +282,15 @@ async function verify(request, claims, accessToken) {
 			typ: "dpop+jwt",
 			maxTokenAge: DPOP_WINDOW_SECONDS
 		});
-		if (await jose.calculateJwkThumbprint(jwk, "sha256") !== expectedJkt) return {
+		const jkt = await jose.calculateJwkThumbprint(jwk, "sha256");
+		if (jkt !== expectedJkt) return {
 			ok: false,
 			cause: "dpop-proof-invalid"
 		};
 		const htm = result.payload["htm"];
 		const htu = result.payload["htu"];
-		if (htm !== request.method || htu !== requestUrl(request)) return {
+		const expectedHtu = withoutQuery(request.url);
+		if (htm !== request.method || expectedHtu === null || withoutQuery(htu) !== expectedHtu) return {
 			ok: false,
 			cause: "dpop-proof-invalid"
 		};
@@ -290,6 +301,14 @@ async function verify(request, claims, accessToken) {
 				cause: "dpop-proof-invalid"
 			};
 		}
+		if (options.replay !== void 0) {
+			const jti = result.payload.jti;
+			const iat = result.payload.iat;
+			if (typeof jti !== "string" || jti === "" || typeof iat !== "number" || !await claimJti(options.replay, `dpop\u0000${jkt}\u0000${jti}`, iat + DPOP_WINDOW_SECONDS)) return {
+				ok: false,
+				cause: "dpop-proof-invalid"
+			};
+		}
 		return { ok: true };
 	} catch {
 		return {
@@ -541,7 +560,7 @@ async function resolveSubject(token, options, request) {
 		const proof = request === void 0 ? {
 			ok: false,
 			cause: "dpop-proof-invalid"
-		} : await verifyDpopProof(request, verified.claims, token);
+		} : await verifyDpopProof(request, verified.claims, token, compact({ replay: options.replay }));
 		if (!proof.ok) {
 			emitAuth(options, proof.cause, token);
 			return anonymousSubject();
@@ -568,4 +587,4 @@ async function resolveSubject(token, options, request) {
 	return extraMemberships(options, mapped.subject, mapped.subject.principal.tenant);
 }
 //#endregion
-export { createJwtSubjectResolver, joseTokenSigner, joseTokenVerifier, subjectFromCapability, subjectFromCiOidc, subjectFromIntrospection, subjectFromJwt, verifyDpopProof };
+export { createJwtSubjectResolver, joseTokenSigner, joseTokenVerifier, memoryReplayStore, subjectFromCapability, subjectFromCiOidc, subjectFromIntrospection, subjectFromJwt, verifyDpopProof };

package/dist/kernel-GSQnMz3O.js

@@ -0,0 +1,208 @@
+import { t as compact } from "./compact-y6vfu2_f.js";
+import { t as describe } from "./describe-B_gVZEVi.js";
+import { a as deniedMessage } from "./errors-Cz5zn0mW.js";
+import { t as createPermDock } from "./permdock-CzqXjCpU.js";
+import { n as resourceRef } from "./resource-ref-CaS9yVPi.js";
+import { t as mayUse } from "./may-use-DndQ5tQ-.js";
+import { l as storedApprovalToken, s as resumeDecision } from "./helpers-H_KARDVC.js";
+import { t as instanceOptions } from "./instance-options-Dhhcnm3y.js";
+import { n as tenantScope, t as actorFrom } from "./adapter-context-mlWsVGGg.js";
+//#region src/agent/reason.ts
+function modelReason(decision, permission, subjectId) {
+	if (decision.outcome === "denied") return deniedMessage(permission?.key ?? "unknown", subjectId, decision.denials, decision.alternatives.map((leaf) => leaf.key));
+	return describe(decision).detail;
+}
+function unmappedReason(toolName) {
+	return `Denied: unmapped tool ${toolName}.`;
+}
+function thrownReason(toolName) {
+	return `Denied: ${toolName} failed closed.`;
+}
+//#endregion
+//#region src/agent/kernel.ts
+/** The resume token an agent run carries under the namespaced `permdockApproval` key. */
+function approvalTokenOf(context) {
+	if (context === null || typeof context !== "object") return;
+	const token = context.permdockApproval;
+	return typeof token === "string" && token !== "" ? token : void 0;
+}
+function runDecide(permdock, permission, data, how) {
+	return permdock.decide(permission, data, how);
+}
+function createAgentKernel(policy, options) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	const instance = (context) => {
+		if (typeof context === "object" && context !== null) {
+			const hit = cache.get(context);
+			if (hit !== void 0) return hit;
+		}
+		const built = (async () => {
+			let user = null;
+			try {
+				user = await options.subject(context);
+			} catch {
+				user = null;
+			}
+			const actor = await actorFrom(options.actor, context);
+			let delegation;
+			if (options.delegation !== void 0) try {
+				delegation = await options.delegation(context);
+			} catch {
+				delegation = void 0;
+			}
+			const { tenant } = await tenantScope(options.tenant, context);
+			const created = await createPermDock(policy, user, compact({
+				tenant,
+				actor,
+				delegation,
+				...instanceOptions(options)
+			}));
+			return options.wrap?.(created) ?? created;
+		})();
+		if (typeof context === "object" && context !== null) {
+			cache.set(context, built);
+			const release = () => {
+				if (cache.get(context) === built) cache.delete(context);
+			};
+			built.then(release, release);
+		}
+		return built;
+	};
+	const boundary = options.boundary ?? "tool-args";
+	const tools = options.tools ?? {};
+	const run = async (binding, args, context, how) => {
+		let permdock;
+		try {
+			permdock = await instance(context);
+			let data;
+			if (binding.data !== void 0) {
+				try {
+					data = await binding.data(args);
+				} catch {
+					return {
+						ok: false,
+						failure: "load-failed",
+						permdock
+					};
+				}
+				if (binding.permission.kind === "instance" && (data === null || data === void 0)) return {
+					ok: false,
+					failure: "no-data",
+					permdock
+				};
+			}
+			const raw = runDecide(permdock, binding.permission, data, {
+				adapter: options.adapter,
+				boundary,
+				source: how.source
+			});
+			const decision = how.resume ? await resumeDecision({
+				decision: raw,
+				permission: binding.permission,
+				subject: permdock.subject,
+				store: options.store,
+				resource: resourceRef(binding.permission, data),
+				adapter: options.adapter,
+				token: how.decideOptions.resumeToken ?? await storedApprovalToken(options.store, raw, { denyPending: how.decideOptions.denyPending === true })
+			}) : raw;
+			return {
+				ok: true,
+				permdock,
+				data,
+				raw,
+				decision
+			};
+		} catch {
+			return compact({
+				ok: false,
+				failure: "failed",
+				permdock
+			});
+		}
+	};
+	const check = (binding, args, context, checkOptions = {}) => run(binding, args, context, {
+		resume: checkOptions.simulate !== true,
+		source: checkOptions.simulate === true ? "simulate" : "adapter",
+		decideOptions: checkOptions
+	});
+	const evaluate = async (binding, toolName, args, context, decideOptions = {}) => {
+		const checked = await check(binding, args, context, decideOptions);
+		if (!checked.ok) {
+			if (checked.failure !== "no-data" || checked.permdock === void 0) return {
+				outcome: "denied",
+				decision: null,
+				permission: binding.permission,
+				reason: thrownReason(toolName)
+			};
+			const decision = {
+				outcome: "denied",
+				denials: [{
+					role: null,
+					reason: "validation"
+				}],
+				alternatives: []
+			};
+			return {
+				outcome: "denied",
+				decision,
+				permission: binding.permission,
+				reason: modelReason(decision, binding.permission, checked.permdock.subject.principal?.id)
+			};
+		}
+		const { permdock, decision, data } = checked;
+		if (decision.outcome === "granted") return {
+			outcome: "granted",
+			decision,
+			permission: binding.permission,
+			data
+		};
+		if (decision.outcome === "approval-required") return {
+			outcome: "approval-required",
+			decision,
+			permission: binding.permission,
+			data,
+			token: decision.token,
+			summary: modelReason(decision, binding.permission, permdock.subject.principal?.id)
+		};
+		return {
+			outcome: "denied",
+			decision,
+			permission: binding.permission,
+			reason: modelReason(decision, binding.permission, permdock.subject.principal?.id)
+		};
+	};
+	const tokenFor = async (binding, args, context) => {
+		const checked = await run(binding, args, context, {
+			resume: false,
+			source: "adapter",
+			decideOptions: {}
+		});
+		return checked.ok && checked.raw.outcome === "approval-required" ? checked.raw.token : void 0;
+	};
+	const decideTool = (toolName, args, context, decideOptions = {}) => {
+		const binding = Object.hasOwn(tools, toolName) ? tools[toolName] : void 0;
+		if (binding === void 0) return Promise.resolve({
+			outcome: "denied",
+			decision: null,
+			permission: void 0,
+			reason: unmappedReason(toolName)
+		});
+		return evaluate(binding, toolName, args, context, decideOptions);
+	};
+	const allowedToolNames = async (context) => {
+		const permdock = await instance(context);
+		const allowed = /* @__PURE__ */ new Set();
+		for (const [name, binding] of Object.entries(tools)) if (mayUse(permdock, binding.permission)) allowed.add(name);
+		return allowed;
+	};
+	return {
+		instance,
+		decideTool,
+		evaluate,
+		check,
+		tokenFor,
+		allowedToolNames
+	};
+}
+//#endregion
+export { createAgentKernel as n, approvalTokenOf as t };

package/dist/kysely/index.d.ts

@@ -1,6 +1,7 @@
-import { _r as Condition, hr as Subject, tn as WhereResult } from "../policy-CInmNGkM.js";
-import { n as WithSubjectOptions, r as RelationsMapping, t as RowCheck } from "../row-check-BajTgQZ-.js";
-import { t as MembershipsMapping } from "../compile-CQbvyIBr.js";
+import { Ir as Condition, Pr as Subject, mn as WhereResult } from "../policy-CFZAr_Al.js";
+import { r as RelationsMapping } from "../graph-sql-B-dsAT6j.js";
+import { s as MembershipsMapping } from "../compile-CNnl6uIt.js";
+import { n as WithSubjectOptions, t as RowCheck } from "../row-check-Dt35czLy.js";
 //#region src/kysely/types.d.ts
 type KyselySelectQuery = {
   select(expr: unknown): KyselySelectQuery;

package/dist/kysely/index.js

@@ -1,7 +1,7 @@
 import { t as compact } from "../compact-y6vfu2_f.js";
-import { x as assertSafeKey } from "../permissions-DC7GROPA.js";
-import { n as escapeLike, t as compileWhere } from "../compile-D22iwvuV.js";
-import { i as rowCheckFrom, r as subjectStatements, t as statementTemplate } from "../subject-settings-xt7V845g.js";
+import { w as assertSafeKey } from "../permissions-DVoF6dMt.js";
+import { n as escapeLike, t as compileWhere } from "../compile-Ba4blROR.js";
+import { i as rowCheckFrom, r as subjectStatements, t as statementTemplate } from "../subject-settings-BwBmCdTR.js";
 //#region src/kysely/to-where.ts
 function ident(name) {
 	assertSafeKey(name, "sql identifier");

package/dist/live-options-H2eG8dfJ.js

@@ -0,0 +1,60 @@
+import { createContext, useLayoutEffect, useRef, useState } from "react";
+//#region src/react/context.ts
+const PermDockStoreContext = createContext(null);
+const PermDockSnapshotPromiseContext = createContext(null);
+//#endregion
+//#region src/react/keyed.ts
+/**
+* `create()` once per distinct `inputs`, held in state: React may drop a
+* `useMemo` value and rebuild it, and a rebuilt store loses its answers,
+* polls and followed snapshot.
+*/
+function useKeyed(create, inputs) {
+	const [held, setHeld] = useState(() => ({
+		inputs,
+		value: create()
+	}));
+	if (held.inputs.length === inputs.length && held.inputs.every((input, index) => Object.is(input, inputs[index]))) return held.value;
+	const next = {
+		inputs,
+		value: create()
+	};
+	setHeld(next);
+	return next.value;
+}
+//#endregion
+//#region src/react/live-options.ts
+function sameHeaders(a, b) {
+	if (a === b) return true;
+	if (a === void 0 || b === void 0) return false;
+	const keys = Object.keys(a);
+	return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && a[key] === b[key]);
+}
+/**
+* Store options whose identity survives a re-render, so an inline `headers`
+* object or `fetch` arrow does not rebuild the store and drop its snapshot.
+* `headers` compare by value, unless `headersByValue` is `false` for a store
+* that only reads `readHeaders`; `fetch` and `verifier` call the latest prop.
+*/
+function useLiveOptions(props, headersByValue = true) {
+	const latest = useRef(props);
+	useLayoutEffect(() => {
+		latest.current = props;
+	});
+	const [headers, setHeaders] = useState(props.headers);
+	if (headersByValue && !sameHeaders(headers, props.headers)) setHeaders(props.headers);
+	const [readHeaders] = useState(() => () => latest.current.headers);
+	const [liveFetch] = useState(() => (...args) => (latest.current.fetch ?? fetch)(...args));
+	const [liveVerifier] = useState(() => ({ verify: (token, expectations) => {
+		const verifier = latest.current.verifier;
+		return verifier === void 0 ? Promise.reject(/* @__PURE__ */ new Error("PermDock: the verifier prop was removed.")) : verifier.verify(token, expectations);
+	} }));
+	return {
+		headers,
+		readHeaders,
+		fetch: liveFetch,
+		verifier: props.verifier === void 0 ? void 0 : liveVerifier
+	};
+}
+//#endregion
+export { PermDockStoreContext as i, useKeyed as n, PermDockSnapshotPromiseContext as r, useLiveOptions as t };

package/dist/{load-BZ24CpZP.js → load-DhWEB9P1.js}

@@ -1,4 +1,4 @@
-import { g as listPermissions } from "./permissions-DC7GROPA.js";
+import { _ as listPermissions } from "./permissions-DVoF6dMt.js";
 import { dirname, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createJiti } from "jiti";
@@ -19,6 +19,15 @@ function loadsWithJiti(error) {
 	const code = error !== null && typeof error === "object" && "code" in error ? error.code : void 0;
 	return typeof code === "string" && NOT_NATIVE.has(code);
 }
+function importWithJiti(abs, fresh) {
+	return createJiti(import.meta.url, {
+		interopDefault: false,
+		jsx: true,
+		tsconfigPaths: dirname(abs),
+		moduleCache: !fresh,
+		fsCache: !fresh
+	}).import(abs);
+}
 /**
 * Imports a project module the way its bundler would. Node's own `import()`
 * comes first; a module it cannot resolve or parse (tsconfig `paths`
@@ -26,17 +35,14 @@ function loadsWithJiti(error) {
 * with the `paths` of the nearest `tsconfig.json` above it. Exports are
 * returned as written; `default` is not merged into the namespace.
 */
-async function loadModule(abs) {
+async function loadModule(abs, options) {
 	let loaded;
-	try {
+	if (options?.fresh === true) loaded = await importWithJiti(abs, true);
+	else try {
 		loaded = await import(pathToFileURL(abs).href);
 	} catch (error) {
 		if (!loadsWithJiti(error)) throw error;
-		loaded = await createJiti(import.meta.url, {
-			interopDefault: false,
-			jsx: true,
-			tsconfigPaths: dirname(abs)
-		}).import(abs);
+		loaded = await importWithJiti(abs, false);
 	}
 	if (loaded === null || typeof loaded !== "object") throw new Error(`PermDock CLI: module '${abs}' did not export an object`);
 	return loaded;
@@ -57,10 +63,10 @@ function leavesOf(tree) {
 	return listPermissions(tree);
 }
 /** The configured policy export, or `undefined` when unset or unloadable. */
-async function loadConfiguredPolicy(cwd, path) {
+async function loadConfiguredPolicy(cwd, path, options) {
 	if (path === void 0) return;
 	try {
-		return asPolicy(pickNamed(await loadModule(resolve(cwd, path)), ["policy"]));
+		return asPolicy(pickNamed(await loadModule(resolve(cwd, path), options), ["policy"]));
 	} catch {
 		return;
 	}

package/dist/load-DwJUafYN.js

@@ -0,0 +1,2 @@
+import { a as loadModule, o as pickNamed } from "./load-DhWEB9P1.js";
+export { loadModule, pickNamed };