@devdogsuga/backstage 0.1.6 → 0.1.7

package/README.md

@@ -49,6 +49,7 @@ pnpm backstage export stars --from 2026-08-17   # audited under your gh login
 | `deploy plan`, `deploy migrate`                  | Dry-run the migrations into the job summary; apply them to `DB_URL`.                   |
 | `deploy smoke --tier <t> [--app]`                | Public routes answer 200, the auth redirect works, this deploy's Sentry release shows. |
 | `deploy reconcile --tier <t>`                    | The platform's config reconcile, after the deploy (`CRON_SECRET`).                     |
+| `deploy prune-monitors --tier <t> [--app]`       | Deletes the app's Sentry Crons monitors it no longer declares (production only).       |
 | `env pull\|push\|audit --target <t>`             | One env file per target, synced to Bitwarden and GitHub. `audit` lists orphans.        |
 | `planner status\|create\|reset-password\|drop`   | The `migration_planner` role the preflight tier holds.                                 |
 | `graphics [graphic…]`                            | Club images from `@devdogsuga/brand`: `brand/*`, `app/*`, `event/*`.                   |
@@ -234,7 +235,8 @@ stderr, and every confirmation needs `--yes`. Against staging or production a
 command that is not read-only asks once first (`--yes` answers it).
 
 Each command checks for the secrets it uses up front: `deploy <app>` for
-`CLOUDFLARE_API_TOKEN`, `deploy reconcile` for `CRON_SECRET`, `env` for the
+`CLOUDFLARE_API_TOKEN`, `deploy reconcile` for `CRON_SECRET`, `deploy
+prune-monitors` for `SENTRY_MONITORS_TOKEN` (skipped without it), `env` for the
 Secrets Manager token (flag, environment, then the Bitwarden vault, which `env`
 signs in to and unlocks itself, then asking).
 

package/dist/{catalog-Dke7bQVz.js → catalog-BiXI0wyi.js}

@@ -1143,6 +1143,16 @@ const deployCommand = {
 			summary: "Run the platform's config reconcile after a deploy.",
 			hint: "needs CRON_SECRET",
 			options: [DEPLOY_TIER, SMOKE_APP]
+		},
+		{
+			name: "prune-monitors",
+			summary: "Delete the Sentry Crons monitors an app no longer declares.",
+			hint: "needs SENTRY_MONITORS_TOKEN; production only",
+			options: [
+				DEPLOY_TIER,
+				SMOKE_APP,
+				DRY_RUN
+			]
 		}
 	]
 };

package/dist/{cli-BhZ4je2D.js → cli-Cz8faASC.js}

@@ -1,5 +1,5 @@
 import { C as discoverRepoRoot, T as cliName, b as ownPackageDir, c as reportDevtoolsError, f as isNoEnv, l as reportDevtoolsFailure, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as isNonInteractive, w as findRepoRoot, x as ownVersion } from "./telemetry-Bjoz29Hl.js";
-import { a as recordEnteredTier, f as helpPath, i as beginInvocation, l as dbPush, m as renderHelp, n as bareGroupStartPath, o as recordResolved, p as renderCommandList, r as runMenu, s as reproducibleCommand, t as catalog, u as dbPushDryRun } from "./catalog-Dke7bQVz.js";
+import { a as recordEnteredTier, f as helpPath, i as beginInvocation, l as dbPush, m as renderHelp, n as bareGroupStartPath, o as recordResolved, p as renderCommandList, r as runMenu, s as reproducibleCommand, t as catalog, u as dbPushDryRun } from "./catalog-BiXI0wyi.js";
 import { a as repoPeerUrl, n as loadEnv, r as loadEnvLoad, t as getEnvSync } from "./peers-B0KDkI6a.js";
 import { t as nonEmpty } from "./connection-D3XsOE3S.js";
 import { a as wouldRunLine, n as isDryRun, t as dryRunKind } from "./dry-run-3IxPmCtW.js";
@@ -553,6 +553,116 @@ async function runDeployMigrate(env = process.env, push = (url) => dbPush(url, {
 	say(["deploy migrate: migrations applied."]);
 }
 //#endregion
+//#region src/deploy/monitors.ts
+/**
+* `deploy prune-monitors`: deletes the Sentry Crons monitors an app no longer
+* declares.
+*
+* Sentry creates a monitor the first time a job checks in, and never removes
+* one. Rename or drop a `monitorSlug` and the old monitor keeps expecting
+* check-ins that will never come, opening a "missed check-in" issue every
+* period until someone deletes it by hand (PLATFORM-2: the Discord role sync
+* folded into the fifteen-minute cron, and its ten-minute monitor alerted
+* every ten minutes after the deploy).
+*
+* The declared set is every `monitorSlug` on the entries of the app's
+* `cloudflare/scheduled.ts` exports `CRON_ROUTES` and `WORKFLOW_CRONS`. Every
+* monitor in the app's Sentry project that is not in it, and whose slug
+* starts with `<app>-`, is deleted. The prefix keeps a monitor someone made
+* by hand in the Sentry UI out of reach.
+*
+* Delete, not disable. Sentry drops every check-in sent to a disabled monitor
+* and never re-enables one from a check-in, so a slug that came back would
+* report nowhere. A deleted one is recreated by the next check-in that
+* carries its config (each `withMonitor`/`captureCheckIn` here does), and the
+* delete renames the old slug first, so the name is free at once.
+*
+* Production only. Monitors belong to a project, not a tier, and staging
+* deploys `main`, which can be ahead of production: a monitor `main` dropped
+* still has a production job checking in to it.
+*
+* `SENTRY_MONITORS_TOKEN`, not `SENTRY_AUTH_TOKEN`: the deploy token is an
+* organization token (`org:ci`), which Sentry lets neither list nor delete
+* monitors. This one needs `alerts:write` (`alerts:read` to list), and is
+* held in this step's `env:` alone. Absent, the step is skipped with a
+* notice, the same as the Sentry release check.
+*/
+const SENTRY_API$1 = "https://sentry.io/api/0";
+/** Only the field read here; the exports' own shapes are devtools' to check. */
+const Declarations = z.record(z.string(), z.object({ monitorSlug: z.string().min(1).optional() }));
+const MonitorList = z.array(z.object({ slug: z.string() }));
+/**
+* Every `monitorSlug` the app's `cloudflare/scheduled.ts` declares, or
+* `undefined` when the app has no such file (no crons, nothing to prune).
+*/
+async function declaredMonitorSlugs(app, root = findRepoRoot()) {
+	const path = join(root, "apps", app, "cloudflare", "scheduled.ts");
+	if (!existsSync(path)) return void 0;
+	const mod = await import(pathToFileURL(path).href);
+	const slugs = /* @__PURE__ */ new Set();
+	for (const name of ["CRON_ROUTES", "WORKFLOW_CRONS"]) {
+		const parsed = Declarations.safeParse(mod[name] ?? {});
+		if (!parsed.success) throw new DeployError(`${path}: ${name} is not a map of entries.`);
+		for (const entry of Object.values(parsed.data)) if (entry.monitorSlug) slugs.add(entry.monitorSlug);
+	}
+	return slugs;
+}
+/** The `rel="next"` URL of a Sentry `Link` header, when it has results. */
+function nextPage(link) {
+	for (const part of link?.split(",") ?? []) if (part.includes("rel=\"next\"") && part.includes("results=\"true\"")) return /<([^>]+)>/.exec(part)?.[1];
+}
+async function listMonitorSlugs(org, project, headers, fetchImpl) {
+	const slugs = [];
+	let url = `${SENTRY_API$1}/organizations/${org}/monitors/?project=${encodeURIComponent(project)}`;
+	while (url) {
+		const response = await fetchImpl(url, { headers });
+		if (!response.ok) throw new DeployError(`Listing Sentry monitors: HTTP ${response.status}.`, ["SENTRY_MONITORS_TOKEN needs alerts:read and alerts:write."]);
+		slugs.push(...MonitorList.parse(await response.json()).map((m) => m.slug));
+		url = nextPage(response.headers.get("link"));
+	}
+	return slugs;
+}
+/** Returns the slugs it deleted (or would have, on a dry run). */
+async function runPruneMonitors(options) {
+	const env = options.env ?? process.env;
+	const { app } = options;
+	if (options.tier !== "production") {
+		say([`prune-monitors: skipped on ${options.tier}; monitors are pruned against production only.`]);
+		return [];
+	}
+	const token = env.SENTRY_MONITORS_TOKEN;
+	if (!token) {
+		say(["::notice::Sentry monitor pruning skipped -- SENTRY_MONITORS_TOKEN is not configured."]);
+		return [];
+	}
+	if (!env.SENTRY_ORG) throw new DeployError("SENTRY_ORG is not set.");
+	const declared = options.declared ?? await declaredMonitorSlugs(app);
+	if (!declared) {
+		say([`prune-monitors: ${app} has no cloudflare/scheduled.ts; nothing to prune.`]);
+		return [];
+	}
+	const headers = { authorization: `Bearer ${token}` };
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const orphans = (await listMonitorSlugs(env.SENTRY_ORG, app, headers, fetchImpl)).filter((slug) => slug.startsWith(`${app}-`) && !declared.has(slug));
+	if (orphans.length === 0) {
+		say([`prune-monitors: every ${app} monitor is declared.`]);
+		return [];
+	}
+	for (const slug of orphans) {
+		if (options.dryRun) {
+			say([`Would delete Sentry monitor ${slug}`]);
+			continue;
+		}
+		const response = await fetchImpl(`${SENTRY_API$1}/projects/${env.SENTRY_ORG}/${app}/monitors/${encodeURIComponent(slug)}/`, {
+			method: "DELETE",
+			headers
+		});
+		if (!response.ok && response.status !== 404) throw new DeployError(`Deleting Sentry monitor ${slug}: HTTP ${response.status}.`);
+		say([`Deleted Sentry monitor ${slug}`]);
+	}
+	return orphans;
+}
+//#endregion
 //#region src/deploy/preflight.ts
 /**
 * `pnpm devtools deploy preflight`
@@ -1554,10 +1664,11 @@ function renderWriteEnvReport(result) {
 * Sandbox (plain Worker) always used this shape, so all three apps share one
 * deploy step.
 *
-* Steps (`write-env`, `preflight`, `plan`, `migrate`, `smoke`, `reconcile`) are
-* individually addressable for jobs that run only one. The ones that hold a
-* single credential in the job's own `env:` block and compose no env file
-* (`preflight`, `plan`, `migrate`, `smoke`, `reconcile`), and `write-env`,
+* Steps (`write-env`, `preflight`, `plan`, `migrate`, `smoke`, `reconcile`,
+* `prune-monitors`) are individually addressable for jobs that run only one.
+* The ones that hold a single credential in the job's own `env:` block and
+* compose no env file (`preflight`, `plan`, `migrate`, `smoke`, `reconcile`,
+* `prune-monitors`), and `write-env`,
 * which CREATES the file tier resolution would otherwise insist on reading,
 * run with `--no-env`.
 */
@@ -1707,6 +1818,14 @@ async function runStep(sub, rest) {
 		});
 		return true;
 	}
+	if (sub === "prune-monitors") {
+		await runPruneMonitors({
+			app: flagValue(rest, "--app") ?? "platform",
+			tier: requireTier(rest),
+			dryRun: rest.includes("--dry-run")
+		});
+		return true;
+	}
 	if (sub === "write-env") {
 		await loadRegistry();
 		const index = rest.indexOf("--source");

package/dist/launch.js

@@ -1,5 +1,5 @@
 import { C as discoverRepoRoot, E as setCliName, S as RepoNotFoundError, T as cliName, _ as installFailureLog, d as hasYes, g as stripTierFlag, h as stripNoEnvFlag, m as setNoEnv, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as isNonInteractive, s as lastSentryEventId } from "./telemetry-Bjoz29Hl.js";
-import { c as setMenuEnvHook, d as formatCommand, f as helpPath, n as bareGroupStartPath, t as catalog } from "./catalog-Dke7bQVz.js";
+import { c as setMenuEnvHook, d as formatCommand, f as helpPath, n as bareGroupStartPath, t as catalog } from "./catalog-BiXI0wyi.js";
 import { i as loadEnvSession, r as loadEnvLoad } from "./peers-B0KDkI6a.js";
 import { t as nonEmpty } from "./connection-D3XsOE3S.js";
 import { i as setDryRun, n as isDryRun, r as resolveDryRun } from "./dry-run-3IxPmCtW.js";
@@ -322,7 +322,7 @@ async function launchWith(argv, options) {
 */
 async function launch(argv) {
 	await launchWith(argv, { dispatch: async (args) => {
-		const { main } = await import("./cli-BhZ4je2D.js");
+		const { main } = await import("./cli-Cz8faASC.js");
 		await main(args);
 	} });
 }

package/env.ts

@@ -96,7 +96,22 @@ declare({
       doc:
         "A Sentry organization auth token. Deploys use it to create each " +
         "release and upload its source maps, and the smoke test uses it to " +
-        "read cron check-ins. One token serves every environment.",
+        "confirm the release landed. One token serves every environment.",
+      scope: "environment",
+      secrecy: "secret",
+      commented: true,
+    }),
+    // Read only by `deploy prune-monitors`, in its own step's `env:`: an
+    // organization token (above) can neither list nor delete Crons monitors,
+    // and one that can delete monitors and alert rules org-wide should not
+    // sit in every step of the deploy job. Without it, pruning is skipped
+    // with a notice.
+    SENTRY_MONITORS_TOKEN: define(z.string().min(1).optional(), {
+      doc:
+        "A Sentry internal integration token with Alerts: Read & Write and " +
+        "nothing else. The production deploy uses it to delete the Crons " +
+        "monitors an app no longer declares, which would otherwise alert " +
+        "on missed check-ins forever.",
       scope: "environment",
       secrecy: "secret",
       commented: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devdogsuga/backstage",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "description": "Officer and production CLI for DevDogsUGA: deploys, env sync with Bitwarden and GitHub, the migration planner role, club graphics and QR codes, GitHub rulesets and settings, and the newsletter. Ships built JS; run it anywhere with `pnpm dlx @devdogsuga/backstage` (no checkout needed to start; commands that read a checkout say so).",
@@ -41,9 +41,9 @@
     "typescript": "^6.0.3",
     "zod": "4.4.3",
     "@devdogsuga/brand": "0.1.5",
+    "@devdogsuga/events": "0.1.5",
     "@devdogsuga/newsletter": "0.1.10",
-    "@devdogsuga/telemetry": "0.1.3",
-    "@devdogsuga/events": "0.1.5"
+    "@devdogsuga/telemetry": "0.1.3"
   },
   "peerDependencies": {
     "@devdogsuga/db": "*",
@@ -64,10 +64,10 @@
     "eslint": "^9.39.5",
     "tsdown": "^0.23.0",
     "vitest": "^4.1.11",
-    "@devdogsuga/config": "0.1.2",
+    "@devdogsuga/cli-core": "0.0.0",
     "@devdogsuga/db": "0.1.3",
-    "@devdogsuga/env": "0.1.5",
-    "@devdogsuga/cli-core": "0.0.0"
+    "@devdogsuga/config": "0.1.2",
+    "@devdogsuga/env": "0.1.5"
   },
   "scripts": {
     "build": "tsdown && node scripts/write-build-info.mjs && node ../../scripts/check-bundle-imports.mjs",