@devdogsuga/backstage 0.1.4 → 0.1.6

package/dist/document-DumoZXoO.js

@@ -0,0 +1,287 @@
+//#region ../cli-core/src/env/document.ts
+/**
+* An editable `.env` that survives being edited.
+*
+* The root `.env` is not a data file. It is 150 lines of hard-won commentary
+* about which value breaks the Supabase CLI when empty, which one must stay
+* commented out, and why. A writer that parses to a Map and serializes back
+* destroys all of it on the first save.
+*
+* So this keeps the file as **lines** and edits in place. An untouched line is
+* returned byte-for-byte, including its spacing, quoting style and trailing
+* comment. Only the lines actually being changed are rewritten.
+*
+* Nothing is ever deleted. Removing a key comments it out, so the value stays
+* recoverable from the file itself, and re-adding it later uncomments that line
+* rather than appending a duplicate.
+*/
+/**
+* `KEY=value`, active. Groups: indent, `export ` prefix, key, value.
+*
+* The prefix is CAPTURED rather than skipped so an update can put it back.
+* Dropping it turns `export FOO=` into `FOO=`, which still parses here and
+* stops being exported to child processes. That shows up as a missing variable
+* three tools downstream.
+*/
+const ACTIVE = /^(\s*)((?:export\s+)?)([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/;
+/** `# KEY=value`, the commented form this tool writes and reads back. */
+const COMMENTED = /^(\s*)#\s?((?:export\s+)?)([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/;
+/**
+* Reads the value half of an assignment.
+*
+* Deliberately NOT a general dotenv parser: it does not expand `$VAR`, because
+* a stored value that means one thing in the file and another in the process
+* cannot be rotated with confidence.
+*/
+function parseValue(rest) {
+	const text = rest.trim();
+	if (text.startsWith("\"")) {
+		const end = findClosing(text, "\"");
+		if (end === -1) return unescape(text.slice(1));
+		return unescape(text.slice(1, end));
+	}
+	if (text.startsWith("'")) {
+		const end = findClosing(text, "'");
+		if (end === -1) return text.slice(1);
+		return text.slice(1, end);
+	}
+	const hash = text.search(/\s#/);
+	return (hash === -1 ? text : text.slice(0, hash)).trim();
+}
+function findClosing(text, quote) {
+	for (let i = 1; i < text.length; i += 1) {
+		if (text[i] === "\\") {
+			i += 1;
+			continue;
+		}
+		if (text[i] === quote) return i;
+	}
+	return -1;
+}
+function unescape(text) {
+	return text.replace(/\\([nrt\\"'])/g, (_, c) => c === "n" ? "\n" : c === "r" ? "\r" : c === "t" ? "	" : c);
+}
+/**
+* Splits everything after `=` into its value and its trailing comment.
+*
+* Quote-aware, because the naive "cut at the first `#`" truncates a generated
+* password into something that still looks like one. A `#` inside quotes is
+* part of the value; outside them it starts a comment only when whitespace
+* precedes it.
+*/
+function splitComment(rest) {
+	const text = rest.trimStart();
+	let after;
+	if (text.startsWith("\"") || text.startsWith("'")) {
+		const end = findClosing(text, text[0]);
+		after = end === -1 ? text.length : end + 1;
+	} else {
+		const hash = text.search(/\s#/);
+		after = hash === -1 ? text.length : hash;
+	}
+	const tail = text.slice(after);
+	const hash = tail.indexOf("#");
+	return { comment: hash === -1 ? "" : tail.slice(hash).trimEnd() };
+}
+/**
+* Recognises a stamp this tool wrote, so it is replaced rather than duplicated.
+*
+* Deliberately narrow: it matches the exact bracketed shape below and nothing
+* else, because the cost of a false positive is deleting somebody's own note.
+*/
+const STAMP = /\s*#\s*\[[a-z][a-z0-9-]* (?:pushed|pulled) \d{4}-\d{2}-\d{2}\]\s*$/;
+function stampText(stamp) {
+	return `# [${stamp.environment} ${stamp.action} ${stamp.date}]`;
+}
+function isStamp(comment) {
+	return STAMP.test(comment);
+}
+/** Always double-quoted, so a multi-line value round-trips through one line. */
+function quote(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
+}
+var EnvDocument = class EnvDocument {
+	lines;
+	/** Whether this session has already appended, so it separates only once. */
+	appended = false;
+	constructor(lines) {
+		this.lines = lines;
+	}
+	static parse(text) {
+		const lines = text.split("\n").map((raw) => {
+			const active = ACTIVE.exec(raw);
+			if (active) return {
+				raw,
+				key: active[3],
+				value: parseValue(active[4])
+			};
+			const commented = COMMENTED.exec(raw);
+			if (commented) return {
+				raw,
+				key: commented[3],
+				value: parseValue(commented[4]),
+				commented: true
+			};
+			return { raw };
+		});
+		return new EnvDocument(lines);
+	}
+	static empty() {
+		return new EnvDocument([]);
+	}
+	find(key, commented) {
+		return this.lines.findIndex((l) => l.key === key && Boolean(l.commented) === commented);
+	}
+	/** The active value, or undefined when absent or commented out. */
+	get(key) {
+		const i = this.find(key, false);
+		return i === -1 ? void 0 : this.lines[i].value;
+	}
+	/** Present and active. */
+	has(key) {
+		return this.find(key, false) !== -1;
+	}
+	/** Present, but commented out. */
+	isCommented(key) {
+		return this.find(key, false) === -1 && this.find(key, true) !== -1;
+	}
+	/** Every active assignment, in file order. */
+	entries() {
+		return this.lines.filter((l) => l.key !== void 0 && !l.commented).map((l) => [l.key, l.value]);
+	}
+	keys() {
+		return this.entries().map(([k]) => k);
+	}
+	/**
+	* Sets a value, preferring to revive a commented line over appending.
+	*
+	* Appending when a commented form already exists is how a file ends up with
+	* the same key twice: one stale, both plausible, and which one looks
+	* authoritative depends on where the reader scrolled to.
+	*/
+	set(key, value, stamp) {
+		const active = this.find(key, false);
+		if (active !== -1) {
+			const line = this.lines[active];
+			const match = ACTIVE.exec(line.raw);
+			const existing = splitComment(match[4]).comment;
+			if (stamp && existing !== "" && !isStamp(existing)) this.lines.splice(this.first(key), 0, { raw: existing });
+			const trailing = stamp ? ` ${stampText(stamp)}` : existing === "" ? "" : ` ${existing}`;
+			const at = this.find(key, false);
+			const target = this.lines[at];
+			target.raw = `${match[1]}${match[2]}${key}=${quote(value)}${trailing}`;
+			target.value = value;
+			return;
+		}
+		const commented = this.find(key, true);
+		if (commented !== -1) {
+			const line = this.lines[commented];
+			line.raw = `${key}=${quote(value)}${stamp ? ` ${stampText(stamp)}` : ""}`;
+			line.value = value;
+			line.commented = false;
+			return;
+		}
+		if (!this.appended && this.lines.length > 0 && this.lines.at(-1).raw !== "") this.lines.push({ raw: "" });
+		this.appended = true;
+		this.lines.push({
+			raw: `${key}=${quote(value)}${stamp ? ` ${stampText(stamp)}` : ""}`,
+			key,
+			value
+		});
+	}
+	/** Index of the first line mentioning a key, active or commented. */
+	first(key) {
+		return this.lines.findIndex((l) => l.key === key);
+	}
+	/**
+	* Moves every line for a key next to that key's first appearance.
+	*
+	* Files drift: a key gets commented out near the bottom, re-added at the top
+	* six weeks later, and now two lines claim the same name a hundred lines
+	* apart. Whichever one a reader scrolls to first looks authoritative.
+	*
+	* The FIRST occurrence keeps its position, so the standalone comment block
+	* documenting a key stays attached to it. Everything else moves up to join
+	* it, in the order it already had.
+	*/
+	group() {
+		const out = [];
+		const taken = /* @__PURE__ */ new Set();
+		let moved = false;
+		for (let i = 0; i < this.lines.length; i += 1) {
+			if (taken.has(i)) continue;
+			const line = this.lines[i];
+			out.push(line);
+			taken.add(i);
+			if (line.key === void 0) continue;
+			for (let j = i + 1; j < this.lines.length; j += 1) {
+				if (taken.has(j) || this.lines[j].key !== line.key) continue;
+				if (j !== i + 1 || taken.has(i + 1)) moved = true;
+				out.push(this.lines[j]);
+				taken.add(j);
+			}
+		}
+		this.lines = out;
+		return moved;
+	}
+	/**
+	* Blanks every active value without losing one.
+	*
+	* Each becomes a commented line holding what it was, plus an empty active
+	* line under it. The file still declares every key it needs, which is what
+	* makes it a usable checklist, while holding nothing.
+	*
+	* Already-empty keys are skipped. Commenting out `FOO=""` to write `FOO=""`
+	* underneath is churn that makes the next diff harder to read.
+	*/
+	reset() {
+		const out = [];
+		const cleared = [];
+		for (const line of this.lines) {
+			if (line.key === void 0 || line.commented || line.value === "") {
+				out.push(line);
+				continue;
+			}
+			const exported = ACTIVE.exec(line.raw)?.[2] ?? "";
+			line.raw = `# ${line.raw.trimStart()}`;
+			line.commented = true;
+			out.push(line);
+			out.push({
+				raw: `${exported}${line.key}=""`,
+				key: line.key,
+				value: ""
+			});
+			cleared.push(line.key);
+		}
+		this.lines = out;
+		return cleared;
+	}
+	/**
+	* Comments a key out rather than deleting it.
+	*
+	* A no-op when it is already commented or absent, so running a sync twice
+	* cannot produce `## KEY=`.
+	*/
+	comment(key) {
+		const i = this.find(key, false);
+		if (i === -1) return false;
+		const line = this.lines[i];
+		line.raw = `# ${line.raw.trimStart()}`;
+		line.commented = true;
+		return true;
+	}
+	/** Restores a commented assignment. Returns its value, or undefined. */
+	uncomment(key) {
+		const i = this.find(key, true);
+		if (i === -1) return void 0;
+		const line = this.lines[i];
+		line.raw = line.raw.replace(/^(\s*)#\s?/, "$1");
+		line.commented = false;
+		return line.value;
+	}
+	toString() {
+		return this.lines.map((l) => l.raw).join("\n");
+	}
+};
+//#endregion
+export { EnvDocument as t };

package/dist/dry-run-3IxPmCtW.js

@@ -0,0 +1,58 @@
+import { T as cliName } from "./telemetry-Bjoz29Hl.js";
+//#region ../cli-core/src/dry-run.ts
+const DRY_RUN_FLAG = "--dry-run";
+/** Commands that forward everything after their name to another tool. */
+const FORWARDING = /* @__PURE__ */ new Set([
+	"supabase",
+	"wrangler",
+	"drizzle-kit",
+	"psql",
+	"bw",
+	"run"
+]);
+let active = false;
+function setDryRun(on) {
+	active = on;
+}
+function isDryRun() {
+	return active;
+}
+/**
+* Decides whether `argv` asks for a dry run and returns the argv to dispatch.
+*
+* For a forwarding command a leading `--dry-run` is consumed (the tool never
+* sees it) and a later one is the tool's. For any other command the argv is
+* returned as it came, because several commands read `--dry-run` themselves.
+*/
+function resolveDryRun(argv) {
+	const firstPositional = argv.findIndex((arg) => !arg.startsWith("-"));
+	const lead = firstPositional === -1 ? argv.length : firstPositional;
+	const command = argv[firstPositional];
+	if (command !== void 0 && FORWARDING.has(command)) {
+		const rest = argv.filter((arg, i) => i >= lead || arg !== "--dry-run");
+		return {
+			dryRun: rest.length !== argv.length,
+			rest
+		};
+	}
+	return {
+		dryRun: argv.includes(DRY_RUN_FLAG),
+		rest: [...argv]
+	};
+}
+/**
+* How a command treats `--dry-run`, from the nearest node on its path that
+* says. `undefined` means it did not say, and the dispatcher stops it.
+*/
+function dryRunKind(catalog, path) {
+	for (let end = path.length; end > 0; end -= 1) {
+		const kind = catalog.findCommand(path.slice(0, end))?.dryRun;
+		if (kind !== void 0) return kind;
+	}
+}
+/** The command line a stopped command would have run. */
+function wouldRunLine(argv) {
+	return `Would run: ${cliName()} ${argv.join(" ")}`;
+}
+//#endregion
+export { wouldRunLine as a, setDryRun as i, isDryRun as n, resolveDryRun as r, dryRunKind as t };

package/dist/launch.js

@@ -1,8 +1,8 @@
 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-BuNLUu08.js";
+import { c as setMenuEnvHook, d as formatCommand, f as helpPath, n as bareGroupStartPath, t as catalog } from "./catalog-Dke7bQVz.js";
 import { i as loadEnvSession, r as loadEnvLoad } from "./peers-B0KDkI6a.js";
 import { t as nonEmpty } from "./connection-D3XsOE3S.js";
-import { c as setDryRun, o as isDryRun, s as resolveDryRun } from "./options-BTjOf5KP.js";
+import { i as setDryRun, n as isDryRun, r as resolveDryRun } from "./dry-run-3IxPmCtW.js";
 import { o as unwrap, r as errorMessage } from "./ui-CdKo8mLw.js";
 import { confirm } from "@clack/prompts";
 //#region ../cli-core/src/pipes.ts
@@ -322,7 +322,7 @@ async function launchWith(argv, options) {
 */
 async function launch(argv) {
 	await launchWith(argv, { dispatch: async (args) => {
-		const { main } = await import("./cli-BI5Vn9sR.js");
+		const { main } = await import("./cli-BhZ4je2D.js");
 		await main(args);
 	} });
 }

package/dist/meetings-DfU867eV.js

@@ -0,0 +1,118 @@
+import { t as UsageError } from "./ui-CdKo8mLw.js";
+import "./cli-Do2nWD7W.js";
+//#region src/production/time.ts
+/**
+* Dates as officers type them. Meetings happen in Athens, so a bare
+* `2026-09-30` means that Eastern day, never UTC's: UTC's date rolls at 20:00
+* Eastern, and the platform's old `to=` filter cut off the evening's meeting
+* on exactly the day it named.
+*/
+const EVENT_TZ = "America/New_York";
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+function isDay(text) {
+	return DAY.test(text);
+}
+/** Minutes `zone` is ahead of UTC at `at` (negative west of Greenwich). */
+function offsetMinutes(at, zone) {
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone: zone,
+		hourCycle: "h23",
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit"
+	}).formatToParts(at);
+	const get = (type) => Number(parts.find((p) => p.type === type)?.value);
+	const asUtc = Date.UTC(get("year"), get("month") - 1, get("day"), get("hour"), get("minute"), get("second"));
+	return Math.round((asUtc - at.getTime()) / 6e4);
+}
+/** Midnight at the start of `day` (YYYY-MM-DD) in {@link EVENT_TZ}. */
+function startOfDay(day, zone = EVENT_TZ) {
+	const utcMidnight = /* @__PURE__ */ new Date(`${day}T00:00:00Z`);
+	const probe = new Date(utcMidnight.getTime() + 216e5);
+	return /* @__PURE__ */ new Date(utcMidnight.getTime() - offsetMinutes(probe, zone) * 6e4);
+}
+/** Midnight at the start of the day after `day`. */
+function endOfDay(day, zone = EVENT_TZ) {
+	const next = /* @__PURE__ */ new Date(`${day}T00:00:00Z`);
+	next.setUTCDate(next.getUTCDate() + 1);
+	return startOfDay(next.toISOString().slice(0, 10), zone);
+}
+/** The Eastern calendar date of `at`, as YYYY-MM-DD. */
+function dayOf(at, zone = EVENT_TZ) {
+	return new Intl.DateTimeFormat("en-CA", {
+		timeZone: zone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	}).format(at);
+}
+/**
+* A `--from`/`--to` value: a day (the whole Eastern day, `to` inclusive) or
+* a full ISO timestamp (exact). Returns the bound to compare with: `from` is
+* inclusive, `to` exclusive.
+*/
+function parseBound(flag, text) {
+	if (!text) return void 0;
+	if (isDay(text)) return flag === "--from" ? startOfDay(text) : endOfDay(text);
+	const at = new Date(text);
+	if (/T\d{2}:\d{2}/.test(text) && !Number.isNaN(at.getTime())) return at;
+	throw new UsageError(`${flag} takes a day (2026-09-30) or a timestamp (2026-09-30T18:00:00-04:00), not "${text}".`);
+}
+//#endregion
+//#region src/production/meetings.ts
+/**
+* Naming a meeting on the command line: `--meeting <day|slug|config id|uuid>`.
+*
+* Slugs are the meeting's Eastern date (`2026-09-09`), with `-2` for a second
+* meeting that day, so a day is how officers will usually name one. A day with
+* two meetings is ambiguous and the error lists both slugs rather than picking.
+*/
+/** Live meetings an argument could mean: by id, slug or config id, or on that Eastern day. */
+const MEETING_QUERY = `
+select
+  m."id"::text as "id",
+  m."slug",
+  m."configId",
+  coalesce(m."nameOverride", m."kind", 'Meeting') as "title",
+  m."startsAt",
+  m."endsAt",
+  m."cancelledAt",
+  m."countsForCredit"
+from "platform"."meetings" m
+where m."deletedAt" is null
+  and (
+    m."id"::text = $1 or m."slug" = $1 or m."configId" = $1
+    or ($2::boolean and (m."startsAt" at time zone '${EVENT_TZ}')::date = $1::date)
+  )
+order by m."startsAt"
+`;
+function findMeetingsWith(sql) {
+	return async (named) => {
+		return (await sql.unsafe(MEETING_QUERY, [named, isDay(named)])).map((r) => ({
+			id: String(r.id),
+			slug: String(r.slug),
+			configId: r.configId ?? null,
+			title: String(r.title),
+			startsAt: r.startsAt,
+			endsAt: r.endsAt,
+			cancelledAt: r.cancelledAt ?? null,
+			countsForCredit: r.countsForCredit === true
+		}));
+	};
+}
+/** The one meeting `named` means, or a usage error saying why there isn't one. */
+function pickMeeting(named, found) {
+	const exact = found.filter((m) => m.id === named || m.slug === named || m.configId === named);
+	const candidates = exact.length > 0 ? exact : found;
+	if (candidates.length === 1) return candidates[0];
+	if (candidates.length === 0) throw new UsageError(`No meeting matches "${named}". Name it by day (2026-09-09), slug, config id or id.`);
+	throw new UsageError(`"${named}" could be ${candidates.map((m) => `${m.slug} (${m.title})`).join(" or ")}. Pass the slug.`);
+}
+function describeMeeting(m) {
+	return `${m.title}, ${dayOf(m.startsAt)} (${m.slug})`;
+}
+//#endregion
+export { parseBound as i, findMeetingsWith as n, pickMeeting as r, describeMeeting as t };

package/dist/{options-BTjOf5KP.js → options-DCaqm8BI.js}

@@ -1,59 +1,3 @@
-import { T as cliName } from "./telemetry-Bjoz29Hl.js";
-//#region ../cli-core/src/dry-run.ts
-const DRY_RUN_FLAG = "--dry-run";
-/** Commands that forward everything after their name to another tool. */
-const FORWARDING = /* @__PURE__ */ new Set([
-	"supabase",
-	"wrangler",
-	"drizzle-kit",
-	"psql",
-	"bw",
-	"run"
-]);
-let active = false;
-function setDryRun(on) {
-	active = on;
-}
-function isDryRun() {
-	return active;
-}
-/**
-* Decides whether `argv` asks for a dry run and returns the argv to dispatch.
-*
-* For a forwarding command a leading `--dry-run` is consumed (the tool never
-* sees it) and a later one is the tool's. For any other command the argv is
-* returned as it came, because several commands read `--dry-run` themselves.
-*/
-function resolveDryRun(argv) {
-	const firstPositional = argv.findIndex((arg) => !arg.startsWith("-"));
-	const lead = firstPositional === -1 ? argv.length : firstPositional;
-	const command = argv[firstPositional];
-	if (command !== void 0 && FORWARDING.has(command)) {
-		const rest = argv.filter((arg, i) => i >= lead || arg !== "--dry-run");
-		return {
-			dryRun: rest.length !== argv.length,
-			rest
-		};
-	}
-	return {
-		dryRun: argv.includes(DRY_RUN_FLAG),
-		rest: [...argv]
-	};
-}
-/**
-* How a command treats `--dry-run`, from the nearest node on its path that
-* says. `undefined` means it did not say, and the dispatcher stops it.
-*/
-function dryRunKind(catalog, path) {
-	for (let end = path.length; end > 0; end -= 1) {
-		const kind = catalog.findCommand(path.slice(0, end))?.dryRun;
-		if (kind !== void 0) return kind;
-	}
-}
-/** The command line a stopped command would have run. */
-function wouldRunLine(argv) {
-	return `Would run: ${cliName()} ${argv.join(" ")}`;
-}
 const QR_FLAGS = {
 	text: {
 		name: "text",
@@ -180,4 +124,4 @@ function qrParseOptions() {
 	return Object.fromEntries([...Object.values(QR_FLAGS), ...Object.values(QR_EXTRA_FLAGS)].map((flag) => [flag.name, { type: "string" }]));
 }
 //#endregion
-export { dryRunKind as a, setDryRun as c, qrParseOptions as i, wouldRunLine as l, QR_FLAGS as n, isDryRun as o, qrCatalogOptions as r, resolveDryRun as s, QR_EXTRA_FLAGS as t };
+export { qrParseOptions as i, QR_FLAGS as n, qrCatalogOptions as r, QR_EXTRA_FLAGS as t };