spur-board 0.1.0

package/dist/client-C1hJzdYE.mjs

@@ -0,0 +1,162 @@
+import { A as errorEnvelopeSchema, O as ERRORS, c as renderJsonError, j as successEnvelopeSchema, k as errorContextSchema } from "./src-CqH_W7D8.mjs";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { request } from "node:http";
+import { request as request$1 } from "node:https";
+//#region src/terminal.ts
+/** Show control bytes as text so server data cannot change terminal state. */
+function escapeTerminalControls(text) {
+	return Array.from(text, (character) => {
+		const code = character.charCodeAt(0);
+		return code < 32 || code >= 127 && code <= 159 ? `\\u${code.toString(16).padStart(4, "0")}` : character;
+	}).join("");
+}
+//#endregion
+//#region src/exit-codes.ts
+var CliError = class extends Error {
+	code;
+	context;
+	requestId;
+	hint;
+	constructor(code, context, requestId = `client-${randomUUID()}`, hint) {
+		super(ERRORS[code].message);
+		this.name = "CliError";
+		this.code = code;
+		this.context = context;
+		this.requestId = requestId;
+		this.hint = hint;
+	}
+};
+function errorExitCode(error) {
+	return ERRORS[error.code].exit;
+}
+function renderCliError(error, json, key) {
+	const envelope = renderJsonError({
+		code: error.code,
+		requestId: error.requestId,
+		...error.context ? { context: error.context } : {}
+	});
+	const recoveryHint = key && ERRORS[error.code].exit === 5 ? `retry with --key ${key}` : null;
+	const hint = [error.hint ?? envelope.error.hint, recoveryHint].filter(Boolean).join(" ");
+	const value = errorEnvelopeSchema.parse({
+		...envelope,
+		error: {
+			...envelope.error,
+			hint
+		}
+	});
+	if (json) return JSON.stringify(value);
+	return [
+		["error", `${value.error.code}: ${value.error.message}`],
+		["fix", value.error.hint],
+		["side effects", value.error.recovery.sideEffects],
+		["recovery", value.error.recovery.action],
+		["requestId", value.requestId]
+	].map(([label, text]) => `${label}: ${escapeTerminalControls(text)}`).join("\n");
+}
+//#endregion
+//#region src/client.ts
+function problemError(status, contentType, body) {
+	if (!body || typeof body !== "object") return new CliError("outcome_unknown");
+	const problem = body;
+	const requestId = typeof problem["requestId"] === "string" && problem["requestId"] ? problem["requestId"] : void 0;
+	if (status === 503 && contentType?.startsWith("application/problem+json") && problem["status"] === 503 && problem["code"] === "starting") return new CliError("daemon_unavailable", void 0, requestId);
+	const code = problem["code"];
+	if (typeof code === "string" && Object.hasOwn(ERRORS, code) && ERRORS[code].status === status) {
+		const context = errorContextSchema.safeParse(problem["context"]);
+		return new CliError(code, context.success ? context.data : void 0, requestId);
+	}
+	return new CliError("outcome_unknown", void 0, requestId);
+}
+function decodeResponse(output, response, raw) {
+	let body;
+	try {
+		body = JSON.parse(raw);
+	} catch {
+		throw new CliError("outcome_unknown");
+	}
+	if (response.statusCode === 200) {
+		const envelope = successEnvelopeSchema.safeParse(body);
+		if (!envelope.success) throw new CliError("outcome_unknown");
+		const parsed = output.safeParse(envelope.data.value);
+		if (!parsed.success) throw new CliError("outcome_unknown");
+		return parsed.data;
+	}
+	throw problemError(response.statusCode ?? 0, response.headers["content-type"], body);
+}
+async function post(path, body, config, output, anonymous) {
+	const target = new URL(path, config.address);
+	const payload = JSON.stringify(body);
+	const transport = target.protocol === "https:" ? request$1 : request;
+	return new Promise((resolve, reject) => {
+		let connected = false;
+		let settled = false;
+		let timer;
+		const settle = (result) => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			if ("error" in result) reject(result.error);
+			else resolve(result.value);
+		};
+		const req = transport(target, {
+			method: "POST",
+			agent: false,
+			headers: {
+				"content-type": "application/json",
+				accept: "application/json, application/problem+json",
+				"content-length": Buffer.byteLength(payload),
+				...anonymous ? {} : config.session ? { "x-board-session": config.session } : { authorization: `Bearer ${config.token ?? ""}` }
+			}
+		}, (response) => {
+			const chunks = [];
+			response.on("data", (chunk) => {
+				chunks.push(chunk);
+			});
+			response.once("error", () => {
+				settle({ error: new CliError("outcome_unknown") });
+			});
+			response.once("end", () => {
+				try {
+					settle({ value: decodeResponse(output, response, Buffer.concat(chunks).toString()) });
+				} catch (error) {
+					settle({ error: error instanceof CliError ? error : new CliError("outcome_unknown") });
+				}
+			});
+		});
+		const onConnected = () => {
+			if (settled || connected) return;
+			connected = true;
+			if (timer) clearTimeout(timer);
+			timer = setTimeout(() => req.destroy(/* @__PURE__ */ new Error("response timeout")), config.responseTimeoutMs);
+		};
+		req.once("socket", (socket) => {
+			if (!socket.connecting && !("secureConnecting" in socket && socket.secureConnecting)) onConnected();
+			else socket.once(target.protocol === "https:" ? "secureConnect" : "connect", onConnected);
+		});
+		req.once("error", () => {
+			settle({ error: new CliError(connected ? "outcome_unknown" : "daemon_unavailable") });
+		});
+		timer = setTimeout(() => req.destroy(/* @__PURE__ */ new Error("connection timeout")), config.connectTimeoutMs);
+		req.end(payload);
+	});
+}
+/** Shared daemon HTTP client. The CLI owns output; this module owns transport and wire parsing. */
+async function requestOperation(op, input, key, config) {
+	if (!config.session && !config.token) throw new CliError("config");
+	return post(`/v1/ops/${encodeURIComponent(op.id)}`, {
+		input,
+		...key ? { key } : {}
+	}, config, op.output, false);
+}
+const enrollmentOutput = z.strictObject({
+	name: z.string(),
+	status: z.literal("pending"),
+	expiresAt: z.iso.datetime()
+});
+/** Bootstrap sends a hash and no authorization header. */
+function requestTokenEnrollment(input, config) {
+	return post("/v1/tokens/requests", input, config, enrollmentOutput, true);
+}
+//#endregion
+export { renderCliError as a, errorExitCode as i, requestTokenEnrollment as n, escapeTerminalControls as o, CliError as r, requestOperation as t };

package/dist/client.mjs

@@ -0,0 +1,2 @@
+import { n as requestTokenEnrollment, t as requestOperation } from "./client-C1hJzdYE.mjs";
+export { requestOperation, requestTokenEnrollment };

package/dist/config-DQmktVi-.mjs

@@ -0,0 +1,92 @@
+import { r as CliError } from "./client-C1hJzdYE.mjs";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+//#region src/config.ts
+const CONNECT_TIMEOUT_MS = 2e3;
+const RESPONSE_TIMEOUT_MS = 3e4;
+function daemonAddress(env) {
+	const rawAddress = env["BOARD_DAEMON_URL"];
+	if (!rawAddress) throw new CliError("config", { environmentVariable: "BOARD_DAEMON_URL" });
+	let address;
+	try {
+		address = new URL(rawAddress);
+	} catch {
+		throw new CliError("config", { environmentVariable: "BOARD_DAEMON_URL" });
+	}
+	if (!["http:", "https:"].includes(address.protocol) || address.username || address.password) throw new CliError("config", { environmentVariable: "BOARD_DAEMON_URL" });
+	return address;
+}
+function tokenInFolder(folder, warn) {
+	const directory = join(folder, ".spur-board");
+	const file = join(directory, "token");
+	try {
+		const owner = process.getuid?.();
+		const directoryInfo = lstatSync(directory);
+		if (!directoryInfo.isDirectory() || directoryInfo.uid !== owner || (directoryInfo.mode & 63) !== 0) throw new Error("unsafe token directory");
+		const descriptor = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+		let value;
+		try {
+			const fileInfo = fstatSync(descriptor);
+			if (!fileInfo.isFile() || fileInfo.uid !== owner || (fileInfo.mode & 63) !== 0) throw new Error("unsafe token file");
+			value = readFileSync(descriptor, "utf8").trimEnd();
+		} finally {
+			closeSync(descriptor);
+		}
+		if (value === "") throw new Error("empty token file");
+		return value;
+	} catch (error) {
+		if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT") return;
+		warn("Ignoring an unsafe .spur-board/token candidate.\n");
+		return;
+	}
+}
+function findTokenFile(cwd, home, warn = (message) => {
+	process.stderr.write(message);
+}) {
+	const current = realpathSync(cwd);
+	const boundary = realpathSync(home);
+	if (current === boundary) return void 0;
+	const toCurrent = relative(boundary, current);
+	const outsideHome = toCurrent === ".." || toCurrent.startsWith(`..${sep}`) || isAbsolute(toCurrent);
+	let folder = current;
+	while (folder !== boundary) {
+		if (outsideHome) {
+			const info = statSync(folder);
+			if (info.uid !== process.getuid?.() || (info.mode & 2) !== 0) break;
+		}
+		const token = tokenInFolder(folder, warn);
+		if (token !== void 0) return token;
+		const parent = dirname(folder);
+		if (parent === folder) break;
+		folder = parent;
+	}
+}
+function loadClientConfig(env = process.env, paths = {
+	cwd: process.cwd(),
+	home: homedir()
+}) {
+	const address = daemonAddress(env);
+	const session = env["SPUR_SESSION"] || void 0;
+	const token = session ? void 0 : env["BOARD_TOKEN"] === void 0 ? findTokenFile(paths.cwd, paths.home) : env["BOARD_TOKEN"];
+	if (!session && !token) throw new CliError("config", { environmentVariable: "BOARD_TOKEN" });
+	return {
+		address,
+		session,
+		token,
+		connectTimeoutMs: CONNECT_TIMEOUT_MS,
+		responseTimeoutMs: RESPONSE_TIMEOUT_MS
+	};
+}
+/** Enrollment sends only a hash and works before any operator credential exists. */
+function loadEnrollmentConfig(env = process.env) {
+	return {
+		address: daemonAddress(env),
+		session: void 0,
+		token: void 0,
+		connectTimeoutMs: CONNECT_TIMEOUT_MS,
+		responseTimeoutMs: RESPONSE_TIMEOUT_MS
+	};
+}
+//#endregion
+export { loadEnrollmentConfig as n, loadClientConfig as t };