atlass 1.7.0 → 1.9.0

package/dist/build-DhED0Zw_.mjs

@@ -0,0 +1,2419 @@
+import { Command } from "commander";
+import { checkbox, confirm, input, password } from "@inquirer/prompts";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { Entry } from "@napi-rs/keyring";
+import { marked } from "marked";
+import { randomUUID } from "node:crypto";
+import { stripVTControlCharacters } from "node:util";
+import kleur from "kleur";
+import { common, createLowlight } from "lowlight";
+//#region src/cli/run.ts
+const SIGINT_EXIT_CODE = 130;
+function run(fn) {
+	return async (...args) => {
+		try {
+			await fn(...args);
+		} catch (err) {
+			fail(err);
+		}
+	};
+}
+function fail(err) {
+	if (isPromptInterrupt(err)) process.exit(SIGINT_EXIT_CODE);
+	console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+	process.exit(1);
+}
+function isPromptInterrupt(err) {
+	return err instanceof Error && err.name === "ExitPromptError";
+}
+//#endregion
+//#region src/api/client.ts
+const DISABLE_XSRF_CHECK = { "X-Atlassian-Token": "nocheck" };
+var AtlassianClient = class {
+	site;
+	authHeader;
+	constructor(auth) {
+		this.site = auth.site;
+		const basic = Buffer.from(`${auth.email}:${auth.token}`).toString("base64");
+		this.authHeader = `Basic ${basic}`;
+	}
+	async request(path, init) {
+		const res = await fetch(`${this.site}${path}`, {
+			method: init.method,
+			body: init.body,
+			headers: {
+				Authorization: this.authHeader,
+				...init.headers
+			}
+		});
+		if (!res.ok) {
+			const body = await res.text().catch(() => "");
+			throw httpError(res.status, path, body);
+		}
+		return res;
+	}
+	async getJson(path) {
+		return (await this.request(path, { headers: { Accept: "application/json" } })).json();
+	}
+	async putJson(path, body) {
+		return (await this.request(path, {
+			method: "PUT",
+			headers: {
+				Accept: "application/json",
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(body)
+		})).json();
+	}
+	async putNoContent(path, body) {
+		await this.request(path, {
+			method: "PUT",
+			headers: {
+				Accept: "application/json",
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(body)
+		});
+	}
+	async postMultipart(path, filename, bytes) {
+		const form = new FormData();
+		const blob = new Blob([bytes]);
+		form.append("file", blob, filename);
+		return (await this.request(path, {
+			method: "POST",
+			headers: {
+				Accept: "application/json",
+				...DISABLE_XSRF_CHECK
+			},
+			body: form
+		})).json();
+	}
+	async getBinary(urlOrPath) {
+		const path = urlOrPath.startsWith("http") ? pathAndQuery(urlOrPath) : urlOrPath;
+		const res = await this.request(path, { headers: { Accept: "*/*" } });
+		return new Uint8Array(await res.arrayBuffer());
+	}
+};
+function pathAndQuery(absoluteUrl) {
+	const u = new URL(absoluteUrl);
+	return u.pathname + u.search;
+}
+var HttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "HttpError";
+	}
+};
+function httpError(status, path, body = "") {
+	if (status === 401 || status === 403) return new HttpError(status, "Authentication failed (401/403). Run `atlass auth login` to update your token.");
+	if (status === 404) return new HttpError(status, `Not found (404): ${path}`);
+	if (status === 409) return new HttpError(status, `Conflict (409): ${extractErrorMessage(body) || "the page changed on the server"}`);
+	if (status === 413) return new HttpError(status, "Payload too large (413): the page or an attachment exceeds the size limit.");
+	if (status === 400) return new HttpError(status, `Bad request (400): ${extractErrorMessage(body) || path}`);
+	return new HttpError(status, `Request failed (${status}): ${extractErrorMessage(body) || path}`);
+}
+function extractErrorMessage(body) {
+	if (!body) return "";
+	const json = tryParseJson(body);
+	if (json?.errorMessages?.length) return json.errorMessages.join("; ");
+	if (json?.message) return json.message;
+	if (json?.error?.message) return json.error.message;
+	return body.slice(0, 300);
+}
+function tryParseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/config.ts
+function configDir() {
+	return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "atlass");
+}
+function configPath() {
+	return join(configDir(), "config.json");
+}
+async function readConfig() {
+	try {
+		const raw = await readFile(configPath(), "utf8");
+		const parsed = JSON.parse(raw);
+		return {
+			site: parsed.site,
+			email: parsed.email,
+			bitbucket: parsed.bitbucket
+		};
+	} catch {
+		return null;
+	}
+}
+async function writeConfig(config) {
+	await mkdir(configDir(), { recursive: true });
+	await writeFile(configPath(), `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+async function clearConfig() {
+	await rm(configPath(), { force: true });
+}
+function siteOrigin(input) {
+	let value = input.trim();
+	if (!/^https?:\/\//i.test(value)) value = `https://${value}`;
+	return new URL(value).origin;
+}
+//#endregion
+//#region src/credentials.ts
+const SERVICE = "atlass";
+const BITBUCKET_ORIGIN = "https://api.bitbucket.org";
+function entry(key) {
+	return new Entry(SERVICE, key);
+}
+function deleteEntryIfPresent(key) {
+	try {
+		entry(key).deleteCredential();
+	} catch {
+		return;
+	}
+}
+function saveToken(email, token) {
+	entry(email).setPassword(token);
+}
+function readToken(email) {
+	return entry(email).getPassword();
+}
+function deleteToken(email) {
+	deleteEntryIfPresent(email);
+}
+function bitbucketKey(email) {
+	return `${email}:bitbucket`;
+}
+function saveBitbucketToken(email, token) {
+	entry(bitbucketKey(email)).setPassword(token);
+}
+function readBitbucketToken(email) {
+	return entry(bitbucketKey(email)).getPassword();
+}
+function deleteBitbucketToken(email) {
+	deleteEntryIfPresent(bitbucketKey(email));
+}
+async function requireAuth() {
+	const config = await readConfig();
+	if (!config || !config.site || !config.email) throw new Error("Not logged in. Run `atlass auth login` first.");
+	const token = readToken(config.email);
+	if (!token) throw new Error("No API token found in keyring. Run `atlass auth login` again.");
+	return {
+		site: config.site,
+		email: config.email,
+		token
+	};
+}
+async function requireBitbucketAuth() {
+	const config = await readConfig();
+	if (!config || !config.email || !config.bitbucket?.workspace) throw new Error("Not logged in to Bitbucket. Run `atlass bitbucket login` first.");
+	const token = readBitbucketToken(config.email);
+	if (!token) throw new Error("No Bitbucket API token found in keyring. Run `atlass bitbucket login` again.");
+	return {
+		site: BITBUCKET_ORIGIN,
+		email: config.email,
+		token,
+		workspace: config.bitbucket.workspace,
+		defaultRepo: config.bitbucket.defaultRepo
+	};
+}
+//#endregion
+//#region src/commands/auth.ts
+async function login() {
+	const site = siteOrigin(await input({
+		message: "Atlassian site (e.g. acme.atlassian.net):",
+		required: true
+	}));
+	const email = await input({
+		message: "Account email:",
+		required: true
+	});
+	const token = await password({
+		message: "API token (from id.atlassian.com/manage-profile/security/api-tokens):",
+		mask: true
+	});
+	const me = await new AtlassianClient({
+		site,
+		email,
+		token
+	}).getJson("/rest/api/3/myself");
+	await writeConfig({
+		...await readConfig() ?? {},
+		site,
+		email
+	});
+	saveToken(email, token);
+	console.log(`Logged in as ${me.displayName} on ${site}.`);
+}
+async function logout() {
+	const config = await readConfig();
+	if (config?.email) deleteToken(config.email);
+	const bitbucketLogin = config?.bitbucket && config.email ? {
+		email: config.email,
+		bitbucket: config.bitbucket
+	} : null;
+	if (bitbucketLogin) await writeConfig(bitbucketLogin);
+	else await clearConfig();
+	console.log("Logged out. Credentials removed.");
+}
+async function status() {
+	const config = await readConfig();
+	if (!config || !config.site || !config.email) {
+		console.log("Not logged in. Run `atlass auth login`.");
+		return;
+	}
+	const hasToken = readToken(config.email) !== null;
+	console.log(`Site:  ${config.site}`);
+	console.log(`Email: ${config.email}`);
+	console.log(`Token: ${hasToken ? "stored in keyring" : "MISSING (run `atlass auth login`)"}`);
+}
+//#endregion
+//#region src/cli/auth.ts
+function registerAuth(auth) {
+	auth.description("Manage Atlassian credentials");
+	auth.command("login").description("Store site, email, and API token").action(run(login));
+	auth.command("logout").description("Remove stored credentials").action(run(logout));
+	auth.command("status").description("Show the current login").action(run(status));
+	return auth;
+}
+//#endregion
+//#region src/api/bitbucket.ts
+const BITBUCKET_MAX_PAGELEN = 100;
+const BUILD_NUMBER_SCAN_LIMIT = 1e3;
+function pipelineStatus(state) {
+	if (!state) return "";
+	if (state.name === "COMPLETED") return state.result?.name ?? "COMPLETED";
+	return state.name ?? "";
+}
+function pipelinesQuery(limit) {
+	return new URLSearchParams({
+		sort: "-created_on",
+		pagelen: String(Math.min(Math.max(limit, 1), BITBUCKET_MAX_PAGELEN))
+	}).toString();
+}
+function wallClockSeconds(startOn, endOn) {
+	if (!startOn || !endOn) return null;
+	const start = Date.parse(startOn);
+	const end = Date.parse(endOn);
+	if (Number.isNaN(start) || Number.isNaN(end)) return null;
+	return Math.floor((end - start) / 1e3);
+}
+function shortHash(hash) {
+	return hash?.slice(0, 7) ?? "";
+}
+function toPipelineSummary(p) {
+	return {
+		buildNumber: p.build_number,
+		status: pipelineStatus(p.state),
+		ref: p.target?.ref_name ?? "",
+		commit: shortHash(p.target?.commit?.hash),
+		durationSeconds: wallClockSeconds(p.created_on, p.completed_on),
+		createdOn: p.created_on ?? "",
+		creator: p.creator?.display_name ?? "",
+		uuid: p.uuid
+	};
+}
+function toPipelineDetail(p) {
+	return {
+		...toPipelineSummary(p),
+		repo: p.repository?.full_name ?? "",
+		trigger: p.trigger?.name ?? ""
+	};
+}
+function toStepSummary(step) {
+	return {
+		name: step.name ?? "",
+		status: pipelineStatus(step.state),
+		durationSeconds: wallClockSeconds(step.started_on, step.completed_on)
+	};
+}
+function repoPath(ref) {
+	return `/2.0/repositories/${encodeURIComponent(ref.workspace)}/${encodeURIComponent(ref.repo)}/pipelines`;
+}
+async function* walkPages(client, firstPath) {
+	let path = firstPath;
+	while (path) {
+		const page = await client.getJson(path);
+		for (const value of page.values ?? []) yield value;
+		path = page.next ? pathAndQuery(page.next) : null;
+	}
+}
+async function listPipelines(client, ref, limit) {
+	const out = [];
+	const first = `${repoPath(ref)}?${pipelinesQuery(limit)}`;
+	for await (const value of walkPages(client, first)) {
+		out.push(toPipelineSummary(value));
+		if (out.length >= limit) break;
+	}
+	return out;
+}
+async function getPipeline(client, ref, buildNumber) {
+	const found = await fetchByBuildNumber(client, ref, buildNumber) ?? await findInRecentRuns(client, ref, buildNumber);
+	if (!found) throw new Error(`Could not find pipeline #${buildNumber} in the ${BUILD_NUMBER_SCAN_LIMIT} most recent runs. It may be too old.`);
+	return toPipelineDetail(found);
+}
+async function fetchByBuildNumber(client, ref, buildNumber) {
+	try {
+		return await client.getJson(`${repoPath(ref)}/${encodeURIComponent(String(buildNumber))}`);
+	} catch (err) {
+		if (err instanceof HttpError && (err.status === 400 || err.status === 404)) return null;
+		throw err;
+	}
+}
+async function findInRecentRuns(client, ref, buildNumber) {
+	const first = `${repoPath(ref)}?${pipelinesQuery(BITBUCKET_MAX_PAGELEN)}`;
+	let scanned = 0;
+	for await (const pipeline of walkPages(client, first)) {
+		if (pipeline.build_number === buildNumber) return pipeline;
+		if (++scanned >= BUILD_NUMBER_SCAN_LIMIT) break;
+	}
+	return null;
+}
+async function listSteps(client, ref, pipelineId) {
+	const out = [];
+	const first = `${repoPath(ref)}/${encodeURIComponent(pipelineId)}/steps`;
+	for await (const step of walkPages(client, first)) out.push(toStepSummary(step));
+	return out;
+}
+//#endregion
+//#region src/util/format.ts
+function formatDuration(seconds) {
+	if (seconds == null) return "-";
+	if (seconds < 60) return `${seconds}s`;
+	const m = Math.floor(seconds / 60);
+	const s = seconds % 60;
+	if (m < 60) return `${m}m${String(s).padStart(2, "0")}s`;
+	return `${Math.floor(m / 60)}h${String(m % 60).padStart(2, "0")}m`;
+}
+function formatDateTime(iso) {
+	const date = new Date(iso);
+	if (Number.isNaN(date.getTime())) return iso;
+	return date.toISOString().replace("T", " ").slice(0, 16);
+}
+const MINUTE = 60;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+function relativeTime(iso, nowMs) {
+	if (!iso) return "-";
+	const then = Date.parse(iso);
+	if (Number.isNaN(then)) return "-";
+	const secs = Math.floor((nowMs - then) / 1e3);
+	if (secs < MINUTE) return "just now";
+	if (secs < HOUR) return `${Math.floor(secs / MINUTE)}m ago`;
+	if (secs < DAY) return `${Math.floor(secs / HOUR)}h ago`;
+	const days = Math.floor(secs / DAY);
+	if (days < 45) return `${days}d ago`;
+	if (days < 365) return `${Math.floor(days / 30)}mo ago`;
+	return `${Math.floor(days / 365)}y ago`;
+}
+//#endregion
+//#region src/util/parse.ts
+function parseIssueKey(input) {
+	const match = input.toUpperCase().match(/[A-Z][A-Z0-9]+-\d+/);
+	return match ? match[0] : null;
+}
+function parsePageId(input) {
+	const trimmed = input.trim();
+	if (/^\d+$/.test(trimmed)) return trimmed;
+	const fromPath = trimmed.match(/\/pages\/(\d+)/);
+	if (fromPath) return fromPath[1];
+	const fromQuery = trimmed.match(/[?&]pageId=(\d+)/);
+	if (fromQuery) return fromQuery[1];
+	return null;
+}
+function isExternalHref(href) {
+	return /^[a-z][a-z0-9+.-]*:\/\//i.test(href);
+}
+function resolveRepo(flag, config) {
+	if (flag) {
+		if (flag.includes("/")) {
+			const parts = flag.split("/");
+			const [workspace, repo] = parts;
+			if (parts.length !== 2 || !workspace || !repo) throw new Error(`Invalid --repo "${flag}". Expected "workspace/slug" or "slug".`);
+			return {
+				workspace,
+				repo
+			};
+		}
+		if (!config.workspace) throw new Error(`No Bitbucket workspace configured. Pass --repo workspace/slug or run \`atlass bitbucket login\`.`);
+		return {
+			workspace: config.workspace,
+			repo: flag
+		};
+	}
+	if (config.workspace && config.defaultRepo) return {
+		workspace: config.workspace,
+		repo: config.defaultRepo
+	};
+	throw new Error(`No repo given. Pass --repo workspace/slug (or a bare slug), or set a default repo at \`atlass bitbucket login\`.`);
+}
+const DEFAULT_LIMIT = 25;
+const MAX_LIMIT = 100;
+function parseLimit(value) {
+	if (!value) return DEFAULT_LIMIT;
+	const n = Number.parseInt(value, 10);
+	if (!Number.isFinite(n) || n < 1) throw new Error(`Invalid --limit "${value}".`);
+	return Math.min(n, MAX_LIMIT);
+}
+//#endregion
+//#region src/commands/bitbucket.ts
+async function bitbucketLogin() {
+	const existing = await readConfig() ?? {};
+	const email = existing.email ?? await input({
+		message: "Account email:",
+		required: true
+	});
+	const workspace = (await input({
+		message: "Bitbucket workspace (e.g. acme):",
+		required: true
+	})).trim();
+	const defaultRepo = (await input({ message: "Default repo slug (optional):" })).trim() || void 0;
+	const token = await password({
+		message: "Bitbucket API token (needs read:pipeline + workspace read scopes):",
+		mask: true
+	});
+	const ws = await verifyWorkspace(new AtlassianClient({
+		site: BITBUCKET_ORIGIN,
+		email,
+		token
+	}), workspace);
+	await writeConfig({
+		...existing,
+		email,
+		bitbucket: {
+			workspace,
+			...defaultRepo ? { defaultRepo } : {}
+		}
+	});
+	saveBitbucketToken(email, token);
+	console.log(`Logged in to Bitbucket workspace ${ws.name ?? workspace} as ${email}.`);
+}
+async function bitbucketLogout() {
+	const config = await readConfig();
+	if (config?.email) deleteBitbucketToken(config.email);
+	const jiraLogin = config?.site && config.email ? {
+		site: config.site,
+		email: config.email
+	} : null;
+	if (jiraLogin) await writeConfig(jiraLogin);
+	else await clearConfig();
+	console.log("Logged out of Bitbucket. Credentials removed.");
+}
+async function bitbucketStatus() {
+	const config = await readConfig();
+	if (!config?.email || !config.bitbucket?.workspace) {
+		console.log("Not logged in to Bitbucket. Run `atlass bitbucket login`.");
+		return;
+	}
+	const hasToken = readBitbucketToken(config.email) !== null;
+	console.log(`Workspace:    ${config.bitbucket.workspace}`);
+	console.log(`Email:        ${config.email}`);
+	console.log(`Default repo: ${config.bitbucket.defaultRepo ?? "(none)"}`);
+	console.log(`Token:        ${hasToken ? "stored in keyring" : "MISSING (run `atlass bitbucket login`)"}`);
+}
+async function bitbucketPipelines(options) {
+	const auth = await requireBitbucketAuth();
+	const ref = resolveRepo(options.repo, auth);
+	const client = new AtlassianClient(auth);
+	const limit = parseLimit(options.limit);
+	const pipelines = await withScopeHint(() => listPipelines(client, ref, limit));
+	if (options.json) {
+		console.log(JSON.stringify(pipelines, null, 2));
+		return;
+	}
+	if (pipelines.length === 0) {
+		console.log("No pipelines found.");
+		return;
+	}
+	for (const line of formatPipelineRows(pipelines, Date.now())) console.log(line);
+}
+async function bitbucketPipeline(arg, options) {
+	const buildNumber = parseBuildNumber(arg);
+	const auth = await requireBitbucketAuth();
+	const ref = resolveRepo(options.repo, auth);
+	const client = new AtlassianClient(auth);
+	const detail = await withScopeHint(() => getPipeline(client, ref, buildNumber));
+	printPipelineDetail(detail, await withScopeHint(() => listSteps(client, ref, detail.uuid)), Date.now());
+}
+function formatPipelineRows(pipelines, nowMs) {
+	const rows = pipelines.map((p) => ({
+		num: `#${p.buildNumber}`,
+		status: p.status || "-",
+		ref: p.ref || p.commit || "-",
+		dur: formatDuration(p.durationSeconds),
+		age: relativeTime(p.createdOn, nowMs),
+		creator: p.creator || "-"
+	}));
+	const width = (sel) => Math.max(...rows.map((r) => sel(r).length));
+	const wn = width((r) => r.num);
+	const ws = width((r) => r.status);
+	const wr = width((r) => r.ref);
+	const wd = width((r) => r.dur);
+	const wa = width((r) => r.age);
+	return rows.map((r) => `${r.num.padEnd(wn)}  ${r.status.padEnd(ws)}  ${r.ref.padEnd(wr)}  ${r.dur.padEnd(wd)}  ${r.age.padEnd(wa)}  ${r.creator}`);
+}
+function formatStepRows(steps) {
+	const rows = steps.map((s) => ({
+		name: s.name || "-",
+		status: s.status || "-",
+		dur: formatDuration(s.durationSeconds)
+	}));
+	const wn = Math.max(...rows.map((r) => r.name.length));
+	const ws = Math.max(...rows.map((r) => r.status.length));
+	return rows.map((r) => `  ${r.name.padEnd(wn)}  ${r.status.padEnd(ws)}  ${r.dur}`);
+}
+function printPipelineDetail(detail, steps, nowMs) {
+	console.log(`Pipeline #${detail.buildNumber}  ${detail.status || "-"}`);
+	if (detail.repo) console.log(`Repo:     ${detail.repo}`);
+	console.log(`Ref:      ${refWithCommit(detail)}`);
+	if (detail.trigger) console.log(`Trigger:  ${detail.trigger}`);
+	console.log(`Duration: ${formatDuration(detail.durationSeconds)}`);
+	const by = detail.creator ? ` by ${detail.creator}` : "";
+	console.log(`Created:  ${relativeTime(detail.createdOn, nowMs)}${by}`);
+	if (steps.length > 0) {
+		console.log("");
+		console.log("Steps:");
+		for (const line of formatStepRows(steps)) console.log(line);
+	}
+}
+function refWithCommit(detail) {
+	if (!detail.ref) return detail.commit || "-";
+	return detail.commit ? `${detail.ref} (${detail.commit})` : detail.ref;
+}
+async function verifyWorkspace(client, workspace) {
+	try {
+		return await client.getJson(`/2.0/workspaces/${encodeURIComponent(workspace)}`);
+	} catch (err) {
+		if (err instanceof HttpError && (err.status === 401 || err.status === 403)) throw new Error(`Could not verify Bitbucket workspace "${workspace}" (401/403). Check the token and that it has workspace read + read:pipeline:bitbucket scopes.`);
+		if (err instanceof HttpError && err.status === 404) throw new Error(`Bitbucket workspace "${workspace}" not found (404). Check the slug.`);
+		throw err;
+	}
+}
+function parseBuildNumber(arg) {
+	const raw = (arg ?? "").replace(/^#/, "").trim();
+	if (!/^\d+$/.test(raw)) throw new Error(`Invalid pipeline number "${arg ?? ""}". Expected a build number, e.g. 123.`);
+	return Number.parseInt(raw, 10);
+}
+async function withScopeHint(fn) {
+	try {
+		return await fn();
+	} catch (err) {
+		if (err instanceof HttpError && (err.status === 401 || err.status === 403)) throw new Error("Bitbucket rejected the request (401/403). Check the token has the read:pipeline:bitbucket scope, or run `atlass bitbucket login` to update it.");
+		throw err;
+	}
+}
+//#endregion
+//#region src/cli/bitbucket.ts
+function registerBitbucket(bitbucket) {
+	bitbucket.description("Bitbucket commands");
+	bitbucket.command("login").description("Store Bitbucket workspace and API token").action(run(bitbucketLogin));
+	bitbucket.command("logout").description("Remove stored Bitbucket credentials").action(run(bitbucketLogout));
+	bitbucket.command("status").description("Show the current Bitbucket login").action(run(bitbucketStatus));
+	bitbucket.command("pipelines").description("List recent pipeline runs for a repo").option("-r, --repo <repo>", "workspace/slug, or a bare slug (defaults to config)").option("-l, --limit <n>", "max results (default 25, max 100)").option("--json", "output results as JSON").action(run(bitbucketPipelines));
+	bitbucket.command("pipeline <number>").description("Show one pipeline run and its steps").option("-r, --repo <repo>", "workspace/slug, or a bare slug (defaults to config)").action(run(bitbucketPipeline));
+	return bitbucket;
+}
+//#endregion
+//#region src/adf/from-markdown.ts
+function mediaNode(source, alt) {
+	const attrs = { ...source };
+	if (alt) attrs["alt"] = alt;
+	return {
+		type: "mediaSingle",
+		attrs: { layout: "center" },
+		content: [{
+			type: "media",
+			attrs
+		}]
+	};
+}
+function imageHrefs(md) {
+	const hrefs = /* @__PURE__ */ new Set();
+	marked.walkTokens(marked.lexer(md), (token) => {
+		if (token.type === "image") hrefs.add(token.href);
+	});
+	return [...hrefs];
+}
+function markdownToAdf(md, options = {}) {
+	const ctx = { resolveImage: options.resolveImage ?? externalMedia };
+	return {
+		type: "doc",
+		version: 1,
+		content: blocks(marked.lexer(md), ctx)
+	};
+}
+function blocks(tokens, ctx) {
+	const out = [];
+	for (const token of tokens) out.push(...block(token, ctx));
+	return out;
+}
+function block(token, ctx) {
+	switch (token.type) {
+		case "space": return [];
+		case "heading": return [{
+			type: "heading",
+			attrs: { level: clampLevel$1(token.depth) },
+			content: inline(token.tokens ?? [], ctx)
+		}];
+		case "paragraph": return paragraphsSplitAtImages(token.tokens ?? [], ctx);
+		case "text": return paragraphsSplitAtImages(token.tokens ?? [textToken(token.text)], ctx);
+		case "list": return [list(token, ctx)];
+		case "code": return [codeBlock(token)];
+		case "blockquote": return [{
+			type: "blockquote",
+			content: blocks(token.tokens ?? [], ctx)
+		}];
+		case "table": return [table(token, ctx)];
+		case "hr": return [{ type: "rule" }];
+		default: return [];
+	}
+}
+function paragraphsSplitAtImages(tokens, ctx) {
+	const out = [];
+	let buffer = [];
+	const flush = () => {
+		if (buffer.length === 0) return;
+		const nodes = inline(buffer, ctx);
+		if (nodes.length > 0) out.push({
+			type: "paragraph",
+			content: nodes
+		});
+		buffer = [];
+	};
+	for (const token of tokens) if (token.type === "image") {
+		flush();
+		const image = token;
+		const node = ctx.resolveImage(image.href, image.text ?? "");
+		if (node) out.push(node);
+	} else buffer.push(token);
+	flush();
+	return out;
+}
+function list(token, ctx) {
+	if (token.items.length > 0 && token.items.every((i) => i.task)) return {
+		type: "taskList",
+		attrs: { localId: randomUUID() },
+		content: token.items.map((item) => ({
+			type: "taskItem",
+			attrs: {
+				localId: randomUUID(),
+				state: item.checked ? "DONE" : "TODO"
+			},
+			content: inline(taskItemInline(item), ctx)
+		}))
+	};
+	const node = {
+		type: token.ordered ? "orderedList" : "bulletList",
+		content: token.items.map((item) => listItem(item, ctx))
+	};
+	const start = Number(token.start);
+	if (token.ordered && Number.isFinite(start) && start !== 1) node.attrs = { order: start };
+	return node;
+}
+function listItem(item, ctx) {
+	const children = blocks(item.tokens.filter((t) => t.type !== "checkbox"), ctx);
+	return {
+		type: "listItem",
+		content: children.length > 0 ? children : [emptyParagraph()]
+	};
+}
+function emptyParagraph() {
+	return {
+		type: "paragraph",
+		content: []
+	};
+}
+function taskItemInline(item) {
+	const first = item.tokens.find((t) => t.type === "text");
+	if (first && "tokens" in first && first.tokens) return first.tokens;
+	return [textToken(item.text)];
+}
+function codeBlock(token) {
+	return {
+		type: "codeBlock",
+		attrs: token.lang ? { language: token.lang } : {},
+		content: token.text.length > 0 ? [{
+			type: "text",
+			text: token.text
+		}] : []
+	};
+}
+function table(token, ctx) {
+	return {
+		type: "table",
+		content: [{
+			type: "tableRow",
+			content: token.header.map((cell) => tableCell(cell, "tableHeader", ctx))
+		}, ...token.rows.map((row) => ({
+			type: "tableRow",
+			content: row.map((cell) => tableCell(cell, "tableCell", ctx))
+		}))]
+	};
+}
+function tableCell(cell, type, ctx) {
+	return {
+		type,
+		content: [{
+			type: "paragraph",
+			content: inline(cell.tokens, ctx)
+		}]
+	};
+}
+function inline(tokens, ctx, marks = []) {
+	const out = [];
+	for (const token of tokens) out.push(...inlineNode(token, ctx, marks));
+	return out;
+}
+function inlineNode(token, ctx, marks) {
+	switch (token.type) {
+		case "text":
+		case "escape": {
+			const t = token;
+			if ("tokens" in t && t.tokens?.length) return inline(t.tokens, ctx, marks);
+			return textNode(t.text, marks);
+		}
+		case "strong": return inline(token.tokens, ctx, withUniqueMark(marks, { type: "strong" }));
+		case "em": return inline(token.tokens, ctx, withUniqueMark(marks, { type: "em" }));
+		case "del": return inline(token.tokens, ctx, withUniqueMark(marks, { type: "strike" }));
+		case "codespan": return textNode(token.text, withUniqueMark(marks, { type: "code" }));
+		case "link": {
+			const link = token;
+			return inline(link.tokens, ctx, withUniqueMark(marks, {
+				type: "link",
+				attrs: { href: link.href }
+			}));
+		}
+		case "br": return [{ type: "hardBreak" }];
+		case "html": return textNode(token.text, marks);
+		default: return "text" in token && token.text ? textNode(token.text, marks) : [];
+	}
+}
+function textNode(text, marks) {
+	if (text.length === 0) return [];
+	const node = {
+		type: "text",
+		text
+	};
+	if (marks.length > 0) node.marks = marks;
+	return [node];
+}
+function withUniqueMark(marks, mark) {
+	return [...marks.filter((m) => m.type !== mark.type), mark];
+}
+function externalMedia(href, alt) {
+	return mediaNode({
+		type: "external",
+		url: href
+	}, alt);
+}
+function textToken(text) {
+	return {
+		type: "text",
+		raw: text,
+		text,
+		escaped: false
+	};
+}
+function clampLevel$1(value) {
+	return Math.min(6, Math.max(1, Math.trunc(value) || 1));
+}
+//#endregion
+//#region src/util/html.ts
+const MAX_CODE_POINT = 1114111;
+const NAMED = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: " "
+};
+function decodeEntities(text) {
+	return text.replace(/&(#x?[0-9a-f]+|[a-z]+);/gi, (match, body) => {
+		if (body[0] === "#") {
+			const code = body[1] === "x" || body[1] === "X" ? Number.parseInt(body.slice(2), 16) : Number.parseInt(body.slice(1), 10);
+			return isCodePoint(code) ? String.fromCodePoint(code) : match;
+		}
+		return NAMED[body.toLowerCase()] ?? match;
+	});
+}
+function isCodePoint(code) {
+	return Number.isFinite(code) && code >= 0 && code <= MAX_CODE_POINT;
+}
+//#endregion
+//#region src/api/confluence.ts
+async function fetchPage(client, site, id) {
+	const page = await client.getJson(`/wiki/api/v2/pages/${encodeURIComponent(id)}?body-format=atlas_doc_format`);
+	const names = new UserNames(client);
+	const [spaceKey, attachments, comments, author] = await Promise.all([
+		fetchSpaceKey(client, page.spaceId),
+		fetchAttachments(client, id),
+		fetchComments$1(client, id, names),
+		names.resolve(page.version?.authorId ?? page.authorId)
+	]);
+	const webui = page._links?.webui ?? "";
+	return {
+		id: page.id,
+		title: page.title,
+		spaceKey,
+		version: page.version?.number ?? 0,
+		author,
+		createdAt: page.createdAt ?? "",
+		updatedAt: page.version?.createdAt ?? "",
+		url: webui ? `${site}/wiki${webui}` : "",
+		body: parseAdfJson(page.body?.atlas_doc_format?.value),
+		attachments,
+		comments
+	};
+}
+async function fetchPageState(client, id) {
+	const page = await client.getJson(`/wiki/api/v2/pages/${encodeURIComponent(id)}?body-format=atlas_doc_format`);
+	return {
+		version: page.version?.number ?? 0,
+		title: page.title,
+		body: parseAdfJson(page.body?.atlas_doc_format?.value)
+	};
+}
+const UNKNOWN_SIZE = -1;
+async function listAttachments(client, id) {
+	return (await client.getJson(`/wiki/api/v2/pages/${encodeURIComponent(id)}/attachments?limit=250`)).results.map((a) => ({
+		filename: a.title ?? a.id,
+		fileId: mediaNodeId(a),
+		size: typeof a.fileSize === "number" ? a.fileSize : UNKNOWN_SIZE
+	}));
+}
+async function uploadAttachment(client, pageId, filename, bytes) {
+	return (await client.postMultipart(`/wiki/rest/api/content/${encodeURIComponent(pageId)}/child/attachment`, filename, bytes)).results?.[0]?.extensions?.fileId ?? await fileIdByListing(client, pageId, filename);
+}
+async function fileIdByListing(client, pageId, filename) {
+	const match = (await listAttachments(client, pageId)).find((a) => a.filename === filename);
+	if (match) return match.fileId;
+	throw new Error(`Upload of "${filename}" did not return a fileId.`);
+}
+async function updatePage(client, id, params) {
+	return (await client.putJson(`/wiki/api/v2/pages/${encodeURIComponent(id)}`, {
+		id,
+		status: "current",
+		title: params.title,
+		body: {
+			representation: "atlas_doc_format",
+			value: JSON.stringify(params.body)
+		},
+		version: {
+			number: params.nextVersion,
+			message: params.message
+		}
+	})).version?.number ?? params.nextVersion;
+}
+async function searchPages(client, site, params) {
+	const cql = buildCql(params);
+	const query = new URLSearchParams({
+		cql,
+		limit: String(params.limit),
+		expand: "space"
+	});
+	const results = (await client.getJson(`/wiki/rest/api/search?${query.toString()}`)).results ?? [];
+	const serverPageWasFull = results.length === params.limit;
+	return {
+		pages: results.filter((r) => r.content?.id).map((r) => ({
+			id: r.content?.id ?? "",
+			space: r.space?.key ?? r.resultGlobalContainer?.title ?? "",
+			title: decodeEntities(r.content?.title ?? r.title ?? ""),
+			url: r.url ? `${site}/wiki${r.url}` : ""
+		})),
+		hasMore: serverPageWasFull
+	};
+}
+function buildCql(params) {
+	if (params.cql) return params.cql;
+	const clauses = ["type = page"];
+	if (params.space) clauses.push(`space = ${cqlStringLiteral(params.space)}`);
+	if (params.text) clauses.push(`text ~ ${cqlStringLiteral(params.text)}`);
+	return `${clauses.join(" AND ")} ORDER BY lastmodified DESC`;
+}
+function cqlStringLiteral(value) {
+	return `"${value.replace(/(["\\])/g, "\\$1")}"`;
+}
+async function fetchSpaceKey(client, spaceId) {
+	if (!spaceId) return "";
+	try {
+		return (await client.getJson(`/wiki/api/v2/spaces/${encodeURIComponent(spaceId)}`)).key ?? "";
+	} catch {
+		return "";
+	}
+}
+async function fetchAttachments(client, id) {
+	return (await client.getJson(`/wiki/api/v2/pages/${encodeURIComponent(id)}/attachments?limit=250`)).results.filter((a) => a.downloadLink).map((a) => ({
+		mediaId: mediaNodeId(a),
+		filename: a.title ?? a.id,
+		url: withWikiContextPath(a.downloadLink ?? "")
+	}));
+}
+function mediaNodeId(a) {
+	return a.fileId ?? a.id;
+}
+async function fetchComments$1(client, id, names) {
+	const res = await client.getJson(`/wiki/api/v2/pages/${encodeURIComponent(id)}/footer-comments?body-format=atlas_doc_format&limit=250`);
+	return Promise.all(res.results.map(async (c) => ({
+		author: await names.resolve(c.version?.authorId),
+		created: c.version?.createdAt ?? "",
+		body: parseAdfJson(c.body?.atlas_doc_format?.value)
+	})));
+}
+function withWikiContextPath(link) {
+	if (link.startsWith("http") || link.startsWith("/wiki")) return link;
+	return `/wiki${link}`;
+}
+function parseAdfJson(value) {
+	if (!value) return null;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return null;
+	}
+}
+var UserNames = class {
+	client;
+	cache = /* @__PURE__ */ new Map();
+	constructor(client) {
+		this.client = client;
+	}
+	async resolve(accountId) {
+		if (!accountId) return "";
+		const cached = this.cache.get(accountId);
+		if (cached !== void 0) return cached;
+		const name = await this.fetchDisplayName(accountId) ?? accountId;
+		this.cache.set(accountId, name);
+		return name;
+	}
+	async fetchDisplayName(accountId) {
+		try {
+			return (await this.client.getJson(`/wiki/rest/api/user?accountId=${encodeURIComponent(accountId)}`)).displayName || null;
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+//#region src/commands/resolve-ref.ts
+async function resolveRef(arg, kind) {
+	const raw = arg ?? await input({
+		message: kind.message,
+		required: true
+	});
+	const ref = kind.parse(raw);
+	if (!ref) throw new Error(kind.notFound(raw));
+	return ref;
+}
+//#endregion
+//#region src/commands/search-run.ts
+const COPY_CONCURRENCY = 5;
+async function runSearch(rows, options, noun, copyOne) {
+	if (options.json) {
+		console.log(JSON.stringify(rows.map((r) => r.json), null, 2));
+		return;
+	}
+	if (rows.length === 0) {
+		console.log(options.empty);
+		return;
+	}
+	if (options.copy) {
+		if (options.out?.endsWith(".md")) throw new Error("--out must be a directory when using --copy; a .md file path would overwrite each selection.");
+		await copySelected(rows, noun, copyOne);
+		return;
+	}
+	for (const row of rows) console.log(formatRow(row));
+	if (options.footer) console.log(options.footer);
+}
+function searchFooter(limit) {
+	return `
+Showing first ${limit}; refine with flags or raise --limit.`;
+}
+async function copySelected(rows, noun, copyOne) {
+	if (!process.stdin.isTTY) throw new Error("--copy requires an interactive terminal.");
+	const selected = await checkbox({
+		message: `Select ${noun.plural} to copy:`,
+		choices: rows.map((r) => ({
+			name: formatRow(r),
+			value: r.id
+		})),
+		pageSize: 20
+	});
+	if (selected.length === 0) {
+		console.log("Nothing selected.");
+		return;
+	}
+	let copied = 0;
+	const failures = [];
+	const queue = [...selected];
+	async function worker() {
+		for (let id = queue.shift(); id !== void 0; id = queue.shift()) try {
+			await copyOne(id);
+			copied++;
+		} catch (err) {
+			failures.push(`${id} (${err instanceof Error ? err.message : String(err)})`);
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(COPY_CONCURRENCY, selected.length) }, worker));
+	const summary = `Copied ${copied} ${copied === 1 ? noun.singular : noun.plural}`;
+	if (failures.length === 0) console.log(summary);
+	else console.log(`${summary}, failed ${failures.length}: ${failures.join(", ")}`);
+}
+function formatRow(row) {
+	const room = (process.stdout.columns ?? 80) - stripVTControlCharacters(row.fixedColumns).length - 2;
+	const text = room > 0 ? truncate(row.freeText, room) : "";
+	return text ? `${row.fixedColumns}  ${text}` : row.fixedColumns;
+}
+function truncate(text, max) {
+	const clean = text.replace(/\s+/g, " ").trim();
+	return clean.length <= max ? clean : `${clean.slice(0, Math.max(0, max - 3))}...`;
+}
+//#endregion
+//#region src/adf/to-markdown.ts
+function adfToMarkdown(doc, options = {}) {
+	if (!doc) return "";
+	const ctx = { resolveMedia: options.resolveMedia };
+	return (doc.type === "doc" ? renderBlocks(doc.content ?? [], ctx, "") : renderBlock(doc, ctx, "")).trim();
+}
+function renderBlocks(nodes, ctx, indent) {
+	return nodes.map((n) => renderBlock(n, ctx, indent)).filter((s) => s.length > 0).join("\n\n");
+}
+function renderBlock(node, ctx, indent) {
+	switch (node.type) {
+		case "paragraph": return indent + renderInline(node.content ?? [], ctx);
+		case "heading": {
+			const level = clampLevel(node.attrs?.["level"]);
+			return `${"#".repeat(level)} ${renderInline(node.content ?? [], ctx)}`;
+		}
+		case "bulletList": return renderList(node, ctx, indent, "bullet");
+		case "orderedList": return renderList(node, ctx, indent, "ordered");
+		case "taskList": return renderTaskList(node, ctx, indent);
+		case "decisionList": return renderDecisionList(node, ctx, indent);
+		case "codeBlock": return renderCodeBlock(node, indent);
+		case "blockquote": return prefixLines(renderBlocks(node.content ?? [], ctx, ""), `${indent}> `);
+		case "panel": return renderPanel(node, ctx, indent);
+		case "rule": return `${indent}---`;
+		case "table": return renderTable(node, ctx);
+		case "mediaSingle":
+		case "mediaGroup": return renderBlocks(node.content ?? [], ctx, indent);
+		case "media": return indent + renderMedia(node, ctx);
+		case "expand":
+		case "nestedExpand": return renderExpand(node, ctx, indent);
+		default:
+			if (node.content?.length) return renderBlocks(node.content, ctx, indent);
+			return node.text ? indent + node.text : "";
+	}
+}
+function renderList(node, ctx, indent, kind) {
+	const start = kind === "ordered" ? toNumber(node.attrs?.["order"]) ?? 1 : 0;
+	return (node.content ?? []).filter((n) => n.type === "listItem").map((item, i) => {
+		return renderListItem(item, ctx, indent, kind === "ordered" ? `${start + i}. ` : "- ");
+	}).join("\n");
+}
+function renderListItem(item, ctx, indent, marker) {
+	const continuationIndent = `${indent}${" ".repeat(marker.length)}`;
+	return (item.content ?? []).map((block, i) => i === 0 ? `${indent}${marker}${renderBlock(block, ctx, "")}` : renderBlock(block, ctx, continuationIndent)).join("\n");
+}
+function renderTaskList(node, ctx, indent) {
+	return (node.content ?? []).filter((n) => n.type === "taskItem").map((item) => {
+		return `${indent}- [${item.attrs?.["state"] === "DONE" ? "x" : " "}] ${renderInline(item.content ?? [], ctx)}`;
+	}).join("\n");
+}
+function renderDecisionList(node, ctx, indent) {
+	return (node.content ?? []).filter((n) => n.type === "decisionItem").map((item) => `${indent}- (decision) ${renderInline(item.content ?? [], ctx)}`).join("\n");
+}
+function renderCodeBlock(node, indent) {
+	const lang = typeof node.attrs?.["language"] === "string" ? node.attrs["language"] : "";
+	const code = (node.content ?? []).map((n) => n.text ?? "").join("");
+	const fence = "```";
+	return prefixLines(`${fence}${lang}\n${code}\n${fence}`, indent);
+}
+const PANEL_LABELS = {
+	info: "Info",
+	note: "Note",
+	warning: "Warning",
+	success: "Success",
+	error: "Error"
+};
+function renderPanel(node, ctx, indent) {
+	return prefixLines(`**${PANEL_LABELS[typeof node.attrs?.["panelType"] === "string" ? node.attrs["panelType"] : "info"] ?? "Note"}**\n\n${renderBlocks(node.content ?? [], ctx, "")}`, `${indent}> `);
+}
+function renderExpand(node, ctx, indent) {
+	return `${indent}<details><summary>${typeof node.attrs?.["title"] === "string" ? node.attrs["title"] : "Details"}</summary>\n\n${renderBlocks(node.content ?? [], ctx, "")}\n\n${indent}</details>`;
+}
+function renderTable(node, ctx) {
+	const rows = (node.content ?? []).filter((n) => n.type === "tableRow");
+	if (rows.length === 0) return "";
+	const grid = rows.map((row) => (row.content ?? []).map((cell) => renderCellOnOneLine(cell, ctx)));
+	const cols = Math.max(...grid.map((r) => r.length));
+	const pad = (r) => {
+		const copy = [...r];
+		while (copy.length < cols) copy.push("");
+		return copy;
+	};
+	const header = pad(grid[0] ?? []);
+	const lines = [`| ${header.join(" | ")} |`, `| ${header.map(() => "---").join(" | ")} |`];
+	for (const row of grid.slice(1)) lines.push(`| ${pad(row).join(" | ")} |`);
+	return lines.join("\n");
+}
+function renderCellOnOneLine(cell, ctx) {
+	return renderBlocks(cell.content ?? [], ctx, "").replace(/\n+/g, " ").replace(/\|/g, "\\|").trim();
+}
+function renderMedia(node, ctx) {
+	const attrs = node.attrs ?? {};
+	const alt = attrs.alt ?? "";
+	const resolved = ctx.resolveMedia?.(attrs);
+	if (resolved) return `![${alt}](${resolved})`;
+	return `[embedded media: ${alt || attrs.id || "media"}]`;
+}
+function renderInline(nodes, ctx) {
+	return nodes.map((n) => renderInlineNode(n, ctx)).join("");
+}
+function renderInlineNode(node, ctx) {
+	switch (node.type) {
+		case "text": return applyMarks(node.text ?? "", node.marks ?? []);
+		case "hardBreak": return "  \n";
+		case "mention": return (typeof node.attrs?.["text"] === "string" ? node.attrs["text"] : "") || "@unknown";
+		case "emoji": {
+			const text = node.attrs?.["text"];
+			if (typeof text === "string" && text.length > 0) return text;
+			const short = node.attrs?.["shortName"];
+			return typeof short === "string" ? short : "";
+		}
+		case "date": return formatDate(node.attrs?.["timestamp"]);
+		case "status": return `\`[${typeof node.attrs?.["text"] === "string" ? node.attrs["text"] : ""}]\``;
+		case "inlineCard": {
+			const url = node.attrs?.["url"];
+			if (typeof url === "string") return `[${url}](${url})`;
+			return "";
+		}
+		case "media": return renderMedia(node, ctx);
+		default: return node.text ?? "";
+	}
+}
+function applyMarks(text, marks) {
+	if (text.length === 0) return text;
+	let out = text;
+	let href;
+	for (const mark of marks) switch (mark.type) {
+		case "code":
+			out = `\`${out}\``;
+			break;
+		case "strong":
+			out = `**${out}**`;
+			break;
+		case "em":
+			out = `*${out}*`;
+			break;
+		case "strike":
+			out = `~~${out}~~`;
+			break;
+		case "link": {
+			const value = mark.attrs?.["href"];
+			if (typeof value === "string") href = value;
+			break;
+		}
+		default: break;
+	}
+	if (href) out = `[${out}](${href})`;
+	return out;
+}
+function prefixLines(text, prefix) {
+	return text.split("\n").map((line) => line.length > 0 ? prefix + line : prefix.trimEnd()).join("\n");
+}
+function clampLevel(value) {
+	const n = toNumber(value) ?? 1;
+	return Math.min(6, Math.max(1, n));
+}
+function toNumber(value) {
+	return typeof value === "number" ? value : void 0;
+}
+function formatDate(timestamp) {
+	const ms = typeof timestamp === "string" ? Number(timestamp) : typeof timestamp === "number" ? timestamp : NaN;
+	if (Number.isNaN(ms)) return "";
+	return new Date(ms).toISOString().slice(0, 10);
+}
+//#endregion
+//#region src/api/attachments.ts
+function mediaResolver(downloaded) {
+	const byMediaId = new Map(downloaded.map((d) => [d.mediaId, d.relativePath]));
+	const byFilename = new Map(downloaded.map((d) => [d.filename, d.relativePath]));
+	return (media) => {
+		if (media.id && byMediaId.has(media.id)) return byMediaId.get(media.id);
+		if (media.alt && byFilename.has(media.alt)) return byFilename.get(media.alt);
+	};
+}
+//#endregion
+//#region src/markdown/copied-document.ts
+const COMMENTS_HEADING = "## Comments";
+const ATTACHMENTS_HEADING = "## Attachments";
+const FRONTMATTER_BLOCK = /^---\n([\s\S]*?)\n---\n?/;
+const FRONTMATTER_KEY = /^([A-Za-z0-9_]+):\s*(.*)$/;
+const FRONTMATTER_LIST_ITEM = /^ {2}- (.*)$/;
+const BARE_NUMBER = /^-?\d+(\.\d+)?$/;
+const TRAILING_SECTION_HEADING = /^## (Comments|Attachments)\s*$/;
+function render(doc) {
+	return `${[
+		frontmatter(doc.fields),
+		`# ${doc.title}`,
+		doc.body,
+		commentsSection(doc.comments),
+		attachmentsSection(doc.attachments)
+	].filter((s) => s.trim().length > 0).join("\n\n")}\n`;
+}
+function parse(text) {
+	const match = text.match(FRONTMATTER_BLOCK);
+	if (!match) throw new Error("Not an atlass file: no YAML frontmatter found.");
+	const fields = parseFrontmatter(match[1] ?? "");
+	const lines = text.slice(match[0].length).split("\n");
+	const h1 = leadingH1(lines);
+	const start = h1 ? h1.index + 1 : 0;
+	const trailing = lines.findIndex((line, i) => i >= start && TRAILING_SECTION_HEADING.test(line));
+	const end = trailing === -1 ? lines.length : trailing;
+	const fallbackTitle = typeof fields["title"] === "string" ? fields["title"] : "";
+	return {
+		fields,
+		title: h1?.title ?? fallbackTitle,
+		body: lines.slice(start, end).join("\n").trim()
+	};
+}
+function parseIssueSource(text) {
+	const source = parse(text);
+	const key = scalarString(source.fields["key"]);
+	if (!key) throw new Error("Frontmatter is missing the issue `key`; re-copy the issue.");
+	return {
+		...source,
+		key,
+		updatedAtCopy: scalarString(source.fields["updated"])
+	};
+}
+function parsePageSource(text) {
+	const source = parse(text);
+	const id = scalarString(source.fields["id"]);
+	if (!id) throw new Error("Frontmatter is missing the page `id`; re-copy the page.");
+	const rawVersion = scalarString(source.fields["version"]);
+	const version = rawVersion === "" ? NaN : Number(rawVersion);
+	if (!Number.isFinite(version)) throw new Error("Frontmatter is missing a numeric `version`; re-copy the page.");
+	return {
+		...source,
+		id,
+		version
+	};
+}
+function scalarString(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return String(value);
+	return "";
+}
+function frontmatter(fields) {
+	const lines = ["---"];
+	for (const [key, value] of Object.entries(fields)) if (Array.isArray(value)) if (value.length === 0) lines.push(`${key}: []`);
+	else lines.push(`${key}:`, ...value.map((v) => `  - ${quote(v)}`));
+	else if (typeof value === "number") lines.push(`${key}: ${value}`);
+	else lines.push(`${key}: ${quote(value)}`);
+	lines.push("---");
+	return lines.join("\n");
+}
+function parseFrontmatter(block) {
+	const fields = {};
+	const lines = block.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const m = lines[i]?.match(FRONTMATTER_KEY);
+		if (!m) continue;
+		const key = m[1] ?? "";
+		const raw = (m[2] ?? "").trim();
+		if (raw === "[]") fields[key] = [];
+		else if (raw === "") {
+			const items = [];
+			for (let item; item = lines[i + 1]?.match(FRONTMATTER_LIST_ITEM); i++) items.push(unquote((item[1] ?? "").trim()));
+			fields[key] = items;
+		} else fields[key] = scalar(raw);
+	}
+	return fields;
+}
+function scalar(raw) {
+	if (raw.startsWith("\"")) return unquote(raw);
+	if (BARE_NUMBER.test(raw)) return Number(raw);
+	return raw;
+}
+function quote(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function unquote(value) {
+	if (!value.startsWith("\"") || !value.endsWith("\"")) return value;
+	return value.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+}
+function leadingH1(lines) {
+	for (const [index, line] of lines.entries()) {
+		if (line.startsWith("# ")) return {
+			index,
+			title: line.slice(2).trim()
+		};
+		if (line.trim().length > 0) return null;
+	}
+	return null;
+}
+function commentsSection(comments) {
+	if (comments.length === 0) return "";
+	return [
+		COMMENTS_HEADING,
+		"",
+		comments.map((c) => {
+			const heading = `### ${c.author || "Unknown"}${c.created ? ` - ${formatDateTime(c.created)}` : ""}`;
+			return c.body ? `${heading}\n\n${c.body}` : heading;
+		}).join("\n\n")
+	].join("\n");
+}
+function attachmentsSection(attachments) {
+	if (attachments.length === 0) return "";
+	return [
+		ATTACHMENTS_HEADING,
+		"",
+		...attachments.map((a) => `- [${a.filename}](${a.relativePath})`)
+	].join("\n");
+}
+//#endregion
+//#region src/copy/plan.ts
+function planIssueCopy(issue, out) {
+	return planCopy({
+		baseName: issue.key,
+		fields: {
+			key: issue.key,
+			type: issue.type,
+			status: issue.status,
+			assignee: issue.assignee,
+			reporter: issue.reporter,
+			priority: issue.priority,
+			labels: issue.labels,
+			created: issue.created,
+			updated: issue.updated,
+			url: issue.url
+		},
+		title: issue.summary,
+		body: issue.description,
+		comments: issue.comments,
+		attachments: issue.attachments
+	}, out);
+}
+function planPageCopy(page, out) {
+	return planCopy({
+		baseName: `${page.id}-${slugify(page.title)}`,
+		fields: {
+			title: page.title,
+			id: page.id,
+			space: page.spaceKey,
+			version: page.version,
+			author: page.author,
+			created: page.createdAt,
+			updated: page.updatedAt,
+			url: page.url
+		},
+		title: page.title,
+		body: page.body,
+		comments: page.comments,
+		attachments: page.attachments
+	}, out);
+}
+function renderCopy(plan, landed) {
+	const resolveMedia = mediaResolver(landed);
+	return render({
+		fields: plan.fields,
+		title: plan.title,
+		body: adfToMarkdown(plan.body, { resolveMedia }),
+		comments: plan.comments.map((c) => ({
+			author: c.author,
+			created: c.created,
+			body: adfToMarkdown(c.body, { resolveMedia })
+		})),
+		attachments: landed
+	});
+}
+function planCopy(source, out) {
+	const { baseName, attachments, ...content } = source;
+	const target = outputTarget(baseName, out);
+	return {
+		...content,
+		filePath: target.filePath,
+		assetsDir: target.assetsDir,
+		downloads: planDownloads(attachments, target)
+	};
+}
+function outputTarget(base, out) {
+	let filePath;
+	if (!out) filePath = resolve(`${base}.md`);
+	else if (out.endsWith(".md")) filePath = isAbsolute(out) ? out : resolve(out);
+	else filePath = resolve(out, `${base}.md`);
+	const dir = dirname(filePath);
+	const assetsDirName = `${filePath.slice(dir.length + 1).replace(/\.md$/, "")}.assets`;
+	return {
+		filePath,
+		assetsDir: join(dir, assetsDirName),
+		assetsDirName
+	};
+}
+function slugify(title) {
+	return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "") || "page";
+}
+function planDownloads(attachments, target) {
+	const used = /* @__PURE__ */ new Set();
+	return attachments.map((att) => {
+		const savedAs = uniqueName(bareFilename(att.filename), used);
+		return {
+			...att,
+			relativePath: `${target.assetsDirName}/${savedAs}`,
+			path: join(target.assetsDir, savedAs)
+		};
+	});
+}
+function bareFilename(name) {
+	return basename(name).replace(/[/\\]/g, "_") || "attachment";
+}
+function uniqueName(name, used) {
+	let candidate = name;
+	for (let suffix = 1; used.has(candidate); suffix++) candidate = numberedName(name, suffix);
+	used.add(candidate);
+	return candidate;
+}
+function numberedName(name, suffix) {
+	const dot = name.lastIndexOf(".");
+	return `${dot > 0 ? name.slice(0, dot) : name}-${suffix}${dot > 0 ? name.slice(dot) : ""}`;
+}
+//#endregion
+//#region src/copy/run.ts
+async function runCopy(plan, fetchBytes) {
+	const landed = await download(plan, fetchBytes);
+	await mkdir(dirname(plan.filePath), { recursive: true });
+	await writeFile(plan.filePath, renderCopy(plan, landed), "utf8");
+	console.log(wroteLine(plan.filePath, landed.length));
+}
+async function download(plan, fetchBytes) {
+	if (plan.downloads.length === 0) return [];
+	await mkdir(plan.assetsDir, { recursive: true });
+	const landed = [];
+	for (const { path, ...attachment } of plan.downloads) try {
+		await writeFile(path, await fetchBytes(attachment.url));
+		landed.push(attachment);
+	} catch (err) {
+		console.warn(`  ! could not download ${attachment.filename}: ${err.message}`);
+	}
+	return landed;
+}
+function wroteLine(filePath, attachmentCount) {
+	return `Wrote ${filePath}${attachmentCount > 0 ? ` (+${attachmentCount} attachment${attachmentCount === 1 ? "" : "s"})` : ""}`;
+}
+//#endregion
+//#region src/adf/lossy.ts
+const LOSSY_LABELS = {
+	panel: "panel",
+	expand: "expand",
+	nestedExpand: "expand",
+	decisionList: "decision list",
+	layoutSection: "layout",
+	extension: "macro",
+	bodiedExtension: "macro",
+	inlineExtension: "macro"
+};
+const JIRA_LOSSY_LABELS = {
+	...LOSSY_LABELS,
+	media: "image",
+	mediaInline: "image"
+};
+function findLossyNodes(node, lossyLabels = LOSSY_LABELS) {
+	const counts = /* @__PURE__ */ new Map();
+	const visit = (n) => {
+		const label = lossyLabels[n.type];
+		if (label) counts.set(label, (counts.get(label) ?? 0) + 1);
+		for (const child of n.content ?? []) visit(child);
+	};
+	if (node) visit(node);
+	return counts;
+}
+function formatLossy(counts) {
+	return [...counts.entries()].map(([label, n]) => `${n} ${label}${n === 1 ? "" : "s"}`).join(", ");
+}
+//#endregion
+//#region src/update/plan.ts
+function planIssueUpdate(source, issue, options) {
+	const images = imageHrefs(source.body).map((href) => ({
+		href,
+		kind: isExternalHref(href) ? "external" : "unsupported"
+	}));
+	const unsupported = images.filter((i) => i.kind === "unsupported").map((i) => i.href);
+	const body = markdownToAdf(source.body, { resolveImage: (href, alt) => isExternalHref(href) ? externalMedia(href, alt) : void 0 });
+	const refusals = [...unsupported.length > 0 ? [`jira update does not support image changes yet. Remove local image reference(s) or edit text only: ${unsupported.join(", ")}`] : [], ...emptyBodyRefusal(body)];
+	return withVerdict({
+		noun: "issue",
+		id: source.key,
+		headline: headline("summary", issue.summary, source.title, options.summary),
+		revision: revision(source.updatedAtCopy, issue.updated),
+		lossy: findLossyNodes(issue.description, JIRA_LOSSY_LABELS),
+		images,
+		uploads: [],
+		body,
+		refusals
+	}, options.force ?? false);
+}
+function planPageUpdate(source, state, attachments, localImages, options) {
+	const collection = `contentId-${source.id}`;
+	const entries = imageHrefs(source.body).map((href) => pageImage(href, localImages, attachments));
+	const byHref = new Map(entries.map((e) => [e.href, e]));
+	const body = markdownToAdf(source.body, { resolveImage: (href, alt) => {
+		const entry = byHref.get(href);
+		if (!entry || entry.kind === "missing") return void 0;
+		if (entry.kind === "external") return externalMedia(href, alt);
+		return mediaNode({
+			type: "file",
+			id: entry.kind === "reuse" ? entry.fileId : href,
+			collection
+		}, alt);
+	} });
+	const missing = entries.filter((e) => e.kind === "missing").map((e) => e.href);
+	const refusals = [...missing.length > 0 ? [`Image file(s) not found: ${missing.join(", ")}`] : [], ...emptyBodyRefusal(body)];
+	return withVerdict({
+		noun: "page",
+		id: source.id,
+		headline: headline("title", state.title, source.title, options.title),
+		revision: revision(`v${source.version}`, `v${state.version}`),
+		lossy: findLossyNodes(state.body),
+		images: entries.map(({ href, kind }) => ({
+			href,
+			kind
+		})),
+		uploads: entries.flatMap((e) => e.kind === "upload" || e.kind === "changed" ? [{
+			href: e.href,
+			path: e.path,
+			filename: e.filename
+		}] : []),
+		body,
+		refusals
+	}, options.force ?? false);
+}
+function pageImage(href, localImages, attachments) {
+	if (isExternalHref(href)) return {
+		href,
+		kind: "external"
+	};
+	const local = localImages.find((l) => l.href === href);
+	if (!local || local.size === void 0) return {
+		href,
+		kind: "missing"
+	};
+	const existing = attachments.find((a) => a.filename === local.filename);
+	if (existing && existing.size === local.size) return {
+		href,
+		kind: "reuse",
+		fileId: existing.fileId
+	};
+	return {
+		href,
+		kind: existing ? "changed" : "upload",
+		path: local.path,
+		filename: local.filename
+	};
+}
+function withUploadedIds(doc, ids) {
+	if (!doc.content) return doc;
+	return {
+		...doc,
+		content: doc.content.map((n) => withUploadedId(n, ids))
+	};
+}
+function withUploadedId(node, ids) {
+	const id = node.type === "media" ? node.attrs?.["id"] : void 0;
+	const swapped = typeof id === "string" && ids.has(id) ? {
+		...node,
+		attrs: {
+			...node.attrs,
+			id: ids.get(id)
+		}
+	} : node;
+	if (!swapped.content) return swapped;
+	return {
+		...swapped,
+		content: swapped.content.map((n) => withUploadedId(n, ids))
+	};
+}
+function formatPlan(plan) {
+	const lines = [`Dry run for ${plan.noun} ${plan.id} "${plan.headline.current}"`];
+	if (plan.headline.next !== plan.headline.current) lines.push(row(plan.headline.label, `"${plan.headline.current}" -> "${plan.headline.next}"`));
+	const counts = imageCounts(plan.images);
+	if (counts) lines.push(row("images", counts));
+	for (const refusal of plan.refusals) lines.push(row("blocked", refusal));
+	if (plan.lossy.size > 0) lines.push(row("warning", `${formatLossy(plan.lossy)} will be removed`));
+	if (plan.revision.stale) lines.push(row("stale", `${revisionText(plan.revision)} (would refuse without --force)`));
+	lines.push("  nothing was written (dry run)");
+	return lines;
+}
+const IMAGE_COUNT_LABELS = [
+	["upload", "new"],
+	["changed", "changed"],
+	["reuse", "reused"],
+	["external", "external"],
+	["unsupported", "unsupported"],
+	["missing", "missing"]
+];
+function imageCounts(images) {
+	return IMAGE_COUNT_LABELS.map(([kind, label]) => ({
+		n: images.filter((i) => i.kind === kind).length,
+		label
+	})).filter(({ n }) => n > 0).map(({ n, label }) => `${n} ${label}`).join(", ");
+}
+function row(label, value) {
+	return `  ${`${label}:`.padEnd(9)}${value}`;
+}
+function headline(label, current, title, useTitle) {
+	return {
+		label,
+		current,
+		next: useTitle && title ? title : current
+	};
+}
+function revision(local, server) {
+	return {
+		local: local || "unknown",
+		server: server || "unknown",
+		stale: local !== server
+	};
+}
+function revisionText(revision) {
+	return `copied at ${revision.local}, server now ${revision.server}`;
+}
+function emptyBodyRefusal(body) {
+	if (body.content && body.content.length > 0) return [];
+	return ["Refusing to update: the converted body is empty."];
+}
+function withVerdict(plan, force) {
+	return {
+		...plan,
+		verdict: verdict(plan, force)
+	};
+}
+function verdict(plan, force) {
+	if (plan.refusals.length > 0) return {
+		kind: "refuse",
+		message: plan.refusals.join("\n")
+	};
+	const noun = plan.noun;
+	if (plan.revision.stale && !force) return {
+		kind: "refuse",
+		message: `${capitalize(noun)} changed on the server since you copied it (${revisionText(plan.revision)}). Re-copy the ${noun} or pass --force.`
+	};
+	if (plan.lossy.size > 0 && !force) return {
+		kind: "confirm",
+		message: `This ${noun} contains ${formatLossy(plan.lossy)} that Markdown cannot represent and will be removed. Continue?`
+	};
+	return { kind: "proceed" };
+}
+function capitalize(text) {
+	return text.charAt(0).toUpperCase() + text.slice(1);
+}
+//#endregion
+//#region src/update/run.ts
+async function runPlan(plan, options, push) {
+	if (options.dryRun) {
+		for (const line of formatPlan(plan)) console.log(line);
+		return;
+	}
+	const verdict = plan.verdict;
+	if (verdict.kind === "refuse") throw new Error(verdict.message);
+	if (verdict.kind === "confirm") {
+		if (!await confirm({
+			message: verdict.message,
+			default: false
+		})) {
+			console.log("Aborted.");
+			return;
+		}
+	}
+	await push();
+}
+//#endregion
+//#region src/commands/confluence.ts
+async function confluenceCopy(arg, options) {
+	const auth = await requireAuth();
+	const id = await resolveRef(arg, PAGE_REF);
+	await copyPage(new AtlassianClient(auth), auth.site, id, options.out);
+}
+async function confluenceUpdate(arg, options) {
+	const file = arg ?? await input({
+		message: "Path to the page Markdown file:",
+		required: true
+	});
+	const src = parsePageSource(await readFile(file, "utf8"));
+	const client = new AtlassianClient(await requireAuth());
+	const state = await fetchPageState(client, src.id);
+	const plan = planPageUpdate(src, state, await listAttachments(client, src.id), await statLocalImages(dirname(resolve(file)), src.body), options);
+	await runPlan(plan, options, async () => {
+		const ids = /* @__PURE__ */ new Map();
+		for (const upload of plan.uploads) {
+			console.log(`Uploading ${upload.filename} ...`);
+			const bytes = await readFile(upload.path);
+			ids.set(upload.href, await uploadAttachment(client, src.id, upload.filename, bytes));
+		}
+		const version = await updatePage(client, src.id, {
+			title: plan.headline.next,
+			nextVersion: state.version + 1,
+			body: withUploadedIds(plan.body, ids),
+			message: options.message ?? "Updated via atlass"
+		});
+		console.log(`Updated page ${src.id} to version ${version}.`);
+	});
+}
+async function statLocalImages(dir, md) {
+	const hrefs = imageHrefs(md).filter((href) => !isExternalHref(href));
+	return Promise.all(hrefs.map(async (href) => {
+		const path = isAbsolute(href) ? href : resolve(dir, href);
+		return {
+			href,
+			path,
+			filename: basename(path),
+			...await fileSize(path)
+		};
+	}));
+}
+async function fileSize(path) {
+	try {
+		return { size: (await stat(path)).size };
+	} catch {
+		return {};
+	}
+}
+async function confluenceSearch(query, options) {
+	if (options.cql && (query || options.space)) throw new Error("--cql cannot be combined with a text query or --space.");
+	if (options.json && options.copy) throw new Error("--json and --copy cannot be used together.");
+	const auth = await requireAuth();
+	const client = new AtlassianClient(auth);
+	const limit = parseLimit(options.limit);
+	const { pages, hasMore } = await searchPages(client, auth.site, {
+		text: query,
+		space: options.space,
+		cql: options.cql,
+		limit
+	});
+	await runSearch(pages.map((p) => ({
+		id: p.id,
+		fixedColumns: `${p.id}  ${p.space}`,
+		freeText: p.title,
+		json: {
+			id: p.id,
+			space: p.space,
+			title: p.title,
+			url: p.url
+		}
+	})), {
+		json: options.json,
+		copy: options.copy,
+		out: options.out,
+		empty: "No matching pages.",
+		footer: hasMore ? searchFooter(limit) : void 0
+	}, {
+		singular: "page",
+		plural: "pages"
+	}, (id) => copyPage(client, auth.site, id, options.out));
+}
+async function copyPage(client, site, id, out) {
+	console.log(`Fetching page ${id} ...`);
+	await runCopy(planPageCopy(await fetchPage(client, site, id), out), (url) => client.getBinary(url));
+}
+const PAGE_REF = {
+	message: "Confluence page id or URL:",
+	parse: parsePageId,
+	notFound: (raw) => `Could not find a page id in "${raw}".`
+};
+//#endregion
+//#region src/cli/confluence.ts
+function registerConfluence(confluence) {
+	confluence.description("Confluence commands");
+	confluence.command("copy [page]").description("Copy a Confluence page (id or URL) to a Markdown file").option("-o, --out <path>", "output file or directory").action(run(confluenceCopy));
+	confluence.command("update [file]").description("Update a Confluence page from an edited Markdown file").option("--title", "also push the H1 as the page title").option("-m, --message <text>", "version message (default 'Updated via atlass')").option("-f, --force", "skip the stale-version and data-loss checks").option("--dry-run", "show what would change without writing").action(run(confluenceUpdate));
+	confluence.command("search [query]").description("Search Confluence pages (text query, --space, or --cql)").option("-s, --space <key>", "limit to a space").option("--cql <cql>", "raw CQL query (ignores other filters)").option("-l, --limit <n>", "max results (default 25, max 100)").option("--json", "output results as JSON").option("-c, --copy", "pick results to copy to Markdown").option("-o, --out <dir>", "output directory for --copy").action(run(confluenceSearch));
+	return confluence;
+}
+//#endregion
+//#region src/api/jira.ts
+const FIELDS = [
+	"summary",
+	"description",
+	"issuetype",
+	"status",
+	"assignee",
+	"reporter",
+	"priority",
+	"labels",
+	"created",
+	"updated",
+	"attachment"
+].join(",");
+const RECENT_ISSUES_CLAUSE = "updated >= -30d";
+function browseUrl(site, key) {
+	return `${site}/browse/${key}`;
+}
+async function fetchIssue(client, site, key) {
+	const issue = await client.getJson(`/rest/api/3/issue/${encodeURIComponent(key)}?fields=${FIELDS}`);
+	const comments = await fetchComments(client, key);
+	const f = issue.fields;
+	return {
+		key: issue.key,
+		url: browseUrl(site, issue.key),
+		summary: f.summary ?? "",
+		type: f.issuetype?.name ?? "",
+		status: f.status?.name ?? "",
+		statusCategory: f.status?.statusCategory?.key ?? "",
+		assignee: f.assignee?.displayName ?? "Unassigned",
+		reporter: f.reporter?.displayName ?? "",
+		priority: f.priority?.name ?? "",
+		labels: f.labels ?? [],
+		created: f.created ?? "",
+		updated: f.updated ?? "",
+		description: f.description ?? null,
+		comments,
+		attachments: (f.attachment ?? []).map((a) => ({
+			mediaId: a.id,
+			filename: a.filename,
+			url: a.content
+		}))
+	};
+}
+async function updateIssue(client, key, update) {
+	const fields = { description: update.description };
+	if (update.summary !== void 0) fields["summary"] = update.summary;
+	await client.putNoContent(`/rest/api/3/issue/${encodeURIComponent(key)}`, { fields });
+}
+const SEARCH_FIELDS = "summary,status,updated";
+async function searchIssues(client, site, params) {
+	return ((await fetchSearchPage(client, buildJql(params), params.limit)).issues ?? []).map((i) => toIssueSummary(site, i));
+}
+async function fetchSearchPage(client, jql, maxResults, nextPageToken) {
+	const query = new URLSearchParams({
+		jql,
+		maxResults: String(maxResults),
+		fields: SEARCH_FIELDS
+	});
+	if (nextPageToken) query.set("nextPageToken", nextPageToken);
+	return client.getJson(`/rest/api/3/search/jql?${query.toString()}`);
+}
+function toIssueSummary(site, i) {
+	return {
+		key: i.key,
+		status: i.fields?.status?.name ?? "",
+		statusCategory: i.fields?.status?.statusCategory?.key ?? "",
+		summary: decodeEntities(i.fields?.summary ?? ""),
+		updated: i.fields?.updated ?? "",
+		url: browseUrl(site, i.key)
+	};
+}
+function buildJql(params) {
+	if (params.jql) return params.jql;
+	const clauses = [];
+	if (params.project) clauses.push(`project = ${jqlStringLiteral(params.project)}`);
+	if (params.assignee) clauses.push(params.assignee === "me" ? "assignee = currentUser()" : `assignee = ${jqlStringLiteral(params.assignee)}`);
+	if (params.status) clauses.push(`status = ${jqlStringLiteral(params.status)}`);
+	if (params.text) clauses.push(`text ~ ${jqlStringLiteral(params.text)}`);
+	if (clauses.length === 0) clauses.push(RECENT_ISSUES_CLAUSE);
+	return `${clauses.join(" AND ")} ORDER BY updated DESC`;
+}
+const OPEN_CLAUSE = "statusCategory != Done";
+function buildListJql(params) {
+	const clauses = ["assignee = currentUser()"];
+	if (params.project) clauses.push(`project = ${jqlStringLiteral(params.project)}`);
+	clauses.push(params.all ? `(${OPEN_CLAUSE} OR ${RECENT_ISSUES_CLAUSE})` : OPEN_CLAUSE);
+	return `${clauses.join(" AND ")} ORDER BY updated DESC`;
+}
+const LIST_PAGE_SIZE = 100;
+const LIST_CAP = 500;
+async function listAssignedIssues(client, site, params) {
+	const jql = buildListJql(params);
+	const issues = [];
+	let nextPageToken;
+	for (;;) {
+		const room = LIST_CAP - issues.length;
+		const res = await fetchSearchPage(client, jql, Math.min(LIST_PAGE_SIZE, room), nextPageToken);
+		const page = res.issues ?? [];
+		issues.push(...page.map((i) => toIssueSummary(site, i)));
+		if (res.isLast || !res.nextPageToken || page.length === 0) return {
+			issues,
+			truncated: false
+		};
+		if (issues.length >= LIST_CAP) return {
+			issues,
+			truncated: true
+		};
+		nextPageToken = res.nextPageToken;
+	}
+}
+const LIST_CATEGORY_ORDER = {
+	indeterminate: 0,
+	new: 1,
+	done: 2
+};
+const LIST_UNKNOWN_CATEGORY_RANK = Object.keys(LIST_CATEGORY_ORDER).length;
+function sortByCategoryThenUpdated(issues) {
+	const rank = (i) => LIST_CATEGORY_ORDER[i.statusCategory] ?? LIST_UNKNOWN_CATEGORY_RANK;
+	const updatedMs = (i) => Date.parse(i.updated) || 0;
+	return [...issues].sort((a, b) => rank(a) - rank(b) || updatedMs(b) - updatedMs(a));
+}
+const PROJECT_PAGE_SIZE = 50;
+async function listProjects(client, site, query) {
+	const projects = [];
+	for (let startAt = 0;;) {
+		const res = await client.getJson(`/rest/api/3/project/search?${projectSearchQuery(query, startAt)}`);
+		const values = res.values ?? [];
+		for (const p of values) projects.push({
+			key: p.key,
+			name: p.name,
+			id: p.id,
+			type: p.projectTypeKey ?? "",
+			url: browseUrl(site, p.key)
+		});
+		if (res.isLast || values.length === 0) break;
+		startAt += values.length;
+	}
+	return projects;
+}
+function projectSearchQuery(query, startAt) {
+	const params = new URLSearchParams({
+		orderBy: "key",
+		maxResults: String(PROJECT_PAGE_SIZE),
+		startAt: String(startAt)
+	});
+	if (query) params.set("query", query);
+	return params.toString();
+}
+async function listStatuses(client, project) {
+	return dedupeAndSortStatuses((project ? await fetchProjectStatuses(client, project) : await client.getJson("/rest/api/3/status")).map(toStatusSummary));
+}
+async function fetchProjectStatuses(client, project) {
+	let groups;
+	try {
+		groups = await client.getJson(`/rest/api/3/project/${encodeURIComponent(project)}/statuses`);
+	} catch (err) {
+		if (err instanceof HttpError && err.status === 404) throw new Error(`No project found with key "${project}".`);
+		throw err;
+	}
+	return groups.flatMap((g) => g.statuses ?? []);
+}
+function toStatusSummary(s) {
+	return {
+		name: s.name,
+		id: s.id,
+		category: s.statusCategory?.name ?? "",
+		categoryKey: s.statusCategory?.key ?? ""
+	};
+}
+const CATEGORY_ORDER = {
+	new: 0,
+	indeterminate: 1,
+	done: 2
+};
+const UNKNOWN_CATEGORY_RANK = Object.keys(CATEGORY_ORDER).length;
+function dedupeAndSortStatuses(statuses) {
+	const byNameCategory = /* @__PURE__ */ new Map();
+	for (const s of statuses) {
+		const key = `${s.name}\0${s.categoryKey}`;
+		if (!byNameCategory.has(key)) byNameCategory.set(key, s);
+	}
+	return [...byNameCategory.values()].sort((a, b) => {
+		const rank = (s) => CATEGORY_ORDER[s.categoryKey] ?? UNKNOWN_CATEGORY_RANK;
+		return rank(a) - rank(b) || a.name.localeCompare(b.name);
+	});
+}
+function jqlStringLiteral(value) {
+	return `"${value.replace(/(["\\])/g, "\\$1")}"`;
+}
+async function fetchComments(client, key) {
+	return (await client.getJson(`/rest/api/3/issue/${encodeURIComponent(key)}/comment?maxResults=100&orderBy=created`)).comments.map((c) => ({
+		author: c.author?.displayName ?? "",
+		created: c.created ?? "",
+		body: c.body ?? null
+	}));
+}
+//#endregion
+//#region src/markdown/highlight.ts
+const HEADING = /^#{1,6} /;
+const QUOTE = /^(\s*)>( |$)/;
+const LIST = /^(\s*)(-|\d+\.) (\[[ x]\] )?/;
+const RULE = /^\s*---$/;
+const TABLE_ROW = /^\|.*\|$/;
+const TABLE_SEPARATOR = /^\|( --- \|)+$/;
+const CELL_DIVIDER = /(?<!\\)\|/;
+const DETAILS_OPEN = /^(\s*)<details><summary>(.*)<\/summary>$/;
+const DETAILS_CLOSE = /^\s*<\/details>$/;
+const FENCE_OPEN = /^((?:\s|> |- |\d+\. )*)```(\S*)$/;
+const FENCE = "```";
+const INLINE = /(`[^`]+`)|\[([^\]]+)\]\(((?:[^()]|\([^()]*\))+)\)|\*\*\*(.+?)\*\*\*|\*\*(.+?)\*\*|\*(?!\*)(.+?)(?<!\*)\*(?!\*)|~~(.+?)~~/g;
+const TOKEN_STYLES = {
+	keyword: kleur.magenta,
+	built_in: kleur.magenta,
+	literal: kleur.magenta,
+	string: kleur.green,
+	regexp: kleur.green,
+	addition: kleur.green,
+	number: kleur.yellow,
+	symbol: kleur.yellow,
+	meta: kleur.yellow,
+	attr: kleur.yellow,
+	comment: kleur.dim,
+	quote: kleur.dim,
+	deletion: kleur.dim,
+	title: kleur.cyan,
+	type: kleur.cyan,
+	section: kleur.cyan
+};
+const lowlight = createLowlight(common);
+function highlightMarkdown(md) {
+	const lines = md.split("\n");
+	const out = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		const fence = line.match(FENCE_OPEN);
+		if (!fence) {
+			out.push(highlightLine(line, lines[i + 1]));
+			continue;
+		}
+		const [, prefix = "", lang = ""] = fence;
+		const styledPrefix = prefix.replace(/\S+/g, (marker) => kleur.dim(marker));
+		out.push(`${styledPrefix}${kleur.dim(`${FENCE}${lang}`)}`);
+		const code = [];
+		const prefixed = [];
+		let j = i + 1;
+		for (; j < lines.length; j++) {
+			const raw = lines[j] ?? "";
+			const hasPrefix = raw.startsWith(prefix) || raw === prefix.trimEnd();
+			const body = raw.startsWith(prefix) ? raw.slice(prefix.length) : hasPrefix ? "" : raw;
+			if (body === FENCE) break;
+			code.push(body);
+			prefixed.push(hasPrefix);
+		}
+		if (code.length > 0) highlightCode(code.join("\n"), lang).split("\n").forEach((codeLine, k) => {
+			const lead = prefixed[k] ? styledPrefix : "";
+			out.push(codeLine ? `${lead}${codeLine}` : lead.trimEnd());
+		});
+		if (j < lines.length) {
+			const lead = (lines[j] ?? "").startsWith(prefix) ? styledPrefix : "";
+			out.push(`${lead}${kleur.dim(FENCE)}`);
+		}
+		i = j;
+	}
+	return out.join("\n");
+}
+function highlightCode(code, lang) {
+	if (!lang || !lowlight.registered(lang)) return styleEachLine(code, kleur.yellow);
+	return renderTree(lowlight.highlight(lang, code), (text) => text);
+}
+function renderTree(node, style) {
+	if (node.type === "text") return styleEachLine(node.value, style);
+	if (node.type !== "root" && node.type !== "element") return "";
+	const own = node.type === "element" ? tokenStyle(node.properties["className"]) : void 0;
+	const next = own ? (text) => style(own(text)) : style;
+	return node.children.map((child) => renderTree(child, next)).join("");
+}
+function tokenStyle(className) {
+	if (!Array.isArray(className)) return void 0;
+	for (const name of className) {
+		if (typeof name !== "string" || !name.startsWith("hljs-")) continue;
+		const style = TOKEN_STYLES[name.slice(5)];
+		if (style) return style;
+	}
+}
+function styleEachLine(text, style) {
+	return text.split("\n").map((line) => line ? style(line) : line).join("\n");
+}
+function highlightLine(line, nextLine) {
+	const quote = line.match(QUOTE);
+	if (quote) {
+		const [whole, indent = ""] = quote;
+		const rest = line.slice(whole.length);
+		const gap = whole.endsWith(" ") ? " " : "";
+		return `${indent}${kleur.dim(">")}${gap}${highlightLine(rest, stripPrefix(nextLine, whole))}`;
+	}
+	const list = line.match(LIST);
+	if (list) {
+		const [whole, indent = "", marker = "", checkbox] = list;
+		const rest = line.slice(whole.length);
+		const box = checkbox ? `${kleur.bold(checkbox.trim())} ` : "";
+		return `${indent}${kleur.dim(marker)} ${box}${highlightLine(rest, void 0)}`;
+	}
+	if (HEADING.test(line)) return kleur.bold().cyan(line);
+	if (RULE.test(line)) return kleur.dim(line);
+	if (TABLE_SEPARATOR.test(line)) return kleur.dim(line);
+	if (TABLE_ROW.test(line)) return tableRow(line, nextLine !== void 0 && TABLE_SEPARATOR.test(nextLine));
+	const details = line.match(DETAILS_OPEN);
+	if (details) {
+		const [, indent = "", title = ""] = details;
+		return `${indent}${kleur.dim("<details><summary>")}${highlightInline(title)}${kleur.dim("</summary>")}`;
+	}
+	if (DETAILS_CLOSE.test(line)) return kleur.dim(line);
+	return highlightInline(line);
+}
+function stripPrefix(line, prefix) {
+	return line?.startsWith(prefix) ? line.slice(prefix.length) : void 0;
+}
+function tableRow(line, header) {
+	const styled = line.split(CELL_DIVIDER).slice(1, -1).map((cell) => header ? kleur.bold(highlightInline(cell)) : highlightInline(cell));
+	const pipe = kleur.dim("|");
+	return `${pipe}${styled.join(pipe)}${pipe}`;
+}
+function highlightInline(text) {
+	return text.replace(INLINE, (match, code, linkText, url, boldItalic, bold, italic, strike) => {
+		if (code !== void 0) return kleur.yellow(code);
+		if (linkText !== void 0 && url !== void 0) return link(linkText, url);
+		if (boldItalic !== void 0) return kleur.bold().italic(match);
+		if (bold !== void 0) return kleur.bold(`**${highlightInline(bold)}**`);
+		if (italic !== void 0) return kleur.italic(`*${highlightInline(italic)}*`);
+		if (strike !== void 0) return kleur.strikethrough(`~~${highlightInline(strike)}~~`);
+		return match;
+	});
+}
+function link(text, url) {
+	const open = kleur.dim("[");
+	const middle = kleur.dim("](");
+	return `${open}${highlightInline(text)}${middle}${kleur.dim().underline(url)}${kleur.dim(")")}`;
+}
+//#endregion
+//#region src/commands/jira.ts
+async function jiraProjects(query, options) {
+	const auth = await requireAuth();
+	const projects = await listProjects(new AtlassianClient(auth), auth.site, query);
+	if (options.json) {
+		console.log(JSON.stringify(projects, null, 2));
+		return;
+	}
+	if (projects.length === 0) {
+		console.log("No matching projects.");
+		return;
+	}
+	for (const line of formatProjectRows(projects)) console.log(line);
+}
+function formatProjectRows(projects) {
+	const width = Math.max(...projects.map((p) => p.key.length));
+	return projects.map((p) => `${p.key.padEnd(width)}  ${p.name}`);
+}
+async function jiraStatuses(query, options) {
+	let statuses = await listStatuses(new AtlassianClient(await requireAuth()), options.project);
+	if (query) {
+		const needle = query.toLowerCase();
+		statuses = statuses.filter((s) => s.name.toLowerCase().includes(needle));
+	}
+	if (options.json) {
+		console.log(JSON.stringify(statuses, null, 2));
+		return;
+	}
+	if (statuses.length === 0) {
+		console.log("No matching statuses.");
+		return;
+	}
+	for (const line of formatStatusRows(statuses)) console.log(line);
+}
+function formatStatusRows(statuses) {
+	const width = Math.max(...statuses.map((s) => s.name.length));
+	return statuses.map((s) => `${s.name.padEnd(width)}  ${s.category}`);
+}
+async function jiraView(arg, options) {
+	const auth = await requireAuth();
+	const key = await resolveRef(arg, ISSUE_REF);
+	const issue = await fetchIssue(new AtlassianClient(auth), auth.site, key);
+	for (const line of formatIssueView(issue, Date.now(), options.allComments ?? false)) console.log(line);
+}
+const CATEGORY_COLORS = {
+	new: kleur.cyan,
+	indeterminate: kleur.yellow,
+	done: kleur.green
+};
+function colorForCategory(category) {
+	return CATEGORY_COLORS[category] ?? ((text) => text);
+}
+function formatIssueView(issue, nowMs, allComments) {
+	return [
+		`${kleur.bold(issue.key)}  ${issue.summary}`,
+		...fieldLines(issue, nowMs),
+		...bodyLines(adfToMarkdown(issue.description)),
+		...commentSection(issue.comments, allComments),
+		...attachmentSection(issue.attachments)
+	];
+}
+function fieldLines(issue, nowMs) {
+	const colorStatus = colorForCategory(issue.statusCategory);
+	const kept = [
+		["Type", issue.type],
+		["Status", issue.status && colorStatus(issue.status)],
+		["Assignee", issue.assignee],
+		["Reporter", issue.reporter],
+		["Priority", issue.priority],
+		["Labels", issue.labels.join(", ")],
+		["Created", dateWithAge(issue.created, nowMs)],
+		["Updated", dateWithAge(issue.updated, nowMs)],
+		["URL", issue.url]
+	].filter(([, value]) => value !== "");
+	const width = Math.max(...kept.map(([label]) => label.length)) + 1;
+	return kept.map(([label, value]) => `${kleur.dim(`${label}:`.padEnd(width))}  ${value}`);
+}
+function dateWithAge(iso, nowMs) {
+	if (!iso) return "";
+	return `${formatDateTime(iso).slice(0, 10)} (${relativeTime(iso, nowMs)})`;
+}
+function bodyLines(body) {
+	return body ? ["", highlightMarkdown(body)] : [];
+}
+function commentSection(comments, allComments) {
+	if (comments.length === 0) return [];
+	const visible = allComments ? comments : comments.slice(-5);
+	const heading = comments.length - visible.length > 0 ? `Comments (${comments.length}, showing last ${visible.length} — --all-comments for all)` : `Comments (${comments.length})`;
+	const lines = ["", kleur.bold(heading)];
+	for (const comment of visible) {
+		const body = adfToMarkdown(comment.body);
+		lines.push("", commentHeader(comment), ...body ? [highlightMarkdown(body)] : []);
+	}
+	return lines;
+}
+function commentHeader(comment) {
+	return `─ ${kleur.bold(comment.author || "Unknown")}${comment.created ? ` · ${kleur.dim(formatDateTime(comment.created))}` : ""}`;
+}
+function attachmentSection(attachments) {
+	if (attachments.length === 0) return [];
+	return [
+		"",
+		kleur.bold("Attachments"),
+		...attachments.map((a) => `- ${a.filename}`)
+	];
+}
+async function jiraCopy(arg, options) {
+	const auth = await requireAuth();
+	const key = await resolveRef(arg, ISSUE_REF);
+	await copyIssue(new AtlassianClient(auth), auth.site, key, options.out);
+}
+async function jiraUpdate(arg, options) {
+	const src = parseIssueSource(await readFile(arg ?? await input({
+		message: "Path to the issue Markdown file:",
+		required: true
+	}), "utf8"));
+	const auth = await requireAuth();
+	const client = new AtlassianClient(auth);
+	const plan = planIssueUpdate(src, await fetchIssue(client, auth.site, src.key), options);
+	await runPlan(plan, options, async () => {
+		const { current, next } = plan.headline;
+		await updateIssue(client, src.key, {
+			description: plan.body,
+			summary: next !== current ? next : void 0
+		});
+		console.log(`Updated ${src.key}.`);
+	});
+}
+async function jiraSearch(query, options) {
+	if (options.jql && (query || options.project || options.assignee || options.status)) throw new Error("--jql cannot be combined with a text query or other filters.");
+	if (options.json && options.copy) throw new Error("--json and --copy cannot be used together.");
+	const auth = await requireAuth();
+	const client = new AtlassianClient(auth);
+	const limit = parseLimit(options.limit);
+	const issues = await searchIssues(client, auth.site, {
+		text: query,
+		project: options.project,
+		assignee: options.assignee,
+		status: options.status,
+		jql: options.jql,
+		limit
+	});
+	await runSearch(issues.map((i) => ({
+		id: i.key,
+		fixedColumns: `${i.key}  ${i.status}`,
+		freeText: i.summary,
+		json: {
+			key: i.key,
+			status: i.status,
+			summary: i.summary,
+			url: i.url
+		}
+	})), {
+		json: options.json,
+		copy: options.copy,
+		out: options.out,
+		empty: "No matching issues.",
+		footer: issues.length === limit ? searchFooter(limit) : void 0
+	}, ISSUE_NOUN, (key) => copyIssue(client, auth.site, key, options.out));
+}
+async function jiraList(options) {
+	if (options.json && options.copy) throw new Error("--json and --copy cannot be used together.");
+	const auth = await requireAuth();
+	const client = new AtlassianClient(auth);
+	const { issues, truncated } = await listAssignedIssues(client, auth.site, {
+		all: options.all,
+		project: options.project
+	});
+	await runSearch(formatListRows(sortByCategoryThenUpdated(issues), Date.now()), {
+		json: options.json,
+		copy: options.copy,
+		out: options.out,
+		empty: options.all ? "No issues assigned to you." : "No open issues assigned to you.",
+		footer: truncated ? `\nShowing the first ${issues.length}; narrow with --project.` : void 0
+	}, ISSUE_NOUN, (key) => copyIssue(client, auth.site, key, options.out));
+}
+function formatListRows(issues, nowMs) {
+	const ages = issues.map((i) => relativeTime(i.updated, nowMs));
+	const width = (values) => Math.max(...values.map((v) => v.length));
+	const keyWidth = width(issues.map((i) => i.key));
+	const statusWidth = width(issues.map((i) => i.status));
+	const ageWidth = width(ages);
+	return issues.map((i, n) => {
+		const status = colorForCategory(i.statusCategory)(i.status.padEnd(statusWidth));
+		return {
+			id: i.key,
+			fixedColumns: `${i.key.padEnd(keyWidth)}  ${status}  ${(ages[n] ?? "").padEnd(ageWidth)}`,
+			freeText: i.summary,
+			json: { ...i }
+		};
+	});
+}
+const ISSUE_NOUN = {
+	singular: "issue",
+	plural: "issues"
+};
+async function copyIssue(client, site, key, out) {
+	console.log(`Fetching ${key} ...`);
+	await runCopy(planIssueCopy(await fetchIssue(client, site, key), out), (url) => client.getBinary(url));
+}
+const ISSUE_REF = {
+	message: "Jira issue key or URL:",
+	parse: parseIssueKey,
+	notFound: (raw) => `Could not find an issue key in "${raw}" (expected e.g. PROJ-123).`
+};
+//#endregion
+//#region src/cli/jira.ts
+function registerJira(jira) {
+	jira.description("Jira commands");
+	jira.command("projects [query]").description("List projects (optionally filtered by key or name)").option("--json", "output results as JSON").action(run(jiraProjects));
+	jira.command("statuses [query]").description("List statuses (optionally filtered by name, scoped with --project)").option("-p, --project <key>", "limit to statuses used by a project").option("--json", "output results as JSON").action(run(jiraStatuses));
+	jira.command("view [issue]").description("Show a Jira issue (key or URL) in the terminal").option("--all-comments", "show all comments instead of the last 5").action(run(jiraView));
+	jira.command("copy [issue]").description("Copy a Jira issue (key or URL) to a Markdown file").option("-o, --out <path>", "output file or directory").action(run(jiraCopy));
+	jira.command("update [file]").description("Update a Jira issue description from an edited Markdown file").option("--summary", "also push the H1 as the issue summary").option("-f, --force", "skip the stale-issue and data-loss checks").option("--dry-run", "show what would change without writing").action(run(jiraUpdate));
+	jira.command("list").description("List open issues assigned to you").option("-p, --project <key>", "limit to a project").option("-a, --all", "include Done issues updated in the last 30 days").option("--json", "output results as JSON").option("-c, --copy", "pick results to copy to Markdown").option("-o, --out <dir>", "output directory for --copy").action(run(jiraList));
+	jira.command("search [query]").description("Search Jira issues (text query, filters, or --jql)").option("-p, --project <key>", "limit to a project").option("-a, --assignee <who>", "limit to an assignee (or 'me')").option("-s, --status <status>", "limit to a status").option("--jql <jql>", "raw JQL query (ignores other filters)").option("-l, --limit <n>", "max results (default 25, max 100)").option("--json", "output results as JSON").option("-c, --copy", "pick results to copy to Markdown").option("-o, --out <dir>", "output directory for --copy").action(run(jiraSearch));
+	return jira;
+}
+//#endregion
+//#region package.json
+var version = "1.9.0";
+//#endregion
+//#region src/cli/build.ts
+const PRODUCTS = {
+	jira: registerJira,
+	confluence: registerConfluence,
+	bitbucket: registerBitbucket
+};
+function buildAtlass() {
+	const program = new Command().name("atlass").description("Copy Jira issues and Confluence pages to Markdown.").version(version);
+	registerAuth(program.command("auth"));
+	registerJira(program.command("jira"));
+	registerConfluence(program.command("confluence").alias("conf"));
+	registerBitbucket(program.command("bitbucket").alias("bb"));
+	return program;
+}
+function buildStandalone(product) {
+	return PRODUCTS[product](new Command().name(product).version(version));
+}
+//#endregion
+export { buildStandalone as n, fail as r, buildAtlass as t };