hngr 0.1.0 → 0.2.0

package/dist/commands-BchmocR_.mjs

@@ -0,0 +1,13 @@
+import { t as commandCatalog } from "./catalog-jU0-wzh3.mjs";
+// src/commands/commands.ts
+function run(ctx) {
+	const catalog = commandCatalog();
+	if (ctx.io.stdout.isTTY && !ctx.flags.json) {
+		const width = Math.max(...catalog.map((entry) => entry.name.length));
+		for (const entry of catalog) ctx.io.stdout.write(`${entry.name.padEnd(width)}  ${entry.summary}\n`);
+		return 0;
+	}
+	ctx.writePayload(catalog);
+	return 0;
+}
+export { run };

package/dist/http-2HWxLIOq.mjs

@@ -0,0 +1,459 @@
+import { chmod, lstat, mkdir, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+// src/errors.ts
+var HngrError = class extends Error {
+	body;
+	exitCode;
+	constructor(body, exitCode = 1) {
+		super(body.title);
+		this.name = "HngrError";
+		this.body = body;
+		this.exitCode = exitCode;
+	}
+};
+/** Interactive prompt cancelled via Ctrl+C / Esc; maps to exit code 130. */
+var CancelledError = class extends Error {
+	constructor(message = "cancelled") {
+		super(message);
+		this.name = "CancelledError";
+	}
+};
+function bodyOf(err) {
+	if (err instanceof HngrError) return {
+		body: err.body,
+		exitCode: err.exitCode
+	};
+	return {
+		body: {
+			type: "io",
+			title: err instanceof Error ? err.message : String(err)
+		},
+		exitCode: 1
+	};
+}
+/**
+* Renders an error per the output contract: human text on a TTY (unless
+* --json), otherwise a single-line JSON object on stderr. Returns the exit
+* code. Never prints tokens or passwords; bodies must be pre-redacted.
+*/
+function renderError(io, options, err) {
+	if (err instanceof CancelledError) {
+		if (io.stderr.isTTY && !options.json) io.stderr.write(`${options.colors.dim(err.message)}\n`);
+		else io.stderr.write(`${JSON.stringify({ error: {
+			type: "usage",
+			title: err.message
+		} })}\n`);
+		return 130;
+	}
+	const { body, exitCode } = bodyOf(err);
+	if (io.stderr.isTTY && !options.json) {
+		io.stderr.write(`${options.colors.red(`error: ${body.title}`)}\n`);
+		if (body.detail) io.stderr.write(`${options.colors.dim(body.detail)}\n`);
+	} else io.stderr.write(`${JSON.stringify({ error: body })}\n`);
+	return exitCode;
+}
+// src/atomic.ts
+/**
+* Writes a file through a temp file plus rename, so readers see either the old
+* content or the complete new content.
+*/
+async function writeFileAtomically(path, content, options = {}) {
+	const dir = dirname(path);
+	const temp = resolve(dir, `.${basename(path)}.${randomUUID()}.tmp`);
+	try {
+		const existed = await stat(dir).then((stats) => stats.isDirectory(), () => false);
+		if (options.dirMode === void 0) await mkdir(dir, { recursive: true });
+		else {
+			await mkdir(dir, {
+				recursive: true,
+				mode: options.dirMode
+			});
+			if (!existed) await chmod(dir, options.dirMode);
+		}
+		await writeFile(temp, content, { mode: options.mode ?? 420 });
+		await rename(temp, path);
+	} catch (err) {
+		await unlink(temp).catch(() => {});
+		if (err instanceof HngrError) throw err;
+		throw new HngrError({
+			type: "io",
+			title: `Could not write ${options.label ?? path}`,
+			detail: err instanceof Error ? err.message : String(err)
+		});
+	}
+}
+/**
+* Writes a directory through "temp → rename": the destination is either
+* absent or complete, never half-written. With `force`, the old directory is
+* moved aside before the rename so a failed swap puts it back.
+*/
+async function writeDirectoryAtomically(dest, writeTemp, options) {
+	const parent = dirname(dest);
+	await mkdir(parent, { recursive: true });
+	const temp = resolve(parent, `.hngr-${basename(dest)}-${randomUUID()}.tmp`);
+	try {
+		await writeTemp(temp);
+		const exists = await lstat(dest).then(() => true, () => false);
+		if (exists && !options.force) throw options.existsError();
+		if (!exists) {
+			await rename(temp, dest);
+			return;
+		}
+		const backup = resolve(parent, `.hngr-${basename(dest)}-${randomUUID()}.bak`);
+		await rename(dest, backup);
+		try {
+			await rename(temp, dest);
+		} catch (err) {
+			await rename(backup, dest).catch(() => {});
+			throw err;
+		}
+		await rm(backup, {
+			recursive: true,
+			force: true
+		});
+	} catch (err) {
+		await rm(temp, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		if (err instanceof HngrError) throw err;
+		throw new HngrError({
+			type: "io",
+			title: `Could not install into ${options.label ?? dest}`,
+			detail: err instanceof Error ? err.message : String(err)
+		});
+	}
+}
+// src/config.ts
+/** `$XDG_CONFIG_HOME/hngr/config.json`, falling back to `~/.config/hngr/config.json`. */
+function configFilePath(env) {
+	const xdg = env.XDG_CONFIG_HOME;
+	const home = env.HOME ?? homedir();
+	const base = xdg && xdg.length > 0 ? xdg : home ? join(home, ".config") : void 0;
+	return base ? join(base, "hngr", "config.json") : void 0;
+}
+/** Reads the stored config; a missing file is not an error, invalid JSON is. */
+async function readStoredConfig(env) {
+	const path = configFilePath(env);
+	if (!path) return;
+	let raw;
+	try {
+		raw = await readFile(path, "utf8");
+	} catch (err) {
+		if (err.code === "ENOENT") return;
+		throw new HngrError({
+			type: "config",
+			title: `Could not read ${path}`,
+			detail: err instanceof Error ? err.message : String(err)
+		});
+	}
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("expected a JSON object");
+		return parsed;
+	} catch (err) {
+		throw new HngrError({
+			type: "config",
+			title: `Invalid config file ${path}`,
+			detail: err instanceof Error ? err.message : String(err)
+		});
+	}
+}
+/**
+* The instance the CLI talks to when `--server`, `HANGAR_URL` and the config
+* file are all absent. Point a deployment elsewhere with any of those.
+*/
+const DEFAULT_SERVER_URL = "http://10.199.100.24:26434";
+const INVALID_SERVER_DETAIL = "Pass --server <url>, set HANGAR_URL, or run `hngr auth login` to store one in the config file.";
+/** Parses and normalizes a server URL (no trailing slash); invalid input is a config error. */
+function normalizeServerUrl(server) {
+	let url;
+	try {
+		url = new URL(server);
+	} catch {
+		throw new HngrError({
+			type: "config",
+			title: `Invalid server URL: ${redactUrl(server)}`,
+			detail: INVALID_SERVER_DETAIL
+		});
+	}
+	return url.toString().replace(/\/+$/, "");
+}
+/**
+* Atomically writes the config file: a `0600` temp file renamed into place
+* inside a `0700` directory. Returns the config path. Never logs the content.
+*/
+async function writeStoredConfig(env, config) {
+	const path = configFilePath(env);
+	if (!path) throw new HngrError({
+		type: "config",
+		title: "No config location available",
+		detail: "Set HOME or XDG_CONFIG_HOME so hngr can store credentials."
+	});
+	await writeFileAtomically(path, `${JSON.stringify(config, null, 2)}\n`, {
+		mode: 384,
+		dirMode: 448
+	});
+	return path;
+}
+/** Deletes the stored config file; a missing file is not an error. */
+async function deleteStoredConfig(env) {
+	const path = configFilePath(env);
+	if (!path) return;
+	try {
+		await unlink(path);
+	} catch (err) {
+		if (err.code !== "ENOENT") throw new HngrError({
+			type: "io",
+			title: `Could not delete ${path}`,
+			detail: err instanceof Error ? err.message : String(err)
+		});
+	}
+}
+/**
+* Resolves the server and credentials for one call: `--server` beats
+* `HANGAR_URL` beats the config file beats the built-in default; `HANGAR_TOKEN`
+* beats a stored token.
+*/
+async function resolveConnection(flags, env) {
+	const config = await readStoredConfig(env);
+	const server = flags.server ?? env.HANGAR_URL ?? config?.server ?? "http://10.199.100.24:26434";
+	const token = env.HANGAR_TOKEN ?? config?.token;
+	return {
+		server: normalizeServerUrl(server),
+		token
+	};
+}
+/** Strips any embedded credentials so a URL is safe to print. */
+function redactUrl(raw) {
+	try {
+		const url = new URL(raw);
+		url.username = "";
+		url.password = "";
+		return url.toString();
+	} catch {
+		return raw;
+	}
+}
+/** Removes any credentials embedded in `server` from free-form error text. */
+function scrubCredentials(text, server) {
+	try {
+		const url = new URL(server);
+		for (const secret of [url.username, url.password]) if (secret) text = text.split(secret).join("<redacted>");
+	} catch {}
+	return text;
+}
+// ../client/src/problem.ts
+/** A typed transport failure. `detail` is developer text, never the primary message. */
+var ApiError = class ApiError extends Error {
+	status;
+	type;
+	title;
+	detail;
+	requestId;
+	retryAfter;
+	problem;
+	constructor(init) {
+		super(init.title ?? (init.status === 0 ? "网络连接失败" : "请求失败"));
+		this.name = "ApiError";
+		this.status = init.status;
+		this.type = init.type;
+		this.title = init.title;
+		this.detail = init.detail;
+		this.requestId = init.requestId;
+		this.retryAfter = init.retryAfter;
+		this.problem = init.problem;
+	}
+	static network() {
+		return new ApiError({
+			status: 0,
+			type: "network"
+		});
+	}
+};
+/** Narrows a decoded body to a problem document; anything else maps to about:blank. */
+function asProblemDetails(body) {
+	if (body === null || typeof body !== "object") return;
+	return body;
+}
+/** Parses the `Retry-After` delta-seconds header; absent or invalid means no hint. */
+function parseRetryAfter(header) {
+	if (header === null) return;
+	const value = Number.parseInt(header, 10);
+	return Number.isFinite(value) ? value : void 0;
+}
+/** Maps a decoded problem+json body onto an `ApiError`. */
+function apiErrorFromProblem(init) {
+	const problem = asProblemDetails(init.body);
+	return new ApiError({
+		status: init.status,
+		type: problem?.type ?? "about:blank",
+		title: problem?.title,
+		detail: problem?.detail,
+		requestId: init.requestId,
+		retryAfter: parseRetryAfter(init.retryAfter ?? null),
+		problem
+	});
+}
+/** Maps a failed HTTP response onto an `ApiError`; non-JSON bodies degrade to status only. */
+async function apiErrorFromResponse(response, requestId) {
+	let body;
+	if ((response.headers.get("Content-Type") ?? "").includes("json")) try {
+		body = await response.json();
+	} catch {
+		body = void 0;
+	}
+	return apiErrorFromProblem({
+		status: response.status,
+		body,
+		retryAfter: response.headers.get("Retry-After"),
+		requestId
+	});
+}
+// ../client/src/query.ts
+/**
+* Serializes query parameters with `URLSearchParams` semantics (spaces become
+* `+`), dropping `undefined`, `null` and empty-string values. Returns the empty
+* string when nothing survives, so callers can skip the `?` separator.
+*/
+function serializeQueryParams(query = {}) {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null || value === "") continue;
+		params.set(key, String(value));
+	}
+	return params.toString();
+}
+// src/redact.ts
+const REDACTED = "<redacted>";
+/**
+* One redaction rule for every human-visible representation of a request:
+* a key is sensitive when it contains password, token, secret, authorization
+* or cookie, case-insensitively.
+*/
+const SENSITIVE_KEY = /password|token|secret|authorization|cookie/i;
+function isSensitiveKey(key) {
+	return SENSITIVE_KEY.test(key);
+}
+/** Recursively replaces sensitive object values with `<redacted>`. */
+function redactSensitive(value) {
+	if (Array.isArray(value)) return value.map((item) => redactSensitive(item));
+	if (value === null || typeof value !== "object") return value;
+	const redacted = {};
+	for (const [key, inner] of Object.entries(value)) redacted[key] = isSensitiveKey(key) ? REDACTED : redactSensitive(inner);
+	return redacted;
+}
+/** Replaces the value of every sensitive query parameter. */
+function redactQuery(query) {
+	const redacted = {};
+	for (const [key, value] of Object.entries(query)) redacted[key] = isSensitiveKey(key) ? REDACTED : value;
+	return redacted;
+}
+/**
+* A URL safe to print: embedded credentials are removed and sensitive query
+* values are redacted, matching the object redaction rule.
+*/
+function redactUrlForDisplay(raw) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		return raw;
+	}
+	url.username = "";
+	url.password = "";
+	for (const key of [...url.searchParams.keys()]) if (isSensitiveKey(key)) url.searchParams.set(key, REDACTED);
+	return url.toString();
+}
+// src/http.ts
+const AUTH_REMEDIATION = "Run `hngr auth login` or set HANGAR_TOKEN.";
+/** Builds the absolute request URL; the redacted form is safe for dry-run and errors. */
+function buildRequestUrl(connection, path, query) {
+	const qs = serializeQueryParams(query);
+	const url = `${connection.server}${path}${qs ? `?${qs}` : ""}`;
+	return {
+		url,
+		redactedUrl: redactUrlForDisplay(url)
+	};
+}
+/** Maps a failed response or transport error onto the CLI error contract. */
+function toHngrError(err) {
+	if (err.status === 401) return new HngrError({
+		type: err.type === "about:blank" ? "auth" : err.type,
+		title: err.title ?? "Unauthenticated",
+		status: err.status,
+		requestId: err.requestId,
+		detail: err.detail ? `${err.detail} ${AUTH_REMEDIATION}` : AUTH_REMEDIATION
+	}, 4);
+	let detail = err.detail;
+	if (err.retryAfter !== void 0) {
+		const hint = `retry after ${err.retryAfter}s`;
+		detail = detail ? `${detail} (${hint})` : hint;
+	}
+	return new HngrError({
+		type: err.type,
+		title: err.title ?? `Request failed with status ${err.status}`,
+		status: err.status,
+		requestId: err.requestId,
+		detail
+	});
+}
+/**
+* Sends one request and returns the raw Response. A Bearer token goes out
+* when the connection has one; non-2xx responses and transport errors become
+* HngrErrors through the same mapping as everything else.
+*/
+async function apiRequest(connection, options) {
+	const { url } = buildRequestUrl(connection, options.path, options.query);
+	const headers = {
+		Accept: "application/json",
+		...options.headers
+	};
+	if (connection.token) headers.Authorization = `Bearer ${connection.token}`;
+	const init = {
+		method: options.method,
+		headers,
+		signal: options.signal
+	};
+	if (options.rawBody !== void 0) init.body = options.rawBody;
+	else if (options.body !== void 0) {
+		if (!("Content-Type" in headers)) headers["Content-Type"] = "application/json";
+		init.body = JSON.stringify(options.body);
+	}
+	let response;
+	try {
+		response = await fetch(url, init);
+	} catch (err) {
+		const origin = redactUrl(connection.server);
+		const cause = err instanceof Error ? err.message : String(err);
+		throw new HngrError({
+			type: "network",
+			title: `Could not reach the Hangar server at ${origin}`,
+			detail: scrubCredentials(cause, connection.server)
+		});
+	}
+	if (!response.ok) throw toHngrError(await apiErrorFromResponse(response, response.headers.get("X-Request-ID") ?? void 0));
+	return response;
+}
+/** GETs a JSON resource; anonymous reads work when no token is configured. */
+async function apiGet(connection, path, query, options) {
+	return (await apiRequest(connection, {
+		method: "GET",
+		path,
+		query,
+		signal: options?.signal
+	})).json();
+}
+/** Sends a non-GET JSON request and returns the raw Response (status, headers). */
+async function apiFetch(connection, options) {
+	return apiRequest(connection, {
+		method: options.method,
+		path: options.path,
+		body: options.body,
+		headers: options.headers,
+		signal: options.signal
+	});
+}
+export { renderError as C, HngrError as S, scrubCredentials as _, toHngrError as a, writeFileAtomically as b, redactUrlForDisplay as c, configFilePath as d, deleteStoredConfig as f, resolveConnection as g, redactUrl as h, buildRequestUrl as i, apiErrorFromResponse as l, readStoredConfig as m, apiGet as n, redactQuery as o, normalizeServerUrl as p, apiRequest as r, redactSensitive as s, apiFetch as t, DEFAULT_SERVER_URL as u, writeStoredConfig as v, CancelledError as x, writeDirectoryAtomically as y };