@agi-ventures-canada/hackathon-cli 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,711 @@
+import { o as REQUEST_TIMEOUT_MS, s as VERSION } from "./_chunks/constants.mjs";
+import { a as AuthError, i as ApiError, n as loadConfig, o as ConfigError, s as ScopeError } from "./_chunks/config.mjs";
+import pc from "picocolors";
+//#region src/client.ts
+var OatmealClient = class {
+	baseUrl;
+	apiKey;
+	constructor(options) {
+		this.baseUrl = options.baseUrl.replace(/\/$/, "");
+		this.apiKey = options.apiKey;
+	}
+	async get(path, options) {
+		return this.request(path, {
+			...options,
+			method: "GET"
+		});
+	}
+	async post(path, body, options) {
+		return this.request(path, {
+			...options,
+			method: "POST",
+			body
+		});
+	}
+	async patch(path, body, options) {
+		return this.request(path, {
+			...options,
+			method: "PATCH",
+			body
+		});
+	}
+	async delete(path, options) {
+		return this.request(path, {
+			...options,
+			method: "DELETE"
+		});
+	}
+	async request(path, options = {}) {
+		const { method = "GET", body, params, timeout = REQUEST_TIMEOUT_MS } = options;
+		let url = `${this.baseUrl}${path}`;
+		if (params) {
+			const searchParams = new URLSearchParams();
+			for (const [key, value] of Object.entries(params)) if (value !== void 0) searchParams.set(key, String(value));
+			const qs = searchParams.toString();
+			if (qs) url += `?${qs}`;
+		}
+		const headers = {};
+		if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+		if (body !== void 0) headers["Content-Type"] = "application/json";
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeout);
+		try {
+			const response = await this.fetchWithRetry(url, {
+				method,
+				headers,
+				body: body !== void 0 ? JSON.stringify(body) : void 0,
+				signal: controller.signal
+			});
+			clearTimeout(timer);
+			if (response.status === 204) return;
+			const contentType = response.headers.get("content-type") ?? "";
+			let data;
+			if (contentType.includes("application/json")) data = await response.json();
+			else data = { message: await response.text() };
+			if (!response.ok) this.handleErrorResponse(response.status, data);
+			return data;
+		} catch (error) {
+			clearTimeout(timer);
+			if (error instanceof ApiError || error instanceof AuthError || error instanceof ScopeError) throw error;
+			if (error instanceof DOMException && error.name === "AbortError") throw new ApiError(0, `Request timed out after ${timeout / 1e3}s`);
+			if (error instanceof TypeError && (error.message.includes("fetch") || error.message.includes("network"))) throw new ApiError(0, `Could not connect to ${this.baseUrl}. Is the server running?`);
+			throw new ApiError(0, `Network error: ${error.message}`);
+		}
+	}
+	async fetchWithRetry(url, init, retried = false) {
+		const response = await fetch(url, init);
+		if (response.status === 429 && !retried) {
+			const retryAfter = response.headers.get("retry-after");
+			const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 1e3;
+			await new Promise((resolve) => setTimeout(resolve, Math.min(delay, 1e4)));
+			return this.fetchWithRetry(url, init, true);
+		}
+		return response;
+	}
+	handleErrorResponse(status, data) {
+		const body = data;
+		const message = body?.error || body?.message || `Request failed`;
+		if (status === 401) throw new AuthError(message);
+		if (status === 403) {
+			const scope = body?.requiredScope;
+			if (scope) throw new ScopeError(scope, body?.currentScopes);
+			throw new ApiError(403, message);
+		}
+		if (status === 404) throw new ApiError(404, body?.message ? message : "Resource not found");
+		if (status === 429) throw new ApiError(429, "Rate limited. Please try again later.", "Wait a moment before retrying.");
+		throw new ApiError(status, message);
+	}
+};
+//#endregion
+//#region src/output.ts
+const noColor = !!process.env.NO_COLOR;
+function color(fn, s) {
+	return noColor ? s : fn(s);
+}
+function formatTable(rows, columns) {
+	if (rows.length === 0) return "";
+	const widths = columns.map((col) => {
+		const headerWidth = col.label.length;
+		const maxDataWidth = rows.reduce((max, row) => {
+			const val = String(row[col.key] ?? "");
+			return Math.max(max, val.length);
+		}, 0);
+		return col.width ?? Math.min(Math.max(headerWidth, maxDataWidth), 50);
+	});
+	const header = columns.map((col, i) => col.label.padEnd(widths[i])).join("  ");
+	const separator = widths.map((w) => "─".repeat(w)).join("──");
+	const dataRows = rows.map((row) => columns.map((col, i) => {
+		const val = String(row[col.key] ?? "");
+		return val.length > widths[i] ? val.slice(0, widths[i] - 1) + "…" : val.padEnd(widths[i]);
+	}).join("  "));
+	return [
+		color(pc.bold, header),
+		separator,
+		...dataRows
+	].join("\n");
+}
+function formatJson(data) {
+	return JSON.stringify(data, null, 2);
+}
+function formatDetail(fields) {
+	const maxLabel = fields.reduce((max, f) => Math.max(max, f.label.length), 0);
+	return fields.map((f) => `${color(pc.bold, f.label.padEnd(maxLabel))}  ${f.value ?? color(pc.dim, "—")}`).join("\n");
+}
+function formatError(error) {
+	const lines = [color(pc.red, `Error: ${error.message}`)];
+	if (error.hint) lines.push(color(pc.dim, `Hint: ${error.hint}`));
+	return lines.join("\n");
+}
+function formatSuccess(message) {
+	return color(pc.green, `✓ ${message}`);
+}
+function formatWarning(message) {
+	return color(pc.yellow, `⚠ ${message}`);
+}
+//#endregion
+//#region src/cli.ts
+function parseGlobalFlags(args) {
+	const flags = {
+		json: false,
+		yes: false,
+		help: false
+	};
+	const rest = [];
+	for (let i = 0; i < args.length; i++) switch (args[i]) {
+		case "--json":
+			flags.json = true;
+			break;
+		case "--yes":
+		case "-y":
+			flags.yes = true;
+			break;
+		case "--base-url":
+			flags.baseUrl = args[++i];
+			break;
+		case "--api-key":
+			flags.apiKey = args[++i];
+			break;
+		case "--help":
+		case "-h":
+			flags.help = true;
+			break;
+		case "--version":
+		case "-v":
+			console.log(VERSION);
+			process.exit(0);
+			break;
+		default: rest.push(args[i]);
+	}
+	return {
+		flags,
+		rest
+	};
+}
+function createPublicClient(flags) {
+	const config = loadConfig();
+	return new OatmealClient({ baseUrl: flags.baseUrl ?? config?.baseUrl ?? "https://oatmeal.app" });
+}
+function createAuthenticatedClient(flags) {
+	const apiKey = flags.apiKey ?? process.env.OATMEAL_API_KEY;
+	if (apiKey) return new OatmealClient({
+		baseUrl: flags.baseUrl ?? "https://oatmeal.app",
+		apiKey
+	});
+	const config = loadConfig();
+	if (!config?.apiKey) throw new AuthError();
+	return new OatmealClient({
+		baseUrl: flags.baseUrl ?? config.baseUrl,
+		apiKey: config.apiKey
+	});
+}
+const BANNER = `
+  ${pc.bold("oatmeal")} — CLI for the Oatmeal hackathon platform
+
+  ${pc.dim("USAGE")}
+    oatmeal <command> [options]
+
+  ${pc.dim("PUBLIC COMMANDS (no auth required)")}
+    browse hackathons          Search public hackathons
+    browse submissions <slug>  View submissions for a hackathon
+    browse results <slug>      View published results
+    browse org <slug>          View organization profile
+
+  ${pc.dim("AUTH")}
+    login                      Sign in via browser or API key
+    logout                     Remove saved credentials
+    whoami                     Show current auth info
+
+  ${pc.dim("HACKATHON MANAGEMENT (auth required)")}
+    hackathons list            List your hackathons
+    hackathons get <id>        Get hackathon details
+    hackathons create          Create a hackathon
+    hackathons update <id>     Update a hackathon
+    hackathons delete <id>     Delete a hackathon
+
+  ${pc.dim("JUDGING")}
+    judging criteria list <id>              List criteria
+    judging criteria create <id>            Create criteria
+    judging criteria update <id> <cid>      Update criteria
+    judging criteria delete <id> <cid>      Delete criteria
+    judging judges list <id>                List judges
+    judging judges add <id>                 Add a judge
+    judging judges remove <id> <pid>        Remove a judge
+    judging assignments list <id>           List assignments
+    judging assignments create <id>         Create assignment
+    judging assignments delete <id> <aid>   Delete assignment
+    judging auto-assign <id>                Auto-assign judges
+    judging invitations list <id>           List invitations
+    judging invitations cancel <id> <iid>   Cancel invitation
+    judging pick-results <id>               View pick results
+
+  ${pc.dim("PRIZES")}
+    prizes list <id>                         List prizes
+    prizes create <id>                       Create a prize
+    prizes update <id> <pid>                 Update a prize
+    prizes delete <id> <pid>                 Delete a prize
+    prizes reorder <id>                      Reorder prizes
+    prizes assign <id> <pid>                 Assign prize
+    prizes unassign <id> <pid> <sid>         Unassign prize
+
+  ${pc.dim("JUDGE DISPLAY")}
+    judge-display list <id>             List display profiles
+    judge-display create <id>           Create display profile
+    judge-display update <id> <jid>     Update display profile
+    judge-display delete <id> <jid>     Delete display profile
+    judge-display reorder <id>          Reorder profiles
+
+  ${pc.dim("RESULTS")}
+    results calculate <id>     Calculate results
+    results get <id>           Get detailed results
+    results publish <id>       Publish results
+    results unpublish <id>     Unpublish results
+
+  ${pc.dim("WEBHOOKS")}
+    webhooks list              List webhooks
+    webhooks create            Create a webhook
+    webhooks delete <id>       Delete a webhook
+
+  ${pc.dim("JOBS")}
+    jobs list                  List jobs
+    jobs get <id>              Get job details
+    jobs create                Create a job
+    jobs result <id>           Get job result
+    jobs cancel <id>           Cancel a job
+
+  ${pc.dim("SCHEDULES")}
+    schedules list             List schedules
+    schedules create           Create a schedule
+    schedules get <id>         Get schedule details
+    schedules update <id>      Update a schedule
+    schedules delete <id>      Delete a schedule
+
+  ${pc.dim("GLOBAL OPTIONS")}
+    --json           Output as JSON
+    --yes, -y        Skip confirmation prompts
+    --base-url       API base URL
+    --api-key        API key (overrides config)
+    --help, -h       Show help
+    --version, -v    Show version
+`;
+async function main() {
+	const { flags, rest } = parseGlobalFlags(process.argv.slice(2));
+	if (rest.length === 0 || flags.help) {
+		console.log(BANNER);
+		return;
+	}
+	const command = rest[0];
+	const sub = rest[1];
+	const sub2 = rest[2];
+	try {
+		switch (command) {
+			case "login": {
+				const { runLogin } = await import("./_chunks/login.mjs");
+				await runLogin(rest.slice(1).concat(flags.yes ? ["--yes"] : []).concat(flags.baseUrl ? ["--base-url", flags.baseUrl] : []).concat(flags.apiKey ? ["--api-key", flags.apiKey] : []));
+				break;
+			}
+			case "logout": {
+				const { runLogout } = await import("./_chunks/logout.mjs");
+				await runLogout();
+				break;
+			}
+			case "whoami": {
+				const client = createAuthenticatedClient(flags);
+				const { runWhoAmI } = await import("./_chunks/whoami.mjs");
+				await runWhoAmI(client, { json: flags.json });
+				break;
+			}
+			case "browse": {
+				const client = createPublicClient(flags);
+				switch (sub) {
+					case "hackathons": {
+						const { runBrowseHackathons } = await import("./_chunks/hackathons.mjs");
+						await runBrowseHackathons(client, rest.slice(2).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "submissions": {
+						const { runBrowseSubmissions } = await import("./_chunks/submissions.mjs");
+						await runBrowseSubmissions(client, rest[2], { json: flags.json });
+						break;
+					}
+					case "results": {
+						const { runBrowseResults } = await import("./_chunks/results.mjs");
+						await runBrowseResults(client, rest[2], { json: flags.json });
+						break;
+					}
+					case "org": {
+						const { runBrowseOrg } = await import("./_chunks/org.mjs");
+						await runBrowseOrg(client, rest[2], { json: flags.json });
+						break;
+					}
+					default:
+						console.error(`Unknown browse command: ${sub}. Run "oatmeal browse --help" for usage.`);
+						process.exit(1);
+				}
+				break;
+			}
+			case "hackathons": {
+				const client = createAuthenticatedClient(flags);
+				switch (sub) {
+					case "list": {
+						const { runHackathonsList } = await import("./_chunks/list.mjs");
+						await runHackathonsList(client, { json: flags.json });
+						break;
+					}
+					case "get": {
+						const { runHackathonsGet } = await import("./_chunks/get.mjs");
+						await runHackathonsGet(client, rest[2], { json: flags.json });
+						break;
+					}
+					case "create": {
+						const { runHackathonsCreate } = await import("./_chunks/create.mjs");
+						await runHackathonsCreate(client, rest.slice(2).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "update": {
+						const { runHackathonsUpdate } = await import("./_chunks/update.mjs");
+						await runHackathonsUpdate(client, rest[2], rest.slice(3).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "delete": {
+						const { runHackathonsDelete } = await import("./_chunks/delete.mjs");
+						await runHackathonsDelete(client, rest[2], { yes: flags.yes });
+						break;
+					}
+					default:
+						console.error(`Unknown hackathons command: ${sub}. Run "oatmeal hackathons --help" for usage.`);
+						process.exit(1);
+				}
+				break;
+			}
+			case "judging": {
+				const client = createAuthenticatedClient(flags);
+				const hackathonId = rest[2];
+				switch (sub) {
+					case "criteria":
+						switch (sub2) {
+							case "list": {
+								const { runCriteriaList } = await import("./_chunks/criteria-list.mjs");
+								await runCriteriaList(client, rest[3], { json: flags.json });
+								break;
+							}
+							case "create": {
+								const { runCriteriaCreate } = await import("./_chunks/criteria-create.mjs");
+								await runCriteriaCreate(client, rest[3], rest.slice(4).concat(flags.json ? ["--json"] : []));
+								break;
+							}
+							case "update": {
+								const { runCriteriaUpdate } = await import("./_chunks/criteria-update.mjs");
+								await runCriteriaUpdate(client, rest[3], rest[4], rest.slice(5).concat(flags.json ? ["--json"] : []));
+								break;
+							}
+							case "delete": {
+								const { runCriteriaDelete } = await import("./_chunks/criteria-delete.mjs");
+								await runCriteriaDelete(client, rest[3], rest[4], { yes: flags.yes });
+								break;
+							}
+							default:
+								console.error(`Unknown judging criteria command: ${sub2}`);
+								process.exit(1);
+						}
+						break;
+					case "judges":
+						switch (sub2) {
+							case "list": {
+								const { runJudgesList } = await import("./_chunks/judges-list.mjs");
+								await runJudgesList(client, rest[3], { json: flags.json });
+								break;
+							}
+							case "add": {
+								const { runJudgesAdd } = await import("./_chunks/judges-add.mjs");
+								await runJudgesAdd(client, rest[3], rest.slice(4).concat(flags.json ? ["--json"] : []));
+								break;
+							}
+							case "remove": {
+								const { runJudgesRemove } = await import("./_chunks/judges-remove.mjs");
+								await runJudgesRemove(client, rest[3], rest[4], { yes: flags.yes });
+								break;
+							}
+							default:
+								console.error(`Unknown judging judges command: ${sub2}`);
+								process.exit(1);
+						}
+						break;
+					case "assignments":
+						switch (sub2) {
+							case "list": {
+								const { runAssignmentsList } = await import("./_chunks/assignments-list.mjs");
+								await runAssignmentsList(client, rest[3], { json: flags.json });
+								break;
+							}
+							case "create": {
+								const { runAssignmentsCreate } = await import("./_chunks/assignments-create.mjs");
+								await runAssignmentsCreate(client, rest[3], rest.slice(4).concat(flags.json ? ["--json"] : []));
+								break;
+							}
+							case "delete": {
+								const { runAssignmentsDelete } = await import("./_chunks/assignments-delete.mjs");
+								await runAssignmentsDelete(client, rest[3], rest[4], { yes: flags.yes });
+								break;
+							}
+							default:
+								console.error(`Unknown judging assignments command: ${sub2}`);
+								process.exit(1);
+						}
+						break;
+					case "auto-assign": {
+						const { runAutoAssign } = await import("./_chunks/auto-assign.mjs");
+						await runAutoAssign(client, hackathonId, rest.slice(3).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "invitations":
+						switch (sub2) {
+							case "list": {
+								const { runInvitationsList } = await import("./_chunks/invitations-list.mjs");
+								await runInvitationsList(client, rest[3], { json: flags.json });
+								break;
+							}
+							case "cancel": {
+								const { runInvitationsCancel } = await import("./_chunks/invitations-cancel.mjs");
+								await runInvitationsCancel(client, rest[3], rest[4], { yes: flags.yes });
+								break;
+							}
+							default:
+								console.error(`Unknown judging invitations command: ${sub2}`);
+								process.exit(1);
+						}
+						break;
+					case "pick-results": {
+						const { runPickResults } = await import("./_chunks/pick-results.mjs");
+						await runPickResults(client, hackathonId, { json: flags.json });
+						break;
+					}
+					default:
+						console.error(`Unknown judging command: ${sub}`);
+						process.exit(1);
+				}
+				break;
+			}
+			case "prizes": {
+				const client = createAuthenticatedClient(flags);
+				switch (sub) {
+					case "list": {
+						const { runPrizesList } = await import("./_chunks/list4.mjs");
+						await runPrizesList(client, rest[2], { json: flags.json });
+						break;
+					}
+					case "create": {
+						const { runPrizesCreate } = await import("./_chunks/create4.mjs");
+						await runPrizesCreate(client, rest[2], rest.slice(3).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "update": {
+						const { runPrizesUpdate } = await import("./_chunks/update3.mjs");
+						await runPrizesUpdate(client, rest[2], rest[3], rest.slice(4).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "delete": {
+						const { runPrizesDelete } = await import("./_chunks/delete3.mjs");
+						await runPrizesDelete(client, rest[2], rest[3], { yes: flags.yes });
+						break;
+					}
+					case "reorder": {
+						const { runPrizesReorder } = await import("./_chunks/reorder2.mjs");
+						await runPrizesReorder(client, rest[2], rest.slice(3));
+						break;
+					}
+					case "assign": {
+						const { runPrizesAssign } = await import("./_chunks/assign.mjs");
+						await runPrizesAssign(client, rest[2], rest[3], rest.slice(4).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "unassign": {
+						const { runPrizesUnassign } = await import("./_chunks/unassign.mjs");
+						await runPrizesUnassign(client, rest[2], rest[3], rest[4], { yes: flags.yes });
+						break;
+					}
+					default:
+						console.error(`Unknown prizes command: ${sub}`);
+						process.exit(1);
+				}
+				break;
+			}
+			case "judge-display": {
+				const client = createAuthenticatedClient(flags);
+				switch (sub) {
+					case "list": {
+						const { runJudgeDisplayList } = await import("./_chunks/list3.mjs");
+						await runJudgeDisplayList(client, rest[2], { json: flags.json });
+						break;
+					}
+					case "create": {
+						const { runJudgeDisplayCreate } = await import("./_chunks/create3.mjs");
+						await runJudgeDisplayCreate(client, rest[2], rest.slice(3).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "update": {
+						const { runJudgeDisplayUpdate } = await import("./_chunks/update2.mjs");
+						await runJudgeDisplayUpdate(client, rest[2], rest[3], rest.slice(4).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "delete": {
+						const { runJudgeDisplayDelete } = await import("./_chunks/delete2.mjs");
+						await runJudgeDisplayDelete(client, rest[2], rest[3], { yes: flags.yes });
+						break;
+					}
+					case "reorder": {
+						const { runJudgeDisplayReorder } = await import("./_chunks/reorder.mjs");
+						await runJudgeDisplayReorder(client, rest[2], rest.slice(3));
+						break;
+					}
+					default:
+						console.error(`Unknown judge-display command: ${sub}`);
+						process.exit(1);
+				}
+				break;
+			}
+			case "results": {
+				const client = createAuthenticatedClient(flags);
+				switch (sub) {
+					case "calculate": {
+						const { runResultsCalculate } = await import("./_chunks/calculate.mjs");
+						await runResultsCalculate(client, rest[2], { json: flags.json });
+						break;
+					}
+					case "get": {
+						const { runResultsGet } = await import("./_chunks/get3.mjs");
+						await runResultsGet(client, rest[2], { json: flags.json });
+						break;
+					}
+					case "publish": {
+						const { runResultsPublish } = await import("./_chunks/publish.mjs");
+						await runResultsPublish(client, rest[2], { yes: flags.yes });
+						break;
+					}
+					case "unpublish": {
+						const { runResultsUnpublish } = await import("./_chunks/unpublish.mjs");
+						await runResultsUnpublish(client, rest[2], { yes: flags.yes });
+						break;
+					}
+					default:
+						console.error(`Unknown results command: ${sub}`);
+						process.exit(1);
+				}
+				break;
+			}
+			case "webhooks": {
+				const client = createAuthenticatedClient(flags);
+				switch (sub) {
+					case "list": {
+						const { runWebhooksList } = await import("./_chunks/list6.mjs");
+						await runWebhooksList(client, { json: flags.json });
+						break;
+					}
+					case "create": {
+						const { runWebhooksCreate } = await import("./_chunks/create6.mjs");
+						await runWebhooksCreate(client, rest.slice(2).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "delete": {
+						const { runWebhooksDelete } = await import("./_chunks/delete5.mjs");
+						await runWebhooksDelete(client, rest[2], { yes: flags.yes });
+						break;
+					}
+					default:
+						console.error(`Unknown webhooks command: ${sub}`);
+						process.exit(1);
+				}
+				break;
+			}
+			case "jobs": {
+				const client = createAuthenticatedClient(flags);
+				switch (sub) {
+					case "list": {
+						const { runJobsList } = await import("./_chunks/list2.mjs");
+						await runJobsList(client, rest.slice(2), { json: flags.json });
+						break;
+					}
+					case "get": {
+						const { runJobsGet } = await import("./_chunks/get2.mjs");
+						await runJobsGet(client, rest[2], { json: flags.json });
+						break;
+					}
+					case "create": {
+						const { runJobsCreate } = await import("./_chunks/create2.mjs");
+						await runJobsCreate(client, rest.slice(2).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "result": {
+						const { runJobsResult } = await import("./_chunks/result.mjs");
+						await runJobsResult(client, rest[2], rest.slice(3).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "cancel": {
+						const { runJobsCancel } = await import("./_chunks/cancel.mjs");
+						await runJobsCancel(client, rest[2], { yes: flags.yes });
+						break;
+					}
+					default:
+						console.error(`Unknown jobs command: ${sub}`);
+						process.exit(1);
+				}
+				break;
+			}
+			case "schedules": {
+				const client = createAuthenticatedClient(flags);
+				switch (sub) {
+					case "list": {
+						const { runSchedulesList } = await import("./_chunks/list5.mjs");
+						await runSchedulesList(client, { json: flags.json });
+						break;
+					}
+					case "create": {
+						const { runSchedulesCreate } = await import("./_chunks/create5.mjs");
+						await runSchedulesCreate(client, rest.slice(2).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "get": {
+						const { runSchedulesGet } = await import("./_chunks/get4.mjs");
+						await runSchedulesGet(client, rest[2], { json: flags.json });
+						break;
+					}
+					case "update": {
+						const { runSchedulesUpdate } = await import("./_chunks/update4.mjs");
+						await runSchedulesUpdate(client, rest[2], rest.slice(3).concat(flags.json ? ["--json"] : []));
+						break;
+					}
+					case "delete": {
+						const { runSchedulesDelete } = await import("./_chunks/delete4.mjs");
+						await runSchedulesDelete(client, rest[2], { yes: flags.yes });
+						break;
+					}
+					default:
+						console.error(`Unknown schedules command: ${sub}`);
+						process.exit(1);
+				}
+				break;
+			}
+			default:
+				console.error(`Unknown command: ${command}. Run "oatmeal --help" for usage.`);
+				process.exit(1);
+		}
+	} catch (error) {
+		if (error instanceof ScopeError) console.error(formatError({
+			message: error.message,
+			hint: error.hint
+		}));
+		else if (error instanceof AuthError) console.error(formatError({ message: error.message }));
+		else if (error instanceof ConfigError) console.error(formatError({ message: error.message }));
+		else if (error instanceof ApiError) console.error(formatError({
+			message: error.toString(),
+			hint: error.hint
+		}));
+		else if (error instanceof Error) console.error(formatError({ message: error.message }));
+		else console.error(formatError({ message: String(error) }));
+		process.exit(1);
+	}
+}
+main();
+//#endregion
+export { formatWarning as a, formatTable as i, formatJson as n, OatmealClient as o, formatSuccess as r, formatDetail as t };
+
+//# sourceMappingURL=cli.mjs.map