wawesome 0.22.0 → 0.24.0

package/dist/assets-Cgw3_rAq.mjs

@@ -0,0 +1,336 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+//#region src/errors.ts
+/**
+* A rejection carrying the gateway's own prose and, where given, its reason.
+*
+* The call's trace id rides in the message itself, on a line of its own, so
+* every place that prints a refusal prints the one thing support can search by.
+*/
+var GatewayError = class extends Error {
+	status;
+	reason;
+	/** The raw response, for `--verbose` to print when the prose is not enough. */
+	body;
+	traceId;
+	/** When a `locked` rename refusal says the next rename is allowed. */
+	renamableAt;
+	constructor(message, status, reason, body = "", traceId, renamableAt) {
+		super(traceId ? `${message}\n${traceLine(traceId)}` : message);
+		this.name = "GatewayError";
+		this.status = status;
+		this.reason = reason;
+		this.body = body;
+		this.traceId = traceId;
+		this.renamableAt = renamableAt;
+	}
+};
+function traceLine(traceId) {
+	return `Trace ID: ${traceId}`;
+}
+/**
+* Read a failed response into a `GatewayError`.
+*
+* `fallback` is used only when the response carries no prose of its own — a
+* proxy's HTML error page, or an empty body. A 401 is deliberately *not* special
+* cased here: what to say about an expired session depends on what the caller
+* was doing, so callers handle it before reaching this.
+*/
+async function asGatewayError(res, fallback) {
+	const traceId = res.headers?.get("x-wawesome-trace-id") ?? void 0;
+	return rejectionOf(await res.text().catch(() => ""), res.status, fallback, traceId);
+}
+/**
+* The same reading, for a caller that has already taken the body off the wire.
+* `traceId` is the header's, for a body that never made it here as JSON.
+*/
+function rejectionOf(body, status, fallback, traceId) {
+	try {
+		const parsed = JSON.parse(body);
+		return new GatewayError(parsed.error || fallback, status, parsed.reason, body, parsed.trace_id || traceId, parsed.renamable_at);
+	} catch {
+		return new GatewayError(fallback, status, void 0, body, traceId);
+	}
+}
+/** Why the gateway refused, where what was thrown might not be a refusal at all. */
+function reasonOf(err) {
+	return err instanceof GatewayError ? err.reason : void 0;
+}
+/** What went wrong, as text, whatever was thrown. */
+function errorText(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/credential.ts
+const CREDENTIAL_ENV_VAR = "WAWESOME_DEPLOY_CREDENTIAL";
+const SECRET_PREFIX = "wawe_";
+function credentialFromEnvironment() {
+	const secret = process.env[CREDENTIAL_ENV_VAR]?.trim();
+	return secret ? secret : null;
+}
+/** Enough to match a credential against the one in a CI settings page, and no more. */
+function credentialPrefix(secret) {
+	return secret.slice(0, 11);
+}
+/**
+* A credential has no session behind it, so the platform's own reason — unknown,
+* revoked, expired, or a scope it does not carry — is the whole answer, and
+* "sign in again" names a door a CI runner cannot open.
+*/
+function unauthorizedMessage(status, body) {
+	const secret = credentialFromEnvironment();
+	if (!secret) {
+		const refusal = rejectionOf(body, status, `The platform refused this request (HTTP ${status}).`);
+		if (status !== 401) return refusal.message;
+		const expired = "Authentication expired. Run 'wawesome login' again.";
+		return refusal.traceId ? `${expired}\n${traceLine(refusal.traceId)}` : expired;
+	}
+	return rejectionOf(body, status, `The deploy credential ${credentialPrefix(secret)} was refused (HTTP ${status}).`).message;
+}
+function reportSessionCommandRefused(secret, consequence) {
+	console.error(`[wawesome] Error: ${CREDENTIAL_ENV_VAR} is set, so this CLI authenticates as deploy credential ${credentialPrefix(secret)}.`);
+	console.error(`[wawesome] ${consequence} Unset ${CREDENTIAL_ENV_VAR} first.`);
+}
+//#endregion
+//#region src/config.ts
+/** Path to the user-level settings file (~/.wawesome/settings.json) */
+function getSettingsPath() {
+	return path.join(os.homedir(), ".wawesome", "settings.json");
+}
+/**
+* Read stored user settings from ~/.wawesome/settings.json.
+*/
+function readSettings() {
+	const settingsPath = getSettingsPath();
+	if (!fs.existsSync(settingsPath)) return {};
+	try {
+		const raw = fs.readFileSync(settingsPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return {};
+	}
+}
+const GATEWAY_ENV_NAMES = ["GATEWAY_URL", "WAWESOME_GATEWAY_URL"];
+const DASHBOARD_ENV_NAMES = ["DASHBOARD_URL", "WAWESOME_DASHBOARD_URL"];
+const GATEWAY_URL_FALLBACK = "https://api.wawesome.io";
+const DASHBOARD_URL_FALLBACK = "https://dashboard.wawesome.io";
+function resolveAddress(overrideUrl, envNames, settingsKey, stored, fallback) {
+	if (overrideUrl) return overrideUrl;
+	for (const name of envNames) {
+		const fromEnv = process.env[name];
+		if (fromEnv) return fromEnv;
+	}
+	const configured = readSettings()[settingsKey];
+	if (configured && typeof configured === "string") return configured;
+	return stored || fallback;
+}
+function getGatewayUrl(overrideUrl) {
+	return resolveAddress(overrideUrl, GATEWAY_ENV_NAMES, "gateway_url", readStoredCredentials()?.gateway_url, GATEWAY_URL_FALLBACK);
+}
+/**
+* A tenant token is only valid at the gateway that issued it, so every other
+* command has to follow the credentials. A login holds no token yet, and
+* reading that rung here made a local gateway outlive the removal of every
+* documented override, since only `logout` clears it. A **Deploy credential**
+* reads the same rungs, and for a sharper reason: following a stale file would
+* present it at a gateway that never minted it.
+*/
+function resolveGatewayUrlWithoutSession(overrideUrl) {
+	return resolveAddress(overrideUrl, GATEWAY_ENV_NAMES, "gateway_url", void 0, GATEWAY_URL_FALLBACK);
+}
+getGatewayUrl();
+function getDashboardUrl(overrideUrl) {
+	return resolveAddress(overrideUrl, DASHBOARD_ENV_NAMES, "dashboard_url", readStoredCredentials()?.dashboard_url, DASHBOARD_URL_FALLBACK);
+}
+/**
+* The dashboard for the environment this login is going to.
+*
+* Taken from the address the platform handed back to open, so a login that
+* configures nothing stores the dashboard belonging to the gateway it signed
+* into. An explicit flag, `DASHBOARD_URL` or a settings file still outrank it,
+* on the rung they outrank every other address on.
+*/
+function resolveDashboardUrlForLogin(overrideUrl, signInUrl) {
+	return resolveAddress(overrideUrl, DASHBOARD_ENV_NAMES, "dashboard_url", originOf(signInUrl), DASHBOARD_URL_FALLBACK);
+}
+/** Undefined rather than throwing: an unreadable address falls to the rung below. */
+function originOf(url) {
+	try {
+		return new URL(url).origin;
+	} catch {
+		return;
+	}
+}
+const LOGIN_CALLBACK_PORT = 9999;
+/** Path to the user-level credentials file */
+function getCredentialsPath() {
+	return path.join(os.homedir(), ".wawesome", "credentials.json");
+}
+/**
+* What this process authenticates with: the **Deploy credential** in the
+* environment where one is set, and otherwise the session `login` left on disk.
+*
+* The environment wins outright rather than filling a gap, so a CI runner
+* carrying a stale cached home directory still authenticates as itself.
+*/
+function readCredentials() {
+	const secret = credentialFromEnvironment();
+	return secret ? environmentCredential(secret) : readStoredCredentials();
+}
+/**
+* A credential wears the shape of a session so that every command reaches the
+* platform the same way. What it does not carry is the point: no refresh token,
+* because there is nothing behind it to renew, and no Tenant, because the
+* platform resolves that from the credential.
+*/
+function environmentCredential(secret) {
+	return {
+		gateway_url: resolveGatewayUrlWithoutSession(void 0),
+		tenant_jwt: secret,
+		credential_prefix: credentialPrefix(secret)
+	};
+}
+/** The session on disk, whatever the environment says. */
+function readStoredCredentials() {
+	const credPath = getCredentialsPath();
+	if (!fs.existsSync(credPath)) return null;
+	try {
+		const raw = fs.readFileSync(credPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+/**
+* Write credentials to disk, creating the directory if needed.
+*
+* Owner-only, because the file holds a refresh token. The `chmod` is what
+* tightens a file an older CLI left world-readable; a mode passed to
+* `writeFileSync` applies only where it creates the file.
+*/
+function writeCredentials(creds) {
+	if (credentialFromEnvironment()) return;
+	const credPath = getCredentialsPath();
+	const dir = path.dirname(credPath);
+	fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	fs.writeFileSync(credPath, JSON.stringify(creds, null, 2), {
+		encoding: "utf-8",
+		mode: 384
+	});
+	fs.chmodSync(credPath, 384);
+}
+/**
+* Delete stored credentials.
+*/
+function deleteCredentials() {
+	const credPath = getCredentialsPath();
+	if (fs.existsSync(credPath)) {
+		fs.rmSync(credPath, { force: true });
+		return true;
+	}
+	return false;
+}
+function getFunctionConfigPath(projectDir) {
+	return path.join(projectDir || process.cwd(), "wawesome-function.json");
+}
+function readFunctionConfig(projectDir) {
+	const configPath = getFunctionConfigPath(projectDir);
+	if (!fs.existsSync(configPath)) return null;
+	try {
+		const raw = fs.readFileSync(configPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/assets.ts
+/**
+* The files under `dir`, hashed.
+*
+* Hashes are read off disk in a stream rather than by reading each file whole:
+* a client build's largest chunk is not something to hold in memory just to
+* find out the platform already has it.
+*/
+function collectAssets(dir) {
+	return listFiles(dir).map((file) => ({
+		...file,
+		content_hash: hashFile(file.source)
+	}));
+}
+/** The files a deploy of `dir` carries, before any is read. */
+function listFiles(dir) {
+	if (!fs.existsSync(dir)) return [];
+	const files = [];
+	const walk = (current, prefix) => {
+		for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+			const absolute = path.join(current, entry.name);
+			const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) walk(absolute, relative);
+			else if (entry.isFile()) files.push({
+				path: relative,
+				size_bytes: fs.statSync(absolute).size,
+				source: absolute
+			});
+		}
+	};
+	walk(dir, "");
+	return files;
+}
+/**
+* A **Static asset** a browser renders as a page. Read off the extension, as the
+* content type the platform records is — mirrors `content_type_for_path` in
+* `server/crates/core/src/features/assets/content_type.rs`.
+*/
+function isDocument(assetPath) {
+	const name = assetPath.split("/").pop() ?? "";
+	const dot = name.lastIndexOf(".");
+	const extension = dot === -1 ? "" : name.slice(dot + 1).toLowerCase();
+	return extension === "html" || extension === "htm";
+}
+function hashFile(file) {
+	return sha256(fs.readFileSync(file));
+}
+function sha256(bytes) {
+	return crypto.createHash("sha256").update(bytes).digest("hex");
+}
+/**
+* What this deploy *is*: the server bundle together with the sorted set of
+* asset path and content-hash pairs, the same set for its **Private file**s
+* marked apart, and the **Fallback document** it declares.
+*
+* Computed here, before anything is uploaded, so a deploy that changed nothing
+* is refused before a byte moves. Mirrors `deploy_digest` in
+* `server/crates/core/src/features/assets/identity.rs` — the gateway recomputes
+* it from what actually arrives, so the two have to agree exactly.
+*
+* A deploy declaring no fallback and no private files contributes nothing here
+* for either rather than a stated absence, so every digest computed before
+* they existed is unmoved.
+*/
+const DEPLOY_DIGEST_DOMAIN = "wawesome-deploy-v1";
+function deployDigest(bundle, assets, fallback, privateFiles = []) {
+	const byPath = (files) => [...files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+	const digest = crypto.createHash("sha256");
+	digest.update(`${DEPLOY_DIGEST_DOMAIN}\n`);
+	digest.update(`${sha256(bundle)}\n`);
+	for (const asset of byPath(assets)) digest.update(`${asset.path}\0${asset.content_hash}\n`);
+	for (const file of byPath(privateFiles)) digest.update(`private\0${file.path}\0${file.content_hash}\n`);
+	if (fallback) digest.update(`fallback\0${fallback.path}\0${fallback.status}\n`);
+	return digest.digest("hex");
+}
+/** The manifest as the gateway reads it — the bytes on disk are the CLI's business. */
+function manifestOf(assets) {
+	return assets.map(({ path, content_hash, size_bytes }) => ({
+		path,
+		content_hash,
+		size_bytes
+	}));
+}
+//#endregion
+export { asGatewayError as C, rejectionOf as E, GatewayError as S, reasonOf as T, SECRET_PREFIX as _, manifestOf as a, reportSessionCommandRefused as b, getDashboardUrl as c, readCredentials as d, readFunctionConfig as f, CREDENTIAL_ENV_VAR as g, writeCredentials as h, listFiles as i, getFunctionConfigPath as l, resolveGatewayUrlWithoutSession as m, deployDigest as n, LOGIN_CALLBACK_PORT as o, resolveDashboardUrlForLogin as p, isDocument as r, deleteCredentials as s, collectAssets as t, getGatewayUrl as u, credentialFromEnvironment as v, errorText as w, unauthorizedMessage as x, credentialPrefix as y };