@pablopunk/tau 0.1.0 → 0.1.2

package/dist/bin.js

@@ -14,7 +14,7 @@ function withoutSqliteWarning(emitWarning) {
 process.emitWarning = withoutSqliteWarning(process.emitWarning.bind(process));
 //#endregion
 //#region src/bin.ts
-const { main } = await import("./main-CI9q691u.js");
+const { main } = await import("./main-R5EDx89w.js");
 main(process.argv.slice(2)).catch((error) => {
 	console.error(error instanceof Error ? error.message : error);
 	process.exit(1);

package/dist/latest-version-di9hD7cY.js

@@ -0,0 +1,106 @@
+import { l as isPlainVersion } from "./src-DO9LUlhi.js";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+//#region src/private-files.ts
+const PRIVATE_DIRECTORY_MODE = 448;
+const PRIVATE_FILE_MODE = 384;
+async function ensurePrivateDirectory(path) {
+	await mkdir(path, {
+		recursive: true,
+		mode: PRIVATE_DIRECTORY_MODE
+	});
+}
+/** Temp file, then rename, so readers never see a half-written file. */
+async function writePrivateFile(path, content) {
+	await ensurePrivateDirectory(dirname(path));
+	const temporary = `${path}.${process.pid}.tmp`;
+	await writeFile(temporary, content, { mode: PRIVATE_FILE_MODE });
+	await rename(temporary, path);
+}
+//#endregion
+//#region src/token.ts
+const TOKEN_BYTES = 32;
+const MIN_TOKEN_LENGTH = 32;
+const tokenPath = (home) => join(home, "token");
+async function readExistingToken(home) {
+	try {
+		const token = (await readFile(tokenPath(home), "utf8")).trim();
+		return token.length >= MIN_TOKEN_LENGTH ? token : void 0;
+	} catch {
+		return;
+	}
+}
+/** The token outlives restarts so open browser tabs keep their cookie. */
+async function readOrCreateToken(home) {
+	const existing = await readExistingToken(home);
+	if (existing) return existing;
+	const token = randomBytes(TOKEN_BYTES).toString("base64url");
+	await writePrivateFile(tokenPath(home), `${token}\n`);
+	return token;
+}
+//#endregion
+//#region src/version.ts
+/** From the `package.json` next to `src/` and next to `dist/`. */
+function cliVersion() {
+	return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+}
+//#endregion
+//#region src/update/command-runner.ts
+/** Spawns with an args array and no shell. A missing binary is a result with `code: null`. */
+const spawnCommand = (command, args, options) => new Promise((resolve) => {
+	const child = spawn(command, [...args], {
+		env: options.env ?? process.env,
+		stdio: options.stdio === "inherit" ? "inherit" : [
+			"inherit",
+			options.stdio === "tee" ? "inherit" : "pipe",
+			"pipe"
+		],
+		timeout: options.timeoutMs
+	});
+	let stdout = "";
+	let stderr = "";
+	child.stdout?.on("data", (chunk) => {
+		stdout += chunk.toString();
+	});
+	child.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+		if (options.stdio === "tee") process.stderr.write(chunk);
+	});
+	child.on("error", (error) => resolve({
+		code: null,
+		stdout,
+		stderr: stderr + error.message
+	}));
+	child.on("close", (code) => resolve({
+		code,
+		stdout,
+		stderr
+	}));
+});
+//#endregion
+//#region src/update/latest-version.ts
+const PACKAGE_NAME = "@pablopunk/tau";
+const VIEW_TIMEOUT_MS = 15e3;
+const npmOf = (execPath) => join(dirname(execPath), "npm");
+/** The registry's `latest` as plain `x.y.z`; anything else is an error. */
+async function fetchLatestVersion(run, execPath) {
+	const args = [
+		"view",
+		`${PACKAGE_NAME}@latest`,
+		"version",
+		"--prefer-online"
+	];
+	const result = await run(npmOf(execPath), args, {
+		stdio: "capture",
+		timeoutMs: VIEW_TIMEOUT_MS
+	});
+	if (result.code !== 0) throw new Error(`Could not read the latest version from the npm registry (${result.stderr.trim().split("\n")[0] || `exit ${result.code}`}).`);
+	const version = result.stdout.trim();
+	if (!isPlainVersion(version)) throw new Error(`The registry returned an unexpected version: ${version}`);
+	return version;
+}
+//#endregion
+export { cliVersion as a, writePrivateFile as c, spawnCommand as i, fetchLatestVersion as n, readOrCreateToken as o, npmOf as r, ensurePrivateDirectory as s, PACKAGE_NAME as t };

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 };