atlass 1.5.0 → 1.6.0

package/README.md

@@ -50,6 +50,36 @@ atlass auth logout   # remove config and delete the token from the keyring
 
 Only one account is supported at a time.
 
+### Bitbucket
+
+Bitbucket Cloud is supported for viewing pipeline results. It uses the same
+Atlassian account email but a separate, Bitbucket-scoped API token (Atlassian
+tokens are scoped per product at creation, so a Jira token cannot be reused).
+
+```bash
+atlass bitbucket login
+```
+
+You are prompted for:
+
+- workspace, e.g. `acme` (from `bitbucket.org/acme/<repo>`)
+- default repo slug (optional)
+- API token, created with the `read:pipeline` and workspace-read scopes at
+  `https://id.atlassian.com/manage-profile/security/api-tokens` (select Bitbucket
+  as the app)
+
+The login is verified against the workspace before anything is saved. The
+workspace and optional default repo are stored in the `bitbucket` block of
+`config.json`; the token is stored in the OS keyring under a separate entry.
+
+```bash
+atlass bitbucket status   # show workspace, default repo, and token presence
+atlass bitbucket logout   # remove the Bitbucket config block and token
+```
+
+`bitbucket login`/`logout` are independent of `auth login`/`logout`: logging out
+of one leaves the other intact.
+
 ## Usage
 
 ### Copy a Jira issue
@@ -219,6 +249,32 @@ atlass confluence search --space DOCS --copy
 
 Copying continues on failure and reports a summary at the end.
 
+### View Bitbucket pipelines
+
+```bash
+atlass bitbucket pipelines                 # recent runs for the default repo
+atlass bitbucket pipelines --repo acme/web # a specific workspace/repo
+atlass bitbucket pipelines --repo web      # bare slug, under the config workspace
+atlass bitbucket pipelines --limit 50 --json
+```
+
+Lists recent pipeline runs, newest first, one per line
+(`#build  status  ref  duration  age  creator`). Status shows the result
+(`SUCCESSFUL`/`FAILED`/...) once a run completes, else its state
+(`IN_PROGRESS`/`PENDING`/...). The repo comes from `--repo` (a `workspace/slug`
+or a bare slug under the configured workspace), falling back to the configured
+default repo. `--limit` defaults to 25, max 100. `--json` emits the full mapped
+objects.
+
+```bash
+atlass bitbucket pipeline 124              # one run and its steps
+atlass bitbucket pipeline 124 --repo acme/web
+```
+
+Shows a run summary (status, ref, commit, trigger, duration, creator) and its
+step list (name, status, duration). The build number you pass is resolved to the
+run directly, falling back to a bounded scan of recent runs if needed.
+
 ### Output location
 
 By default files are written to the current directory, named after the issue
@@ -302,8 +358,8 @@ pnpm dev       # build in watch mode
 ### Layout
 
 - `src/cli.ts` command wiring (commander)
-- `src/commands/` `auth`, `jira`, `confluence` command handlers
-- `src/api/` fetch client, Jira and Confluence endpoints, attachment up/download
+- `src/commands/` `auth`, `jira`, `confluence`, `bitbucket` command handlers
+- `src/api/` fetch client, Jira, Confluence and Bitbucket endpoints, attachment up/download
 - `src/adf/` ADF to Markdown and Markdown to ADF converters (unit tested)
 - `src/markdown/` frontmatter, comments, attachments, media resolver, update source
 - `src/config.ts`, `src/credentials.ts` config file and keyring

package/dist/cli.mjs

@@ -8,7 +8,7 @@ import { Entry } from "@napi-rs/keyring";
 import { marked } from "marked";
 import { randomUUID } from "node:crypto";
 //#region package.json
-var version = "1.5.0";
+var version = "1.6.0";
 //#endregion
 //#region src/api/client.ts
 var AtlassianClient = class {
@@ -98,6 +98,7 @@ function extractError(body) {
 		const json = JSON.parse(body);
 		if (json.errorMessages?.length) return json.errorMessages.join("; ");
 		if (json.message) return json.message;
+		if (json.error?.message) return json.error.message;
 	} catch {}
 	return body.slice(0, 300);
 }
@@ -113,10 +114,10 @@ async function readConfig() {
 	try {
 		const raw = await readFile(configPath(), "utf8");
 		const parsed = JSON.parse(raw);
-		if (!parsed.site || !parsed.email) return null;
 		return {
 			site: parsed.site,
-			email: parsed.email
+			email: parsed.email,
+			bitbucket: parsed.bitbucket
 		};
 	} catch {
 		return null;
@@ -137,8 +138,9 @@ function normalizeSite(input) {
 //#endregion
 //#region src/credentials.ts
 const SERVICE = "atlass";
-function entry(email) {
-	return new Entry(SERVICE, email);
+const BITBUCKET_ORIGIN = "https://api.bitbucket.org";
+function entry(key) {
+	return new Entry(SERVICE, key);
 }
 function saveToken(email, token) {
 	entry(email).setPassword(token);
@@ -151,16 +153,44 @@ function deleteToken(email) {
 		entry(email).deleteCredential();
 	} catch {}
 }
+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) {
+	try {
+		entry(bitbucketKey(email)).deleteCredential();
+	} catch {}
+}
 async function requireAuth() {
 	const config = await readConfig();
-	if (!config) throw new Error("Not logged in. Run `atlass auth login` first.");
+	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 {
-		...config,
+		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() {
@@ -182,6 +212,7 @@ async function login() {
 		token
 	}).getJson("/rest/api/3/myself");
 	await writeConfig({
+		...await readConfig() ?? {},
 		site,
 		email
 	});
@@ -190,13 +221,17 @@ async function login() {
 }
 async function logout() {
 	const config = await readConfig();
-	if (config) deleteToken(config.email);
-	await clearConfig();
+	if (config?.email) deleteToken(config.email);
+	if (config?.bitbucket && config.email) await writeConfig({
+		email: config.email,
+		bitbucket: config.bitbucket
+	});
+	else await clearConfig();
 	console.log("Logged out. Credentials removed.");
 }
 async function status() {
 	const config = await readConfig();
-	if (!config) {
+	if (!config || !config.site || !config.email) {
 		console.log("Not logged in. Run `atlass auth login`.");
 		return;
 	}
@@ -206,6 +241,313 @@ async function status() {
 	console.log(`Token: ${hasToken ? "stored in keyring" : "MISSING (run `atlass auth login`)"}`);
 }
 //#endregion
+//#region src/api/bitbucket.ts
+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), 100))
+	}).toString();
+}
+function elapsedSeconds(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);
+}
+const MAX_SCAN = 1e3;
+function repoPath(ref) {
+	return `/2.0/repositories/${encodeURIComponent(ref.workspace)}/${encodeURIComponent(ref.repo)}/pipelines`;
+}
+function toPath(url) {
+	const u = new URL(url);
+	return u.pathname + u.search;
+}
+async function* paginate(client, firstPath) {
+	let path = firstPath;
+	while (path) {
+		const page = await client.getJson(path);
+		for (const value of page.values ?? []) yield value;
+		path = page.next ? toPath(page.next) : null;
+	}
+}
+function mapPipeline(p) {
+	return {
+		buildNumber: p.build_number,
+		status: pipelineStatus(p.state),
+		ref: p.target?.ref_name ?? "",
+		commit: p.target?.commit?.hash?.slice(0, 7) ?? "",
+		durationSeconds: elapsedSeconds(p.created_on, p.completed_on),
+		createdOn: p.created_on ?? "",
+		creator: p.creator?.display_name ?? "",
+		uuid: p.uuid
+	};
+}
+function mapDetail(p) {
+	return {
+		...mapPipeline(p),
+		repo: p.repository?.full_name ?? "",
+		trigger: p.trigger?.name ?? ""
+	};
+}
+async function listPipelines(client, ref, limit) {
+	const out = [];
+	const first = `${repoPath(ref)}?${pipelinesQuery(limit)}`;
+	for await (const value of paginate(client, first)) {
+		out.push(mapPipeline(value));
+		if (out.length >= limit) break;
+	}
+	return out;
+}
+async function getPipeline(client, ref, buildNumber) {
+	const base = repoPath(ref);
+	try {
+		return mapDetail(await client.getJson(`${base}/${encodeURIComponent(String(buildNumber))}`));
+	} catch (err) {
+		if (!(err instanceof HttpError) || err.status !== 400 && err.status !== 404) throw err;
+	}
+	const found = await scanForBuild(client, ref, buildNumber);
+	if (!found) throw new Error(`Could not find pipeline #${buildNumber} in the ${MAX_SCAN} most recent runs. It may be too old.`);
+	return mapDetail(found);
+}
+async function scanForBuild(client, ref, buildNumber) {
+	const first = `${repoPath(ref)}?${pipelinesQuery(100)}`;
+	let scanned = 0;
+	for await (const pipeline of paginate(client, first)) {
+		if (pipeline.build_number === buildNumber) return pipeline;
+		if (++scanned >= MAX_SCAN) break;
+	}
+	return null;
+}
+async function listSteps(client, ref, pipelineId) {
+	const out = [];
+	const first = `${repoPath(ref)}/${encodeURIComponent(pipelineId)}/steps`;
+	for await (const step of paginate(client, first)) out.push({
+		name: step.name ?? "",
+		status: pipelineStatus(step.state),
+		durationSeconds: elapsedSeconds(step.started_on, step.completed_on)
+	});
+	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`;
+}
+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 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\`.`);
+}
+function parseLimit(value) {
+	if (!value) return 25;
+	const n = Number.parseInt(value, 10);
+	if (!Number.isFinite(n) || n < 1) throw new Error(`Invalid --limit "${value}".`);
+	return Math.min(n, 100);
+}
+//#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);
+	if (config?.site && config.email) await writeConfig({
+		site: config.site,
+		email: config.email
+	});
+	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}`);
+	const refLine = detail.ref ? detail.commit ? `${detail.ref} (${detail.commit})` : detail.ref : detail.commit || "-";
+	console.log(`Ref:      ${refLine}`);
+	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);
+	}
+}
+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/adf/from-markdown.ts
 function markdownToAdf(md, options = {}) {
 	const ctx = { resolveImage: options.resolveImage ?? defaultResolveImage };
@@ -948,27 +1290,6 @@ function slugify(title) {
 	return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "") || "page";
 }
 //#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 parseLimit(value) {
-	if (!value) return 25;
-	const n = Number.parseInt(value, 10);
-	if (!Number.isFinite(n) || n < 1) throw new Error(`Invalid --limit "${value}".`);
-	return Math.min(n, 100);
-}
-//#endregion
 //#region src/commands/search-run.ts
 const COPY_CONCURRENCY = 5;
 async function runSearch(rows, options, noun, copyOne) {
@@ -1585,6 +1906,12 @@ const confluence = program.command("confluence").description("Confluence command
 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));
+const bitbucket = program.command("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));
 program.parseAsync().catch(fail);
 function run(fn) {
 	return async (...args) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "atlass",
-	"version": "1.5.0",
+	"version": "1.6.0",
 	"description": "CLI to copy Jira issues and Confluence pages to Markdown, and update Confluence pages.",
 	"license": "MIT",
 	"repository": {