@devdogsuga/backstage 0.1.5 → 0.1.6

package/dist/commands-5Ou8xJw5.js

@@ -0,0 +1,225 @@
+import { n as isDryRun } from "./dry-run-3IxPmCtW.js";
+import { r as errorMessage, t as UsageError } from "./ui-CdKo8mLw.js";
+import { i as exportParams, n as EXPORT_KINDS, r as auditFilters, t as EXPORTS } from "./queries-DeEwfe2c.js";
+import { t as DONE } from "./dispatch-D048O65I.js";
+import { a as reportFailure, c as connect, l as dbError, o as say, r as plural, s as ProductionError, u as requireProductionKey } from "./cli-Do2nWD7W.js";
+import { i as parseBound, n as findMeetingsWith, r as pickMeeting, t as describeMeeting } from "./meetings-DfU867eV.js";
+import { open, rm } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { parseArgs, promisify } from "node:util";
+/**
+* Quotes a field only when it has to be: a comma, a quote, a carriage return
+* or a line feed. Quoting only what needs it keeps the file readable in a
+* terminal.
+*
+* A leading `=`, `+`, `-`, `@`, tab or carriage return gets a tab prefix:
+* spreadsheets start a formula on the first four, and a member can name their
+* team `=cmd|'/c calc'!A1`. The tab is invisible in a cell and neutralises it.
+*/
+function csvField(value) {
+	if (value === null || value === void 0) return "";
+	let text;
+	if (typeof value === "string") text = value;
+	else if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") text = String(value);
+	else if (value instanceof Date) text = csvTimestamp(value);
+	else text = JSON.stringify(value) ?? "";
+	const guarded = /^[=+\-@\t\r]/.test(text) ? `\t${text}` : text;
+	if (!/[",\r\n]/.test(guarded)) return guarded;
+	return `"${guarded.replace(/"/g, "\"\"")}"`;
+}
+function csvRow(values) {
+	return values.map(csvField).join(",") + "\r\n";
+}
+/**
+* ISO 8601 with an explicit offset, never a bare local time: a timestamp
+* without one is read in whatever zone the importer runs in.
+*/
+function csvTimestamp(value) {
+	if (value === null) return "";
+	const date = value instanceof Date ? value : new Date(value);
+	return Number.isNaN(date.getTime()) ? "" : date.toISOString();
+}
+//#endregion
+//#region src/export/commands.ts
+/**
+* `backstage export <stars|attendance|reflections>`: the platform's CSV
+* downloads, moved here from `/console/exports`.
+*
+*   pnpm backstage export stars --from 2026-08-17 --to 2026-12-12
+*   pnpm backstage export attendance --meeting 2026-09-09 --out -
+*
+* ## Audited, as the downloads were
+*
+* Each export writes a `platform.exportAudit` row BEFORE the first row is
+* read, as the web routes did: an export that fails halfway still put rows
+* in front of somebody. The row names the officer's platform account, found
+* through the GitHub login `gh` is signed in as (the identity they linked on
+* the platform), so an export nobody can attribute is refused rather than
+* recorded as nobody's. The row count is filled in when the file is done.
+*
+* ## The file
+*
+* Written to `./<kind>[-<meeting>][-<from>][-<to>].csv` by default, created
+* readable by its owner only (it is member PII), never over an existing file
+* without `--yes`. `--out -` streams to stdout without the byte-order mark,
+* for a pipe. A failure partway removes the partial file.
+*
+* `--from`/`--to` take Eastern days, `--to` inclusive (see `production/time.ts`).
+*/
+function parse(argv) {
+	const [kind, ...rest] = argv;
+	if (!kind || !EXPORT_KINDS.includes(kind)) throw new UsageError(kind ? `Unknown export "${kind}". Try ${EXPORT_KINDS.join(", ")}.` : `Name the export: ${EXPORT_KINDS.join(", ")}.`);
+	try {
+		const { values } = parseArgs({
+			args: rest,
+			options: {
+				from: { type: "string" },
+				to: { type: "string" },
+				meeting: { type: "string" },
+				out: { type: "string" },
+				yes: { type: "boolean" },
+				"dry-run": { type: "boolean" }
+			},
+			allowPositionals: false,
+			strict: true
+		});
+		if (values.meeting && kind !== "attendance") throw new UsageError("--meeting only applies to the attendance export.");
+		return {
+			kind,
+			values
+		};
+	} catch (err) {
+		if (err instanceof UsageError) throw err;
+		throw new UsageError(errorMessage(err));
+	}
+}
+const run = promisify(execFile);
+/** The GitHub login `gh` is signed in as. */
+async function ghLogin() {
+	try {
+		const { stdout } = await run("gh", [
+			"api",
+			"user",
+			"--jq",
+			".login"
+		]);
+		const login = stdout.trim();
+		if (login) return login;
+	} catch {}
+	throw new ProductionError("Exports are audited under your GitHub login, and `gh` could not say who you are. Install it from https://cli.github.com and run `gh auth login`.");
+}
+const OFFICER_QUERY = `
+select distinct i."user_id"::text as "userId"
+from "auth"."identities" i
+where i."provider" = 'github'
+  and lower(i."identity_data" ->> 'user_name') = lower($1)
+`;
+function sourceWith(sql) {
+	return {
+		officersFor: async (login) => (await sql.unsafe(OFFICER_QUERY, [login])).map((r) => String(r.userId)),
+		findMeetings: findMeetingsWith(sql),
+		audit: async (userId, kind, filters) => {
+			const [row] = await sql.unsafe(`insert into "platform"."exportAudit" ("userId", "kind", "filters")
+         values ($1, $2, $3::text::jsonb) returning "id"::text as "id"`, [
+				userId,
+				kind,
+				JSON.stringify(filters)
+			]);
+			return String(row.id);
+		},
+		rows: (kind, filters) => sql.unsafe(EXPORTS[kind].sql, exportParams(filters)).cursor(500),
+		finish: async (auditId, rowCount) => {
+			await sql.unsafe(`update "platform"."exportAudit" set "rowCount" = $1 where "id" = $2::uuid`, [rowCount, auditId]);
+		},
+		close: () => sql.end({ timeout: 5 })
+	};
+}
+async function productionSource() {
+	return sourceWith(connect(await requireProductionKey("DB_URL")));
+}
+async function fileSink(path, overwrite) {
+	if (path === "-") return {
+		write: (text) => new Promise((resolve, reject) => process.stdout.write(text, (err) => err ? reject(err) : resolve())),
+		close: () => Promise.resolve(),
+		discard: () => Promise.resolve()
+	};
+	let handle;
+	try {
+		handle = await open(path, overwrite ? "w" : "wx", 384);
+	} catch (err) {
+		if (err.code === "EEXIST") throw new UsageError(`${path} already exists. Pass --yes to replace it.`);
+		throw new UsageError(`Could not write ${path}.`);
+	}
+	await handle.write("");
+	return {
+		write: async (text) => {
+			await handle.write(text);
+		},
+		close: () => handle.close(),
+		discard: async () => {
+			await handle.close().catch(() => void 0);
+			await rm(path, { force: true });
+		}
+	};
+}
+function defaultPath(kind, values, meetingSlug) {
+	const parts = [kind];
+	if (meetingSlug) parts.push(meetingSlug);
+	if (values.from) parts.push(values.from.slice(0, 10));
+	if (values.to) parts.push(values.to.slice(0, 10));
+	return `${parts.join("-")}.csv`;
+}
+async function runExport(argv, deps = {}) {
+	let source;
+	let sink;
+	let done = false;
+	try {
+		const { kind, values } = parse(argv);
+		const filters = {
+			from: parseBound("--from", values.from),
+			to: parseBound("--to", values.to)
+		};
+		if (filters.from && filters.to && filters.from >= filters.to) throw new UsageError("--from must come before --to.");
+		const login = await (deps.ghLogin ?? ghLogin)();
+		source = await (deps.source ?? productionSource)();
+		const officers = await source.officersFor(login);
+		if (officers.length !== 1) throw new ProductionError(officers.length === 0 ? `No platform account has linked the GitHub login ${login}. Link GitHub on your platform profile, then export again.` : `${plural(officers.length, "platform account")} linked the GitHub login ${login}; an export must be attributable to one.`);
+		let slug;
+		if (values.meeting) {
+			const meeting = pickMeeting(values.meeting, await source.findMeetings(values.meeting));
+			filters.meetingId = meeting.id;
+			slug = meeting.slug;
+			say(`Meeting: ${describeMeeting(meeting)}.`);
+		}
+		const path = values.out ?? defaultPath(kind, values, slug);
+		if (values["dry-run"] === true || isDryRun()) {
+			say(`Would export ${kind} to ${path === "-" ? "stdout" : path}, audited as ${login}.`);
+			return;
+		}
+		sink = await (deps.sink ?? fileSink)(path, values.yes === true);
+		const auditId = await source.audit(officers[0], kind, auditFilters(filters));
+		const { columns } = EXPORTS[kind];
+		await sink.write(csvRow(columns));
+		let count = 0;
+		for await (const page of source.rows(kind, filters)) {
+			await sink.write(page.map((row) => csvRow(columns.map((c) => row[c]))).join(""));
+			count += page.length;
+		}
+		await sink.close();
+		done = true;
+		await source.finish(auditId, count);
+		say(`Exported ${plural(count, "row")} to ${path === "-" ? "stdout" : path}.`, "success");
+	} catch (err) {
+		if (sink && !done) await sink.discard().catch(() => void 0);
+		const worded = err instanceof UsageError || err instanceof ProductionError ? err : err.code ? dbError("The export failed", err) : err;
+		reportFailure("export", worded);
+	} finally {
+		await source?.close().catch(() => void 0);
+	}
+}
+const handleExport = async (rest) => {
+	await runExport(rest);
+	return process.exitCode ? null : DONE;
+};
+//#endregion
+export { handleExport };

package/dist/commands-BQ2NIqub.js

@@ -0,0 +1,436 @@
+import { n as isDryRun } from "./dry-run-3IxPmCtW.js";
+import { o as unwrap, r as errorMessage, t as UsageError } from "./ui-CdKo8mLw.js";
+import { t as DONE } from "./dispatch-D048O65I.js";
+import { a as reportFailure, c as connect, d as withConnection, i as readInputFile, n as confirmWrite, o as say, r as plural, s as ProductionError, t as canPrompt, u as requireProductionKey } from "./cli-Do2nWD7W.js";
+import { a as createAccounts, i as createAccountFor, n as accountFinder, r as accountsWith, t as parseCsv } from "./read-B-aJJewb.js";
+import { n as findMeetingsWith, r as pickMeeting, t as describeMeeting } from "./meetings-DfU867eV.js";
+import { text } from "@clack/prompts";
+import { parseArgs } from "node:util";
+//#region src/attendance/plan.ts
+/**
+* What an attendance import would do to one meeting, before anything is
+* written.
+*
+* A member's own check-in (`qr`, `manual_code`) is never touched: the sheet
+* can only add the people who could not check in. Imported rows carry method
+* `import`, so `--replace` can find exactly the rows an earlier import wrote
+* and remove the ones the corrected sheet no longer lists.
+*/
+const IMPORT_METHOD = "import";
+function planAttendance(attendees, accounts, existing, replace) {
+	const find = accountFinder(accounts);
+	const methodOf = new Map(existing.map((e) => [e.userId, e.method]));
+	const plan = {
+		record: [],
+		create: [],
+		cannotCreate: [],
+		checkedIn: [],
+		imported: [],
+		remove: []
+	};
+	const onSheet = /* @__PURE__ */ new Set();
+	for (const attendee of attendees) {
+		const account = find(attendee.email);
+		if (!account) {
+			(attendee.name ? plan.create : plan.cannotCreate).push(attendee);
+			continue;
+		}
+		if (onSheet.has(account.userId)) continue;
+		onSheet.add(account.userId);
+		const match = {
+			attendee,
+			userId: account.userId
+		};
+		const method = methodOf.get(account.userId);
+		if (method === void 0) plan.record.push(match);
+		else if (method === "import") plan.imported.push(match);
+		else plan.checkedIn.push({
+			...match,
+			method
+		});
+	}
+	if (replace) {
+		const byId = new Map(accounts.map((a) => [a.userId, a]));
+		for (const e of existing) {
+			if (e.method !== "import" || onSheet.has(e.userId)) continue;
+			const account = byId.get(e.userId);
+			plan.remove.push({
+				userId: e.userId,
+				name: account?.preferredName?.trim() ?? account?.ugaEmail ?? account?.authEmail ?? e.userId
+			});
+		}
+		plan.remove.sort((a, b) => a.name.localeCompare(b.name));
+	}
+	return plan;
+}
+//#endregion
+//#region src/attendance/sheet.ts
+/**
+* Reading a sign-in sheet: a Google or Microsoft Forms response export, or a
+* spreadsheet an officer typed up. There is no fixed layout, so the columns
+* are found rather than assumed:
+*
+* - the header is the first row (of the first ten) that names a column with
+*   "email" or "name" and holds no addresses itself;
+* - the email column is `--email-column`, else the header mentioning "email"
+*   whose values are most often UGA addresses (a form can have both the
+*   respondent's account email and a "UGA email" question), else whichever
+*   column holds the most addresses;
+* - the name is `--name-column`, else "First Name" + "Last Name", else the
+*   first header mentioning "name" that is not an email or username column.
+*   It is optional: it only matters when an account has to be created.
+*
+* A sheet with no header at all (a pasted list of addresses) is read as every
+* address in every cell.
+*
+* Only UGA (MyID) addresses are imported: that is the address an account is
+* created for and the one members sign in with. Anything else is reported.
+*/
+const ADDRESS = /[^\s<>,;:"'()[\]]+@[^\s<>,;:"'()[\]]+\.[a-z]{2,}/i;
+const UGA = /@uga\.edu$/i;
+function addressIn(cell) {
+	const match = ADDRESS.exec(cell ?? "");
+	return match ? match[0].toLowerCase() : null;
+}
+const norm = (h) => h.trim().toLowerCase();
+function findHeader(rows, options) {
+	const wanted = [options.emailColumn, options.nameColumn].filter((c) => !!c).map(norm);
+	for (let i = 0; i < Math.min(rows.length, 10); i += 1) {
+		const cells = rows[i].map(norm);
+		if (wanted.length > 0) {
+			if (wanted.every((w) => cells.includes(w))) return i;
+			continue;
+		}
+		if (cells.some((c) => c.includes("@"))) continue;
+		if (cells.some((c) => /e-?mail|\bname\b/.test(c))) return i;
+	}
+	if (wanted.length > 0) throw new UsageError(`No header row names ${wanted.map((w) => `"${w}"`).join(" and ")}.`);
+	return -1;
+}
+function columnNamed(header, name) {
+	const i = header.map(norm).indexOf(norm(name));
+	if (i < 0) throw new UsageError(`No column called "${name}". The columns are: ${header.map((h) => `"${h.trim()}"`).join(", ")}.`);
+	return i;
+}
+function emailColumn(header, body, options) {
+	if (options.emailColumn) return columnNamed(header, options.emailColumn);
+	const count = (i, test) => body.filter((r) => test.test(addressIn(r[i]) ?? "")).length;
+	const named = header.map((h, i) => ({
+		i,
+		h: norm(h)
+	})).filter(({ h }) => /e-?mail/.test(h)).map(({ i }) => i);
+	const best = (named.length > 0 ? named : header.map((_, i) => i)).map((i) => ({
+		i,
+		uga: count(i, UGA),
+		any: count(i, /@/)
+	})).sort((a, b) => b.uga - a.uga || b.any - a.any || a.i - b.i)[0];
+	if (!best || best.any === 0) throw new UsageError("Could not find a column of email addresses. Name it with --email-column.");
+	return best.i;
+}
+/** The name for a row, or how to build it. */
+function nameReader(header, options) {
+	const at = (i) => (row) => row[i]?.trim() ? row[i].trim() : null;
+	if (options.nameColumn) {
+		const i = columnNamed(header, options.nameColumn);
+		return {
+			label: header[i].trim(),
+			read: at(i)
+		};
+	}
+	const cells = header.map(norm);
+	const first = cells.findIndex((c) => c.includes("first") && c.includes("name"));
+	const last = cells.findIndex((c) => c.includes("last") && c.includes("name"));
+	if (first >= 0 && last >= 0) return {
+		label: `${header[first].trim()} + ${header[last].trim()}`,
+		read: (row) => {
+			return [row[first], row[last]].map((v) => v?.trim()).filter(Boolean).join(" ") || null;
+		}
+	};
+	const i = cells.findIndex((c) => /\bname\b/.test(c) && !/e-?mail|user/.test(c));
+	return i >= 0 ? {
+		label: header[i].trim(),
+		read: at(i)
+	} : {
+		label: null,
+		read: () => null
+	};
+}
+function parseSheet(text, options = {}) {
+	const rows = parseCsv(text);
+	const headerAt = findHeader(rows, options);
+	const out = {
+		attendees: [],
+		emailColumn: null,
+		nameColumn: null,
+		notUga: [],
+		missingEmail: [],
+		duplicates: 0
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const add = (email, name, line) => {
+		if (!UGA.test(email)) out.notUga.push({
+			email,
+			line
+		});
+		else if (seen.has(email)) out.duplicates += 1;
+		else {
+			seen.add(email);
+			out.attendees.push({
+				email,
+				name,
+				line
+			});
+		}
+	};
+	if (headerAt < 0) {
+		rows.forEach((row, i) => {
+			for (const cell of row) {
+				const email = addressIn(cell);
+				if (email) add(email, null, i + 1);
+			}
+		});
+		return out;
+	}
+	const header = rows[headerAt];
+	const body = rows.slice(headerAt + 1);
+	const emailAt = emailColumn(header, body, options);
+	const name = nameReader(header, options);
+	out.emailColumn = header[emailAt].trim() || `column ${emailAt + 1}`;
+	out.nameColumn = name.label;
+	body.forEach((row, i) => {
+		const line = headerAt + i + 2;
+		if (row.every((c) => !c.trim())) return;
+		const email = addressIn(row[emailAt]);
+		if (!email) {
+			out.missingEmail.push(line);
+			return;
+		}
+		add(email, name.read(row), line);
+	});
+	return out;
+}
+//#endregion
+//#region src/attendance/store.ts
+/**
+* Production reads and writes for `import attendance`.
+*
+* Accounts are created before {@link applyAttendance} (Auth is a separate
+* service). If the transaction then fails, they exist without profiles or
+* check-ins; rerunning the import finds them by sign-in address and records
+* them, so a rerun is the recovery.
+*/
+async function readCheckIns(sql, meetingId) {
+	return (await sql.unsafe(`select "userId"::text as "userId", "method"::text as "method"
+     from "platform"."attendance" where "meetingId" = $1::uuid`, [meetingId])).map((r) => ({
+		userId: String(r.userId),
+		method: String(r.method)
+	}));
+}
+/**
+* Whether production's `checkInMethod` has `import` yet. It arrives with a
+* DevDogsUGA migration; an import run before that deploy would fail on the
+* first insert with an enum error, so it is checked up front and worded.
+*/
+async function requireImportMethod(sql) {
+	const [row] = await sql.unsafe(`select $1 = any(enum_range(null::"platform"."checkInMethod")::text[]) as "ok"`, [IMPORT_METHOD]);
+	if (row?.ok !== true) throw new ProductionError("Production cannot record imported check-ins yet: its checkInMethod has no 'import' value. Deploy the DevDogsUGA migration that adds it first.");
+}
+function applyAttendanceFor(url) {
+	return (w) => withConnection(url, "The import was rolled back", (sql) => sql.begin(async (tx) => {
+		if (w.profiles.length > 0) await tx.unsafe(`insert into "platform"."profile" ("userId", "preferredName", "ugaEmail")
+             select * from unnest($1::uuid[], $2::text[], $3::text[])
+             on conflict ("userId") do nothing`, [
+			w.profiles.map((p) => p.userId),
+			w.profiles.map((p) => p.name),
+			w.profiles.map((p) => p.email)
+		]);
+		let removed = 0;
+		if (w.replace) removed = (await tx.unsafe(`delete from "platform"."attendance"
+               where "meetingId" = $1::uuid
+                 and "method" = $2
+                 and not ("userId" = any($3::uuid[]))`, [
+			w.meetingId,
+			IMPORT_METHOD,
+			w.userIds
+		])).count;
+		return {
+			recorded: (await tx.unsafe(`insert into "platform"."attendance" ("meetingId", "userId", "method", "recordedAt")
+             select $1::uuid, u, $2::"platform"."checkInMethod", $3::timestamptz
+             from unnest($4::uuid[]) as u
+             on conflict ("meetingId", "userId") do nothing`, [
+				w.meetingId,
+				IMPORT_METHOD,
+				w.recordedAt.toISOString(),
+				w.userIds
+			])).count,
+			removed
+		};
+	}));
+}
+//#endregion
+//#region src/attendance/commands.ts
+/**
+* `backstage import attendance --meeting <day> --file <sheet.csv>`: record a
+* meeting's attendance from a sign-in sheet, for the members who could not
+* check in on the platform (a dead QR code, no phone, the code rotated past).
+*
+* The sheet is a Google or Microsoft Forms response export or a hand-made
+* spreadsheet, saved as CSV; `sheet.ts` finds the email and name columns
+* (or take `--email-column`/`--name-column`). One sheet is one meeting,
+* named with `--meeting`.
+*
+* 1. read the sheet; only UGA addresses count;
+* 2. find the meeting (not cancelled, not in the future) and its check-ins;
+* 3. preview who is recorded, who needs an account, who checked in already,
+*    and with `--replace` whose earlier imported row goes; then ask;
+* 4. create the missing accounts, then one transaction writes their profiles
+*    and the check-ins (method `import`, stamped with the meeting's start).
+*
+* Rerunning the same sheet records nothing new. `--replace` makes the sheet
+* the whole set of imported check-ins for the meeting, for a corrected sheet;
+* a member's own check-in is never removed or overwritten either way.
+*/
+function parse(argv) {
+	try {
+		return parseArgs({
+			args: [...argv],
+			options: {
+				meeting: { type: "string" },
+				file: { type: "string" },
+				"email-column": { type: "string" },
+				"name-column": { type: "string" },
+				replace: { type: "boolean" },
+				yes: { type: "boolean" },
+				"dry-run": { type: "boolean" }
+			},
+			allowPositionals: false,
+			strict: true
+		}).values;
+	} catch (err) {
+		throw new UsageError(errorMessage(err));
+	}
+}
+async function productionSource() {
+	const sql = connect(await requireProductionKey("DB_URL"));
+	return {
+		findMeetings: findMeetingsWith(sql),
+		checkIns: (id) => readCheckIns(sql, id),
+		accounts: () => accountsWith(sql),
+		requireImportMethod: () => requireImportMethod(sql),
+		close: () => sql.end({ timeout: 5 })
+	};
+}
+const who = (a) => a.name ? `${a.name} <${a.email}>` : a.email;
+function describePlan(meeting, sheet, plan, replace) {
+	const lines = [
+		`Meeting: ${describeMeeting(meeting)}${meeting.countsForCredit ? "" : " (does not count for credit)"}`,
+		sheet.emailColumn ? `Sheet: ${plural(sheet.attendees.length, "UGA address", "UGA addresses")} from "${sheet.emailColumn}"` + (sheet.nameColumn ? `, names from "${sheet.nameColumn}"` : ", no name column") : `Sheet: no header; ${plural(sheet.attendees.length, "UGA address", "UGA addresses")} found in its cells`,
+		`  ${plan.record.length} to record (have an account)`,
+		`  ${plan.create.length} to create an account for, then record`,
+		`  ${plan.checkedIn.length} checked in themselves (left as is)`,
+		`  ${plan.imported.length} imported before (left as is)`
+	];
+	if (replace) lines.push(`  ${plan.remove.length} imported before but not on this sheet, to remove`);
+	const section = (title, items) => {
+		if (items.length > 0) lines.push("", title, ...items.map((i) => `  ${i}`));
+	};
+	section("To record:", plan.record.map((m) => who(m.attendee)));
+	section("New accounts:", plan.create.map(who));
+	section("To remove:", plan.remove.map((r) => r.name));
+	section("Skipped, no account and no name on the sheet to create one with:", plan.cannotCreate.map((a) => `${a.email} (line ${a.line})`));
+	section("Skipped, not a UGA address:", sheet.notUga.map((n) => `${n.email} (line ${n.line})`));
+	if (sheet.missingEmail.length > 0) section("Skipped, no address:", [`lines ${sheet.missingEmail.join(", ")}`]);
+	return lines.join("\n");
+}
+async function runAttendance(argv, deps = {}) {
+	const interactive = deps.interactive ?? canPrompt();
+	let source;
+	try {
+		const values = parse(argv);
+		const dryRun = values["dry-run"] === true || isDryRun();
+		const replace = values.replace === true;
+		let named = values.meeting;
+		if (!named) {
+			if (!interactive) throw new UsageError("Name the meeting with --meeting <day|slug>, e.g. --meeting 2026-09-09.");
+			named = unwrap(await text({
+				message: "Which meeting? Its day or slug",
+				placeholder: "2026-09-09",
+				validate: (v) => v?.trim() ? void 0 : "A day or slug, please."
+			})).trim();
+		}
+		const sheet = parseSheet(await readInputFile(values.file, {
+			interactive,
+			message: "Path to the sign-in sheet (CSV)",
+			placeholder: "sign-in.csv",
+			read: deps.readFile
+		}), {
+			emailColumn: values["email-column"],
+			nameColumn: values["name-column"]
+		});
+		if (sheet.attendees.length === 0 && !replace) throw new UsageError("The sheet has no UGA addresses to record.");
+		if (sheet.duplicates > 0) say(`${plural(sheet.duplicates, "repeat row")} for an address already read, ignored.`, "warn");
+		source = await (deps.source ?? productionSource)();
+		const meeting = pickMeeting(named, await source.findMeetings(named));
+		if (meeting.cancelledAt) throw new UsageError(`${describeMeeting(meeting)} was cancelled.`);
+		const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+		if (meeting.startsAt > now) throw new UsageError(`${describeMeeting(meeting)} has not started yet.`);
+		const [checkIns, accounts] = await Promise.all([source.checkIns(meeting.id), source.accounts()]);
+		const plan = planAttendance(sheet.attendees, accounts, checkIns, replace);
+		process.stderr.write(`${describePlan(meeting, sheet, plan, replace)}\n`);
+		if (dryRun) {
+			say("Dry run: nothing written.");
+			return;
+		}
+		if (plan.record.length + plan.create.length + plan.remove.length === 0) {
+			say("Nothing to change.");
+			return;
+		}
+		await source.requireImportMethod();
+		const question = `Record ${plural(plan.record.length + plan.create.length, "check-in")} for ${meeting.slug}` + (plan.create.length > 0 ? `, creating ${plural(plan.create.length, "account")}` : "") + (replace ? `, removing ${plan.remove.length}` : "") + "?";
+		if (!await confirmWrite(question, {
+			yes: values.yes === true,
+			interactive
+		})) {
+			say("Nothing written.");
+			return;
+		}
+		let create = deps.createAccount;
+		if (!create && plan.create.length > 0) create = createAccountFor(await requireProductionKey("API_URL"), await requireProductionKey("SECRET_KEY"));
+		const { created, failed } = create ? await createAccounts(plan.create.map((a) => a.email), create) : {
+			created: /* @__PURE__ */ new Map(),
+			failed: []
+		};
+		if (failed.length > 0) say(`Could not create ${plural(failed.length, "account")}; rerun the import to record them:\n${failed.map((f) => `  ${f.email}: ${f.reason}`).join("\n")}`, "warn");
+		const profiles = plan.create.flatMap((a) => {
+			const userId = created.get(a.email);
+			return userId ? [{
+				userId,
+				email: a.email,
+				name: a.name
+			}] : [];
+		});
+		const { recorded, removed } = await (deps.apply ?? applyAttendanceFor(await requireProductionKey("DB_URL")))({
+			meetingId: meeting.id,
+			recordedAt: meeting.startsAt,
+			profiles,
+			userIds: [
+				...plan.record,
+				...plan.checkedIn,
+				...plan.imported
+			].map((m) => m.userId).concat(profiles.map((p) => p.userId)),
+			replace
+		});
+		say(`Recorded ${plural(recorded, "check-in")} for ${meeting.slug}` + (profiles.length > 0 ? ` (${plural(profiles.length, "new account")})` : "") + (replace ? `, removed ${removed}` : "") + ".", "success");
+		if (failed.length > 0) process.exitCode = 1;
+	} catch (err) {
+		reportFailure("import attendance", err, [ProductionError]);
+	} finally {
+		await source?.close().catch(() => void 0);
+	}
+}
+const handleAttendance = async (rest) => {
+	await runAttendance(rest);
+	return process.exitCode ? null : DONE;
+};
+//#endregion
+export { handleAttendance };