permdock 0.0.0 → 0.2.0

package/dist/vue/index.d.ts

@@ -0,0 +1,79 @@
+import { Ft as TokenVerifier, Mr as Membership, Tt as Snapshot, Yn as Decision } from "../policy-CFZAr_Al.js";
+import { f as Permission } from "../permissions-DttnqqxC.js";
+import { r as Role } from "../vocabulary-DA8a8zif.js";
+import { n as requiredPlans } from "../problem-details-CkL50EEf.js";
+import { i as describe } from "../describe-PdoqESvg.js";
+import { t as PermissionBoundaryState } from "../boundary-BmHxVH1J.js";
+import { t as approvalHeaders } from "../headers-Cf-zWvsO.js";
+import { a as FilterResult, c as SubjectView, i as ClientStatus, l as TenantView, n as ApprovalState, o as PermissionSet, r as ClientPermDock, s as PermissionState, t as ApprovalHandle, u as UseRolesOptions } from "../types-kxznc7cn.js";
+import { ComputedRef, DefineComponent, MaybeRefOrGetter, Plugin } from "vue";
+//#region src/vue/types.d.ts
+type PermDockPluginOptions = {
+  /**
+   * A ref or getter re-hydrates the store when it changes; a promise keeps
+   * the store `pending` until it settles (await the same promise in an async
+   * `setup` under `<Suspense>`).
+   */
+  readonly snapshot: MaybeRefOrGetter<Snapshot | string> | PromiseLike<Snapshot | string>;
+  /**
+   * The AuthZEN evaluations endpoint for checks the snapshot cannot answer.
+   * `false` never calls one: such a check is denied with reason `server-only`.
+   */
+  readonly endpoint?: string | false;
+  /** Where `refresh()` fetches a fresh snapshot. Defaults to `endpoint`. */
+  readonly snapshotUrl?: string;
+  readonly approvals?: string;
+  /** A ref or getter switches the active tenant (`refresh({ tenant })`) when it changes. */
+  readonly tenant?: MaybeRefOrGetter<string | undefined>;
+  readonly fetch?: typeof fetch;
+  /** Read on every request: a ref or getter carries a rotated token without rebuilding the store. */
+  readonly headers?: MaybeRefOrGetter<Readonly<Record<string, string>> | undefined>;
+  readonly maxAge?: number;
+  /** Read on every verification; set it at install to verify signed snapshots. */
+  readonly verifier?: MaybeRefOrGetter<TokenVerifier | undefined>;
+};
+//#endregion
+//#region src/vue/composables.d.ts
+export declare function usePermDock(): ClientPermDock;
+export declare function usePermission(permission: MaybeRefOrGetter<Permission>, data?: MaybeRefOrGetter<unknown>): {
+  readonly allowed: ComputedRef<boolean>;
+  readonly status: ComputedRef<PermissionState["status"]>;
+  readonly decision: ComputedRef<Decision>;
+};
+export declare function usePermissions(permissions: MaybeRefOrGetter<readonly Permission[]>, data?: MaybeRefOrGetter<unknown>): ComputedRef<PermissionSet>;
+export declare function useFilter<T>(permission: Permission<string, T, "instance">, rows: MaybeRefOrGetter<readonly T[]>): ComputedRef<FilterResult<T>>;
+export declare function useTenant(): ComputedRef<TenantView>;
+export declare function useMemberships(): ComputedRef<readonly Membership[]>;
+export declare function useRoles(options?: MaybeRefOrGetter<UseRolesOptions>): ComputedRef<{
+  readonly roles: readonly Role[];
+}>;
+export declare function useAssignableRoles(): ComputedRef<readonly Role[]>;
+export declare function useAssignablePermissions(options?: MaybeRefOrGetter<{
+  readonly tenant?: string;
+}>): ComputedRef<readonly Permission[]>;
+export declare function useSubject(): ComputedRef<SubjectView>;
+export declare function useApproval(decision: MaybeRefOrGetter<Decision>): ComputedRef<ApprovalHandle>;
+//#endregion
+//#region src/vue/boundary.d.ts
+/**
+ * Catches `PermDockDeniedError` and `PermDockApprovalRequiredError` thrown
+ * by a descendant and renders the `denied` slot, or the `approval` slot for
+ * an approval request (default `denied`). The slots receive the refused
+ * permission and `retry()`. Any other error propagates.
+ */
+export declare const PermissionBoundary: DefineComponent;
+/** Inside a `PermissionBoundary`: what was refused and `retry()`, or `null` while the children render. */
+export declare function usePermissionBoundary(): PermissionBoundaryState | null;
+//#endregion
+//#region src/vue/plugin.d.ts
+export declare const permdockPlugin: Plugin<PermDockPluginOptions>;
+//#endregion
+//#region src/vue/protected.d.ts
+type ProtectedProps = {
+  readonly permission: Permission;
+  readonly data?: unknown;
+  readonly tenant?: string;
+};
+export declare const Protected: DefineComponent<ProtectedProps>;
+//#endregion
+export { type ApprovalHandle, type ApprovalState, type ClientPermDock, type ClientStatus, type FilterResult, type PermDockPluginOptions, type PermissionBoundaryState, type PermissionSet, type PermissionState, type ProtectedProps, type SubjectView, type TenantView, type UseRolesOptions, approvalHeaders, describe, requiredPlans };

package/dist/vue/index.js

@@ -0,0 +1,196 @@
+import { r as requiredPlans } from "../problem-details-_AMOYz-w.js";
+import { t as describe } from "../describe-B_gVZEVi.js";
+import { t as approvalHeaders } from "../headers-BZSDieNT.js";
+import { i as isPromiseLike } from "../store-options-yO0V6gRn.js";
+import { a as protectedView, c as subjectView, i as permissionSet, l as tenantView, n as filterResult, o as rolesView, r as livePermDock, s as scopedTenant, t as approvalHandle } from "../views-Soe7bGSC.js";
+import { n as boundaryFallback, t as boundaryDigest } from "../boundary-BM8a_P6E.js";
+import { n as switchTenant, t as providerStore } from "../provider-store-DNyC1y48.js";
+import { computed, defineComponent, effectScope, getCurrentScope, inject, isRef, onErrorCaptured, onScopeDispose, provide, shallowRef, toValue, watch } from "vue";
+//#region src/vue/context.ts
+const permDockKey = Symbol("permdock");
+//#endregion
+//#region src/vue/composables.ts
+function useStore() {
+	const store = inject(permDockKey);
+	if (store === void 0) throw new Error("PermDock: composables require permdockPlugin.");
+	return store;
+}
+function useTick(store) {
+	if (getCurrentScope() === void 0) throw new Error("PermDock: call composables in setup() or an effectScope, which removes their store subscription.");
+	const tick = shallowRef(0);
+	onScopeDispose(store.subscribe(() => {
+		tick.value += 1;
+	}));
+	return computed(() => {
+		tick.value;
+		return store.get();
+	});
+}
+function usePermDock() {
+	const permdock = useTick(useStore());
+	return livePermDock(() => permdock.value);
+}
+function usePermission(permission, data) {
+	const store = useStore();
+	const permdock = useTick(store);
+	const state = computed(() => {
+		permdock.value;
+		return store.permissionState(toValue(permission), toValue(data));
+	});
+	return {
+		allowed: computed(() => state.value.allowed),
+		status: computed(() => state.value.status),
+		decision: computed(() => state.value.decision)
+	};
+}
+function usePermissions(permissions, data) {
+	const store = useStore();
+	const permdock = useTick(store);
+	return computed(() => {
+		permdock.value;
+		return permissionSet(store, toValue(permissions), toValue(data));
+	});
+}
+function useFilter(permission, rows) {
+	const permdock = useTick(useStore());
+	return computed(() => filterResult(permdock.value, permission, toValue(rows)));
+}
+function useTenant() {
+	const permdock = useTick(useStore());
+	return computed(() => tenantView(permdock.value));
+}
+function useMemberships() {
+	const permdock = useTick(useStore());
+	return computed(() => permdock.value.memberships());
+}
+function useRoles(options = {}) {
+	const permdock = useTick(useStore());
+	return computed(() => rolesView(permdock.value, toValue(options)));
+}
+function useAssignableRoles() {
+	const permdock = useTick(useStore());
+	return computed(() => permdock.value.assignableRoles());
+}
+function useAssignablePermissions(options = {}) {
+	const permdock = useTick(useStore());
+	return computed(() => permdock.value.assignablePermissions(toValue(options)));
+}
+function useSubject() {
+	const permdock = useTick(useStore());
+	return computed(() => subjectView(permdock.value));
+}
+function useApproval(decision) {
+	const store = useStore();
+	const permdock = useTick(store);
+	return computed(() => {
+		permdock.value;
+		return approvalHandle(store, toValue(decision));
+	});
+}
+//#endregion
+//#region src/vue/boundary.ts
+const boundaryKey = Symbol("permdock-boundary");
+/**
+* Catches `PermDockDeniedError` and `PermDockApprovalRequiredError` thrown
+* by a descendant and renders the `denied` slot, or the `approval` slot for
+* an approval request (default `denied`). The slots receive the refused
+* permission and `retry()`. Any other error propagates.
+*/
+const PermissionBoundary = defineComponent({
+	name: "PermissionBoundary",
+	setup(_props, { slots }) {
+		const state = shallowRef(null);
+		provide(boundaryKey, state);
+		onErrorCaptured((error) => {
+			const digest = boundaryDigest(error);
+			if (digest === null) return;
+			state.value = {
+				...digest,
+				retry: () => {
+					state.value = null;
+				}
+			};
+			return false;
+		});
+		return () => {
+			const current = state.value;
+			if (current === null) return slots["default"]?.() ?? null;
+			return boundaryFallback(current, {
+				denied: slots["denied"],
+				approval: slots["approval"]
+			})?.(current) ?? null;
+		};
+	}
+});
+/** Inside a `PermissionBoundary`: what was refused and `retry()`, or `null` while the children render. */
+function usePermissionBoundary() {
+	return inject(boundaryKey, null)?.value ?? null;
+}
+//#endregion
+//#region src/vue/plugin.ts
+const permdockPlugin = { install(app, options) {
+	const source = options.snapshot;
+	const promised = isPromiseLike(source);
+	const store = providerStore({
+		...options,
+		tenant: toValue(options.tenant)
+	}, () => ({
+		headers: toValue(options.headers),
+		fetch: options.fetch,
+		verifier: toValue(options.verifier)
+	}), promised ? source : toValue(source));
+	const scope = effectScope(true);
+	scope.run(() => {
+		if (!promised && (isRef(source) || typeof source === "function")) watch(() => toValue(source), (next) => {
+			store.replace(next);
+		});
+		const tenant = options.tenant;
+		if (isRef(tenant) || typeof tenant === "function") watch(() => toValue(tenant), (next) => {
+			switchTenant(store, next);
+		});
+	});
+	app.onUnmount(() => {
+		scope.stop();
+		store.dispose();
+	});
+	app.provide(permDockKey, store);
+} };
+//#endregion
+//#region src/vue/protected.ts
+const Protected = defineComponent({
+	name: "Protected",
+	props: {
+		permission: {
+			type: Object,
+			required: true
+		},
+		data: {
+			type: null,
+			required: false
+		},
+		tenant: {
+			type: String,
+			required: false
+		}
+	},
+	setup(props, { slots }) {
+		const local = usePermission(() => props.permission, () => props.data);
+		const root = usePermDock();
+		const scoped = computed(() => scopedTenant(root, props.tenant));
+		return () => {
+			const view = protectedView({
+				allowed: local.allowed.value,
+				status: local.status.value,
+				decision: local.decision.value
+			}, root, props.permission, props.data, scoped.value);
+			switch (view.slot) {
+				case "pending": return slots["pending"]?.() ?? null;
+				case "fallback": return slots["fallback"]?.({ decision: view.decision }) ?? null;
+				case "default": return slots["default"]?.({ decision: view.decision }) ?? null;
+				default: return view;
+			}
+		};
+	}
+});
+//#endregion
+export { PermissionBoundary, Protected, approvalHeaders, describe, permdockPlugin, requiredPlans, useApproval, useAssignablePermissions, useAssignableRoles, useFilter, useMemberships, usePermDock, usePermission, usePermissionBoundary, usePermissions, useRoles, useSubject, useTenant };

package/dist/watch-Etoa_Mvr.js

@@ -0,0 +1,2 @@
+import { n as createCollectScheduler } from "./watch-UihESpsJ.js";
+export { createCollectScheduler };

package/dist/watch-UihESpsJ.js

@@ -0,0 +1,128 @@
+import { i as describeError } from "./errors-CWfoNg9N.js";
+import { t as defaultSrcPath } from "./files-DWUN9PzI.js";
+import { r as runCollect } from "./collect-DDDv_ESs.js";
+import { n as isConfigFile, r as loadConfig } from "./config-BJiM-xAm.js";
+import { watch } from "node:fs";
+import { basename, dirname, relative, resolve, sep } from "node:path";
+//#region src/cli/watch.ts
+const DEBOUNCE_MS = 50;
+function report(message) {
+	if (message !== void 0) process.stderr.write(`permdock: ${message}\n`);
+}
+function watchRoot(cwd, entry) {
+	const wildcard = entry.search(/[*?[{]/u);
+	return resolve(cwd, wildcard === -1 ? entry : dirname(`${entry.slice(0, wildcard)}x`));
+}
+function within(dirs, file) {
+	return dirs.some((dir) => {
+		const path = relative(dir, file);
+		return path !== "" && !path.startsWith("..") && !path.startsWith(sep);
+	});
+}
+async function collectOnce(cwd, options, check, fresh, configFile) {
+	const config = await loadConfig(cwd, configFile, { fresh });
+	const collect = {
+		...config.collect,
+		...options?.collect
+	};
+	const result = await runCollect({
+		cwd,
+		config,
+		collect,
+		check,
+		now: /* @__PURE__ */ new Date(),
+		fresh
+	});
+	const inputs = [
+		configFile,
+		config.permissions,
+		config.policy
+	].filter((path) => path !== void 0).map((path) => resolve(cwd, path));
+	const sources = (collect.srcPath ?? defaultSrcPath()).map((entry) => watchRoot(cwd, entry));
+	const run = {
+		written: result.written ?? [],
+		inputs,
+		sources
+	};
+	if (result.code === 0) return {
+		message: void 0,
+		...run
+	};
+	if (check && options?.onDrift !== "warn" && result.code === 1) throw new Error(result.message);
+	return {
+		message: result.message,
+		...run
+	};
+}
+function createCollectScheduler(cwd, options, settings) {
+	const log = settings?.report ?? report;
+	let loaded = false;
+	let ignored = /* @__PURE__ */ new Set();
+	let inputs = [];
+	let sources = (options?.collect?.srcPath ?? defaultSrcPath()).map((entry) => watchRoot(cwd, entry));
+	let running = false;
+	let pending = false;
+	let timer;
+	const watchers = [];
+	async function run(check) {
+		const fresh = loaded;
+		loaded = true;
+		const result = await collectOnce(cwd, options, check, fresh, settings?.configFile);
+		ignored = new Set(result.written);
+		inputs = result.inputs;
+		sources = result.sources;
+		return result.message;
+	}
+	async function drain() {
+		running = true;
+		while (pending) {
+			pending = false;
+			try {
+				log(await run(false));
+			} catch (error) {
+				log(describeError(error));
+			}
+		}
+		running = false;
+	}
+	function changed(file) {
+		if (file !== void 0 && ignored.has(resolve(cwd, file))) return;
+		pending = true;
+		if (running) return;
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			drain();
+		}, DEBOUNCE_MS);
+	}
+	function watchDir(dir, recursive, accept) {
+		try {
+			watchers.push(watch(dir, { recursive }, (_event, name) => {
+				if (name === null) {
+					changed(void 0);
+					return;
+				}
+				const file = resolve(dir, name);
+				if (accept(file)) changed(file);
+			}));
+		} catch {}
+	}
+	function startWatch() {
+		if (watchers.length > 0) return;
+		for (const dir of sources) watchDir(dir, true, () => true);
+		const loose = inputs.filter((file) => !within(sources, file));
+		const dirs = /* @__PURE__ */ new Set([cwd, ...loose.map((file) => dirname(file))]);
+		for (const dir of dirs) watchDir(dir, false, (file) => loose.includes(file) || dir === cwd && isConfigFile(basename(file)));
+	}
+	function close() {
+		clearTimeout(timer);
+		for (const watcher of watchers.splice(0)) watcher.close();
+	}
+	return {
+		run,
+		changed,
+		watch: startWatch,
+		close
+	};
+}
+//#endregion
+export { createCollectScheduler as n, report as r, collectOnce as t };

package/dist/webmcp/index.d.ts

@@ -0,0 +1,75 @@
+import { Tt as Snapshot, Yn as Decision } from "../policy-CFZAr_Al.js";
+import { f as Permission, m as PermissionTree } from "../permissions-DttnqqxC.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/webmcp/types.d.ts
+type WebMcpClientStatus = "ready" | "pending" | "stale" | "server-only";
+type WebMcpPermDock = {
+  can(permission: Permission, data?: unknown): boolean;
+  decide(permission: Permission, data?: unknown): Decision;
+  snapshot(): Snapshot | string | Promise<Snapshot | string>;
+  tenant?(id: string): WebMcpPermDock;
+  subscribe?(listener: () => void): () => void;
+  status?(permission?: Permission, data?: unknown): WebMcpClientStatus;
+};
+type WebMcpToolContent = {
+  readonly type: "text";
+  readonly text: string;
+};
+type WebMcpToolResult = {
+  readonly isError?: boolean;
+  readonly content: readonly WebMcpToolContent[];
+  readonly structuredContent?: Readonly<Record<string, unknown>>;
+};
+type WebMcpToolCall = {
+  /** Validated arguments with the tenant key bound. */
+  readonly input: unknown;
+  /** The decision token; send it as `PermDock-Approval` so the server resumes. */
+  readonly token: string | undefined;
+};
+type WebMcpToolHandler = (call: WebMcpToolCall) => Promise<unknown>;
+type WebMcpToolAnnotations = {
+  readonly readOnlyHint?: boolean;
+  readonly untrustedContentHint?: boolean;
+};
+type WebMcpRegisteredTool = {
+  readonly name: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly inputSchema?: Readonly<Record<string, unknown>>;
+  readonly annotations?: WebMcpToolAnnotations;
+  execute(input: unknown): Promise<WebMcpToolResult>;
+};
+type ModelContext = {
+  registerTool(tool: WebMcpRegisteredTool, options?: {
+    readonly signal?: AbortSignal;
+  }): {
+    readonly unregister?: () => void;
+  };
+};
+type WebMcpApprovalRequest = {
+  readonly permission: Permission;
+  readonly decision: Extract<Decision, {
+    readonly outcome: "approval-required";
+  }>;
+  readonly input: unknown;
+};
+type RegisterToolsOptions = {
+  readonly permdock: WebMcpPermDock;
+  readonly handlers?: Readonly<Record<string, WebMcpToolHandler>>;
+  readonly signal?: AbortSignal;
+  readonly tenant?: string;
+  readonly tenantKey?: string;
+  readonly schema?: StandardSchemaV1;
+  readonly untrustedContentHint?: boolean;
+  readonly onApprovalRequired?: (request: WebMcpApprovalRequest) => Promise<boolean | undefined>;
+  readonly warn?: (message: string) => void;
+};
+type RegisterToolsHandle = {
+  readonly unregister: () => void;
+};
+type PermissionGroup = PermissionTree | Permission;
+//#endregion
+//#region src/webmcp/register.d.ts
+export declare function registerTools(modelContext: ModelContext | null | undefined, group: PermissionGroup, options: RegisterToolsOptions): RegisterToolsHandle;
+//#endregion
+export type { ModelContext, PermissionGroup, RegisterToolsHandle, RegisterToolsOptions, WebMcpApprovalRequest, WebMcpClientStatus, WebMcpPermDock, WebMcpRegisteredTool, WebMcpToolAnnotations, WebMcpToolCall, WebMcpToolHandler, WebMcpToolResult };