remoteclaw 0.1.0-next.049f396 → 0.1.0-next.05abcca

package/dist/systemd-linger-DDvkfxH-.js

@@ -0,0 +1,75 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { t as note } from "./note-D-EI0czq.js";
+import { d as enableSystemdUserLinger, f as readSystemdUserLingerStatus, r as isSystemdUserServiceAvailable } from "./systemd-40Rij3QR.js";
+
+//#region src/commands/systemd-linger.ts
+var systemd_linger_exports = /* @__PURE__ */ __exportAll({
+	ensureSystemdUserLingerInteractive: () => ensureSystemdUserLingerInteractive,
+	ensureSystemdUserLingerNonInteractive: () => ensureSystemdUserLingerNonInteractive
+});
+async function ensureSystemdUserLingerInteractive(params) {
+	if (process.platform !== "linux") return;
+	if (params.prompt === false) return;
+	const env = params.env ?? process.env;
+	const prompter = params.prompter ?? { note };
+	const title = params.title ?? "Systemd";
+	if (!await isSystemdUserServiceAvailable()) {
+		await prompter.note("Systemd user services are unavailable. Skipping lingering checks.", title);
+		return;
+	}
+	const status = await readSystemdUserLingerStatus(env);
+	if (!status) {
+		await prompter.note("Unable to read loginctl linger status. Ensure systemd + loginctl are available.", title);
+		return;
+	}
+	if (status.linger === "yes") return;
+	const reason = params.reason ?? "Systemd user services stop when you log out or go idle, which kills the Gateway.";
+	const actionNote = params.requireConfirm ? "We can enable lingering now (may require sudo; writes /var/lib/systemd/linger)." : "Enabling lingering now (may require sudo; writes /var/lib/systemd/linger).";
+	await prompter.note(`${reason}\n${actionNote}`, title);
+	if (params.requireConfirm && prompter.confirm) {
+		if (!await prompter.confirm({
+			message: `Enable systemd lingering for ${status.user}?`,
+			initialValue: true
+		})) {
+			await prompter.note("Without lingering, the Gateway will stop when you log out.", title);
+			return;
+		}
+	}
+	if ((await enableSystemdUserLinger({
+		env,
+		user: status.user
+	})).ok) {
+		await prompter.note(`Enabled systemd lingering for ${status.user}.`, title);
+		return;
+	}
+	const result = await enableSystemdUserLinger({
+		env,
+		user: status.user,
+		sudoMode: "prompt"
+	});
+	if (result.ok) {
+		await prompter.note(`Enabled systemd lingering for ${status.user}.`, title);
+		return;
+	}
+	params.runtime.error(`Failed to enable lingering: ${result.stderr || result.stdout || "unknown error"}`);
+	await prompter.note(`Run manually: sudo loginctl enable-linger ${status.user}`, title);
+}
+async function ensureSystemdUserLingerNonInteractive(params) {
+	if (process.platform !== "linux") return;
+	const env = params.env ?? process.env;
+	if (!await isSystemdUserServiceAvailable()) return;
+	const status = await readSystemdUserLingerStatus(env);
+	if (!status || status.linger === "yes") return;
+	if ((await enableSystemdUserLinger({
+		env,
+		user: status.user,
+		sudoMode: "non-interactive"
+	})).ok) {
+		params.runtime.log(`Enabled systemd lingering for ${status.user}.`);
+		return;
+	}
+	params.runtime.log(`Systemd lingering is disabled for ${status.user}. Run: sudo loginctl enable-linger ${status.user}`);
+}
+
+//#endregion
+export { ensureSystemdUserLingerNonInteractive as n, systemd_linger_exports as r, ensureSystemdUserLingerInteractive as t };

package/dist/table-DFx25vNb.js

@@ -0,0 +1,279 @@
+import { a as displayString } from "./utils-DPoNpP7D.js";
+import { n as visibleWidth } from "./ansi-DtaiOnt1.js";
+
+//#region src/terminal/table.ts
+function repeat(ch, n) {
+	if (n <= 0) return "";
+	return ch.repeat(n);
+}
+function padCell(text, width, align) {
+	const w = visibleWidth(text);
+	if (w >= width) return text;
+	const pad = width - w;
+	if (align === "right") return `${repeat(" ", pad)}${text}`;
+	if (align === "center") {
+		const left = Math.floor(pad / 2);
+		const right = pad - left;
+		return `${repeat(" ", left)}${text}${repeat(" ", right)}`;
+	}
+	return `${text}${repeat(" ", pad)}`;
+}
+function wrapLine(text, width) {
+	if (width <= 0) return [text];
+	const ESC = "\x1B";
+	const tokens = [];
+	for (let i = 0; i < text.length;) {
+		if (text[i] === ESC) {
+			if (text[i + 1] === "[") {
+				let j = i + 2;
+				while (j < text.length) {
+					const ch = text[j];
+					if (ch === "m") break;
+					if (ch && ch >= "0" && ch <= "9") {
+						j += 1;
+						continue;
+					}
+					if (ch === ";") {
+						j += 1;
+						continue;
+					}
+					break;
+				}
+				if (text[j] === "m") {
+					tokens.push({
+						kind: "ansi",
+						value: text.slice(i, j + 1)
+					});
+					i = j + 1;
+					continue;
+				}
+			}
+			if (text[i + 1] === "]" && text.slice(i + 2, i + 5) === "8;;") {
+				const st = text.indexOf(`${ESC}\\`, i + 5);
+				if (st >= 0) {
+					tokens.push({
+						kind: "ansi",
+						value: text.slice(i, st + 2)
+					});
+					i = st + 2;
+					continue;
+				}
+			}
+		}
+		const cp = text.codePointAt(i);
+		if (!cp) break;
+		const ch = String.fromCodePoint(cp);
+		tokens.push({
+			kind: "char",
+			value: ch
+		});
+		i += ch.length;
+	}
+	const firstCharIndex = tokens.findIndex((t) => t.kind === "char");
+	if (firstCharIndex < 0) return [text];
+	let lastCharIndex = -1;
+	for (let i = tokens.length - 1; i >= 0; i -= 1) if (tokens[i]?.kind === "char") {
+		lastCharIndex = i;
+		break;
+	}
+	const prefixAnsi = tokens.slice(0, firstCharIndex).filter((t) => t.kind === "ansi").map((t) => t.value).join("");
+	const suffixAnsi = tokens.slice(lastCharIndex + 1).filter((t) => t.kind === "ansi").map((t) => t.value).join("");
+	const coreTokens = tokens.slice(firstCharIndex, lastCharIndex + 1);
+	const lines = [];
+	const isBreakChar = (ch) => ch === " " || ch === "	" || ch === "/" || ch === "-" || ch === "_" || ch === ".";
+	const isSpaceChar = (ch) => ch === " " || ch === "	";
+	let skipNextLf = false;
+	const buf = [];
+	let bufVisible = 0;
+	let lastBreakIndex = null;
+	const bufToString = (slice) => (slice ?? buf).map((t) => t.value).join("");
+	const bufVisibleWidth = (slice) => slice.reduce((acc, t) => acc + (t.kind === "char" ? 1 : 0), 0);
+	const pushLine = (value) => {
+		const cleaned = value.replace(/\s+$/, "");
+		if (cleaned.trim().length === 0) return;
+		lines.push(cleaned);
+	};
+	const flushAt = (breakAt) => {
+		if (buf.length === 0) return;
+		if (breakAt == null || breakAt <= 0) {
+			pushLine(bufToString());
+			buf.length = 0;
+			bufVisible = 0;
+			lastBreakIndex = null;
+			return;
+		}
+		const left = buf.slice(0, breakAt);
+		const rest = buf.slice(breakAt);
+		pushLine(bufToString(left));
+		while (rest.length > 0 && rest[0]?.kind === "char" && isSpaceChar(rest[0].value)) rest.shift();
+		buf.length = 0;
+		buf.push(...rest);
+		bufVisible = bufVisibleWidth(buf);
+		lastBreakIndex = null;
+	};
+	for (const token of coreTokens) {
+		if (token.kind === "ansi") {
+			buf.push(token);
+			continue;
+		}
+		const ch = token.value;
+		if (skipNextLf) {
+			skipNextLf = false;
+			if (ch === "\n") continue;
+		}
+		if (ch === "\n" || ch === "\r") {
+			flushAt(buf.length);
+			if (ch === "\r") skipNextLf = true;
+			continue;
+		}
+		if (bufVisible + 1 > width && bufVisible > 0) flushAt(lastBreakIndex);
+		buf.push(token);
+		bufVisible += 1;
+		if (isBreakChar(ch)) lastBreakIndex = buf.length;
+	}
+	flushAt(buf.length);
+	if (!lines.length) return [""];
+	if (!prefixAnsi && !suffixAnsi) return lines;
+	return lines.map((line) => {
+		if (!line) return line;
+		return `${prefixAnsi}${line}${suffixAnsi}`;
+	});
+}
+function normalizeWidth(n) {
+	if (n == null) return;
+	if (!Number.isFinite(n) || n <= 0) return;
+	return Math.floor(n);
+}
+function renderTable(opts) {
+	const rows = opts.rows.map((row) => {
+		const next = {};
+		for (const [key, value] of Object.entries(row)) next[key] = displayString(value);
+		return next;
+	});
+	const border = opts.border ?? "unicode";
+	if (border === "none") {
+		const columns = opts.columns;
+		return `${[columns.map((c) => c.header).join(" | "), ...rows.map((r) => columns.map((c) => r[c.key] ?? "").join(" | "))].join("\n")}\n`;
+	}
+	const padding = Math.max(0, opts.padding ?? 1);
+	const columns = opts.columns;
+	const metrics = columns.map((c) => {
+		return {
+			headerW: visibleWidth(c.header),
+			cellW: Math.max(0, ...rows.map((r) => visibleWidth(r[c.key] ?? "")))
+		};
+	});
+	const widths = columns.map((c, i) => {
+		const m = metrics[i];
+		const base = Math.max(m?.headerW ?? 0, m?.cellW ?? 0) + padding * 2;
+		const capped = c.maxWidth ? Math.min(base, c.maxWidth) : base;
+		return Math.max(c.minWidth ?? 3, capped);
+	});
+	const maxWidth = normalizeWidth(opts.width);
+	const sepCount = columns.length + 1;
+	const total = widths.reduce((a, b) => a + b, 0) + sepCount;
+	const preferredMinWidths = columns.map((c, i) => Math.max(c.minWidth ?? 3, (metrics[i]?.headerW ?? 0) + padding * 2, 3));
+	const absoluteMinWidths = columns.map((_c, i) => Math.max((metrics[i]?.headerW ?? 0) + padding * 2, 3));
+	if (maxWidth && total > maxWidth) {
+		let over = total - maxWidth;
+		const flexOrder = columns.map((_c, i) => ({
+			i,
+			w: widths[i] ?? 0
+		})).filter(({ i }) => Boolean(columns[i]?.flex)).toSorted((a, b) => b.w - a.w).map((x) => x.i);
+		const nonFlexOrder = columns.map((_c, i) => ({
+			i,
+			w: widths[i] ?? 0
+		})).filter(({ i }) => !columns[i]?.flex).toSorted((a, b) => b.w - a.w).map((x) => x.i);
+		const shrink = (order, minWidths) => {
+			while (over > 0) {
+				let progressed = false;
+				for (const i of order) {
+					if ((widths[i] ?? 0) <= (minWidths[i] ?? 0)) continue;
+					widths[i] = (widths[i] ?? 0) - 1;
+					over -= 1;
+					progressed = true;
+					if (over <= 0) break;
+				}
+				if (!progressed) break;
+			}
+		};
+		shrink(flexOrder, preferredMinWidths);
+		shrink(flexOrder, absoluteMinWidths);
+		shrink(nonFlexOrder, preferredMinWidths);
+		shrink(nonFlexOrder, absoluteMinWidths);
+	}
+	if (maxWidth) {
+		const sepCount = columns.length + 1;
+		let extra = maxWidth - (widths.reduce((a, b) => a + b, 0) + sepCount);
+		if (extra > 0) {
+			const flexCols = columns.map((c, i) => ({
+				c,
+				i
+			})).filter(({ c }) => Boolean(c.flex)).map(({ i }) => i);
+			if (flexCols.length > 0) {
+				const caps = columns.map((c) => typeof c.maxWidth === "number" && c.maxWidth > 0 ? Math.floor(c.maxWidth) : Number.POSITIVE_INFINITY);
+				while (extra > 0) {
+					let progressed = false;
+					for (const i of flexCols) {
+						if ((widths[i] ?? 0) >= (caps[i] ?? Number.POSITIVE_INFINITY)) continue;
+						widths[i] = (widths[i] ?? 0) + 1;
+						extra -= 1;
+						progressed = true;
+						if (extra <= 0) break;
+					}
+					if (!progressed) break;
+				}
+			}
+		}
+	}
+	const box = border === "ascii" ? {
+		tl: "+",
+		tr: "+",
+		bl: "+",
+		br: "+",
+		h: "-",
+		v: "|",
+		t: "+",
+		ml: "+",
+		m: "+",
+		mr: "+",
+		b: "+"
+	} : {
+		tl: "┌",
+		tr: "┐",
+		bl: "└",
+		br: "┘",
+		h: "─",
+		v: "│",
+		t: "┬",
+		ml: "├",
+		m: "┼",
+		mr: "┤",
+		b: "┴"
+	};
+	const hLine = (left, mid, right) => `${left}${widths.map((w) => repeat(box.h, w)).join(mid)}${right}`;
+	const contentWidthFor = (i) => Math.max(1, widths[i] - padding * 2);
+	const padStr = repeat(" ", padding);
+	const renderRow = (record, isHeader = false) => {
+		const wrapped = columns.map((c) => isHeader ? c.header : record[c.key] ?? "").map((cell, i) => wrapLine(cell, contentWidthFor(i)));
+		const height = Math.max(...wrapped.map((w) => w.length));
+		const out = [];
+		for (let li = 0; li < height; li += 1) {
+			const parts = wrapped.map((lines, i) => {
+				return `${padStr}${padCell(lines[li] ?? "", contentWidthFor(i), columns[i]?.align ?? "left")}${padStr}`;
+			});
+			out.push(`${box.v}${parts.join(box.v)}${box.v}`);
+		}
+		return out;
+	};
+	const lines = [];
+	lines.push(hLine(box.tl, box.t, box.tr));
+	lines.push(...renderRow({}, true));
+	lines.push(hLine(box.ml, box.m, box.mr));
+	for (const row of rows) lines.push(...renderRow(row, false));
+	lines.push(hLine(box.bl, box.b, box.br));
+	return `${lines.join("\n")}\n`;
+}
+
+//#endregion
+export { renderTable as t };

package/dist/tables-C5fI0PmT.js

@@ -0,0 +1,55 @@
+import { r as markdownToIRWithMeta } from "./ir-BPwP8hIc.js";
+import { t as renderMarkdownWithMarkers } from "./render-e7fENCYH.js";
+
+//#region src/markdown/tables.ts
+const MARKDOWN_STYLE_MARKERS = {
+	bold: {
+		open: "**",
+		close: "**"
+	},
+	italic: {
+		open: "_",
+		close: "_"
+	},
+	strikethrough: {
+		open: "~~",
+		close: "~~"
+	},
+	code: {
+		open: "`",
+		close: "`"
+	},
+	code_block: {
+		open: "```\n",
+		close: "```"
+	}
+};
+function convertMarkdownTables(markdown, mode) {
+	if (!markdown || mode === "off") return markdown;
+	const { ir, hasTables } = markdownToIRWithMeta(markdown, {
+		linkify: false,
+		autolink: false,
+		headingStyle: "none",
+		blockquotePrefix: "",
+		tableMode: mode
+	});
+	if (!hasTables) return markdown;
+	return renderMarkdownWithMarkers(ir, {
+		styleMarkers: MARKDOWN_STYLE_MARKERS,
+		escapeText: (text) => text,
+		buildLink: (link, text) => {
+			const href = link.href.trim();
+			if (!href) return null;
+			if (!text.slice(link.start, link.end)) return null;
+			return {
+				start: link.start,
+				end: link.end,
+				open: "[",
+				close: `](${href})`
+			};
+		}
+	});
+}
+
+//#endregion
+export { convertMarkdownTables as t };

package/dist/tables-Cm9qvQ9D.js

@@ -0,0 +1,55 @@
+import { s as markdownToIRWithMeta } from "./media-4-qOIjO-.js";
+import { t as renderMarkdownWithMarkers } from "./render-BhKzKdV0.js";
+
+//#region src/markdown/tables.ts
+const MARKDOWN_STYLE_MARKERS = {
+	bold: {
+		open: "**",
+		close: "**"
+	},
+	italic: {
+		open: "_",
+		close: "_"
+	},
+	strikethrough: {
+		open: "~~",
+		close: "~~"
+	},
+	code: {
+		open: "`",
+		close: "`"
+	},
+	code_block: {
+		open: "```\n",
+		close: "```"
+	}
+};
+function convertMarkdownTables(markdown, mode) {
+	if (!markdown || mode === "off") return markdown;
+	const { ir, hasTables } = markdownToIRWithMeta(markdown, {
+		linkify: false,
+		autolink: false,
+		headingStyle: "none",
+		blockquotePrefix: "",
+		tableMode: mode
+	});
+	if (!hasTables) return markdown;
+	return renderMarkdownWithMarkers(ir, {
+		styleMarkers: MARKDOWN_STYLE_MARKERS,
+		escapeText: (text) => text,
+		buildLink: (link, text) => {
+			const href = link.href.trim();
+			if (!href) return null;
+			if (!text.slice(link.start, link.end)) return null;
+			return {
+				start: link.start,
+				end: link.end,
+				open: "[",
+				close: `](${href})`
+			};
+		}
+	});
+}
+
+//#endregion
+export { convertMarkdownTables as t };

package/dist/tables-fRe01eP1.js

@@ -0,0 +1,55 @@
+import { i as markdownToIRWithMeta } from "./media-DTwJhAbE.js";
+import { t as renderMarkdownWithMarkers } from "./render-6ahYfPwj.js";
+
+//#region src/markdown/tables.ts
+const MARKDOWN_STYLE_MARKERS = {
+	bold: {
+		open: "**",
+		close: "**"
+	},
+	italic: {
+		open: "_",
+		close: "_"
+	},
+	strikethrough: {
+		open: "~~",
+		close: "~~"
+	},
+	code: {
+		open: "`",
+		close: "`"
+	},
+	code_block: {
+		open: "```\n",
+		close: "```"
+	}
+};
+function convertMarkdownTables(markdown, mode) {
+	if (!markdown || mode === "off") return markdown;
+	const { ir, hasTables } = markdownToIRWithMeta(markdown, {
+		linkify: false,
+		autolink: false,
+		headingStyle: "none",
+		blockquotePrefix: "",
+		tableMode: mode
+	});
+	if (!hasTables) return markdown;
+	return renderMarkdownWithMarkers(ir, {
+		styleMarkers: MARKDOWN_STYLE_MARKERS,
+		escapeText: (text) => text,
+		buildLink: (link, text) => {
+			const href = link.href.trim();
+			if (!href) return null;
+			if (!text.slice(link.start, link.end)) return null;
+			return {
+				start: link.start,
+				end: link.end,
+				open: "[",
+				close: `](${href})`
+			};
+		}
+	});
+}
+
+//#endregion
+export { convertMarkdownTables as t };

package/dist/tailnet-Da-_9e8E.js

@@ -0,0 +1,40 @@
+import { a as isIpInCidr } from "./ip-D4VG5EJO.js";
+import os from "node:os";
+
+//#region src/infra/tailnet.ts
+const TAILNET_IPV4_CIDR = "100.64.0.0/10";
+const TAILNET_IPV6_CIDR = "fd7a:115c:a1e0::/48";
+function isTailnetIPv4(address) {
+	return isIpInCidr(address, TAILNET_IPV4_CIDR);
+}
+function isTailnetIPv6(address) {
+	return isIpInCidr(address, TAILNET_IPV6_CIDR);
+}
+function listTailnetAddresses() {
+	const ipv4 = [];
+	const ipv6 = [];
+	const ifaces = os.networkInterfaces();
+	for (const entries of Object.values(ifaces)) {
+		if (!entries) continue;
+		for (const e of entries) {
+			if (!e || e.internal) continue;
+			const address = e.address?.trim();
+			if (!address) continue;
+			if (isTailnetIPv4(address)) ipv4.push(address);
+			if (isTailnetIPv6(address)) ipv6.push(address);
+		}
+	}
+	return {
+		ipv4: [...new Set(ipv4)],
+		ipv6: [...new Set(ipv6)]
+	};
+}
+function pickPrimaryTailnetIPv4() {
+	return listTailnetAddresses().ipv4[0];
+}
+function pickPrimaryTailnetIPv6() {
+	return listTailnetAddresses().ipv6[0];
+}
+
+//#endregion
+export { pickPrimaryTailnetIPv4 as n, pickPrimaryTailnetIPv6 as r, isTailnetIPv4 as t };

package/dist/tailnet-xt92Yaop.js

@@ -0,0 +1,40 @@
+import { a as isIpInCidr } from "./ip-MwCwRA7c.js";
+import os from "node:os";
+
+//#region src/infra/tailnet.ts
+const TAILNET_IPV4_CIDR = "100.64.0.0/10";
+const TAILNET_IPV6_CIDR = "fd7a:115c:a1e0::/48";
+function isTailnetIPv4(address) {
+	return isIpInCidr(address, TAILNET_IPV4_CIDR);
+}
+function isTailnetIPv6(address) {
+	return isIpInCidr(address, TAILNET_IPV6_CIDR);
+}
+function listTailnetAddresses() {
+	const ipv4 = [];
+	const ipv6 = [];
+	const ifaces = os.networkInterfaces();
+	for (const entries of Object.values(ifaces)) {
+		if (!entries) continue;
+		for (const e of entries) {
+			if (!e || e.internal) continue;
+			const address = e.address?.trim();
+			if (!address) continue;
+			if (isTailnetIPv4(address)) ipv4.push(address);
+			if (isTailnetIPv6(address)) ipv6.push(address);
+		}
+	}
+	return {
+		ipv4: [...new Set(ipv4)],
+		ipv6: [...new Set(ipv6)]
+	};
+}
+function pickPrimaryTailnetIPv4() {
+	return listTailnetAddresses().ipv4[0];
+}
+function pickPrimaryTailnetIPv6() {
+	return listTailnetAddresses().ipv6[0];
+}
+
+//#endregion
+export { pickPrimaryTailnetIPv4 as n, pickPrimaryTailnetIPv6 as r, isTailnetIPv4 as t };