remobi 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,945 @@
+#!/usr/bin/env node
+import { n as sleep, r as spawnProcess, t as readStdin } from "./node-compat-BzXgbTV9.mjs";
+import { build, bundleOverlay, injectFromStdin, injectOverlay } from "./build.mjs";
+import { defaultConfig, defineConfig, mergeConfig, serialiseThemeForTtyd } from "./src/config.mjs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import * as v from "valibot";
+import { serve } from "@hono/node-server";
+import { createNodeWebSocket } from "@hono/node-ws";
+import { Hono } from "hono";
+import WebSocket from "ws";
+
+//#region src/cli/args.ts
+function isHelpCommand(value) {
+	return value === "--help" || value === "-h" || value === "help";
+}
+function isVersionCommand(value) {
+	return value === "--version" || value === "-v" || value === "version";
+}
+function isMissingOptionValue(value) {
+	return value === void 0 || value.startsWith("-");
+}
+function parseCliArgs(args) {
+	const commandToken = args[0];
+	if (!commandToken || isHelpCommand(commandToken)) return {
+		ok: true,
+		value: {
+			command: "help",
+			dryRun: false,
+			noSleep: false,
+			command_: []
+		}
+	};
+	if (isVersionCommand(commandToken)) return {
+		ok: true,
+		value: {
+			command: "version",
+			dryRun: false,
+			noSleep: false,
+			command_: []
+		}
+	};
+	if (commandToken !== "build" && commandToken !== "inject" && commandToken !== "init" && commandToken !== "serve") return {
+		ok: false,
+		error: `Unknown command: ${commandToken}`
+	};
+	let configPath;
+	let outputPath;
+	let dryRun = false;
+	let port;
+	let noSleep = false;
+	let trailingCommand = [];
+	for (let index = 1; index < args.length; index++) {
+		const arg = args[index];
+		const nextArg = args[index + 1];
+		if (!arg) return {
+			ok: false,
+			error: "Invalid argument list"
+		};
+		if (arg === "--") {
+			trailingCommand = args.slice(index + 1);
+			break;
+		}
+		if (arg === "--help" || arg === "-h") return {
+			ok: true,
+			value: {
+				command: "help",
+				dryRun: false,
+				noSleep: false,
+				command_: []
+			}
+		};
+		if (!arg.startsWith("-")) return {
+			ok: false,
+			error: `Unexpected positional argument: ${arg}`
+		};
+		if (arg === "--config" || arg === "-c") {
+			if (commandToken !== "build" && commandToken !== "inject" && commandToken !== "serve") return {
+				ok: false,
+				error: `${arg} is only valid for 'build', 'inject', or 'serve'`
+			};
+			if (isMissingOptionValue(nextArg)) return {
+				ok: false,
+				error: "Missing value for --config"
+			};
+			configPath = nextArg;
+			index++;
+			continue;
+		}
+		if (arg === "--output" || arg === "-o") {
+			if (commandToken !== "build") return {
+				ok: false,
+				error: `${arg} is only valid for 'build'`
+			};
+			if (isMissingOptionValue(nextArg)) return {
+				ok: false,
+				error: "Missing value for --output"
+			};
+			outputPath = nextArg;
+			index++;
+			continue;
+		}
+		if (arg === "--dry-run" || arg === "-n") {
+			if (commandToken !== "build" && commandToken !== "inject") return {
+				ok: false,
+				error: `${arg} is only valid for 'build' or 'inject'`
+			};
+			dryRun = true;
+			continue;
+		}
+		if (arg === "--port" || arg === "-p") {
+			if (commandToken !== "serve") return {
+				ok: false,
+				error: `${arg} is only valid for 'serve'`
+			};
+			if (isMissingOptionValue(nextArg)) return {
+				ok: false,
+				error: "Missing value for --port"
+			};
+			const portNum = Number(nextArg);
+			if (!Number.isInteger(portNum) || portNum < 1 || portNum > 65535) return {
+				ok: false,
+				error: `Invalid port: ${nextArg}`
+			};
+			port = portNum;
+			index++;
+			continue;
+		}
+		if (arg === "--no-sleep") {
+			if (commandToken !== "serve") return {
+				ok: false,
+				error: `${arg} is only valid for 'serve'`
+			};
+			noSleep = true;
+			continue;
+		}
+		if (isVersionCommand(arg)) return {
+			ok: false,
+			error: `${arg} is only valid as a top-level command`
+		};
+		return {
+			ok: false,
+			error: `Unknown flag: ${arg}`
+		};
+	}
+	return {
+		ok: true,
+		value: {
+			command: commandToken,
+			configPath,
+			outputPath,
+			dryRun,
+			port,
+			noSleep,
+			command_: trailingCommand
+		}
+	};
+}
+
+//#endregion
+//#region src/config-schema.ts
+/**
+* Valibot schemas for remobi config validation.
+* Only used at CLI time (build/inject/serve) — never in the browser bundle.
+*/
+const finiteNumber = v.pipe(v.number(), v.finite());
+const sendActionSchema = v.strictObject({
+	type: v.literal("send"),
+	data: v.string(),
+	keyLabel: v.optional(v.string())
+});
+const ctrlModifierActionSchema = v.strictObject({ type: v.literal("ctrl-modifier") });
+const pasteActionSchema = v.strictObject({ type: v.literal("paste") });
+const comboPickerActionSchema = v.strictObject({ type: v.literal("combo-picker") });
+const drawerToggleActionSchema = v.strictObject({ type: v.literal("drawer-toggle") });
+const buttonActionSchema = v.variant("type", [
+	sendActionSchema,
+	ctrlModifierActionSchema,
+	pasteActionSchema,
+	comboPickerActionSchema,
+	drawerToggleActionSchema
+]);
+const controlButtonSchema = v.strictObject({
+	id: v.string(),
+	label: v.string(),
+	description: v.string(),
+	action: buttonActionSchema
+});
+const buttonArrayInputSchema = v.pipe(v.custom((input) => Array.isArray(input) || typeof input === "function", "array or function"), v.rawCheck(({ dataset, addIssue }) => {
+	if (!dataset.typed || !Array.isArray(dataset.value)) return;
+	const arr = dataset.value;
+	for (let i = 0; i < arr.length; i++) {
+		const result = v.safeParse(controlButtonSchema, arr[i]);
+		if (!result.success) for (const issue of result.issues) addIssue({
+			message: issue.message,
+			expected: issue.expected,
+			received: issue.received,
+			path: [{
+				type: "array",
+				origin: "value",
+				input: arr,
+				key: i,
+				value: arr[i]
+			}, ...issue.path ?? []]
+		});
+	}
+}));
+const themeColourSchema = v.optional(v.string());
+const termThemeOverridesSchema = v.strictObject({
+	background: themeColourSchema,
+	foreground: themeColourSchema,
+	cursor: themeColourSchema,
+	cursorAccent: themeColourSchema,
+	selectionBackground: themeColourSchema,
+	black: themeColourSchema,
+	red: themeColourSchema,
+	green: themeColourSchema,
+	yellow: themeColourSchema,
+	blue: themeColourSchema,
+	magenta: themeColourSchema,
+	cyan: themeColourSchema,
+	white: themeColourSchema,
+	brightBlack: themeColourSchema,
+	brightRed: themeColourSchema,
+	brightGreen: themeColourSchema,
+	brightYellow: themeColourSchema,
+	brightBlue: themeColourSchema,
+	brightMagenta: themeColourSchema,
+	brightCyan: themeColourSchema,
+	brightWhite: themeColourSchema
+});
+const termThemeResolvedSchema = v.strictObject({
+	background: v.string(),
+	foreground: v.string(),
+	cursor: v.string(),
+	cursorAccent: v.string(),
+	selectionBackground: v.string(),
+	black: v.string(),
+	red: v.string(),
+	green: v.string(),
+	yellow: v.string(),
+	blue: v.string(),
+	magenta: v.string(),
+	cyan: v.string(),
+	white: v.string(),
+	brightBlack: v.string(),
+	brightRed: v.string(),
+	brightGreen: v.string(),
+	brightYellow: v.string(),
+	brightBlue: v.string(),
+	brightMagenta: v.string(),
+	brightCyan: v.string(),
+	brightWhite: v.string()
+});
+const fontOverridesSchema = v.strictObject({
+	family: v.optional(v.string()),
+	cdnUrl: v.optional(v.string()),
+	mobileSizeDefault: v.optional(finiteNumber),
+	sizeRange: v.optional(v.pipe(v.tuple([finiteNumber, finiteNumber])))
+});
+const fontResolvedSchema = v.strictObject({
+	family: v.string(),
+	cdnUrl: v.string(),
+	mobileSizeDefault: finiteNumber,
+	sizeRange: v.pipe(v.tuple([finiteNumber, finiteNumber]))
+});
+const swipeOverridesSchema = v.strictObject({
+	enabled: v.optional(v.boolean()),
+	threshold: v.optional(finiteNumber),
+	maxDuration: v.optional(finiteNumber),
+	left: v.optional(v.string()),
+	right: v.optional(v.string()),
+	leftLabel: v.optional(v.string()),
+	rightLabel: v.optional(v.string())
+});
+const swipeResolvedSchema = v.strictObject({
+	enabled: v.boolean(),
+	threshold: finiteNumber,
+	maxDuration: finiteNumber,
+	left: v.string(),
+	right: v.string(),
+	leftLabel: v.string(),
+	rightLabel: v.string()
+});
+const pinchOverridesSchema = v.strictObject({ enabled: v.optional(v.boolean()) });
+const pinchResolvedSchema = v.strictObject({ enabled: v.boolean() });
+const scrollStrategySchema = v.picklist(["keys", "wheel"]);
+const scrollOverridesSchema = v.strictObject({
+	enabled: v.optional(v.boolean()),
+	sensitivity: v.optional(finiteNumber),
+	strategy: v.optional(scrollStrategySchema),
+	wheelIntervalMs: v.optional(finiteNumber)
+});
+const scrollResolvedSchema = v.strictObject({
+	enabled: v.boolean(),
+	sensitivity: finiteNumber,
+	strategy: scrollStrategySchema,
+	wheelIntervalMs: finiteNumber
+});
+const gestureOverridesSchema = v.strictObject({
+	swipe: v.optional(swipeOverridesSchema),
+	pinch: v.optional(pinchOverridesSchema),
+	scroll: v.optional(scrollOverridesSchema)
+});
+const gestureResolvedSchema = v.strictObject({
+	swipe: swipeResolvedSchema,
+	pinch: pinchResolvedSchema,
+	scroll: scrollResolvedSchema
+});
+const mobileOverridesSchema = v.strictObject({
+	initData: v.optional(v.nullable(v.string())),
+	widthThreshold: v.optional(finiteNumber)
+});
+const mobileResolvedSchema = v.strictObject({
+	initData: v.nullable(v.string()),
+	widthThreshold: finiteNumber
+});
+const floatingPositionSchema = v.picklist([
+	"top-left",
+	"top-right",
+	"top-centre",
+	"bottom-left",
+	"bottom-right",
+	"bottom-centre",
+	"centre-left",
+	"centre-right"
+]);
+const floatingDirectionSchema = v.picklist(["row", "column"]);
+const floatingButtonGroupSchema = v.strictObject({
+	position: floatingPositionSchema,
+	direction: v.optional(floatingDirectionSchema),
+	buttons: v.array(controlButtonSchema)
+});
+const pwaOverridesSchema = v.strictObject({
+	enabled: v.optional(v.boolean()),
+	shortName: v.optional(v.string()),
+	themeColor: v.optional(v.string())
+});
+const pwaResolvedSchema = v.strictObject({
+	enabled: v.boolean(),
+	shortName: v.optional(v.string()),
+	themeColor: v.string()
+});
+const reconnectOverridesSchema = v.strictObject({ enabled: v.optional(v.boolean()) });
+const reconnectResolvedSchema = v.strictObject({ enabled: v.boolean() });
+/** Schema for config overrides (all fields optional, button arrays accept array | function) */
+const remobiConfigOverridesSchema = v.strictObject({
+	name: v.optional(v.string()),
+	theme: v.optional(termThemeOverridesSchema),
+	font: v.optional(fontOverridesSchema),
+	toolbar: v.optional(v.strictObject({
+		row1: v.optional(buttonArrayInputSchema),
+		row2: v.optional(buttonArrayInputSchema)
+	})),
+	drawer: v.optional(v.strictObject({ buttons: v.optional(buttonArrayInputSchema) })),
+	gestures: v.optional(gestureOverridesSchema),
+	mobile: v.optional(mobileOverridesSchema),
+	floatingButtons: v.optional(v.array(floatingButtonGroupSchema)),
+	pwa: v.optional(pwaOverridesSchema),
+	reconnect: v.optional(reconnectOverridesSchema)
+});
+/** Schema for fully resolved config (all required fields, plain button arrays) */
+const remobiConfigResolvedSchema = v.strictObject({
+	name: v.string(),
+	theme: termThemeResolvedSchema,
+	font: fontResolvedSchema,
+	toolbar: v.strictObject({
+		row1: v.array(controlButtonSchema),
+		row2: v.array(controlButtonSchema)
+	}),
+	drawer: v.strictObject({ buttons: v.array(controlButtonSchema) }),
+	gestures: gestureResolvedSchema,
+	mobile: mobileResolvedSchema,
+	floatingButtons: v.array(floatingButtonGroupSchema),
+	pwa: pwaResolvedSchema,
+	reconnect: reconnectResolvedSchema
+});
+
+//#endregion
+//#region src/config-validate.ts
+var ConfigValidationError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(formatIssues(issues));
+		this.name = "ConfigValidationError";
+		this.issues = issues;
+	}
+};
+function formatIssues(issues) {
+	const lines = ["Invalid remobi config:"];
+	for (const issue of issues) lines.push(`- ${issue.path}: expected ${issue.expected}, received ${issue.received}`);
+	return lines.join("\n");
+}
+function truncate(value, maxLength) {
+	if (value.length <= maxLength) return value;
+	return `${value.slice(0, maxLength - 3)}...`;
+}
+function describeReceived(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return `array(len=${value.length})`;
+	if (typeof value === "string") return `string(${JSON.stringify(truncate(value, 80))})`;
+	if (typeof value === "number") return `number(${String(value)})`;
+	if (typeof value === "boolean") return `boolean(${String(value)})`;
+	if (typeof value === "bigint") return `bigint(${String(value)})`;
+	if (typeof value === "undefined") return "undefined";
+	if (typeof value === "function") return value.name.length > 0 ? `function(${value.name})` : "function";
+	if (typeof value === "object") {
+		const keys = Object.keys(value);
+		if (keys.length === 0) return "object(empty)";
+		return `object(keys: ${keys.slice(0, 3).join(", ")}${keys.length > 3 ? ", ..." : ""})`;
+	}
+	return typeof value;
+}
+/** Convert Valibot issue path to dotted string */
+function issuePath(issue) {
+	if (!issue.path || issue.path.length === 0) return "config";
+	const segments = ["config"];
+	for (const segment of issue.path) if (typeof segment.key === "number") segments.push(`[${String(segment.key)}]`);
+	else segments.push(`.${String(segment.key)}`);
+	return segments.join("").replaceAll(".[", "[");
+}
+/** Extract human-readable expected string from a Valibot issue */
+function issueExpected(issue) {
+	if (issue.expected === "unknown" || !issue.expected) return issue.message;
+	return issue.expected;
+}
+/** Map Valibot flat issues to our ValidationIssue format */
+function toValidationIssues(issues) {
+	const result = [];
+	for (const issue of issues) {
+		if (issue.issues && issue.issues.length > 0) {
+			result.push(...toValidationIssues(issue.issues));
+			continue;
+		}
+		const received = issue.input !== void 0 ? issue.input : void 0;
+		result.push({
+			path: issuePath(issue),
+			expected: issueExpected(issue),
+			received: describeReceived(received)
+		});
+	}
+	return result;
+}
+function assertValidConfigOverrides(value) {
+	const result = v.safeParse(remobiConfigOverridesSchema, value);
+	if (!result.success) throw new ConfigValidationError(toValidationIssues(result.issues));
+}
+function assertValidResolvedConfig(value) {
+	const result = v.safeParse(remobiConfigResolvedSchema, value);
+	if (!result.success) throw new ConfigValidationError(toValidationIssues(result.issues));
+}
+
+//#endregion
+//#region src/pwa/manifest.ts
+/** Generate a web app manifest object from pwa config */
+function generateManifest(name, pwa) {
+	return {
+		name,
+		short_name: pwa.shortName ?? name,
+		start_url: "/",
+		display: "standalone",
+		background_color: pwa.themeColor,
+		theme_color: pwa.themeColor,
+		icons: [{
+			src: "/icon-192.png",
+			sizes: "192x192",
+			type: "image/png",
+			purpose: "any maskable"
+		}, {
+			src: "/icon-512.png",
+			sizes: "512x512",
+			type: "image/png"
+		}]
+	};
+}
+/** Serialise manifest to JSON string */
+function manifestToJson(name, pwa) {
+	return JSON.stringify(generateManifest(name, pwa), null, 2);
+}
+
+//#endregion
+//#region src/serve.ts
+const DEFAULT_PORT = 7681;
+const DEFAULT_COMMAND = [
+	"tmux",
+	"new-session",
+	"-A",
+	"-s",
+	"main"
+];
+function findIconsDir() {
+	let dir = import.meta.dirname;
+	for (let i = 0; i < 5; i++) {
+		const candidate = resolve(dir, "src/pwa/icons");
+		if (existsSync(candidate)) return candidate;
+		dir = dirname(dir);
+	}
+	return resolve(import.meta.dirname, "pwa/icons");
+}
+const ICONS_DIR = findIconsDir();
+/** Poll until ttyd is accepting connections on the given port */
+async function waitForTtyd(port, retries = 40, intervalMs = 200) {
+	for (let i = 0; i < retries; i++) {
+		try {
+			if ((await fetch(`http://127.0.0.1:${port}/`)).ok) return;
+		} catch {}
+		await sleep(intervalMs);
+	}
+	throw new Error(`ttyd did not start on port ${port} — is ttyd installed and on PATH?\nInstall ttyd: macOS \`brew install ttyd\`; Linux use your distro package manager or build from source: https://github.com/tsl0922/ttyd#installation`);
+}
+/** Pick a random internal port */
+function randomInternalPort() {
+	return 19e3 + Math.floor(Math.random() * 1e3);
+}
+/** Build ttyd args from remobi config */
+function buildTtydArgs(config, internalPort, command) {
+	return [
+		"--writable",
+		"-i",
+		"127.0.0.1",
+		"--port",
+		String(internalPort),
+		"-t",
+		`theme=${serialiseThemeForTtyd(config)}`,
+		"-t",
+		`fontFamily="${config.font.family}"`,
+		"-t",
+		"scrollSensitivity=3",
+		"-t",
+		"disableLeaveAlert=true",
+		...command
+	];
+}
+/** Read a PNG icon, returns undefined if not found */
+function readIcon(filename) {
+	try {
+		return readFileSync(resolve(ICONS_DIR, filename));
+	} catch {
+		return;
+	}
+}
+/** Spawn caffeinate to prevent system sleep while ttyd is running (macOS only).
+* Uses -s (system sleep on AC) and -w <pid> so the assertion drops when ttyd exits. */
+function spawnCaffeinate(pid) {
+	try {
+		const proc = spawnProcess([
+			"caffeinate",
+			"-s",
+			"-w",
+			String(pid)
+		], {
+			stdout: "ignore",
+			stderr: "ignore"
+		});
+		proc.exited.catch(() => {
+			console.warn("remobi: --no-sleep requires caffeinate (macOS only), ignoring");
+		});
+		console.log(`remobi: sleep prevention active (caffeinate -s -w ${pid})`);
+		return proc;
+	} catch {
+		console.warn("remobi: --no-sleep requires caffeinate (macOS only), ignoring");
+		return null;
+	}
+}
+/** Start remobi serve: builds overlay in memory, manages ttyd, serves HTTP + WS */
+async function serve$1(config, port = DEFAULT_PORT, command = DEFAULT_COMMAND, noSleep = false) {
+	console.log("remobi: building overlay...");
+	const { js, css } = await bundleOverlay(config);
+	const internalPort = randomInternalPort();
+	const ttydArgs = buildTtydArgs(config, internalPort, command);
+	console.log(`remobi: starting ttyd on internal port ${internalPort}...`);
+	const ttydProc = spawnProcess(["ttyd", ...ttydArgs], {
+		stdout: "ignore",
+		stderr: "ignore"
+	});
+	const caffeinateProc = noSleep && ttydProc.pid ? spawnCaffeinate(ttydProc.pid) : null;
+	await waitForTtyd(internalPort);
+	const html = injectOverlay(await (await fetch(`http://127.0.0.1:${internalPort}/`)).text(), js, css, config);
+	console.log("remobi: overlay ready");
+	const manifestJson = config.pwa.enabled ? manifestToJson(config.name, config.pwa) : null;
+	const icon180 = readIcon("icon-180.png");
+	const icon192 = readIcon("icon-192.png");
+	const icon512 = readIcon("icon-512.png");
+	const connections = /* @__PURE__ */ new WeakMap();
+	const app = new Hono();
+	const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
+	app.get("/ws", upgradeWebSocket(() => ({
+		onOpen(_event, ws) {
+			const raw = ws.raw;
+			if (!raw) return;
+			const data = {
+				backend: null,
+				buffer: []
+			};
+			connections.set(raw, data);
+			const backend = new WebSocket(`ws://127.0.0.1:${internalPort}/ws`, ["tty"]);
+			backend.binaryType = "arraybuffer";
+			data.backend = backend;
+			backend.on("open", () => {
+				for (const msg of data.buffer) backend.send(msg);
+				data.buffer = [];
+			});
+			backend.on("message", (message, isBinary) => {
+				if (isBinary && message instanceof ArrayBuffer) ws.send(new Uint8Array(message));
+				else ws.send(message.toString());
+			});
+			backend.on("error", () => {
+				ws.close();
+			});
+			backend.on("close", () => {
+				ws.close();
+			});
+		},
+		onMessage(event, ws) {
+			const raw = ws.raw;
+			if (!raw) return;
+			const data = connections.get(raw);
+			if (!data) return;
+			const { backend, buffer } = data;
+			if (backend !== null && backend.readyState === WebSocket.OPEN) backend.send(event.data);
+			else {
+				const msg = event.data;
+				buffer.push(typeof msg === "string" ? msg : new Uint8Array(msg));
+			}
+		},
+		onClose(_event, ws) {
+			const raw = ws.raw;
+			if (!raw) return;
+			connections.get(raw)?.backend?.close();
+			connections.delete(raw);
+		}
+	})));
+	app.get("/", (c) => c.html(html));
+	if (manifestJson !== null) app.get("/manifest.json", (c) => {
+		return c.json(JSON.parse(manifestJson));
+	});
+	if (icon180) app.get("/apple-touch-icon.png", () => {
+		return new Response(Uint8Array.from(icon180), { headers: { "content-type": "image/png" } });
+	});
+	if (icon192) app.get("/icon-192.png", () => {
+		return new Response(Uint8Array.from(icon192), { headers: { "content-type": "image/png" } });
+	});
+	if (icon512) app.get("/icon-512.png", () => {
+		return new Response(Uint8Array.from(icon512), { headers: { "content-type": "image/png" } });
+	});
+	app.all("/*", async (c) => {
+		const url = new URL(c.req.url);
+		const backendUrl = `http://127.0.0.1:${internalPort}${url.pathname}${url.search}`;
+		const resp = await fetch(backendUrl, {
+			method: c.req.method,
+			headers: c.req.raw.headers,
+			body: c.req.raw.body
+		});
+		return new Response(resp.body, {
+			status: resp.status,
+			headers: resp.headers
+		});
+	});
+	const server = serve({
+		fetch: app.fetch,
+		port
+	});
+	injectWebSocket(server);
+	console.log(`remobi: serving on http://localhost:${port}`);
+	const cleanup = () => {
+		console.log("\nremobi: shutting down...");
+		server.close();
+		ttydProc.kill();
+		caffeinateProc?.kill();
+		process.exit(0);
+	};
+	process.on("SIGINT", cleanup);
+	process.on("SIGTERM", cleanup);
+	await ttydProc.exited;
+	server.close();
+}
+
+//#endregion
+//#region cli.ts
+function loadPackageVersion() {
+	let dir = import.meta.dirname;
+	for (let i = 0; i < 5; i++) try {
+		const content = readFileSync(resolve(dir, "package.json"), "utf-8");
+		return JSON.parse(content).version;
+	} catch {
+		dir = dirname(dir);
+	}
+	return "0.0.0";
+}
+const VERSION = loadPackageVersion();
+function usage() {
+	console.log(`remobi v${VERSION} — mobile-friendly terminal overlay for ttyd + tmux
+
+Usage:
+  remobi serve [--config <path>] [--port <n>] [--no-sleep] [-- <command...>]
+    Build overlay in memory, manage ttyd, serve with PWA support.
+    Default port: 7681. Default command: tmux new-session -A -s main
+
+  remobi build [--config <path>] [--output <path>] [--dry-run]
+    Build patched index.html for ttyd --index flag.
+    Starts temp ttyd, fetches base HTML, injects overlay.
+
+  remobi inject [--config <path>] [--dry-run]
+    Pipe mode: reads ttyd HTML from stdin, outputs patched HTML to stdout.
+
+  remobi init
+    Scaffold a remobi.config.ts with defaults.
+
+  remobi --version
+    Print version.
+
+  remobi --help
+    Show this help.
+
+Flags:
+  -c, --config <path>  Use a specific config file (build/inject/serve)
+  -o, --output <path>  Build output path (build only)
+  -p, --port <n>       Port to serve on (serve only, default 7681)
+  -n, --dry-run        Validate + print plan only (build/inject)
+      --no-sleep       Prevent macOS sleep while serving (caffeinate -s, serve only)
+
+Examples:
+  remobi serve
+  remobi serve --no-sleep
+  remobi serve --port 8080 -- tmux new -As dev
+  remobi build -c ./remobi.config.ts -o ./dist/index.html
+  remobi build --dry-run
+  curl -s http://127.0.0.1:7681/ | remobi inject --dry-run`);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractDefaultExport(value) {
+	if (!isRecord(value)) return void 0;
+	if (!("default" in value)) return void 0;
+	return value.default;
+}
+function ensureInjectInputMode(context) {
+	if (process.stdin.isTTY) throw new Error(`${context} expects piped ttyd HTML on stdin`);
+}
+function throwConfigValidationError(source, error) {
+	throw new Error(`Config validation failed for ${source}\n${error.message}`);
+}
+/** Convert a config path to its .local sibling, e.g. remobi.config.ts → remobi.config.local.ts */
+function toLocalPath(configPath) {
+	const dotIdx = configPath.lastIndexOf(".");
+	if (dotIdx === -1) return `${configPath}.local`;
+	return `${configPath.slice(0, dotIdx)}.local${configPath.slice(dotIdx)}`;
+}
+/** Try to load a .local config override file. Returns undefined if the file does not exist. */
+async function loadLocalOverrides(localPath) {
+	if (!existsSync(localPath)) return;
+	const defaultExport = extractDefaultExport(await import(localPath));
+	if (defaultExport === void 0) throw new Error(`Local config file has no default export: ${localPath}`);
+	assertValidOverridesOrThrow(defaultExport, localPath);
+	return defaultExport;
+}
+function assertValidOverridesOrThrow(value, source) {
+	try {
+		assertValidConfigOverrides(value);
+	} catch (error) {
+		if (error instanceof ConfigValidationError) throwConfigValidationError(source, error);
+		throw error;
+	}
+}
+function assertValidResolvedOrThrow(value, source) {
+	try {
+		assertValidResolvedConfig(value);
+	} catch (error) {
+		if (error instanceof ConfigValidationError) throwConfigValidationError(source, error);
+		throw error;
+	}
+}
+async function loadConfig(configPath) {
+	let resolved = configPath;
+	if (!resolved) {
+		const names = ["remobi.config.ts", "remobi.config.js"];
+		const searchDirs = [process.cwd(), join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "remobi")];
+		for (const dir of searchDirs) {
+			for (const name of names) {
+				const full = join(dir, name);
+				if (existsSync(full)) {
+					resolved = full;
+					break;
+				}
+			}
+			if (resolved) break;
+		}
+	}
+	if (resolved) {
+		const abs = resolve(process.cwd(), resolved);
+		const defaultExport = extractDefaultExport(await import(abs));
+		if (defaultExport === void 0) throw new Error(`Config file has no default export: ${abs}`);
+		assertValidOverridesOrThrow(defaultExport, abs);
+		const sharedConfig = defineConfig(defaultExport);
+		const localPath = toLocalPath(abs);
+		const localOverrides = await loadLocalOverrides(localPath);
+		const config = localOverrides !== void 0 ? mergeConfig(sharedConfig, localOverrides) : sharedConfig;
+		const sourceLabel = localOverrides !== void 0 ? `${abs} + ${localPath}` : abs;
+		assertValidResolvedOrThrow(config, sourceLabel);
+		return {
+			config,
+			source: sourceLabel
+		};
+	}
+	assertValidResolvedOrThrow(defaultConfig, "built-in defaults");
+	return {
+		config: defaultConfig,
+		source: "built-in defaults"
+	};
+}
+async function main() {
+	const parsed = parseCliArgs(process.argv.slice(2));
+	if (!parsed.ok) {
+		console.error(parsed.error);
+		usage();
+		process.exit(1);
+	}
+	const { command, configPath, outputPath, dryRun, port, noSleep, command_ } = parsed.value;
+	switch (command) {
+		case "serve":
+			await serve$1((await loadConfig(configPath)).config, port, command_.length > 0 ? command_ : void 0, noSleep);
+			break;
+		case "build": {
+			const loaded = await loadConfig(configPath);
+			const targetPath = outputPath ? resolve(process.cwd(), outputPath) : resolve(process.cwd(), "dist/index.html");
+			if (dryRun) {
+				console.log("Dry run: build");
+				console.log(`- config: ${loaded.source}`);
+				console.log(`- output: ${targetPath}`);
+				console.log("- action: would bundle overlay, fetch ttyd base HTML, inject, and write file");
+				break;
+			}
+			mkdirSync(dirname(targetPath), { recursive: true });
+			await build(loaded.config, targetPath);
+			console.log(`Built: ${targetPath}`);
+			break;
+		}
+		case "inject": {
+			const loaded = await loadConfig(configPath);
+			if (dryRun) {
+				ensureInjectInputMode("remobi inject --dry-run");
+				if ((await readStdin()).trim().length === 0) throw new Error("remobi inject --dry-run expects piped ttyd HTML on stdin");
+				console.log("Dry run: inject");
+				console.log(`- config: ${loaded.source}`);
+				console.log("- stdin: piped input detected");
+				console.log("- action: would read stdin HTML, inject overlay, and write to stdout");
+				break;
+			}
+			ensureInjectInputMode("remobi inject");
+			const result = await injectFromStdin(loaded.config);
+			process.stdout.write(result);
+			break;
+		}
+		case "init": {
+			const targetPath = resolve(process.cwd(), "remobi.config.ts");
+			if (existsSync(targetPath)) {
+				console.error("remobi.config.ts already exists");
+				process.exit(1);
+			}
+			writeFileSync(targetPath, `import { defineConfig } from 'remobi'
+
+export default defineConfig({
+  // name: 'remobi',              // app name (tab title, PWA home screen label)
+  // theme: 'catppuccin-mocha',
+  // font: {
+  //   family: 'JetBrainsMono NFM, monospace',
+  //   mobileSizeDefault: 16,
+  //   sizeRange: [8, 32],
+  // },
+  //
+  // Toolbar/drawer accept a plain array (replace) or a function (transform):
+  //
+  // toolbar: { row1: [{ id, label, description, action }], row2: [...] },
+  //
+  // drawer: {
+  //   buttons: [
+  //     { id: 'sessions', label: 'Sessions', description: 'Choose tmux session', action: { type: 'send', data: '\\x02s' } },
+  //   ],
+  // },
+  //
+  // toolbar: {
+  //   row2: (defaults) => defaults.filter((b) => b.id !== 'q'),
+  // },
+  //
+  // drawer: {
+  //   buttons: (defaults) => [
+  //     ...defaults,
+  //     { id: 'my-btn', label: 'X', description: 'Send x', action: { type: 'send', data: 'x' } },
+  //   ],
+  // },
+  //
+  // gestures: {
+  //   swipe: {
+  //     enabled: true,
+  //     left: '\\x02n',          // data sent on swipe left (default: next tmux window)
+  //     right: '\\x02p',         // data sent on swipe right (default: prev tmux window)
+  //     leftLabel: 'Next tmux window',
+  //     rightLabel: 'Previous tmux window',
+  //   },
+  //   pinch: { enabled: true },
+  //   scroll: { strategy: 'wheel', sensitivity: 40 },
+  // },
+  // mobile: {
+  //   initData: '\\x02z',        // send on load when viewport < widthThreshold (auto-zoom pane)
+  //   widthThreshold: 768,       // px — default matches phone/tablet breakpoint
+  // },
+  // floatingButtons: [
+  //   // Always-visible top-left buttons (touch devices only)
+  //   { position: 'top-left', buttons: [{ id: 'zoom', label: 'Zoom', description: 'Toggle pane zoom', action: { type: 'send', data: '\\x02z' } }] },
+  // ],
+  // pwa: {
+  //   enabled: true,              // enable PWA manifest + meta tags (used by remobi serve)
+  //   shortName: 'remobi',        // short name for home screen icon (defaults to name)
+  //   themeColor: '#1e1e2e',      // theme-color meta tag + manifest
+  // },
+  // reconnect: {
+  //   enabled: true,              // show overlay + auto-reload on connection loss (default true)
+  // },
+})
+`);
+			console.log(`Created: ${targetPath}`);
+			break;
+		}
+		case "version":
+			console.log(VERSION);
+			break;
+		case "help":
+			usage();
+			break;
+		default:
+			console.error(`Unknown command: ${command}`);
+			usage();
+			process.exit(1);
+	}
+}
+if (import.meta.filename === process.argv[1]) main().catch((err) => {
+	console.error(err);
+	process.exit(1);
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.mjs.map