xovris 0.0.0-stage → 0.1.0

package/bin/xovris.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// The published package runs the bundled dist/cli.js; inside the repository the TypeScript source runs directly
+// (Node.js 22.18+ strips types).
+import { existsSync } from 'node:fs';
+
+const dist = new URL('../dist/cli.js', import.meta.url);
+await import(existsSync(dist) ? dist.href : new URL('../src/cli.ts', import.meta.url).href);

package/dist/apicmd-3jWpFhG3.js

@@ -0,0 +1,480 @@
+import { chmod, mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { mkdirSync, readFileSync, rmSync } from "node:fs";
+import * as p from "@clack/prompts";
+
+//#region src/version.ts
+const CLI_VERSION = (() => {
+	try {
+		return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+})();
+const CLI_AGENT = `xovris-cli/${CLI_VERSION}`;
+
+//#endregion
+//#region src/api.ts
+var ApiFailure = class extends Error {
+	problem;
+	network;
+	constructor(problem, network) {
+		super(problem ? `${problem.title}. ${problem.next}` : "No answer from Xovris.");
+		this.problem = problem;
+		this.network = network;
+	}
+};
+var Api = class {
+	token = null;
+	base;
+	sys;
+	constructor(base, sys) {
+		this.base = base;
+		this.sys = sys;
+	}
+	/** G57.72: any request to the public API for `xovris api`, answered as it came - the bearer added, never printed. */
+	raw(method, path, body, headers) {
+		return this.sys.fetch(`${this.base}/v1${path}`, {
+			method,
+			headers: {
+				accept: "application/json",
+				"user-agent": CLI_AGENT,
+				...headers,
+				...body !== void 0 ? { "content-type": "application/json" } : {},
+				...this.token ? { authorization: `Bearer ${this.token}` } : {}
+			},
+			...body !== void 0 ? { body: JSON.stringify(body) } : {}
+		});
+	}
+	async call(method, path, body, form = false) {
+		let res;
+		try {
+			res = await this.sys.fetch(`${this.base}/v1${path}`, {
+				method,
+				headers: {
+					accept: "application/json",
+					"user-agent": CLI_AGENT,
+					...body !== void 0 ? { "content-type": form ? "application/x-www-form-urlencoded" : "application/json" } : {},
+					...this.token ? { authorization: `Bearer ${this.token}` } : {}
+				},
+				...body !== void 0 ? { body: form ? new URLSearchParams(body).toString() : JSON.stringify(body) } : {}
+			});
+		} catch {
+			throw new ApiFailure(null, true);
+		}
+		let data = null;
+		try {
+			data = await res.json();
+		} catch {
+			data = null;
+		}
+		return {
+			status: res.status,
+			data
+		};
+	}
+	async ok(method, path, body) {
+		const r = await this.call(method, path, body);
+		if (r.status >= 200 && r.status < 300) return r.data;
+		const d = r.data ?? {};
+		throw new ApiFailure({
+			status: r.status,
+			title: d.title ?? d.error?.message ?? `Request failed (${r.status})`,
+			detail: d.detail ?? "",
+			next: d.next ?? d.error?.nextStep ?? "Try again in a moment.",
+			...typeof d.type === "string" ? { type: d.type } : {}
+		}, false);
+	}
+	deviceCode(clientName) {
+		return this.ok("POST", "/device/code", {
+			client_id: "xovris-cli",
+			client_name: clientName
+		});
+	}
+	async deviceToken(deviceCode) {
+		return this.call("POST", "/device/token", {
+			grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+			device_code: deviceCode,
+			client_id: "xovris-cli"
+		}, true);
+	}
+	startRun(project, platform, machine) {
+		return this.ok("POST", "/install-runs", {
+			project,
+			platform,
+			machine
+		});
+	}
+	/** AUT-16: the person's counted effort rides with each stage (null when no person is at it - never sent as a zero). */
+	stage(runId, stage, effort = null) {
+		return this.call("POST", `/install-runs/${encodeURIComponent(runId)}/stage`, effort ? {
+			stage,
+			effort
+		} : { stage });
+	}
+	verify(connectionId) {
+		return this.ok("GET", `/connections/${encodeURIComponent(connectionId)}/verify`);
+	}
+	/** D01.02.03: open (or return) the setup pull request. A refusal (412 consent, 409, 422) is an answer, not a throw. */
+	openPullRequest(connectionId, repository, path) {
+		return this.call("POST", `/connections/${encodeURIComponent(connectionId)}/github/pull-request`, {
+			repository,
+			path
+		});
+	}
+	remove(connectionId) {
+		return this.ok("POST", `/connections/${encodeURIComponent(connectionId)}/remove`);
+	}
+};
+
+//#endregion
+//#region src/ui.ts
+var Cancelled = class extends Error {
+	reason;
+	constructor(reason) {
+		super(reason);
+		this.reason = reason;
+	}
+};
+function clackUi(secrets, assumeYes, effort) {
+	const ask = (f) => effort ? effort.answer(f) : f();
+	const r = (s) => secrets.redact(s);
+	const cancelled = (v) => {
+		if (p.isCancel(v)) throw new Cancelled("Stopped. Nothing was changed after this point.");
+	};
+	return {
+		intro: (t) => p.intro(r(t)),
+		outro: (t) => p.outro(r(t)),
+		info: (t) => p.log.info(r(t)),
+		success: (t) => p.log.success(r(t)),
+		warn: (t) => p.log.warn(r(t)),
+		error: (t) => p.log.error(r(t)),
+		note: (b, t) => p.note(r(b), t ? r(t) : void 0),
+		async confirm(message) {
+			if (assumeYes) {
+				p.log.step(`${r(message)} yes (--yes)`);
+				return true;
+			}
+			const v = await ask(() => p.confirm({ message: r(message) }));
+			cancelled(v);
+			return v === true;
+		},
+		async select(message, options) {
+			const v = await ask(() => p.select({
+				message: r(message),
+				options: options.map((o) => ({
+					value: o.value,
+					label: r(o.label),
+					...o.hint ? { hint: r(o.hint) } : {}
+				}))
+			}));
+			cancelled(v);
+			return v;
+		},
+		async task(start, work, done) {
+			const s = p.spinner();
+			s.start(r(start));
+			try {
+				const v = await work();
+				s.stop(r(done(v)));
+				return v;
+			} catch (e) {
+				s.stop(r(start), 1);
+				throw e;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/signin.ts
+/** How many fresh codes the terminal asks for by itself before it stops waiting (each lasts the server's ten minutes). */
+const RENEWALS = 3;
+async function signIn(api, ui, sys, effort) {
+	const begin = async (again) => {
+		const start = await api.deviceCode(`Xovris command line on ${sys.hostname()}`);
+		const opened = await sys.openUrl(start.verification_uri_complete);
+		ui.note(`${again ? "The last code expired, so Xovris made a new one. " : ""}${opened ? "Your browser opened to approve this sign-in." : `Open ${start.verification_uri_complete} to approve this sign-in.`}\nCheck the browser shows the same code: ${start.user_code}\nYour data is never used to train our AI.`, "Sign in");
+		return start;
+	};
+	const approve = (f) => effort ? effort.answer(f) : f();
+	return ui.task("Waiting for you to approve in the browser", () => approve(async () => {
+		for (let round = 0; round <= RENEWALS; round += 1) {
+			const start = await begin(round > 0);
+			let interval = start.interval;
+			const deadline = sys.now() + start.expires_in * 1e3;
+			let expired = false;
+			while (!expired && sys.now() < deadline) {
+				await sys.sleep(interval * 1e3);
+				const r = await api.deviceToken(start.device_code);
+				if (r.status === 200 && r.data.access_token && r.data.workspace) {
+					api.token = r.data.access_token;
+					return { workspace: r.data.workspace };
+				}
+				switch (r.data.error) {
+					case "authorization_pending": continue;
+					case "slow_down":
+						interval += 5;
+						continue;
+					case "access_denied": throw new Cancelled("Sign-in was declined in the browser. Nothing was changed.");
+					case "expired_token":
+						expired = true;
+						continue;
+					default: throw new Cancelled(`Sign-in failed: ${r.data.error_description ?? r.data.error ?? `status ${r.status}`}. Nothing was changed.`);
+				}
+			}
+		}
+		throw new Cancelled(`No one approved the sign-in after ${RENEWALS + 1} codes. Run the command again when you are ready. Nothing was changed.`);
+	}), (v) => `Signed in to ${v.workspace.slug}`);
+}
+
+//#endregion
+//#region ../checks/src/atomic-write.ts
+let seq = 0;
+const asidePath = (file) => `${file}.${process.pid}.${Date.now().toString(36)}.${(seq++).toString(36)}.tmp`;
+/** The same, asynchronously. */
+async function writeFileAtomic(file, data, o = {}) {
+	await mkdir(dirname(file), { recursive: true });
+	const tmp = asidePath(file);
+	try {
+		const fh = await open(tmp, "w", o.mode ?? 438);
+		try {
+			await fh.writeFile(data);
+			await fh.sync();
+		} finally {
+			await fh.close();
+		}
+		await rename(tmp, file);
+	} catch (e) {
+		await rm(tmp, { force: true });
+		throw e;
+	}
+}
+
+//#endregion
+//#region src/apicmd.ts
+/** Where the key is kept: XOVRIS_CONFIG_DIR, else the platform's own per-user config folder. */
+function configDir(env = process.env, platform = process.platform) {
+	if (env.XOVRIS_CONFIG_DIR) return env.XOVRIS_CONFIG_DIR;
+	if (platform === "win32") return join(env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "xovris");
+	if (platform === "darwin") return join(homedir(), "Library", "Application Support", "xovris");
+	return join(env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "xovris");
+}
+const credentialsFile = () => join(configDir(), "credentials.json");
+async function readSaved() {
+	try {
+		const s = JSON.parse(await readFile(credentialsFile(), "utf8"));
+		return typeof s.token === "string" && s.token ? s : null;
+	} catch {
+		return null;
+	}
+}
+async function save(s) {
+	const f = credentialsFile();
+	await mkdir(dirname(f), { recursive: true });
+	await writeFileAtomic(f, `${JSON.stringify(s, null, 2)}\n`, { mode: 384 });
+	await chmod(f, 384).catch(() => void 0);
+	return f;
+}
+/** The key a command uses: XOVRIS_TOKEN first (CI), then the one `xovris login` saved for this API address. */
+async function tokenFor(api, env = process.env) {
+	if (env.XOVRIS_TOKEN) return env.XOVRIS_TOKEN;
+	const s = await readSaved();
+	return s && s.api === api ? s.token : null;
+}
+async function login(o, ui, sys, secrets, io) {
+	const api = new Api(o.api, sys);
+	if (o.withToken) {
+		const token = (await io.stdin()).trim();
+		if (!token) {
+			io.err("No key on standard input. Pipe one in: xovris login --with-token < key.txt (make a key in Settings, Developers).\n");
+			return 2;
+		}
+		secrets.add(token);
+		api.token = token;
+		const me = await meOf(api);
+		if (!me.ok) {
+			io.err(`${me.message}\n${me.next}\n`);
+			return 1;
+		}
+		const f$1 = await save({
+			api: o.api,
+			token,
+			workspace: me.workspace,
+			savedAt: new Date(sys.now()).toISOString()
+		});
+		io.out(`Signed in to ${me.workspace?.slug ?? "your workspace"}. The key is kept in ${f$1}, readable by you alone.\n`);
+		return 0;
+	}
+	const { workspace } = await signIn(api, ui, sys);
+	secrets.add(api.token);
+	const f = await save({
+		api: o.api,
+		token: api.token,
+		workspace,
+		savedAt: new Date(sys.now()).toISOString()
+	});
+	io.out(`Signed in to ${workspace.slug}. The key is kept in ${f}, readable by you alone.\n`);
+	return 0;
+}
+async function logout(io) {
+	const had = await readSaved();
+	await rm(credentialsFile(), { force: true });
+	io.out(had ? "Signed out: the key on this computer is deleted. To stop it everywhere, revoke it in Settings, Developers.\n" : "Not signed in on this computer.\n");
+	return 0;
+}
+async function meOf(api) {
+	const r = await request(api, "GET", "/me", void 0, {});
+	if (r.status === 401) return {
+		ok: false,
+		message: "Xovris did not accept this key: it is unknown, revoked or expired.",
+		next: "Sign in again with xovris login, or make a new key in Settings, Developers."
+	};
+	if (r.status < 200 || r.status >= 300) return {
+		ok: false,
+		message: `Xovris answered ${r.status} to GET /v1/me.`,
+		next: problemNext(r.body)
+	};
+	const b = r.body ?? {};
+	return {
+		ok: true,
+		workspace: b.workspace?.id && b.workspace.slug ? {
+			id: b.workspace.id,
+			slug: b.workspace.slug
+		} : null,
+		who: b.email ?? b.user?.email ?? b.name ?? null
+	};
+}
+async function whoami(o, sys, secrets, io) {
+	const token = await tokenFor(o.api);
+	if (!token) {
+		io.err("Not signed in. Run xovris login, or set XOVRIS_TOKEN to a key from Settings, Developers.\n");
+		return 1;
+	}
+	secrets.add(token);
+	const api = new Api(o.api, sys);
+	api.token = token;
+	let me;
+	try {
+		me = await meOf(api);
+	} catch (e) {
+		io.err(`Xovris could not be reached at ${o.api} (${e instanceof Error ? e.message : String(e)}).\nCheck your connection or the --api address, then run xovris whoami again.\n`);
+		return 1;
+	}
+	if (!me.ok) {
+		io.err(`${me.message}\n${me.next}\n`);
+		return 1;
+	}
+	io.out(`${me.who ?? "Signed in"}${me.workspace ? ` - workspace ${me.workspace.slug}` : ""} at ${o.api}${process.env.XOVRIS_TOKEN ? " (key from XOVRIS_TOKEN)" : ""}\n`);
+	return 0;
+}
+/** -F key=value is typed like gh's: true, false, null and numbers become JSON values; @file reads a file; -f is always text. */
+function fieldValue(v) {
+	if (v === "true") return true;
+	if (v === "false") return false;
+	if (v === "null") return null;
+	if (/^-?(0|[1-9]\d*)(\.\d+)?$/.test(v)) return Number(v);
+	return v;
+}
+/** The request body from -d (JSON, or @file) and the fields; a GET's fields become its query instead. */
+async function bodyOf(a, method) {
+	const query = new URLSearchParams();
+	const obj = {};
+	for (const [list, typed] of [[a.fields, true], [a.rawFields, false]]) for (const f of list) {
+		const eq = f.indexOf("=");
+		if (eq < 1) return { problem: `"${f}" is not key=value.` };
+		const k = f.slice(0, eq);
+		let v = f.slice(eq + 1);
+		if (typed && typeof v === "string" && v.startsWith("@")) v = (await readFile(v.slice(1), "utf8")).replace(/\r?\n$/, "");
+		else if (typed) v = fieldValue(v);
+		if (method === "GET" || method === "HEAD") query.append(k, String(v));
+		else obj[k] = v;
+	}
+	if (a.data !== null) {
+		if (Object.keys(obj).length) return { problem: "Use -d or -F/-f fields, not both." };
+		const raw = a.data.startsWith("@") ? await readFile(a.data.slice(1), "utf8") : a.data;
+		try {
+			return {
+				body: JSON.parse(raw),
+				query
+			};
+		} catch {
+			return { problem: "-d is not valid JSON." };
+		}
+	}
+	return Object.keys(obj).length ? {
+		body: obj,
+		query
+	} : { query };
+}
+async function request(api, method, path, body, headers) {
+	const res = await api.raw(method, path, body, headers);
+	const text = await res.text();
+	let parsed = text;
+	try {
+		parsed = text ? JSON.parse(text) : null;
+	} catch {}
+	return {
+		status: res.status,
+		headers: res.headers,
+		body: parsed,
+		text
+	};
+}
+function problemNext(body) {
+	const b = body ?? {};
+	return b.next ?? b.nextStep ?? b.error?.nextStep ?? "Check the address and the request on https://xovris.ai/developers/.";
+}
+async function apiCommand(a, o, sys, secrets, io) {
+	if (!a.path) {
+		io.err("Name a path: xovris api /incidents, or xovris api -X POST /checks -F url=example.com\n");
+		return 2;
+	}
+	const token = await tokenFor(o.api);
+	if (!token) {
+		io.err("Not signed in. Run xovris login, or set XOVRIS_TOKEN to a key from Settings, Developers.\n");
+		return 1;
+	}
+	secrets.add(token);
+	const path = `/${a.path.replace(/^\/+/, "").replace(/^v1\//, "")}`;
+	const method = (a.method ?? (a.data !== null || a.fields.length || a.rawFields.length ? "POST" : "GET")).toUpperCase();
+	const built = await bodyOf(a, method);
+	if ("problem" in built) {
+		io.err(`${built.problem}\n`);
+		return 2;
+	}
+	const headers = {};
+	for (const h of a.headers) {
+		const i = h.indexOf(":");
+		if (i > 0) headers[h.slice(0, i).trim().toLowerCase()] = h.slice(i + 1).trim();
+	}
+	if (a.idempotency && ![
+		"GET",
+		"HEAD",
+		"OPTIONS"
+	].includes(method) && !headers["idempotency-key"]) headers["idempotency-key"] = crypto.randomUUID();
+	const api = new Api(o.api, sys);
+	api.token = token;
+	const q = built.query.toString();
+	let r;
+	try {
+		r = await request(api, method, q ? `${path}${path.includes("?") ? "&" : "?"}${q}` : path, built.body, headers);
+	} catch {
+		io.err(`Could not reach ${o.api}. Check your connection, or --api for another address.\n`);
+		return 1;
+	}
+	if (a.include) io.out(secrets.redact(`HTTP ${r.status}\n${[...r.headers.entries()].map(([k, v]) => `${k}: ${v}`).join("\n")}\n\n`));
+	const shown = typeof r.body === "string" ? r.body : JSON.stringify(r.body, null, 2);
+	if (r.status >= 200 && r.status < 300) {
+		if (shown) io.out(`${secrets.redact(shown)}\n`);
+		return 0;
+	}
+	io.err(`${secrets.redact(shown || `HTTP ${r.status}`)}\n`);
+	if (r.status === 401) io.err("Xovris did not accept this key: sign in again with xovris login, or set XOVRIS_TOKEN to a key from Settings, Developers.\n");
+	else if (r.status === 403) io.err("This key is not allowed to do that. Its permissions are on Settings, Developers; an owner or admin can change them.\n");
+	return 1;
+}
+
+//#endregion
+export { whoami as a, Cancelled as c, ApiFailure as d, CLI_AGENT as f, tokenFor as i, clackUi as l, login as n, writeFileAtomic as o, CLI_VERSION as p, logout as r, signIn as s, apiCommand as t, Api as u };