@devdogsuga/devtools 0.1.25 → 0.1.27

package/dist/failure-log-BBPGejQv.js

@@ -0,0 +1,256 @@
+import { a as ownVersion } from "./root-C2OmZDwD.js";
+import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform, release } from "node:os";
+//#region ../cli-core/src/catalog.ts
+/**
+* How each scope reads, in the two places that draw it.
+*
+* `menu` sits inline in a hint, so it is one word. `help` heads a block of
+* commands, so it can be a phrase. Both live here rather than in the renderers
+* because they are labels, the same kind of data as a group title.
+*/
+const SCOPES = {
+	machine: {
+		menu: "This machine",
+		help: "Supabase on this machine"
+	},
+	repo: {
+		menu: "Repo",
+		help: "files in the repo"
+	},
+	endpoint: {
+		menu: "Database",
+		help: "the session's database (--tier)"
+	},
+	infra: {
+		menu: "Hosted",
+		help: "hosted infrastructure, each naming its own connection"
+	}
+};
+/**
+* Machine-readable output to stdout.
+*
+* Promptless by design: the wizard is already interactive; a flag that switches
+* its output format has no meaning there. `commands.test.ts` pins the promptless
+* set with a "scripting-only" category for exactly this kind of flag.
+*/
+const JSON_FLAG = {
+	flag: "--json",
+	summary: "Print machine-readable JSON to stdout."
+};
+/** Skip every interactive confirmation prompt. On every destructive command. */
+const YES = {
+	flag: "--yes",
+	summary: "Skip the confirmations."
+};
+function walk(roots, path) {
+	let nodes = roots;
+	let found = null;
+	for (const name of path) {
+		const next = nodes.find((node) => node.name === name);
+		if (!next) return null;
+		found = next;
+		nodes = next.subcommands ?? [];
+	}
+	return found;
+}
+function createCatalog(trees) {
+	const groups = trees.groups;
+	const ciGroups = trees.ciGroups ?? [];
+	const topLevel = groups.flatMap((group) => group.commands);
+	const ciTopLevel = ciGroups.flatMap((group) => group.commands);
+	const subcommandNames = (path) => (walk(topLevel, path)?.subcommands ?? []).map((node) => node.name);
+	return {
+		usage: trees.usage,
+		commonTasks: trees.commonTasks ?? [],
+		groups,
+		ciGroups,
+		topLevel,
+		ciTopLevel,
+		findCommand: (path) => walk(topLevel, path),
+		findCiCommand: (path) => walk(ciTopLevel, path),
+		groupOf: (name) => groups.find((group) => group.commands.some((command) => command.name === name)),
+		subcommandNames,
+		subcommandCiNames: (path) => (walk(ciTopLevel, path)?.subcommands ?? []).map((node) => node.name),
+		subcommandList: (path) => {
+			const names = subcommandNames(path);
+			if (names.length <= 1) return names.join("");
+			return `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}`;
+		},
+		allPaths: () => {
+			const paths = [];
+			const visit = (nodes, prefix) => {
+				for (const node of nodes) {
+					const path = [...prefix, node.name];
+					paths.push(path);
+					visit(node.subcommands ?? [], path);
+				}
+			};
+			visit(topLevel, []);
+			return paths;
+		}
+	};
+}
+//#endregion
+//#region ../cli-core/src/cli-name.ts
+let current = "devtools";
+function cliName() {
+	return current;
+}
+//#endregion
+//#region ../cli-core/src/failure-log.ts
+/**
+* A local log for a failed run, so a contributor has something to attach to
+* #tech-support.
+*
+* When the process is about to exit non-zero, one file is written holding what
+* helps someone else diagnose it: the command line, the version and platform,
+* the tool commands that ran with their exit codes, devtools' own output, the
+* error, and the Sentry event id when telemetry sent one. The path is printed
+* last, on stderr. Output a tool wrote straight to the terminal is not
+* captured (tools keep the terminal so colours and prompts work), and the log
+* says so.
+*
+* Secrets are redacted before anything is stored: credentials inside URLs,
+* and the value of any environment variable named like a secret.
+*
+* Not a failure, so no log: a clean exit, Ctrl-C (130) or SIGTERM (143), the
+* drift code (2) that `--check` uses on purpose, and a cancelled prompt.
+*/
+function nonEmpty(value) {
+	if (value === void 0 || value === "") return void 0;
+	return value;
+}
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function versionOrUnknown() {
+	try {
+		return ownVersion();
+	} catch {
+		return "unknown";
+	}
+}
+const SECRET_NAME = /(SECRET|TOKEN|PASSWORD|PASSWD|KEY|DSN|DB_URL|CREDENTIAL)/i;
+const URL_CREDENTIALS = /\/\/[^/@\s:]+(:[^/@\s]*)?@/g;
+let state = null;
+/** Replaces credentials in `text` with a placeholder. */
+function redact(text, env = process.env) {
+	let out = text.replace(URL_CREDENTIALS, "//***@");
+	for (const [name, value] of Object.entries(env)) if (value && value.length >= 8 && SECRET_NAME.test(name)) out = out.split(value).join("<redacted>");
+	return out;
+}
+function failureLogDir(env = process.env) {
+	return nonEmpty(env.DEVTOOLS_LOG_DIR) ?? join(nonEmpty(env.XDG_STATE_HOME) ?? join(homedir(), ".local", "state"), "devdogs", "logs");
+}
+/** Whether an exit code means the run failed. */
+function isFailureCode(code) {
+	return code !== 0 && code !== 2 && code !== 130 && code !== 143;
+}
+/** The file's text. Pure, so it is testable without a process to fail. */
+function renderFailureLog(input) {
+	const env = input.env ?? process.env;
+	const lines = [
+		"devtools failure log",
+		"Attach this file to your #tech-support message.",
+		"",
+		`time:      ${input.now.toISOString()}`,
+		`version:   ${versionOrUnknown()}`,
+		`command:   devtools ${input.argv.join(" ")}`,
+		`exit code: ${input.code}`,
+		`tier:      ${nonEmpty(env.DEPLOY_ENV) ?? "development"}`,
+		`node:      ${process.version}`,
+		`platform:  ${platform()} ${release()}`,
+		`cwd:       ${process.cwd()}`,
+		`sentry:    ${input.eventId ?? "none (telemetry sent nothing)"}`,
+		"",
+		"== Tool commands that ran ==",
+		...input.ran.length > 0 ? input.ran : ["(none)"],
+		"",
+		"== Error =="
+	];
+	if (input.error === void 0) lines.push("(none thrown)");
+	else lines.push(input.error instanceof Error ? input.error.stack ?? input.error.message : describe(input.error));
+	lines.push("", "== devtools output (tool output that went straight to the terminal is not here) ==", input.output.length > 0 ? input.output : "(none)");
+	return redact(`${lines.join("\n")}\n`, env);
+}
+/** Records a command a tool ran, for the log. */
+function noteRan(line) {
+	state?.ran.push(line);
+}
+/** Records the error a failure came from, for the log. */
+function noteError(error) {
+	if (state) state.error ??= error;
+}
+/** A cancelled prompt is the user's choice, not a failure. */
+function suppressFailureLog() {
+	if (state) state.quiet = true;
+}
+function keepNewest(dir) {
+	try {
+		const old = readdirSync(dir).filter((name) => name.startsWith("devtools-") && name.endsWith(".log")).sort().slice(0, -10);
+		for (const name of old) rmSync(join(dir, name), { force: true });
+	} catch {}
+}
+/** Writes the log and returns its path, or `null` if it could not be written. */
+function writeLog(input) {
+	try {
+		const dir = failureLogDir(input.env);
+		mkdirSync(dir, { recursive: true });
+		const stamp = input.now.toISOString().replace(/[:.]/g, "-");
+		const path = join(dir, `devtools-${stamp}.log`);
+		writeFileSync(path, renderFailureLog(input), { mode: 384 });
+		keepNewest(dir);
+		return path;
+	} catch {
+		return null;
+	}
+}
+/**
+* Starts recording and writes the log if the process exits with a failure.
+* Call once, early. A second call is ignored.
+*/
+function installFailureLog(options) {
+	if (state) return;
+	state = {
+		argv: [...options.argv],
+		eventId: options.eventId,
+		ran: [],
+		output: "",
+		error: void 0,
+		quiet: false
+	};
+	const capture = (stream) => {
+		const original = stream.write.bind(stream);
+		stream.write = (chunk, ...rest) => {
+			if (state && typeof chunk === "string") state.output = (state.output + chunk).slice(-65536);
+			return original(chunk, ...rest);
+		};
+	};
+	capture(process.stdout);
+	capture(process.stderr);
+	process.once("exit", (exitCode) => {
+		const current = state;
+		if (!current || current.quiet) return;
+		const code = process.exitCode === void 0 ? exitCode : Number(process.exitCode);
+		if (!isFailureCode(code)) return;
+		const path = writeLog({
+			argv: current.argv,
+			code,
+			ran: current.ran,
+			output: current.output,
+			error: current.error,
+			eventId: current.eventId(),
+			now: /* @__PURE__ */ new Date()
+		});
+		const eventId = current.eventId();
+		process.stderr.write([
+			path ? `Log for #tech-support: ${path}` : "Could not write a failure log.",
+			...eventId ? [`Sentry event: ${eventId}`] : [],
+			""
+		].join("\n"));
+	});
+}
+//#endregion
+export { cliName as a, YES as c, suppressFailureLog as i, createCatalog as l, noteError as n, JSON_FLAG as o, noteRan as r, SCOPES as s, installFailureLog as t };