@tikoci/quickchr 0.2.0

package/src/cli/format.ts

@@ -0,0 +1,154 @@
+/**
+ * CLI output formatting — tables, colors, status indicators.
+ */
+
+import { listMachineNames } from "../lib/state.ts";
+
+/** Format a "machine not found" error with helpful suggestions. */
+export function machineNotFoundMessage(name: string): string {
+	const names = listMachineNames();
+	let msg = `Machine "${name}" not found.`;
+	if (names.length === 0) {
+		msg += `\n  No machines exist. Create one: quickchr start`;
+	} else if (names.length <= 5) {
+		msg += `\n  Available: ${names.join(", ")}`;
+	} else {
+		msg += `\n  Run 'quickchr list' to see available machines.`;
+	}
+	return msg;
+}
+
+const COLORS = {
+	reset: "\x1b[0m",
+	bold: "\x1b[1m",
+	dim: "\x1b[2m",
+	red: "\x1b[31m",
+	green: "\x1b[32m",
+	yellow: "\x1b[33m",
+	blue: "\x1b[34m",
+	cyan: "\x1b[36m",
+} as const;
+
+const NO_COLORS = Object.fromEntries(
+	Object.keys(COLORS).map((k) => [k, ""]),
+) as unknown as typeof COLORS;
+
+function c(): typeof COLORS {
+	// Respect NO_COLOR env and pipe detection
+	if (process.env.NO_COLOR || !process.stdout.isTTY) return NO_COLORS;
+	return COLORS;
+}
+
+export function statusIcon(status: string): string {
+	const col = c();
+	switch (status) {
+		case "running": return `${col.green}●${col.reset}`;
+		case "stopped": return `${col.dim}○${col.reset}`;
+		case "error": return `${col.red}✗${col.reset}`;
+		case "ok": return `${col.green}✓${col.reset}`;
+		case "warn": return `${col.yellow}⚠${col.reset}`;
+		default: return `${col.dim}?${col.reset}`;
+	}
+}
+
+export function bold(text: string): string {
+	const col = c();
+	return `${col.bold}${text}${col.reset}`;
+}
+
+export function dim(text: string): string {
+	const col = c();
+	return `${col.dim}${text}${col.reset}`;
+}
+
+export function cyan(text: string): string {
+	const col = c();
+	return `${col.cyan}${text}${col.reset}`;
+}
+
+/** Format a simple table with columns. */
+export function table(headers: string[], rows: string[][]): string {
+	const widths = headers.map((h, i) =>
+		Math.max(h.length, ...rows.map((r) => stripAnsi(r[i] ?? "").length)),
+	);
+
+	const sep = widths.map((w) => "─".repeat(w + 2)).join("┼");
+	const headerLine = headers
+		.map((h, i) => ` ${bold(h.padEnd(widths[i] ?? 0))} `)
+		.join("│");
+	const dataLines = rows.map((row) =>
+		row.map((cell, i) => {
+			const stripped = stripAnsi(cell);
+			const padding = (widths[i] ?? 0) - stripped.length;
+			return ` ${cell}${" ".repeat(Math.max(0, padding))} `;
+		}).join("│"),
+	);
+
+	return [headerLine, sep, ...dataLines].join("\n");
+}
+
+/** Strip ANSI escape codes for width calculation. */
+function stripAnsi(str: string): string {
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape stripping requires matching ESC (0x1b)
+	return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+/** Format port mappings as a compact string. */
+export function formatPorts(ports: Record<string, { host: number; guest: number }>): string {
+	return Object.entries(ports)
+		.map(([name, p]) => `${name}:${p.host}`)
+		.join(" ");
+}
+
+/** Format a network config array for display. */
+export function formatNetworks(networks: { specifier: unknown; id: string }[]): string {
+	if (!networks || networks.length === 0) return "none";
+	return networks.map((n) => {
+		const spec = n.specifier;
+		if (typeof spec === "string") return spec;
+		if (typeof spec === "object" && spec !== null) {
+			const s = spec as Record<string, unknown>;
+			if (s.type === "vmnet-bridged") return `vmnet-bridge (${s.iface})`;
+			if (s.type === "bridged") return `bridged (${s.iface})`;
+			if (s.type === "socket-listen") return `socket:listen:${s.port}`;
+			if (s.type === "socket-connect") return `socket:connect:${s.port}`;
+			if (s.type === "socket-mcast") return `socket:mcast:${s.group}:${s.port}`;
+			if (s.type === "socket-named") return `socket::${s.name}`;
+			if (s.type === "tap") return `tap:${s.ifname}`;
+			return JSON.stringify(spec);
+		}
+		return String(spec);
+	}).join(", ");
+}
+
+/** Format a clickable URL (some terminals support this). */
+export function link(url: string, label?: string): string {
+	const col = c();
+	if (!process.stdout.isTTY) return label ?? url;
+	return `${col.cyan}${label ?? url}${col.reset}`;
+}
+
+/** Resolve display credentials for a machine (from secret store or state). */
+export async function resolveDisplayCredentials(
+	state: { name: string; user?: { name: string; password: string } },
+): Promise<{ user: string; password: string }> {
+	const { getInstanceCredentials } = await import("../lib/credentials.ts");
+	const stored = getInstanceCredentials(state.name);
+	if (stored) return { user: stored.user, password: stored.password };
+	if (state.user && state.user.password !== "(stored in secrets)") {
+		return { user: state.user.name, password: state.user.password };
+	}
+	return { user: state.user?.name ?? "admin", password: "" };
+}
+
+/** Format SSH connection string with correct user. */
+export function formatSshCommand(user: string, port: number): string {
+	return `ssh ${user}@127.0.0.1 -p ${port}`;
+}
+
+/** Format REST URL with credentials if available. */
+export function formatRestUrl(httpPort: number, user: string, password: string): string {
+	const auth = password ? `${user}:${password}@` : `${user}@`;
+	return `http://${auth}127.0.0.1:${httpPort}`;
+}
+