permdock 0.4.0 → 0.5.0

package/dist/{errors-drnfxYtm.js → errors-BKy0EfhN.js}

@@ -1,6 +1,6 @@
 import { t as compact } from "./compact-CAf557ZB.js";
-import { t as PROBLEM_BASE } from "./validation-error-ZfUHbKvf.js";
-import { a as wireDenials, n as problemDetails } from "./problem-details-DECUnXAn.js";
+import { a as problemType, n as problemDetails, o as statusProblem } from "./problem-details-cn5X30gZ.js";
+import { t as wireDenials } from "./wire-denial-C7PaVYEM.js";
 import { n as deniedDigest, t as approvalDigest } from "./digest-BI-6aa6d.js";
 //#region src/core/errors.ts
 var PermDockDeniedError = class extends Error {
@@ -101,7 +101,7 @@ var PermDockRevokedError = class extends Error {
 	}
 	toProblemDetails(options) {
 		if (this.code === "denied") return compact({
-			type: `${PROBLEM_BASE}/denied`,
+			type: problemType("denied"),
 			title: "Permission denied",
 			status: 403,
 			detail: this.code,
@@ -109,14 +109,10 @@ var PermDockRevokedError = class extends Error {
 			permission: this.permission,
 			denials: this.decision?.outcome === "denied" ? wireDenials(this.decision.denials) : void 0
 		});
-		return compact({
-			type: `${PROBLEM_BASE}/unauthenticated`,
-			title: "Authorization ended",
-			status: 401,
-			detail: this.code,
+		return statusProblem(401, this.code, compact({
 			instance: options?.instance,
 			permission: this.permission
-		});
+		}));
 	}
 };
 //#endregion

package/dist/errors-BWXBMaKK.d.ts

@@ -0,0 +1,11 @@
+//#region src/approvals/errors.d.ts
+type ApprovalErrorCode = "approval-not-found" | "approval-not-pending" | "approval-expired" | "approver-unauthenticated" | "approver-is-actor" | "approver-is-principal" | "approver-not-eligible" | "approver-repeated";
+declare class ApprovalError extends Error {
+  override readonly name: "ApprovalError";
+  readonly code: ApprovalErrorCode;
+  constructor(code: ApprovalErrorCode, message: string);
+}
+/** Matches by `name` and `code`, so an error from another copy of the module still maps. */
+declare function isApprovalError(value: unknown): value is ApprovalError;
+//#endregion
+export { ApprovalErrorCode as n, isApprovalError as r, ApprovalError as t };

package/dist/{errors-OD_4c__H.d.ts → errors-C2PXIv4c.d.ts}

@@ -1,5 +1,5 @@
-import { En as WireDenial, ir as Decision, kr as Subject } from "./policy-types-sp9P1iIV.js";
-import { t as Disclosure } from "./problem-details-rIIo8B2C.js";
+import { Nn as Decision, an as WireDenial, ir as Subject } from "./policy-types-DzwivBgR.js";
+import { t as Disclosure } from "./problem-details-DXlt-vks.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/core/errors.d.ts
 /** Where and how a human approves; carries no secret. */

package/dist/errors-CWTY6uih.js

@@ -0,0 +1,143 @@
+import { stripVTControlCharacters } from "node:util";
+//#region src/cli/core/errors.ts
+const CODES = {
+	usage: ["Invalid arguments", 2],
+	unknown_command: ["Unknown command", 2],
+	unknown_flag: ["Unknown flag", 2],
+	invalid_value: ["Invalid value", 2],
+	command_moved: ["Command moved", 2],
+	flag_renamed: ["Flag renamed", 2],
+	missing_value: ["Missing value", 2],
+	config_not_found: ["Config file not found", 2],
+	config_invalid: ["Invalid config", 2],
+	dependency_missing: ["Missing dependency", 1],
+	database_unreachable: ["Database unreachable", 1],
+	network_error: ["No response", 1],
+	request_failed: ["Request failed", 1],
+	auth_required: ["Authentication required", 3],
+	dirty_worktree: ["Uncommitted changes", 3],
+	write_failed: ["Write failed", 1],
+	check_failed: ["Out of date", 1],
+	input_required: ["Input required", 3],
+	consent_required: ["Consent required", 3],
+	cancelled: ["Cancelled", 130],
+	internal: ["Unexpected error", 1]
+};
+Object.keys(CODES).filter((code) => code in CODES);
+/** Each code has a heading on this page, so `type` links to its explanation. */
+const CLI_ERRORS_URL = "https://permdock.com/docs/cli/errors";
+/** The exit code a problem with `code` gets. */
+function exitCodeOfProblem(code) {
+	return CODES[code][1];
+}
+const DEFAULT_CODES = {
+	usage: "usage",
+	unavailable: "network_error",
+	failed: "check_failed",
+	action: "input_required",
+	cancelled: "cancelled",
+	internal: "internal"
+};
+var CliError = class extends Error {
+	kind;
+	code;
+	extensions;
+	next;
+	constructor(kind, message, options) {
+		super(message, options);
+		this.name = "CliError";
+		this.kind = kind;
+		this.code = options?.code ?? DEFAULT_CODES[kind];
+		this.extensions = options?.extensions ?? {};
+		this.next = options?.next;
+	}
+};
+function describeError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* The exit code an error ends the run with: its code's, so a `CliError` and
+* the problem printed for it always agree. Anything that is not a
+* `CliError` is a bug in the CLI.
+*/
+function exitCodeOfError(error) {
+	if (error instanceof CliError) return exitCodeOfProblem(error.code);
+	return rejectedDefinition(error) ? exitCodeOfProblem("config_invalid") : exitCodeOf("internal");
+}
+/**
+* The library's own runtime checks throw plain errors whose message starts
+* with `PermDock` (an identifier, a condition, a policy it rejects). Those are
+* the project's to fix, so they count as `config_invalid`, not as a CLI bug.
+*/
+function rejectedDefinition(error) {
+	return error instanceof Error && /^PermDock( CLI)?[:\s]/.test(error.message);
+}
+function exitCodeOf(kind) {
+	switch (kind) {
+		case "usage": return 2;
+		case "unavailable":
+		case "failed":
+		case "internal": return 1;
+		case "action": return 3;
+		case "cancelled": return 130;
+		default: return kind;
+	}
+}
+function kindOfCode(code) {
+	switch (code) {
+		case 2: return "usage";
+		case 3: return "action";
+		case 130:
+		case 143: return "cancelled";
+		case 0:
+		case 1: return "failed";
+		default: return code;
+	}
+}
+function cliProblem(kind, message, command, options) {
+	const code = options?.code ?? DEFAULT_CODES[kind];
+	const [title, exitCode] = CODES[code];
+	return {
+		...options?.extensions,
+		type: `${CLI_ERRORS_URL}#${code}`,
+		title,
+		detail: stripVTControlCharacters(message),
+		code,
+		...command === void 0 ? {} : { command },
+		exitCode: options?.exitCode ?? exitCode
+	};
+}
+function problemOf(error, command) {
+	if (error instanceof CliError) return cliProblem(error.kind, error.message, command, {
+		code: error.code,
+		extensions: error.extensions
+	});
+	return rejectedDefinition(error) ? cliProblem("usage", error.message, command, { code: "config_invalid" }) : cliProblem("internal", describeError(error), command);
+}
+/**
+* The result a command reports for a usage error it caught. A `CliError`
+* propagates instead, so `run()` prints it as Problem Details.
+*/
+function usageResult(error) {
+	if (error instanceof CliError) throw error;
+	return {
+		code: 2,
+		output: describeError(error)
+	};
+}
+/**
+* A config, policy or definition the command cannot compile: the project's
+* to fix, so a usage error (exit 2) and never an `internal` one.
+*/
+function configError(message) {
+	return new CliError("usage", message, { code: "config_invalid" });
+}
+/** The run needs a value only the caller can supply: exit 3 with `missing` naming the flags. */
+function missingInput(command, missing, hint) {
+	return new CliError("action", `${command} needs ${missing.join(" and ")}${hint === void 0 ? "" : `: ${hint}`}`, {
+		code: "input_required",
+		extensions: { missing }
+	});
+}
+//#endregion
+export { describeError as a, missingInput as c, configError as i, problemOf as l, CliError as n, exitCodeOfError as o, cliProblem as r, kindOfCode as s, CLI_ERRORS_URL as t, usageResult as u };