@argos-ci/cli 4.1.4 → 4.1.5-alpha.6

package/dist/index.mjs

@@ -1,9 +1,14 @@
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
 import { Option, program } from "commander";
 import { finalize, skip, upload } from "@argos-ci/core";
 import ora from "ora";
+import { createClient, formatAPIError, throwAPIError } from "@argos-ci/api-client";
+import { homedir } from "node:os";
+import { createServer } from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+import open from "open";
 //#region src/options.ts
 const parallelNonceOption = new Option("--parallel-nonce <string>", "A unique ID for this parallel build").env("ARGOS_PARALLEL_NONCE");
 const tokenOption = new Option("--token <token>", "Repository token").env("ARGOS_TOKEN");
@@ -91,6 +96,482 @@ function skipCommand(program) {
 	});
 }
 //#endregion
+//#region src/auth.ts
+function getConfigPaths() {
+	const configDir = resolve(homedir(), ".config", "argos-ci");
+	return {
+		configDir,
+		configPath: resolve(configDir, "config.json")
+	};
+}
+function parseConfig(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+	const record = parsed;
+	if (!("token" in record) || record.token === void 0) return {};
+	if (typeof record.token !== "string") return null;
+	return { token: record.token };
+}
+async function clearConfig() {
+	const { configPath } = getConfigPaths();
+	try {
+		await unlink(configPath);
+	} catch {}
+}
+async function readConfig() {
+	const { configPath } = getConfigPaths();
+	try {
+		const config = parseConfig(await readFile(configPath, "utf8"));
+		if (config === null) {
+			console.warn("Warning: Config file is invalid and has been cleared. Run `argos login` again.");
+			await clearConfig();
+			return null;
+		}
+		return config;
+	} catch (err) {
+		if (err instanceof Error && err.code === "ENOENT") return null;
+		throw err;
+	}
+}
+async function writeConfig(config) {
+	const { configDir, configPath } = getConfigPaths();
+	await mkdir(configDir, { recursive: true });
+	const tmpPath = configPath + ".tmp";
+	await writeFile(tmpPath, JSON.stringify(config, null, 2), { mode: 384 });
+	await rename(tmpPath, configPath);
+}
+async function getStoredToken() {
+	return (await readConfig())?.token;
+}
+async function saveToken(token) {
+	await writeConfig({
+		...await readConfig() ?? {},
+		token
+	});
+}
+async function removeToken() {
+	await writeConfig({});
+}
+//#endregion
+//#region src/commands/build.ts
+const reviewConclusions = {
+	approve: "APPROVE",
+	"request-changes": "REQUEST_CHANGES"
+};
+async function getTokenOrExit(options) {
+	const token = options.token || process.env["ARGOS_TOKEN"] || await getStoredToken();
+	if (!token) {
+		console.error("Error: No Argos token found. Use --token, set ARGOS_TOKEN, or run `argos login`.");
+		process.exit(1);
+	}
+	return token;
+}
+function getAPIBaseURL() {
+	return process.env["ARGOS_API_BASE_URL"];
+}
+function getProjectTokenOrExit(options) {
+	const projectToken = options.token || process.env["ARGOS_TOKEN"];
+	if (!projectToken) {
+		console.error("Error: No Argos project token found. Use --token or set ARGOS_TOKEN.");
+		process.exit(1);
+	}
+	return projectToken;
+}
+function isBuildPending(build) {
+	return build.status === "pending" || build.status === "progress";
+}
+function parseBuildReferenceDetailsOrExit(buildReference) {
+	const parsedBuildNumber = Number(buildReference);
+	if (Number.isFinite(parsedBuildNumber) && Number.isInteger(parsedBuildNumber)) return { buildNumber: parsedBuildNumber };
+	const urlMatch = buildReference.match(/^https:\/\/app\.argos-ci\.(?:com|dev(?::\d+)?)\/(?<owner>[^/?#]+)\/(?<project>[^/?#]+)\/builds\/(?<buildNumber>\d+)(?:\/?$|[?#])/);
+	if (urlMatch?.groups) return {
+		owner: urlMatch.groups.owner,
+		project: urlMatch.groups.project,
+		buildNumber: Number(urlMatch.groups.buildNumber)
+	};
+	console.error(`Error: Build reference must be a valid build number or Argos build URL (https://app.argos-ci.com/.../builds/<number>), got "${buildReference}".`);
+	process.exit(1);
+}
+function formatValue(value) {
+	if (value === null || value === void 0 || value === "") return "-";
+	return String(value);
+}
+function formatStats(stats) {
+	if (!stats) return "-";
+	return [
+		`total ${stats.total}`,
+		`changed ${stats.changed}`,
+		`added ${stats.added}`,
+		`removed ${stats.removed}`,
+		`unchanged ${stats.unchanged}`
+	].join(", ");
+}
+function formatSnapshotSummary(diffs) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const diff of diffs) counts.set(diff.status, (counts.get(diff.status) ?? 0) + 1);
+	return [
+		"changed",
+		"added",
+		"removed",
+		"unchanged",
+		"ignored",
+		"pending",
+		"failure",
+		"retryFailure"
+	].map((status) => {
+		const count = counts.get(status);
+		return count ? `${status} ${count}` : null;
+	}).filter((part) => Boolean(part)).join(", ");
+}
+function printBuild(build) {
+	const lines = [
+		`Build #${build.number}`,
+		`Status: ${build.status}`,
+		`Snapshots: ${formatStats(build.stats)}`,
+		`Conclusion: ${formatValue(build.conclusion)}`,
+		`Branch: ${formatValue(build.head?.branch)}`,
+		`Commit: ${formatValue(build.head?.sha)}`,
+		`Base branch: ${formatValue(build.base?.branch)}`,
+		`Base commit: ${formatValue(build.base?.sha)}`,
+		`URL: ${build.url}`
+	];
+	console.log(lines.join("\n"));
+}
+function printSnapshots(diffs, build) {
+	if (diffs.length === 0) {
+		console.log("No snapshots found.");
+		return;
+	}
+	const lines = [
+		`Snapshots for build #${build.number}`,
+		`Count: ${diffs.length}`,
+		`Summary: ${formatSnapshotSummary(diffs)}`,
+		"",
+		...diffs.flatMap((diff) => {
+			return [
+				`${diff.name} [${diff.status}]`,
+				`  Review: ${build.url}/${diff.id}`,
+				`  Mask: ${formatValue(diff.url)}`,
+				`  Base file: ${formatValue(diff.base?.url)}`,
+				`  Head file: ${formatValue(diff.head?.url)}`,
+				`  Score: ${formatValue(diff.score)}`,
+				`  Group: ${formatValue(diff.group)}`,
+				""
+			];
+		})
+	];
+	console.log(lines.slice(0, -1).join("\n"));
+}
+function printReview(review, buildNumber) {
+	const lines = [
+		`Review #${review.id}`,
+		`State: ${review.state}`,
+		`Build: #${buildNumber}`
+	];
+	console.log(lines.join("\n"));
+}
+function createProjectClient(options) {
+	return createClient({
+		authToken: getProjectTokenOrExit(options),
+		baseUrl: getAPIBaseURL()
+	});
+}
+async function fetchAllDiffs(client, project, buildNumber, options) {
+	const results = [];
+	let page = 1;
+	const perPage = 100;
+	while (true) {
+		const query = {
+			page: String(page),
+			perPage: String(perPage),
+			...options?.needsReview ? { needsReview: true } : {}
+		};
+		const { data, error } = await client.GET("/projects/{owner}/{project}/builds/{buildNumber}/diffs", { params: {
+			path: {
+				owner: project.account.slug,
+				project: project.name,
+				buildNumber: String(buildNumber)
+			},
+			query
+		} });
+		if (error || !data) {
+			if (error) throwAPIError(error);
+			throw new Error("Unexpected empty response from API.");
+		}
+		results.push(...data.results);
+		if (results.length >= data.pageInfo.total) break;
+		page++;
+	}
+	return results;
+}
+async function fetchProject(client) {
+	const { data, error } = await client.GET("/project");
+	if (error) throwAPIError(error);
+	if (!data) {
+		console.error("Error: Unexpected empty response from API.");
+		process.exit(1);
+	}
+	return data;
+}
+async function fetchBuildByNumber(client, project, buildNumber, errorLabel) {
+	const { data, error, response } = await client.GET("/projects/{owner}/{project}/builds/{buildNumber}", { params: { path: {
+		owner: project.account.slug,
+		project: project.name,
+		buildNumber: String(buildNumber)
+	} } });
+	if (error) {
+		if (response.status === 404) {
+			console.error(`Error: Build number ${errorLabel} not found.`);
+			process.exit(1);
+		}
+		throwAPIError(error);
+	}
+	if (!data) {
+		console.error("Error: Unexpected empty response from API.");
+		process.exit(1);
+	}
+	return data;
+}
+function buildCommand(program) {
+	const build = program.command("build").description("Manage Argos builds");
+	const createJsonOption = () => new Option("--json", "Output machine-readable JSON instead of human-readable text");
+	build.command("get").description("Fetch build metadata").argument("<buildReference>", "Build number or Argos build URL").addOption(tokenOption).addOption(createJsonOption()).action(async (buildReference, options) => {
+		const { buildNumber } = parseBuildReferenceDetailsOrExit(buildReference);
+		const client = createProjectClient(options);
+		const build = await fetchBuildByNumber(client, await fetchProject(client), buildNumber, buildReference);
+		if (options.json) {
+			console.log(JSON.stringify(build, null, 2));
+			return;
+		}
+		printBuild(build);
+	});
+	build.command("snapshots").description("Fetch snapshot diffs for a build").argument("<buildReference>", "Build number or Argos build URL").option("--needs-review", "Only include snapshot diffs that require review").addOption(tokenOption).addOption(createJsonOption()).action(async (buildReference, options) => {
+		const { buildNumber } = parseBuildReferenceDetailsOrExit(buildReference);
+		const client = createProjectClient(options);
+		const project = await fetchProject(client);
+		const build = await fetchBuildByNumber(client, project, buildNumber, buildReference);
+		if (isBuildPending(build)) {
+			if (options.json) {
+				console.error(`Error: Build #${build.number} is still processing (${build.status}). Try again in a moment.`);
+				process.exit(1);
+			}
+			console.log(`Build #${build.number} is still processing (${build.status}). Try again in a moment.`);
+			return;
+		}
+		const diffs = await fetchAllDiffs(client, project, buildNumber, { needsReview: Boolean(options.needsReview) });
+		if (options.json) {
+			console.log(JSON.stringify(diffs, null, 2));
+			return;
+		}
+		printSnapshots(diffs, build);
+	});
+	build.command("review").description("Create a review on a build").argument("<buildReference>", "Build number or Argos build URL").addOption(new Option("--conclusion <conclusion>", "Overall review conclusion for the build: \"approve\" or \"request-changes\"").choices(Object.keys(reviewConclusions)).makeOptionMandatory()).option("--project <project>", "Project path in owner/project format").addOption(tokenOption).addOption(createJsonOption()).action(async (buildReference, options) => {
+		const conclusion = reviewConclusions[options.conclusion];
+		const buildReferenceDetails = parseBuildReferenceDetailsOrExit(buildReference);
+		let owner;
+		let project;
+		if (buildReferenceDetails.owner && buildReferenceDetails.project) {
+			owner = buildReferenceDetails.owner;
+			project = buildReferenceDetails.project;
+		} else if (options.project) {
+			const parts = options.project.split("/");
+			if (parts.length !== 2 || !parts[0] || !parts[1]) {
+				console.error("Error: --project must be in the format 'owner/project'.");
+				process.exit(1);
+			}
+			[owner, project] = parts;
+		} else {
+			console.error("Error: --project <owner/project> is required for build-number references.");
+			process.exit(1);
+		}
+		const { data, error } = await createClient({
+			authToken: await getTokenOrExit(options),
+			baseUrl: getAPIBaseURL()
+		}).POST("/projects/{owner}/{project}/builds/{buildNumber}/reviews", {
+			params: { path: {
+				owner,
+				project,
+				buildNumber: String(buildReferenceDetails.buildNumber)
+			} },
+			body: { conclusion }
+		});
+		if (error) {
+			const message = formatAPIError(error);
+			throw new Error([
+				`Failed to create review for ${owner}/${project} build #${buildReferenceDetails.buildNumber}: ${message}`,
+				"Make sure the token passed with --token is a user access token with access to this project.",
+				"Project tokens from ARGOS_TOKEN can read build data, but they cannot create reviews."
+			].join("\n"));
+		}
+		if (!data) {
+			console.error("Error: Unexpected empty response from API.");
+			process.exit(1);
+		}
+		if (options.json) {
+			console.log(JSON.stringify(data, null, 2));
+			return;
+		}
+		printReview(data, buildReferenceDetails.buildNumber);
+	});
+}
+//#endregion
+//#region src/commands/login.ts
+const APP_BASE_URL = process.env["ARGOS_APP_BASE_URL"] ?? "https://app.argos-ci.com/";
+const API_BASE_URL = process.env["ARGOS_API_BASE_URL"] ?? "https://api.argos-ci.com/v2/";
+const LOGIN_CLI_SUCCESS_ROUTE = `/auth/cli/success`;
+const LOGIN_TIMEOUT_MS = 300 * 1e3;
+const CALLBACK_ERROR_HTML = `<!DOCTYPE html><html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <title>Argos CLI</title>
+  </head>
+  <body>
+    <p>Authorization failed. Please run <code>argos login</code> again.</p>
+  </body>
+</html>`;
+function color(text, code) {
+	if (!process.stderr.isTTY || process.env["NO_COLOR"]) return text;
+	return `\u001B[${code}m${text}\u001B[0m`;
+}
+const successColor = (text) => color(text, 32);
+const warningColor = (text) => color(text, 33);
+const errorColor = (text) => color(text, 31);
+function startCallbackServer() {
+	return new Promise((resolve, reject) => {
+		let resolveCallback = () => {};
+		let rejectCallback = () => {};
+		let timeout;
+		const callbackPromise = new Promise((res, rej) => {
+			resolveCallback = res;
+			rejectCallback = rej;
+		});
+		const closeServer = () => {
+			if (timeout) clearTimeout(timeout);
+			server.close();
+			server.closeAllConnections();
+		};
+		const server = createServer((req, res) => {
+			const url = new URL(req.url ?? "/", "http://localhost");
+			if (url.pathname !== "/callback") {
+				res.writeHead(404, { Connection: "close" });
+				res.end();
+				return;
+			}
+			const callbackError = url.searchParams.get("error");
+			const callbackErrorDescription = url.searchParams.get("error_description");
+			const code = url.searchParams.get("code");
+			const state = url.searchParams.get("state");
+			if (callbackError) {
+				const message = callbackErrorDescription ?? callbackError;
+				res.writeHead(400, {
+					"Content-Type": "text/html; charset=utf-8",
+					Connection: "close"
+				});
+				res.end(CALLBACK_ERROR_HTML, () => {
+					closeServer();
+					rejectCallback(new Error(message));
+				});
+				return;
+			}
+			if (!code || !state) {
+				res.writeHead(400, {
+					"Content-Type": "text/html; charset=utf-8",
+					Connection: "close"
+				});
+				res.end(CALLBACK_ERROR_HTML, () => {
+					closeServer();
+					rejectCallback(/* @__PURE__ */ new Error("Missing code or state in callback"));
+				});
+				return;
+			}
+			res.writeHead(302, {
+				Location: new URL(LOGIN_CLI_SUCCESS_ROUTE, APP_BASE_URL).href,
+				Connection: "close"
+			});
+			res.end(() => {
+				closeServer();
+				resolveCallback({
+					code,
+					state
+				});
+			});
+		});
+		server.on("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const { port } = server.address();
+			timeout = setTimeout(() => {
+				closeServer();
+				rejectCallback(/* @__PURE__ */ new Error("Authentication timed out"));
+			}, LOGIN_TIMEOUT_MS);
+			timeout.unref();
+			resolve({
+				port,
+				waitForCallback: () => callbackPromise
+			});
+		});
+	});
+}
+function loginCommand(program) {
+	program.command("login").description("Log in to Argos by opening your browser").action(async () => {
+		const state = randomBytes(16).toString("hex");
+		const codeVerifier = randomBytes(32).toString("base64url");
+		const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");
+		let port;
+		let waitForCallback;
+		try {
+			({port, waitForCallback} = await startCallbackServer());
+		} catch (err) {
+			console.error(errorColor("Error: Failed to start local callback server."));
+			console.error(err);
+			process.exit(1);
+		}
+		const loginUrl = new URL("/auth/cli", APP_BASE_URL);
+		loginUrl.searchParams.set("port", port.toString());
+		loginUrl.searchParams.set("state", state);
+		loginUrl.searchParams.set("pkce", codeChallenge);
+		console.log("\nOpening browser for authentication…");
+		console.log(`If the browser doesn't open, visit:\n  ${loginUrl.href}\n`);
+		if (process.env["ARGOS_CLI_DISABLE_BROWSER"] !== "1") await open(loginUrl.href).catch((err) => {
+			console.warn(warningColor(`Warning: Failed to open browser — ${err instanceof Error ? err.message : String(err)}`));
+			console.log("Hint: Open the URL above manually to continue authentication.");
+		});
+		let result;
+		try {
+			result = await waitForCallback();
+		} catch (err) {
+			console.error(errorColor(err instanceof Error ? `Error: ${err.message}. Please run \`argos login\` again.` : "Error: Authorization failed or was cancelled."));
+			process.exit(1);
+		}
+		if (result.state !== state) {
+			console.error(errorColor("Error: State mismatch. Try logging in again."));
+			process.exit(1);
+		}
+		const { data, error } = await createClient({ baseUrl: API_BASE_URL }).POST("/auth/cli/token", { body: {
+			code: result.code,
+			code_verifier: codeVerifier
+		} });
+		if (error || !data?.token) {
+			console.error(errorColor("Error: Authentication failed. Please run `argos login` again."));
+			process.exit(1);
+		}
+		await saveToken(data.token);
+		console.log(successColor("Logged in to Argos successfully."));
+	});
+	program.command("logout").description("Log out from Argos").action(async () => {
+		if (!await getStoredToken()) {
+			console.log("No token found. You are already logged out.");
+			return;
+		}
+		await removeToken();
+		console.log("Logged out from Argos.");
+	});
+}
+//#endregion
 //#region src/index.ts
 const rawPkg = await readFile(resolve(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json"), "utf8");
 const pkg = JSON.parse(rawPkg);
@@ -98,6 +579,8 @@ program.name(pkg.name).description("Interact with and upload screenshots to Argo
 uploadCommand(program);
 skipCommand(program);
 finalizeCommand(program);
+buildCommand(program);
+loginCommand(program);
 if (!process.argv.slice(2).length) program.outputHelp();
 else program.parse(process.argv);
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@argos-ci/cli",
   "description": "Command-line (CLI) for visual testing with Argos.",
-  "version": "4.1.4",
+  "version": "4.1.5-alpha.6+74828da",
   "bin": {
     "argos": "./bin/argos-cli.js"
   },
@@ -34,17 +34,22 @@
     "access": "public"
   },
   "dependencies": {
-    "@argos-ci/core": "5.2.0",
+    "@argos-ci/api-client": "0.17.1-alpha.6+74828da",
+    "@argos-ci/core": "5.2.1-alpha.6+74828da",
     "commander": "^14.0.3",
+    "open": "^11.0.0",
     "ora": "^9.3.0",
     "update-notifier": "^7.3.1"
   },
+  "devDependencies": {
+    "vitest": "catalog:"
+  },
   "scripts": {
     "build": "tsdown",
-    "e2e": "node e2e/upload.js && node e2e/skip.js",
+    "e2e": "vitest",
     "check-types": "tsc",
     "check-format": "prettier --check --ignore-unknown --ignore-path=../../.gitignore --ignore-path=../../.prettierignore .",
     "lint": "eslint ."
   },
-  "gitHead": "82add1422f689642095d43a9e3bb0d2a008728af"
+  "gitHead": "74828dafbe25ef00f58c7e87721ea0ec7211fee4"
 }