@theholocron/holocron-plugin-sentry 5.0.0-alpha.23 → 5.0.0-alpha.231

package/dist/index.d.mts

@@ -1,7 +1,17 @@
-import { AuthError, Errors, ResolveTokenInput } from "@theholocron/cli";
+import { AuthError, EnsureRelayInput, EnsureRelayResult, Errors, ResolveTokenInput, VerifyTokenFailure, VerifyTokenResult, VerifyTokenResult as VerifyTokenResult$1, VerifyTokenSuccess } from "@theholocron/cli";
 import { SentryClient, SentryClientOptions, createSentryClient } from "@theholocron/sentry-client";
 //#region src/auth.d.ts
 declare const resolveToken: (input?: ResolveTokenInput) => string;
+/**
+ * The token for the Comlink relay: an integration, its client secret and an alert rule need more than the general token
+ * (`alerts:write`, `org:write`, `event:read`), so it has its own.
+ */
+declare const resolveComlinkToken: (input?: ResolveTokenInput) => string;
+/**
+ * The token for the relay: the Comlink one when there is one, else the general Sentry token as the last resort. The
+ * fallback only helps if the general token happens to carry the scopes; otherwise Sentry's answer names what is missing.
+ */
+declare function resolveRelayToken(input?: ResolveTokenInput): string;
 //#endregion
 //#region src/capabilities/errors.d.ts
 interface SentryErrorsOptions {
@@ -13,16 +23,21 @@ interface SentryErrorsOptions {
 declare class SentryErrors implements Errors {
   private readonly client;
   private readonly opts;
+  /** The client for the relay, made with the Comlink token (see `resolveRelayToken`). */
+  private readonly relayClient;
   readonly key: "errors";
   readonly providerName = "sentry";
-  constructor(client: () => SentryClient, opts: SentryErrorsOptions);
+  constructor(client: () => SentryClient, opts: SentryErrorsOptions,
+  /** The client for the relay, made with the Comlink token (see `resolveRelayToken`). */
+  relayClient?: () => SentryClient);
+  ensureRelay(input: EnsureRelayInput): Promise<EnsureRelayResult>;
   describe(): Promise<{
     provider: string;
     envKeys: string[];
   }>;
   whoami(): Promise<{
     org: string;
-  }>;
+  } | null>;
   ensureProject(input: {
     name: string;
     platform?: string;
@@ -39,20 +54,11 @@ declare class SentryErrors implements Errors {
 }
 //#endregion
 //#region src/verify-token.d.ts
-interface VerifyTokenSuccess {
-  ok: true;
-  subject: string;
-}
-interface VerifyTokenFailure {
-  ok: false;
-  message: string;
-}
-type VerifyTokenResult = VerifyTokenSuccess | VerifyTokenFailure;
 interface VerifyTokenOptions {
   baseUrl?: string;
   fetch?: typeof fetch;
 }
-declare function verifyToken(token: string, opts?: VerifyTokenOptions): Promise<VerifyTokenResult>;
+declare function verifyToken(token: string, opts?: VerifyTokenOptions): Promise<VerifyTokenResult$1>;
 //#endregion
 //#region src/index.d.ts
 interface SentryPluginOptions extends ResolveTokenInput, SentryErrorsOptions {
@@ -69,15 +75,18 @@ interface SentryPluginOptions extends ResolveTokenInput, SentryErrorsOptions {
 interface PluginContext {
   options: SentryPluginOptions;
   client: () => SentryClient;
+  /** The client for the Comlink relay: its own token (`sentry.comlink`), the general one only as a last resort. */
+  relayClient: () => SentryClient;
 }
 declare function createContext(options: SentryPluginOptions): PluginContext;
 declare function errors(ctx: PluginContext): Errors;
 declare function createPlugin(options: SentryPluginOptions): {
   name: string;
+  probes: import("@theholocron/cli").PluginProbes;
   capabilities: {
     errors: () => Errors;
   };
 };
 declare const AUTH_HINT: string;
 //#endregion
-export { AUTH_HINT, AuthError, PluginContext, type ResolveTokenInput, type SentryClient, type SentryClientOptions, SentryErrors, type SentryErrorsOptions, SentryPluginOptions, type VerifyTokenFailure, type VerifyTokenResult, type VerifyTokenSuccess, createContext, createPlugin, createSentryClient, errors, resolveToken, verifyToken };
+export { AUTH_HINT, AuthError, PluginContext, type ResolveTokenInput, type SentryClient, type SentryClientOptions, SentryErrors, type SentryErrorsOptions, SentryPluginOptions, type VerifyTokenFailure, type VerifyTokenResult, type VerifyTokenSuccess, createContext, createPlugin, createSentryClient, errors, resolveComlinkToken, resolveRelayToken, resolveToken, verifyToken };

package/dist/index.mjs

@@ -1,5 +1,7 @@
-import { AuthError, ProviderApiError, createResolveToken } from "@theholocron/cli";
+import { AuthError, ProviderApiError, createFeatureResolver, createResolveToken } from "@theholocron/cli";
+import { randomUUID } from "node:crypto";
 import { createSentryClient } from "@theholocron/sentry-client";
+import { errorMessage } from "@theholocron/misc-utils";
 //#region src/auth.ts
 const resolveToken = createResolveToken({
 	envName: "HOLOCRON_SENTRY_TOKEN",
@@ -7,16 +9,245 @@ const resolveToken = createResolveToken({
 	keyringService: "sentry",
 	errorMessage: "no Sentry auth token found. Pass --token <TOKEN>, set HOLOCRON_SENTRY_TOKEN / SENTRY_AUTH_TOKEN, or run: holocron auth set sentry <TOKEN>"
 });
+/**
+* The token for the Comlink relay: an integration, its client secret and an alert rule need more than the general token
+* (`alerts:write`, `org:write`, `event:read`), so it has its own.
+*/
+const resolveComlinkToken = createFeatureResolver({
+	envName: "HOLOCRON_SENTRY_COMLINK_TOKEN",
+	keyringKey: "sentry.comlink",
+	vendor: "Sentry"
+});
+/**
+* The token for the relay: the Comlink one when there is one, else the general Sentry token as the last resort. The
+* fallback only helps if the general token happens to carry the scopes; otherwise Sentry's answer names what is missing.
+*/
+function resolveRelayToken(input = {}) {
+	try {
+		return resolveComlinkToken(input);
+	} catch (err) {
+		if (!(err instanceof AuthError)) throw err;
+		return resolveToken(input);
+	}
+}
+//#endregion
+//#region src/capabilities/relay.ts
+/** What the integration needs to read: the alert's event. It is also why reading its secret needs the same scope. */
+const INTEGRATION_SCOPES = ["event:read"];
+const DEFAULT_FREQUENCY = 5;
+/**
+* The alert action that sends through an integration, in the shape Sentry's own page writes when "Send a notification via
+* an integration" is picked: a `webhook` action named by the integration's slug. (A `sentry_app` action with the numeric
+* id is accepted too, but the page shows it as an unknown integration.)
+*/
+const integrationAction = (slug) => ({
+	type: "webhook",
+	config: {
+		targetType: null,
+		targetDisplay: null,
+		targetIdentifier: slug
+	},
+	data: {}
+});
+const sendsThrough = (action, slug) => action.type === "webhook" && action.config["targetIdentifier"] === slug;
+/** The `sentry_app` form an earlier version wrote for this integration, which the page cannot name. */
+const isLegacyAction = (action, appId) => action.type === "sentry_app" && String(action.config["targetIdentifier"]) === String(appId);
+/** A workflow as Sentry returned it, as the body to send back (the nested ids are not part of an update). */
+function toInput(wf) {
+	return {
+		name: wf.name,
+		enabled: wf.enabled,
+		environment: wf.environment,
+		config: wf.config,
+		detectorIds: wf.detectorIds,
+		triggers: {
+			logicType: wf.triggers.logicType,
+			conditions: wf.triggers.conditions.map((c) => ({
+				type: c.type,
+				comparison: c.comparison,
+				conditionResult: c.conditionResult
+			}))
+		},
+		actionFilters: wf.actionFilters.map((f) => ({
+			logicType: f.logicType,
+			conditions: f.conditions.map((c) => ({
+				type: c.type,
+				comparison: c.comparison,
+				conditionResult: c.conditionResult
+			})),
+			actions: f.actions.map((a) => ({
+				type: a.type,
+				config: a.config,
+				data: a.data
+			}))
+		}))
+	};
+}
+/** Sentry's own "high priority issues" rule, which is the default for a new alert. */
+function newWorkflow(name, frequency, detectorIds, slug) {
+	return {
+		name,
+		enabled: true,
+		environment: null,
+		config: { frequency },
+		detectorIds,
+		triggers: {
+			logicType: "any-short",
+			conditions: [{
+				type: "new_high_priority_issue",
+				comparison: true,
+				conditionResult: true
+			}, {
+				type: "existing_high_priority_issue",
+				comparison: true,
+				conditionResult: true
+			}]
+		},
+		actionFilters: [{
+			logicType: "all",
+			conditions: [],
+			actions: [integrationAction(slug)]
+		}]
+	};
+}
+/** The integration: found by name, made if missing, and its webhook and alert action brought in line. */
+async function ensureIntegration(client, org, input) {
+	const existing = (await client.sentryApps.list(org)).find((a) => a.name === input.name);
+	if (!existing) return {
+		app: await client.sentryApps.create(org, {
+			name: input.name,
+			scopes: INTEGRATION_SCOPES,
+			webhookUrl: input.webhookUrl,
+			isAlertable: true
+		}),
+		created: true,
+		updated: []
+	};
+	const updated = [];
+	if (existing.webhookUrl !== input.webhookUrl) updated.push("webhook URL");
+	if (!existing.isAlertable) updated.push("alert action");
+	const scopes = [.../* @__PURE__ */ new Set([...existing.scopes, ...INTEGRATION_SCOPES])];
+	if (scopes.length !== existing.scopes.length) updated.push("scopes");
+	if (updated.length === 0) return {
+		app: existing,
+		created: false,
+		updated
+	};
+	return {
+		app: await client.sentryApps.update(existing.slug, {
+			name: existing.name,
+			scopes,
+			webhookUrl: input.webhookUrl,
+			isAlertable: true
+		}),
+		created: false,
+		updated
+	};
+}
+/** The issue stream detector of each project, so a wrong project fails before anything is changed. */
+async function detectorsFor(client, org, slugs) {
+	const [projects, detectors] = await Promise.all([client.projects.list(org), client.workflows.detectors(org)]);
+	return slugs.map((slug) => {
+		const project = projects.find((p) => p.slug === slug);
+		if (!project) throw new Error(`Sentry project \`${slug}\` was not found in ${org}`);
+		const detector = detectors.find((d) => d.projectId === project.id && d.type === "issue_stream");
+		if (!detector) throw new Error(`Sentry project \`${slug}\` has no issue stream detector to attach an alert to`);
+		return detector.id;
+	});
+}
+/** The alert rule: one workflow for every project, found by name, made if missing, reconciled if not. */
+async function ensureRule(client, org, input, install, detectorIds) {
+	const workflows = await client.workflows.list(org);
+	const frequency = input.rule.frequency ?? DEFAULT_FREQUENCY;
+	const existing = workflows.find((w) => w.name === input.rule.name);
+	if (!existing) {
+		await client.workflows.create(org, newWorkflow(input.rule.name, frequency, detectorIds, install.slug));
+		return {
+			created: true,
+			updated: []
+		};
+	}
+	const next = toInput(existing);
+	const updated = [];
+	if (!existing.enabled) {
+		next.enabled = true;
+		updated.push("enabled");
+	}
+	if (input.rule.frequency !== void 0 && existing.config.frequency !== input.rule.frequency) {
+		next.config = {
+			...existing.config,
+			frequency: input.rule.frequency
+		};
+		updated.push("frequency");
+	}
+	const missing = detectorIds.filter((id) => !existing.detectorIds.includes(id));
+	if (missing.length > 0) {
+		next.detectorIds = [...existing.detectorIds, ...missing];
+		updated.push("projects");
+	}
+	const sends = existing.actionFilters.some((f) => f.actions.some((a) => sendsThrough(a, install.slug)));
+	const legacy = existing.actionFilters.some((f) => f.actions.some((a) => isLegacyAction(a, install.appId)));
+	if (legacy) for (const f of next.actionFilters) f.actions = f.actions.filter((a) => !isLegacyAction(a, install.appId));
+	if (!sends) {
+		const open = next.actionFilters.find((f) => f.conditions.length === 0);
+		if (open) open.actions.push(integrationAction(install.slug));
+		else next.actionFilters.push({
+			logicType: "all",
+			conditions: [],
+			actions: [integrationAction(install.slug)]
+		});
+	}
+	if (legacy || !sends) updated.push("action");
+	if (updated.length === 0) return {
+		created: false,
+		updated
+	};
+	await client.workflows.update(org, existing.id, next);
+	return {
+		created: false,
+		updated
+	};
+}
+/** The signing secret, if the token may see it: a new integration's answer omits it, so it is read again. */
+async function secretOf(client, app) {
+	if (app.clientSecret) return app.clientSecret;
+	return (await client.sentryApps.get(app.slug)).clientSecret || void 0;
+}
+async function ensureSentryRelay(client, org, input) {
+	if (input.projects.length === 0) throw new Error("relay needs at least one Sentry project to alert on");
+	const detectorIds = await detectorsFor(client, org, input.projects);
+	const integration = await ensureIntegration(client, org, input);
+	const install = (await client.sentryApps.installations(org)).find((i) => i.app.slug === integration.app.slug);
+	if (!install) throw new Error(`the integration \`${integration.app.name}\` is not installed on ${org}`);
+	const rule = await ensureRule(client, org, input, {
+		slug: install.app.slug,
+		appId: install.app.sentryAppId
+	}, detectorIds);
+	const clientSecret = await secretOf(client, integration.app);
+	return {
+		integration: {
+			created: integration.created,
+			updated: integration.updated
+		},
+		rule,
+		...clientSecret ? { clientSecret } : {}
+	};
+}
 //#endregion
 //#region src/capabilities/errors.ts
 var SentryErrors = class {
 	client;
 	opts;
+	relayClient;
 	key = "errors";
 	providerName = "sentry";
-	constructor(client, opts) {
+	constructor(client, opts, relayClient = client) {
 		this.client = client;
 		this.opts = opts;
+		this.relayClient = relayClient;
+	}
+	async ensureRelay(input) {
+		return ensureSentryRelay(this.relayClient(), this.requireOrg(), input);
 	}
 	async describe() {
 		return {
@@ -25,7 +256,8 @@ var SentryErrors = class {
 		};
 	}
 	async whoami() {
-		return { org: (await this.client().auth.getOrg(this.requireOrg())).slug };
+		if (!this.opts.org) return null;
+		return { org: (await this.client().auth.getOrg(this.opts.org)).slug };
 	}
 	async ensureProject(input) {
 		const org = this.requireOrg();
@@ -69,6 +301,156 @@ function toSlug(name) {
 	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 //#endregion
+//#region src/probes/probe-deps.type.ts
+function requireOrg(deps) {
+	if (!deps.org) throw new Error("the Sentry probes need `org` in the sentry provider's options");
+	return deps.org;
+}
+//#endregion
+//#region src/probes/integrations.ts
+/** Where a webhook points, without a query string that could carry a token. */
+function where(url) {
+	if (!url) return "no webhook";
+	try {
+		const u = new URL(url);
+		return `${u.host}${u.pathname}`;
+	} catch {
+		return "an unreadable URL";
+	}
+}
+function integrationsProbe(deps) {
+	return {
+		summary: "List the custom integrations: scopes, alert action, webhook, and whether the client secret is visible.",
+		writes: false,
+		async run(probe) {
+			const apps = await deps.client().sentryApps.list(requireOrg(deps));
+			if (apps.length === 0) probe.say({
+				status: "info",
+				label: "no custom integrations"
+			});
+			for (const app of apps) {
+				probe.secret(app.clientSecret);
+				probe.say({
+					status: "ok",
+					label: `${app.name} (${app.slug})`,
+					detail: [
+						`scopes: ${app.scopes.join(", ") || "none"}`,
+						`alert action: ${app.isAlertable ? "on" : "off"}`,
+						`webhook: ${where(app.webhookUrl)}`,
+						`secret visible: ${app.clientSecret ? "yes" : "no"}`
+					].join(" | ")
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/probes/rules.ts
+function rulesProbe(deps) {
+	return {
+		summary: "List the alert rules: enabled, projects attached, and what each action sends to.",
+		writes: false,
+		async run(probe) {
+			const org = requireOrg(deps);
+			const client = deps.client();
+			const [workflows, apps] = await Promise.all([client.workflows.list(org), client.sentryApps.list(org)]);
+			const alertable = new Set(apps.filter((a) => a.isAlertable).map((a) => a.slug));
+			if (workflows.length === 0) probe.say({
+				status: "info",
+				label: "no alert rules"
+			});
+			for (const wf of workflows) {
+				const actions = wf.actionFilters.flatMap((f) => f.actions);
+				const described = actions.map((a) => {
+					const target = String(a.config["targetIdentifier"] ?? a.config["targetType"] ?? "");
+					return target ? `${a.type} ${target}` : a.type;
+				});
+				const problems = actions.flatMap((a) => {
+					if (a.type === "sentry_app") return [`a sentry_app action shows as an unknown integration`];
+					if (a.type === "webhook" && !alertable.has(String(a.config["targetIdentifier"]))) return [`webhook ${String(a.config["targetIdentifier"])} is not an alertable integration`];
+					return [];
+				});
+				probe.say({
+					status: problems.length > 0 || !wf.enabled ? "fail" : "ok",
+					label: wf.name,
+					detail: [
+						wf.enabled ? "enabled" : "DISABLED",
+						`detectors: ${wf.detectorIds.length}`,
+						`actions: ${described.join(", ") || "none"}`,
+						...problems
+					].join(" | ")
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/probes/send-error.ts
+/** Which DSN to send to: `SENTRY_DSN`, else the first client key of the project named in `HOLOCRON_SENTRY_PROBE_PROJECT`. */
+async function dsnFor(deps) {
+	const env = deps.env ?? process.env;
+	if (env["SENTRY_DSN"]) return env["SENTRY_DSN"];
+	const project = env["HOLOCRON_SENTRY_PROBE_PROJECT"];
+	if (!project) throw new Error("set SENTRY_DSN, or HOLOCRON_SENTRY_PROBE_PROJECT to a project slug, to say where to send the error");
+	const dsn = (await deps.client().projects.keys(requireOrg(deps), project))[0]?.dsn.public;
+	if (!dsn) throw new Error(`project \`${project}\` has no client key`);
+	return dsn;
+}
+function sendErrorProbe(deps) {
+	return {
+		summary: "Send one labelled test error to a project, to follow it through the alert rule to Discord.",
+		writes: true,
+		async run(probe) {
+			const dsn = new URL(await dsnFor(deps));
+			probe.secret(dsn.username);
+			const projectId = dsn.pathname.replace(/^\/+/, "");
+			const eventId = randomUUID().replaceAll("-", "");
+			const message = `Holocron probe: sent on purpose (${(/* @__PURE__ */ new Date()).toISOString()})`;
+			const envelope = [
+				JSON.stringify({
+					event_id: eventId,
+					sent_at: (/* @__PURE__ */ new Date()).toISOString()
+				}),
+				JSON.stringify({ type: "event" }),
+				JSON.stringify({
+					event_id: eventId,
+					level: "error",
+					platform: "node",
+					environment: "holocron-probe",
+					message: { formatted: message },
+					exception: { values: [{
+						type: "HolocronProbeError",
+						value: message
+					}] },
+					tags: { probe: "sentry.send-error" }
+				})
+			].join("\n");
+			if (await probe.write("send a test error", async () => {
+				const res = await (deps.fetch ?? fetch)(`${dsn.protocol}//${dsn.host}/api/${projectId}/envelope/?sentry_version=7&sentry_key=${dsn.username}&sentry_client=holocron-probe/1`, {
+					method: "POST",
+					headers: { "content-type": "application/x-sentry-envelope" },
+					body: envelope
+				});
+				if (!res.ok) throw new Error(`Sentry answered ${res.status}`);
+				return true;
+			})) probe.say({
+				status: "ok",
+				label: "sent HolocronProbeError",
+				detail: "look for it in the project's issues and, through the rule, in #errors; resolve the issue by hand (a probe cannot delete it)"
+			});
+		}
+	};
+}
+//#endregion
+//#region src/probes/index.ts
+function sentryProbes(deps) {
+	return {
+		integrations: integrationsProbe(deps),
+		rules: rulesProbe(deps),
+		"send-error": sendErrorProbe(deps)
+	};
+}
+//#endregion
 //#region src/verify-token.ts
 async function verifyToken(token, opts = {}) {
 	const client = createSentryClient({
@@ -84,7 +466,7 @@ async function verifyToken(token, opts = {}) {
 	} catch (err) {
 		return {
 			ok: false,
-			message: err instanceof Error ? err.message : String(err)
+			message: errorMessage(err)
 		};
 	}
 }
@@ -92,12 +474,18 @@ async function verifyToken(token, opts = {}) {
 //#region src/index.ts
 function createContext(options) {
 	let client;
+	let relayClient;
 	return {
 		options,
 		client: () => client ??= createSentryClient({
 			token: resolveToken(options),
 			baseUrl: options.baseUrl,
 			fetch: options.fetch
+		}),
+		relayClient: () => relayClient ??= createSentryClient({
+			token: resolveRelayToken(options),
+			baseUrl: options.baseUrl,
+			fetch: options.fetch
 		})
 	};
 }
@@ -105,15 +493,20 @@ function errors(ctx) {
 	return new SentryErrors(ctx.client, {
 		org: ctx.options.org,
 		team: ctx.options.team
-	});
+	}, ctx.relayClient);
 }
 function createPlugin(options) {
 	const ctx = createContext(options);
 	return {
 		name: "@theholocron/holocron-plugin-sentry",
+		probes: sentryProbes({
+			org: options.org,
+			client: ctx.relayClient,
+			fetch: options.fetch
+		}),
 		capabilities: { errors: () => errors(ctx) }
 	};
 }
 const AUTH_HINT = "generate an auth token at https://sentry.io/settings/account/api/auth-tokens/ with project:read, project:write, and org:read scopes, then run: holocron auth set sentry <TOKEN>";
 //#endregion
-export { AUTH_HINT, AuthError, SentryErrors, createContext, createPlugin, createSentryClient, errors, resolveToken, verifyToken };
+export { AUTH_HINT, AuthError, SentryErrors, createContext, createPlugin, createSentryClient, errors, resolveComlinkToken, resolveRelayToken, resolveToken, verifyToken };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theholocron/holocron-plugin-sentry",
-  "version": "5.0.0-alpha.23",
+  "version": "5.0.0-alpha.231",
   "description": "Holocron plugin for Sentry. Implements the errors capability against Sentry's management API — project provisioning and DSN retrieval.",
   "keywords": [
     "errors",
@@ -8,12 +8,12 @@
     "plugin",
     "sentry"
   ],
-  "homepage": "https://github.com/theholocron/holocron/tree/main/packages/holocron-plugin-sentry#readme",
+  "homepage": "https://github.com/theholocron/holocron/tree/main/plugins/holocron-plugin-sentry#readme",
   "bugs": "https://github.com/theholocron/holocron/issues",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/theholocron/holocron.git",
-    "directory": "packages/holocron-plugin-sentry"
+    "directory": "plugins/holocron-plugin-sentry"
   },
   "license": "MIT",
   "author": "Newton Koumantzelis",
@@ -30,12 +30,13 @@
     "dist"
   ],
   "devDependencies": {
-    "@theholocron/eslint-config": "^8.0.0",
-    "@theholocron/http-client": "^1.22.0",
-    "@theholocron/sentry-client": "^1.22.0",
-    "@theholocron/tsconfig": "^8.0.0",
-    "@theholocron/tsdown-config": "^8.0.0",
-    "@theholocron/vitest-config": "^8.0.0",
+    "@theholocron/eslint-config": "^8.8.2",
+    "@theholocron/http-client": "^1.54.2",
+    "@theholocron/misc-utils": "^1.16.0",
+    "@theholocron/sentry-client": "^1.54.0",
+    "@theholocron/tsconfig": "^8.8.2",
+    "@theholocron/tsdown-config": "^8.8.2",
+    "@theholocron/vitest-config": "^8.8.2",
     "@types/node": "^26",
     "@vitest/coverage-v8": "^4.1.11",
     "@vitest/eslint-plugin": "^1.6.27",
@@ -44,14 +45,15 @@
     "eslint-plugin-n": "^18.3.0",
     "globals": "^17.11.0",
     "tsdown": "^0.22.14",
-    "tsx": "4.23.12",
+    "tsx": "4.23.15",
     "typescript": "^5.9.3",
     "vitest": "^4.1.11",
-    "@theholocron/cli": "5.0.0-alpha.23"
+    "@theholocron/cli": "5.0.0-alpha.231"
   },
   "peerDependencies": {
-    "@theholocron/sentry-client": "^1.22.0",
-    "@theholocron/cli": "5.0.0-alpha.23"
+    "@theholocron/misc-utils": "^1.16.0",
+    "@theholocron/sentry-client": "^1.54.0",
+    "@theholocron/cli": "5.0.0-alpha.231"
   },
   "peerDependenciesMeta": {
     "@theholocron/sentry-client": {}