@hardfin/cli 0.1.0-dev.25 → 0.1.0-dev.26

package/dist/cli.js

@@ -8,7 +8,7 @@ process.stdout.on("error", (error) => {
 });
 const answer = await toQuickAnswer(process.argv.slice(2));
 if (answer === void 0) {
-	const { toCli } = await import("./program-b3uLLsYy.js");
+	const { toCli } = await import("./program-C_9qi3K1.js");
 	await toCli().parseAsync(process.argv);
 } else process.stdout.write(`${answer}\n`);
 /**

package/dist/{program-b3uLLsYy.js → program-C_9qi3K1.js}

@@ -435,6 +435,111 @@ function writeFile(held) {
 	renameSync(pending, path);
 }
 //#endregion
+//#region src/http/reach.ts
+/** Unreachable is a request that never reached a server, so there is no answer to report. */
+var Unreachable = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "Unreachable";
+	}
+};
+const OFFLINE = "Couldn't connect to Hardfin. Check your internet connection and try again.";
+const INSECURE = "Couldn't connect to Hardfin securely, so nothing was sent. A work network or security software may be blocking the connection. If this keeps happening, contact your IT team.";
+/** The reasons Node gives, by the code on the error behind fetch's own. */
+const REASONS = {
+	ECONNREFUSED: {
+		message: OFFLINE,
+		detail: "connection refused"
+	},
+	ENOTFOUND: {
+		message: OFFLINE,
+		detail: "address not found"
+	},
+	EAI_AGAIN: {
+		message: OFFLINE,
+		detail: "address lookup failed"
+	},
+	ETIMEDOUT: {
+		message: OFFLINE,
+		detail: "timed out"
+	},
+	UND_ERR_CONNECT_TIMEOUT: {
+		message: OFFLINE,
+		detail: "timed out"
+	},
+	EHOSTUNREACH: {
+		message: OFFLINE,
+		detail: "no route to host"
+	},
+	ENETUNREACH: {
+		message: OFFLINE,
+		detail: "network unreachable"
+	},
+	ECONNRESET: {
+		message: OFFLINE,
+		detail: "connection closed"
+	},
+	UND_ERR_SOCKET: {
+		message: OFFLINE,
+		detail: "connection closed"
+	},
+	DEPTH_ZERO_SELF_SIGNED_CERT: {
+		message: INSECURE,
+		detail: "certificate not trusted"
+	},
+	SELF_SIGNED_CERT_IN_CHAIN: {
+		message: INSECURE,
+		detail: "certificate not trusted"
+	},
+	UNABLE_TO_VERIFY_LEAF_SIGNATURE: {
+		message: INSECURE,
+		detail: "certificate not trusted"
+	},
+	UNABLE_TO_GET_ISSUER_CERT_LOCALLY: {
+		message: INSECURE,
+		detail: "certificate not trusted"
+	},
+	CERT_HAS_EXPIRED: {
+		message: INSECURE,
+		detail: "certificate expired"
+	},
+	ERR_TLS_CERT_ALTNAME_INVALID: {
+		message: INSECURE,
+		detail: "certificate is for another host"
+	},
+	ERR_SSL_WRONG_VERSION_NUMBER: {
+		message: OFFLINE,
+		detail: "not an HTTPS server"
+	},
+	EPROTO: {
+		message: OFFLINE,
+		detail: "not an HTTPS server"
+	}
+};
+/** send is fetch, with a failure to connect reported in words anyone can act on. */
+async function send(url, init) {
+	try {
+		return await fetch(url, init);
+	} catch (error) {
+		throw toUnreachable(url, error);
+	}
+}
+/**
+* toUnreachable describes a request that could not connect. Fetch reports every such failure
+* as "fetch failed", and the reason is on the error it wraps. The person reads a plain
+* message, and the line after it names the reason and host for whoever helps them.
+*/
+function toUnreachable(url, error) {
+	const host = new URL(url).host;
+	const cause = error instanceof Error ? error.cause : void 0;
+	const code = cause instanceof Error ? cause.code : void 0;
+	const reason = (error instanceof Error && error.name === "TimeoutError" ? REASONS["ETIMEDOUT"] : code === void 0 ? void 0 : REASONS[code]) ?? {
+		message: OFFLINE,
+		detail: cause instanceof Error ? cause.message : error instanceof Error ? error.message : String(error)
+	};
+	return new Unreachable(`${reason.message}\nDetails: ${reason.detail} (${host})`);
+}
+//#endregion
 //#region src/auth/metadata.ts
 const METADATA_PATH = "/.well-known/oauth-authorization-server";
 const AuthorizationServerMetadata = z.looseObject({
@@ -461,12 +566,7 @@ async function toMetadata(issuer) {
 	const cached = toCached(issuer);
 	if (cached) return cached;
 	const url = `${issuer.replace(/\/+$/, "")}${METADATA_PATH}`;
-	let response;
-	try {
-		response = await fetch(url, { headers: { Accept: "application/json" } });
-	} catch (error) {
-		throw new DiscoveryFailure(`${url} could not be reached: ${error instanceof Error ? error.message : String(error)}`);
-	}
+	const response = await send(url, { headers: { Accept: "application/json" } });
 	if (!response.ok) throw new DiscoveryFailure(`${url} answered ${response.status}, so this host publishes no authorization server`);
 	const parsed = AuthorizationServerMetadata.safeParse(await response.json().catch(() => void 0));
 	if (!parsed.success) throw new DiscoveryFailure(`${url} does not describe an authorization server`);
@@ -543,7 +643,7 @@ async function toTokensFromRefresh(tokenUrl, clientId, refreshToken) {
 }
 /** revoke tells the server to forget a token, so signing out reaches every machine. */
 async function revoke(revocationUrl, clientId, token) {
-	await fetch(revocationUrl, {
+	await send(revocationUrl, {
 		method: "POST",
 		headers: { "Content-Type": "application/x-www-form-urlencoded" },
 		body: new URLSearchParams({
@@ -555,7 +655,7 @@ async function revoke(revocationUrl, clientId, token) {
 }
 /** toTokens asks the token endpoint, which answers a flat RFC 6749 body, not the envelope. */
 async function toTokens(url, form) {
-	const response = await fetch(url, {
+	const response = await send(url, {
 		method: "POST",
 		headers: {
 			"Content-Type": "application/x-www-form-urlencoded",
@@ -800,7 +900,7 @@ async function request(options) {
 		Accept: options.downloads ? "*/*" : "application/json"
 	};
 	if (options.body !== void 0 && options.form === void 0) headers["Content-Type"] = "application/json";
-	const response = await fetch(url, {
+	const response = await send(url, {
 		method: options.method,
 		headers,
 		body: options.form ?? (options.body === void 0 ? void 0 : JSON.stringify(options.body))
@@ -1593,7 +1693,7 @@ const DeviceResponse = z.looseObject({
 });
 /** toDeviceAuthorization asks for a code a person can type on another machine. */
 async function toDeviceAuthorization(endpoint, clientId, scope) {
-	const response = await fetch(endpoint, {
+	const response = await send(endpoint, {
 		method: "POST",
 		headers: {
 			"Content-Type": "application/x-www-form-urlencoded",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hardfin/cli",
-    "version": "0.1.0-dev.25",
+    "version": "0.1.0-dev.26",
     "description": "Command line interface for the Hardfin API",
     "license": "Apache-2.0",
     "author": "Hardfin, Inc.",