@pablopunk/tau 0.0.0-stage → 0.1.1

package/dist/machines-behind-BjGgmSs_.js

@@ -0,0 +1,257 @@
+import { $ as routes, L as isErrorBody, Z as fillPath, c as isBehind, n as readRunningInstance } from "./src-DO9LUlhi.js";
+import { a as cliVersion, o as readOrCreateToken } from "./latest-version-di9hD7cY.js";
+import { i as realContext, t as createServiceManager } from "./manager-B_WHbb1U.js";
+import { t as cliEntry } from "./cli-entry-DcDpQ30L.js";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { promisify } from "node:util";
+import { readFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+/** A failure that ends the command with a message on stderr and an exit code. */
+var CliExit = class extends Error {
+	exitCode;
+	constructor(exitCode, message) {
+		super(message);
+		this.name = "CliExit";
+		this.exitCode = exitCode;
+	}
+};
+const usageError = (message) => new CliExit(2, message);
+const failure = (message) => new CliExit(1, message);
+const NOT_RUNNING_MESSAGE = "tau is not running. Run `tau` to start it.";
+//#endregion
+//#region src/commands/client.ts
+const URL_POLL_MS = 100;
+async function waitForLockUrl(home, env) {
+	const deadline = env.now() + env.startupWaitMs;
+	for (;;) {
+		const info = await readRunningInstance(home);
+		if (!info) throw failure(NOT_RUNNING_MESSAGE);
+		if (info.url) return info.url;
+		if (env.now() >= deadline) throw failure("tau is starting but has not published its URL yet.");
+		await env.sleep(URL_POLL_MS);
+	}
+}
+async function readToken(home) {
+	try {
+		return (await readFile(join(home, "token"), "utf8")).trim();
+	} catch {
+		throw failure(NOT_RUNNING_MESSAGE);
+	}
+}
+/** The lock gives the URL and `<home>/token` the secret. Retries while a live server has no URL yet. */
+async function discoverServer(env) {
+	return {
+		url: await waitForLockUrl(env.home, env),
+		token: await readToken(env.home)
+	};
+}
+const queryString = (query) => {
+	const entries = Object.entries(query ?? {});
+	return entries.length === 0 ? "" : `?${new URLSearchParams(entries).toString()}`;
+};
+async function errorMessageOf(response) {
+	const text = await response.text();
+	try {
+		const parsed = JSON.parse(text);
+		if (isErrorBody(parsed)) return `${parsed.error.code}: ${parsed.error.message}`;
+	} catch {}
+	return `HTTP ${response.status}${text ? `: ${text.slice(0, 200)}` : ""}`;
+}
+async function send(server, name, request, env) {
+	const route = routes[name];
+	const target = `${server.url}${fillPath(route.path, request.params)}${queryString(request.query)}`;
+	const hasBody = request.body !== void 0;
+	try {
+		return await env.fetch(target, {
+			method: route.method,
+			headers: {
+				authorization: `Bearer ${server.token}`,
+				...hasBody ? { "content-type": "application/json" } : {}
+			},
+			body: hasBody ? JSON.stringify(request.body) : void 0
+		});
+	} catch {
+		throw failure(NOT_RUNNING_MESSAGE);
+	}
+}
+/** Calls one route. Returns the parsed JSON, or `undefined` for an empty answer. An `AppError` becomes a failure. */
+async function callRoute(server, name, request, env) {
+	const response = await send(server, name, request, env);
+	if (!response.ok) throw failure(await errorMessageOf(response));
+	const text = await response.text();
+	return text ? JSON.parse(text) : void 0;
+}
+//#endregion
+//#region src/commands/command-env.ts
+const defaultOpenSocket = (url, headers) => {
+	return new WebSocket(url, { headers });
+};
+const homeOf = (env) => env.TAU_HOME ?? join(homedir(), ".tau");
+function processEnv() {
+	return {
+		home: homeOf(process.env),
+		env: process.env,
+		stdout: (text) => void process.stdout.write(`${text}\n`),
+		stderr: (text) => void process.stderr.write(`${text}\n`),
+		fetch: (input, init) => fetch(input, init),
+		openSocket: defaultOpenSocket,
+		sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+		after: (ms, fn) => {
+			const timer = setTimeout(fn, ms);
+			return () => clearTimeout(timer);
+		},
+		now: Date.now,
+		startupWaitMs: 5e3,
+		pollMs: 2e3,
+		skillPaths: []
+	};
+}
+//#endregion
+//#region src/lifecycle/status-extras.ts
+const NO_EXTRAS = {
+	uptimeSeconds: null,
+	lastExit: null,
+	tunnel: null
+};
+const execFileAsync = promisify(execFile);
+/** `[[dd-]hh:]mm:ss` as printed by `ps -o etime=`. */
+function parseElapsed(text) {
+	const match = /^(?:(?:(\d+)-)?(\d+):)?(\d+):(\d+)$/.exec(text.trim());
+	if (!match) return null;
+	const [, days, hours, minutes, seconds] = match.map((part) => Number(part ?? 0));
+	return ((days ?? 0) * 24 + (hours ?? 0)) * 3600 + (minutes ?? 0) * 60 + (seconds ?? 0);
+}
+async function uptimeOf(pid) {
+	try {
+		const { stdout } = await execFileAsync("ps", [
+			"-o",
+			"etime=",
+			"-p",
+			String(pid)
+		]);
+		return parseElapsed(stdout);
+	} catch {
+		return null;
+	}
+}
+/** Missing or corrupt files give `null`. */
+async function readLastExit(home) {
+	try {
+		const value = JSON.parse(await readFile(join(home, "last-exit.json"), "utf8"));
+		if (typeof value.reason !== "string" || typeof value.at !== "number") return null;
+		return {
+			reason: value.reason,
+			at: value.at,
+			...value.detail ? { detail: String(value.detail) } : {}
+		};
+	} catch {
+		return null;
+	}
+}
+async function readTunnel(home, instance) {
+	if (!instance?.url) return null;
+	try {
+		const token = (await readFile(join(home, "token"), "utf8")).trim();
+		const response = await fetch(`${instance.url}/api/remote`, {
+			headers: { authorization: `Bearer ${token}` },
+			signal: AbortSignal.timeout(2e3)
+		});
+		if (!response.ok) return null;
+		const { state, url, message } = await response.json();
+		return {
+			state,
+			url,
+			message
+		};
+	} catch {
+		return null;
+	}
+}
+async function realExtras(home, instance) {
+	const [uptimeSeconds, lastExit, tunnel] = await Promise.all([
+		instance ? uptimeOf(instance.pid) : null,
+		readLastExit(home),
+		readTunnel(home, instance)
+	]);
+	return {
+		uptimeSeconds,
+		lastExit,
+		tunnel
+	};
+}
+function formatDuration(totalSeconds) {
+	const days = Math.floor(totalSeconds / 86400);
+	const hours = Math.floor(totalSeconds % 86400 / 3600);
+	const minutes = Math.floor(totalSeconds % 3600 / 60);
+	if (days > 0) return `${days}d ${hours}h`;
+	if (hours > 0) return `${hours}h ${minutes}m`;
+	return minutes > 0 ? `${minutes}m ${totalSeconds % 60}s` : `${totalSeconds}s`;
+}
+function renderExtras(extras) {
+	const { uptimeSeconds, lastExit, tunnel } = extras;
+	const exit = lastExit ? `${lastExit.reason}${lastExit.detail ? ` (${lastExit.detail})` : ""} at ${new Date(lastExit.at).toISOString()}` : "-";
+	const tunnelText = tunnel ? `${tunnel.state}${tunnel.url ? ` ${tunnel.url}` : ""}` : "-";
+	return [
+		`uptime: ${uptimeSeconds === null ? "-" : formatDuration(uptimeSeconds)}`,
+		`last exit: ${exit}`,
+		`tunnel: ${tunnelText}`
+	];
+}
+//#endregion
+//#region src/lifecycle/deps.ts
+const withToken = (origin, token) => `${origin}/?token=${encodeURIComponent(token)}`;
+const managerOf = (deps, home) => createServiceManager(deps.context, deps.cli(), home);
+const NOT_RUNNING = "tau is not running. Run `tau` to start it.";
+async function realLifecycleDeps() {
+	const { waitForUrl } = await import("./wait-for-lock-B1Qx8GWg.js");
+	const { existsSync } = await import("node:fs");
+	return {
+		context: realContext(),
+		cli: () => cliEntry(),
+		version: cliVersion,
+		readInstance: readRunningInstance,
+		waitForInstanceUrl: (home) => waitForUrl(home),
+		readToken: readOrCreateToken,
+		openBrowser: async (url) => {
+			const { default: open } = await import("open");
+			await open(url);
+		},
+		out: (message) => console.log(message),
+		fileExists: existsSync,
+		extras: realExtras
+	};
+}
+//#endregion
+//#region src/update/machines-behind.ts
+/** Best effort: `undefined` when no server runs or any request fails. */
+async function fetchLinkedMachines(home) {
+	try {
+		const env = {
+			...processEnv(),
+			home
+		};
+		const server = await discoverServer(env);
+		const machines = await callRoute(server, "listMachines", {}, env);
+		if (machines.length === 0) return void 0;
+		return {
+			machines,
+			hubLatest: (await callRoute(server, "getUpdateStatus", {}, env)).latest
+		};
+	} catch {
+		return;
+	}
+}
+/** The "Linked machines behind" line, or undefined when nothing is behind or worth saying. */
+function linkedMachinesLine(linked, fallbackLatest) {
+	if (!linked) return void 0;
+	const latest = linked.hubLatest ?? fallbackLatest;
+	const items = linked.machines.filter((m) => !m.linkedTo).flatMap((m) => {
+		const behind = isBehind(m.tauVersion, latest);
+		if (behind === void 0) return [`${m.name} (version unknown)`];
+		return behind ? [`${m.name} (${m.tauVersion})`] : [];
+	});
+	return items.length === 0 ? void 0 : `Linked machines behind: ${items.join(", ")}`;
+}
+//#endregion
+export { realLifecycleDeps as a, renderExtras as c, discoverServer as d, CliExit as f, managerOf as i, processEnv as l, usageError as m, linkedMachinesLine as n, withToken as o, failure as p, NOT_RUNNING as r, NO_EXTRAS as s, fetchLinkedMachines as t, callRoute as u };