glimmervoid 0.0.0-stage → 0.30.0

package/dist/chunks/node-pty-preflight-CK1knGIR.js

@@ -0,0 +1,162 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+//#region server/core/node-pty-preflight-core.ts
+var REPAIR_COMMAND = "npm rebuild -g node-pty --allow-scripts=node-pty";
+var FALLBACK_REPAIR_COMMAND = "cd \"$(npm root -g)/glimmervoid\" && npm rebuild node-pty --dangerously-allow-all-scripts";
+var CHECKOUT_REPAIR_COMMAND = "npm rebuild node-pty --dangerously-allow-all-scripts";
+function nativeBindingCandidates({ packageDir, platform, arch }) {
+	return [
+		["build", "Release"],
+		["build", "Debug"],
+		["prebuilds", `${platform}-${arch}`]
+	].flatMap((searchDir) => [path.join(packageDir, ...searchDir, "pty.node"), path.join(packageDir, "lib", ...searchDir, "pty.node")]);
+}
+function spawnHelperCandidates({ packageDir, platform, arch }) {
+	if (platform !== "darwin") return [];
+	return nativeBindingCandidates({
+		packageDir,
+		platform,
+		arch
+	}).map((bindingPath) => path.join(path.dirname(bindingPath), "spawn-helper"));
+}
+function nativeToolchainHint(platform) {
+	if (platform === "linux") return "install build tools: sudo apt install build-essential python3";
+	if (platform === "win32") return "install Visual Studio Build Tools";
+	if (platform === "darwin") return "install Xcode Command Line Tools: xcode-select --install";
+	return "install the native build tools for this platform";
+}
+function nodePtyRebuildHint(platform) {
+	return `${nativeToolchainHint(platform)}; then rebuild. global install: ${REPAIR_COMMAND} (the flag is required on npm 12, unknown-but-harmless on older npm). clone or source checkout, from the checkout root: ${CHECKOUT_REPAIR_COMMAND}`;
+}
+function formatNodePtyBootRefusal({ platform, packageDir, reason }) {
+	return [
+		"Refusing to start: the node-pty native binding did not load, so Glimmervoid cannot spawn a terminal for any session.",
+		`  reason: ${reason}`,
+		`  node-pty package: ${packageDir}`,
+		"  npm 12 blocks dependency install scripts by default, so a global install from a git spec leaves node-pty uncompiled.",
+		`  repair (global install): ${REPAIR_COMMAND}`,
+		"    (run it from a directory outside the installed package; from inside it the same command is project-scoped and dies with EALLOWSCRIPTS)",
+		"    (name node-pty, not glimmervoid: rebuilding the wrapper exits 0 and rebuilds nothing nested)",
+		`  fallback (global install): ${FALLBACK_REPAIR_COMMAND}`,
+		`  repair (clone or source checkout): ${CHECKOUT_REPAIR_COMMAND}`,
+		"    (run it from the checkout root; the global repair above rebuilds nothing in a checkout and exits 0)",
+		`  ${nativeToolchainHint(platform)}`,
+		"  Run \"glimmervoid doctor\" for the same check plus the rest of your install."
+	].join("\n");
+}
+//#endregion
+//#region server/core/text-core.ts
+var OTHER_CATEGORY_RE = /\p{C}+/gu;
+function firstLine(text) {
+	return String(text ?? "").split(/\r?\n/)[0].trim();
+}
+function sanitizeOneLine(raw, maxChars) {
+	return String(raw ?? "").replace(OTHER_CATEGORY_RE, " ").replace(/\s+/g, " ").trim().slice(0, maxChars).trim();
+}
+//#endregion
+//#region server/node-pty-preflight.ts
+function hostScope() {
+	return {
+		platform: process.platform,
+		arch: process.arch
+	};
+}
+function errorMessage(error) {
+	return firstLine(error instanceof Error ? error.message : String(error));
+}
+function resolveNodePtyPackageDir() {
+	try {
+		return { packageDir: path.dirname(createRequire(import.meta.url).resolve("node-pty/package.json")) };
+	} catch (err) {
+		return { error: errorMessage(err) };
+	}
+}
+var EXECUTABLE_MODE = 493;
+function isExecutableByThisProcess(helperPath) {
+	try {
+		fs.accessSync(helperPath, fs.constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function ensureSpawnHelperExecutable(packageDir, scope) {
+	const helperCandidates = spawnHelperCandidates({
+		packageDir,
+		...scope
+	});
+	if (helperCandidates.length === 0) return { ok: true };
+	let hasExecutableHelper = false;
+	let lastRepairError = "no candidate spawn-helper exists";
+	for (const helperPath of helperCandidates) {
+		if (isExecutableByThisProcess(helperPath)) {
+			hasExecutableHelper = true;
+			continue;
+		}
+		if (!fs.existsSync(helperPath)) continue;
+		try {
+			fs.chmodSync(helperPath, EXECUTABLE_MODE);
+		} catch (err) {
+			lastRepairError = `${helperPath}: ${errorMessage(err)}`;
+			continue;
+		}
+		if (isExecutableByThisProcess(helperPath)) {
+			hasExecutableHelper = true;
+			continue;
+		}
+		lastRepairError = `${helperPath}: still not executable after chmod 0755`;
+	}
+	if (hasExecutableHelper) return { ok: true };
+	return {
+		ok: false,
+		reason: `no executable spawn-helper found; checked ${helperCandidates.join(", ")}; last repair failure: ${lastRepairError}`
+	};
+}
+function scanNativeBinding(packageDir, scope = hostScope()) {
+	const candidates = nativeBindingCandidates({
+		packageDir,
+		...scope
+	});
+	if (!candidates.some((candidate) => fs.existsSync(candidate))) return {
+		ok: false,
+		reason: `no pty.node found; checked ${candidates.join(", ")}`,
+		packageDir
+	};
+	const helper = ensureSpawnHelperExecutable(packageDir, scope);
+	if (!helper.ok) return {
+		ok: false,
+		reason: helper.reason,
+		packageDir
+	};
+	return {
+		ok: true,
+		packageDir
+	};
+}
+async function probeNodePty() {
+	const resolved = resolveNodePtyPackageDir();
+	if ("error" in resolved) return {
+		ok: false,
+		reason: resolved.error,
+		packageDir: "(unresolved)"
+	};
+	try {
+		await import("node-pty");
+	} catch (err) {
+		return {
+			ok: false,
+			reason: errorMessage(err),
+			packageDir: resolved.packageDir
+		};
+	}
+	return scanNativeBinding(resolved.packageDir);
+}
+function requireExecutableSpawnHelper(packageDir = null, scope = hostScope()) {
+	const resolved = packageDir === null ? resolveNodePtyPackageDir() : { packageDir };
+	if ("error" in resolved) return;
+	const helper = ensureSpawnHelperExecutable(resolved.packageDir, scope);
+	if (!helper.ok) throw new Error(helper.reason);
+}
+//#endregion
+export { formatNodePtyBootRefusal as a, sanitizeOneLine as i, requireExecutableSpawnHelper as n, nodePtyRebuildHint as o, firstLine as r, probeNodePty as t };

package/dist/chunks/pair-cli-w-gCAF-1.js

@@ -0,0 +1,110 @@
+import { l as resolveConfigPath } from "./config-store-mm7MgzoL.js";
+import { c as defaultPairingsPath, i as REVOCATION_PROPAGATION_SECONDS, l as defaultSeenPath, n as normalizeRemoteConfig, o as createPairingsStore, s as createSeenStore } from "./remote-config-C2ytQwrs.js";
+import fs from "node:fs";
+//#region server/text-format.ts
+function trimIso(iso) {
+	return iso.replace("T", " ").slice(0, 19);
+}
+function formatTimestamp(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return trimIso(new Date(value).toISOString());
+	if (typeof value === "string") return trimIso(value);
+	return "-";
+}
+//#endregion
+//#region server/pair-cli.ts
+var PASSWORD_WARNING = [
+	"Treat this link like a password. Anyone who opens it gets full control of this",
+	"machine through Glimmervoid (it can start Claude Code sessions in any directory).",
+	"It works once and expires in 10 minutes."
+].join("\n");
+function readConfig(configPath) {
+	try {
+		return JSON.parse(fs.readFileSync(configPath, "utf8"));
+	} catch (err) {
+		console.error(`Could not read ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return null;
+	}
+}
+function argValue(args, flag) {
+	const idx = args.indexOf(flag);
+	if (idx === -1 || idx + 1 >= args.length) return null;
+	return args[idx + 1];
+}
+function buildPairUrl(remote, token) {
+	if (remote.publicHost) return `https://${remote.publicHost}/pair/${token}`;
+	return `http://127.0.0.1:${remote.port}/pair/${token}`;
+}
+function runMint(store, remote, name) {
+	if (!remote.publicHost && !remote.port) {
+		console.error("remote.port is not set, so a pairing link cannot be built.");
+		console.error("Set remote.port (and remote.publicHost for a shareable link) in config.json first.");
+		return 1;
+	}
+	const minted = store.mintPending({ name: name || "" });
+	if (!minted) {
+		console.error("Failed to write the pairing file - no token was created.");
+		return 1;
+	}
+	console.log("");
+	console.log(`  ${buildPairUrl(remote, minted.token)}`);
+	console.log("");
+	console.log(PASSWORD_WARNING);
+	if (!remote.publicHost) {
+		console.log("");
+		console.log("remote.publicHost is not set, so the link above points at loopback.");
+		console.log("Set it to the hostname your reverse proxy serves to get a shareable link.");
+	}
+	if (!remote.enabled) {
+		console.log("");
+		console.log("Note: remote.enabled is false, so the remote listener is not running yet.");
+	}
+	return 0;
+}
+function runList(store, seenStore) {
+	const devices = store.listDevices();
+	if (devices.length === 0) {
+		console.log("No paired devices.");
+		return 0;
+	}
+	const seen = seenStore.readAll();
+	console.log(`${"ID".padEnd(14)}${"NAME".padEnd(22)}${"PAIRED".padEnd(21)}${"LAST SEEN".padEnd(21)}STATUS`);
+	for (const device of devices) {
+		const status = device.revokedAt ? `revoked ${formatTimestamp(device.revokedAt)}` : "active";
+		console.log(device.id.padEnd(14) + (device.name || "-").padEnd(22) + formatTimestamp(device.createdAt).padEnd(21) + formatTimestamp(seen[device.id]).padEnd(21) + status);
+	}
+	return 0;
+}
+function runRevoke(store, id) {
+	const outcome = store.revokeDevice(id);
+	if (outcome.ok) {
+		console.log(`Revoked ${id}. A running Glimmervoid applies this within ${REVOCATION_PROPAGATION_SECONDS} seconds, no restart needed.`);
+		return 0;
+	}
+	if (outcome.reason === "unknown") {
+		console.error(`No paired device with id ${id}. Run "glimmervoid pair --list" to see the ids.`);
+		return 1;
+	}
+	console.error("Failed to write the pairing file - nothing was revoked.");
+	return 1;
+}
+function runPairCli(args) {
+	const configPath = resolveConfigPath();
+	const config = readConfig(configPath);
+	if (!config) return 1;
+	const remote = normalizeRemoteConfig(config.remote);
+	const store = createPairingsStore({ filePath: defaultPairingsPath(configPath) });
+	const seenStore = createSeenStore({ filePath: defaultSeenPath(configPath) });
+	if (args.includes("--list")) return runList(store, seenStore);
+	if (args.includes("--revoke")) {
+		const id = argValue(args, "--revoke");
+		if (!id) {
+			console.error("Usage: glimmervoid pair --revoke <device-id>");
+			return 1;
+		}
+		return runRevoke(store, id);
+	}
+	store.prunePending();
+	return runMint(store, remote, argValue(args, "--name"));
+}
+//#endregion
+export { runPairCli };

package/dist/chunks/path-doctor-C23VAqeu.js

@@ -0,0 +1,63 @@
+import path from "node:path";
+//#region bin/path-doctor.ts
+function isWin(platform) {
+	return platform === "win32";
+}
+function normalizeDir(dir, platform) {
+	if (!dir) return "";
+	let d = String(dir).trim();
+	if (d.length >= 2 && d.startsWith("\"") && d.endsWith("\"")) d = d.slice(1, -1);
+	d = d.replace(/[\\/]+$/, "");
+	if (d === "") return "";
+	return isWin(platform) ? d.toLowerCase() : d;
+}
+function onPath(dir, { pathEnv, platform } = {}) {
+	const target = normalizeDir(dir, platform);
+	if (!target) return false;
+	const sep = isWin(platform) ? ";" : ":";
+	for (const entry of String(pathEnv || "").split(sep)) if (normalizeDir(entry, platform) === target) return true;
+	return false;
+}
+function npmGlobalBinDir({ env = {}, platform, homedir, resolvedPrefix } = {}) {
+	const prefix = env.npm_config_prefix || resolvedPrefix || null;
+	if (isWin(platform)) {
+		if (prefix) return prefix;
+		if (homedir) return path.join(homedir, "AppData", "Roaming", "npm");
+		return null;
+	}
+	if (prefix) return path.join(prefix, "bin");
+	return null;
+}
+function pnpmGlobalBinDir({ env = {}, platform, homedir } = {}) {
+	if (env.PNPM_HOME) return env.PNPM_HOME;
+	if (!homedir) return null;
+	if (isWin(platform)) return path.join(homedir, "AppData", "Local", "pnpm");
+	return path.join(homedir, ".local", "share", "pnpm");
+}
+function formatPathNotice({ installedBinDir, onPathFlag, platform } = {}) {
+	const dir = installedBinDir || "(unknown)";
+	if (onPathFlag) return [
+		"glimmervoid installed. Its command directory is on your PATH:",
+		`  ${dir}`,
+		"Run \"glimmervoid\" to start, or \"glimmervoid doctor\" to check your setup."
+	].join("\n");
+	const lines = [
+		"glimmervoid was installed, but its command directory is NOT on your PATH:",
+		`  ${dir}`,
+		"That is why typing \"glimmervoid\" is not recognized yet. To fix it:"
+	];
+	if (isWin(platform)) {
+		lines.push("  In PowerShell (adds it to your user PATH, permanent):");
+		lines.push(`    [Environment]::SetEnvironmentVariable("PATH", [Environment]::GetEnvironmentVariable("PATH","User") + ";${dir}", "User")`);
+		lines.push("  Then open a NEW terminal and run \"glimmervoid\".");
+		lines.push("  (Reinstalling Node.js from the official installer also adds this directory for you.)");
+	}
+	if (!isWin(platform)) {
+		lines.push(`  Add to your shell profile:  export PATH="$PATH:${dir}"`);
+		lines.push("  Then open a new terminal and run \"glimmervoid\".");
+	}
+	lines.push("See the README \"Troubleshooting\" section for more, including pnpm setups.");
+	return lines.join("\n");
+}
+//#endregion
+export { pnpmGlobalBinDir as i, npmGlobalBinDir as n, onPath as r, formatPathNotice as t };

package/dist/chunks/refocus-core-BKQKllq7.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+//#region shared/contracts/refocus.ts
+var SessionStartHookResponse = z.object({ hookSpecificOutput: z.object({
+	hookEventName: z.literal("SessionStart"),
+	additionalContext: z.string()
+}) });
+//#endregion
+//#region session/core/refocus-core.ts
+function buildRefocusReminder({ taskTitle, latestPlanTitle }) {
+	const intentParts = [];
+	if (taskTitle?.trim()) intentParts.push(`Current task: "${taskTitle}".`);
+	if (latestPlanTitle?.trim()) intentParts.push(`Latest plan: "${latestPlanTitle}".`);
+	if (intentParts.length === 0) return null;
+	return `Context was just compacted. ${intentParts.join(" ")} Before your next step, check it still serves this intent and drop work that does not.`;
+}
+function refocusReplyFor({ accepted, event, payload, readContext }) {
+	if (!accepted) return null;
+	if (event.toLowerCase() !== "sessionstart") return null;
+	if (payload.source !== "compact") return null;
+	const additionalContext = buildRefocusReminder(readContext());
+	if (additionalContext === null) return null;
+	return { hookSpecificOutput: {
+		hookEventName: "SessionStart",
+		additionalContext
+	} };
+}
+function sessionStartContextOutput(body) {
+	if (body === null) return null;
+	try {
+		const parsedResponse = SessionStartHookResponse.safeParse(JSON.parse(body));
+		if (!parsedResponse.success) return null;
+		return JSON.stringify(parsedResponse.data);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { sessionStartContextOutput as n, refocusReplyFor as t };

package/dist/chunks/relay-stdin-CpHvLu6M.js

@@ -0,0 +1,20 @@
+//#region session/relay-stdin.ts
+function readStdin(stream) {
+	return new Promise((resolve) => {
+		const chunks = [];
+		let done = false;
+		const finish = () => {
+			if (done) return;
+			done = true;
+			resolve(Buffer.concat(chunks));
+		};
+		stream.on("data", (chunk) => {
+			chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk));
+		});
+		stream.on("end", finish);
+		stream.on("error", finish);
+		stream.on("close", finish);
+	});
+}
+//#endregion
+export { readStdin as t };