glimmervoid 0.0.0-stage → 0.29.1

package/dist/chunks/sandbox-deps-BwvbDBDl.js

@@ -0,0 +1,67 @@
+import { i as execSync } from "./child-process-safe-Cz22RwlG.js";
+import { r as resolvePathCommandMatches } from "./spawn-command-Cc40FiZI.js";
+//#region server/core/sandbox-deps-core.ts
+var LINUX_SANDBOX_BINARIES = Object.freeze(["bwrap", "socat"]);
+var NO_SANDBOX_BINARIES = Object.freeze([]);
+var SANDBOX_INSTALL_HINT = "Install bubblewrap and socat, for example: sudo apt install bubblewrap socat";
+var SANDBOXED_LANE_NAMES = Object.freeze([
+	"team review",
+	"Keep mergeable repairs",
+	"workflow sessions",
+	"benchmark runs"
+]);
+function requiredSandboxBinaries(platform) {
+	return platform === "linux" ? LINUX_SANDBOX_BINARIES : NO_SANDBOX_BINARIES;
+}
+function sandboxDependencyReport({ platform, binariesOnPath }) {
+	const requiredBinaries = requiredSandboxBinaries(platform);
+	const missingBinaries = requiredBinaries.filter((binary) => !binariesOnPath.has(binary));
+	return {
+		platform,
+		requiredBinaries,
+		missingBinaries,
+		installHint: missingBinaries.length > 0 ? SANDBOX_INSTALL_HINT : null
+	};
+}
+function missingBinariesPhrase(report) {
+	return `${report.missingBinaries.join(" and ")} ${report.missingBinaries.length === 1 ? "is" : "are"} not on PATH`;
+}
+function sandboxSpawnRefusal(report) {
+	if (report.missingBinaries.length === 0) return null;
+	return `not started: the Claude Code sandbox needs ${report.requiredBinaries.join(" and ")}, and ${missingBinariesPhrase(report)}. ${report.installHint}`;
+}
+function sandboxBootWarning(report) {
+	if (report.missingBinaries.length === 0) return null;
+	return `[sandbox] ${missingBinariesPhrase(report)}, so ${SANDBOXED_LANE_NAMES.join(", ")} will refuse to start sandboxed sessions. ${report.installHint}`;
+}
+function sandboxDoctorRows(report) {
+	if (report.requiredBinaries.length === 0) return [["sandbox", `nothing to check on ${report.platform}`]];
+	const binaryRows = report.requiredBinaries.map((binary) => [binary, report.missingBinaries.includes(binary) ? "MISSING" : "found"]);
+	if (report.installHint === null) return binaryRows;
+	return [...binaryRows, ["hint", report.installHint]];
+}
+function sandboxInstallNotice(report) {
+	if (report.installHint === null) return null;
+	return `glimmervoid: ${missingBinariesPhrase(report)}; team review, Keep mergeable, workflow sessions and benchmark runs need ${report.requiredBinaries.join(" and ")}. ${report.installHint}`;
+}
+//#endregion
+//#region server/sandbox-deps.ts
+function probeSandboxDependencies({ platform = process.platform, exec = execSync } = {}) {
+	return sandboxDependencyReport({
+		platform,
+		binariesOnPath: new Set(requiredSandboxBinaries(platform).filter((binary) => resolvePathCommandMatches(binary, {
+			platform,
+			exec
+		}).length > 0))
+	});
+}
+function checkSandboxDependencies({ probe = probeSandboxDependencies, log = console } = {}) {
+	const report = probe();
+	const warning = sandboxBootWarning(report);
+	if (warning !== null) log.warn(warning);
+	const refusal = sandboxSpawnRefusal(report);
+	return () => refusal;
+}
+var allowSandboxedSpawn = () => null;
+//#endregion
+export { sandboxInstallNotice as a, sandboxDoctorRows as i, checkSandboxDependencies as n, probeSandboxDependencies as r, allowSandboxedSpawn as t };

package/dist/chunks/session-CJtOveHl.js

@@ -0,0 +1,162 @@
+import { z } from "zod";
+//#region shared/states.ts
+var STATES = Object.freeze({
+	DORMANT: "DORMANT",
+	INITIALIZING: "INITIALIZING",
+	STARTING: "STARTING",
+	RUNNING: "RUNNING",
+	WAITING: "WAITING",
+	IDLE: "IDLE",
+	COMPLETE: "COMPLETE",
+	DONE: "DONE",
+	FAILED: "FAILED"
+});
+Object.freeze({
+	[STATES.DORMANT]: "Dormant",
+	[STATES.INITIALIZING]: "Preparing",
+	[STATES.STARTING]: "Starting",
+	[STATES.RUNNING]: "Working",
+	[STATES.WAITING]: "Needs Input",
+	[STATES.IDLE]: "Idle",
+	[STATES.COMPLETE]: "Complete",
+	[STATES.DONE]: "Exited",
+	[STATES.FAILED]: "Failed"
+});
+Object.freeze({
+	[STATES.DORMANT]: "○",
+	[STATES.INITIALIZING]: "◌",
+	[STATES.STARTING]: "◐",
+	[STATES.RUNNING]: "●",
+	[STATES.WAITING]: "◆",
+	[STATES.IDLE]: "◍",
+	[STATES.FAILED]: "▲",
+	[STATES.DONE]: "■",
+	[STATES.COMPLETE]: "◇"
+});
+var KILLABLE_STATES = Object.freeze([
+	STATES.INITIALIZING,
+	STATES.STARTING,
+	STATES.RUNNING,
+	STATES.WAITING,
+	STATES.IDLE,
+	STATES.COMPLETE
+]);
+var RESTARTABLE_STATES = Object.freeze([STATES.DONE, STATES.FAILED]);
+var MERGEABLE_LIVE_STATES = Object.freeze([
+	STATES.WAITING,
+	STATES.IDLE,
+	STATES.COMPLETE
+]);
+var DETAIL_FIELD_BY_TOOL = Object.freeze({
+	Bash: "command",
+	Read: "file_path",
+	Edit: "file_path",
+	MultiEdit: "file_path",
+	Write: "file_path",
+	NotebookEdit: "notebook_path",
+	Grep: "pattern",
+	Glob: "pattern",
+	WebFetch: "url",
+	WebSearch: "query",
+	Task: "description",
+	Agent: "description",
+	Skill: "skill"
+});
+function firstDetailLine(text) {
+	const line = text.split(/\r?\n/, 1)[0]?.trim() ?? "";
+	if (line.length <= 160) return line;
+	return `${line.slice(0, 157)}...`;
+}
+function toolDetailFieldValue(toolName, toolInput) {
+	const field = DETAIL_FIELD_BY_TOOL[toolName];
+	if (!field) return null;
+	if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) return null;
+	const value = toolInput[field];
+	return typeof value === "string" ? value : null;
+}
+function toolDetailLine(toolName, toolInput) {
+	const fieldValue = toolDetailFieldValue(toolName, toolInput);
+	return fieldValue === null ? "" : firstDetailLine(fieldValue);
+}
+var TASK_TITLE_CONTROL_CHARACTERS = /[\x00-\x1f\x7f-\x9f]/;
+var PROMPT_DETAIL_HIDDEN_CHARACTERS = new RegExp(`${TASK_TITLE_CONTROL_CHARACTERS.source}|[\\p{Cf}\\u2028\\u2029]`, "u");
+var TaskTitle = z.string().refine((title) => !TASK_TITLE_CONTROL_CHARACTERS.test(title)).trim().max(120);
+var SessionState = z.enum(STATES);
+var PendingWakeup = z.object({
+	at: z.number().finite().nullable(),
+	kind: z.string(),
+	reason: z.string().nullable()
+}).passthrough();
+var ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion";
+var hasNoHiddenCharacters = (text) => !PROMPT_DETAIL_HIDDEN_CHARACTERS.test(text);
+var PendingPromptQuestion = z.object({
+	text: z.string().min(1).max(300).refine(hasNoHiddenCharacters),
+	options: z.array(z.string().min(1).max(80).refine(hasNoHiddenCharacters)).min(1).max(8),
+	multiSelect: z.boolean()
+});
+var PendingPromptDetail = z.object({
+	toolName: z.string().max(160),
+	summary: z.string().max(160),
+	isComplete: z.boolean(),
+	question: PendingPromptQuestion.nullable().optional()
+});
+var SessionSnapshot = z.object({
+	id: z.string(),
+	name: z.string(),
+	taskTitle: TaskTitle.nullable().default(null),
+	taskTitleIsCustom: z.boolean().default(false),
+	path: z.string(),
+	agent: z.string(),
+	state: SessionState,
+	stateSince: z.number(),
+	sleeping: z.boolean(),
+	dangerouslySkipPermissions: z.boolean(),
+	ephemeral: z.boolean(),
+	isWorktree: z.boolean(),
+	isWorkspace: z.boolean().default(false),
+	resumeSessionId: z.string().nullable(),
+	activeAgents: z.number().int().nonnegative(),
+	awaitingBackgroundTasks: z.boolean(),
+	hasEndedTurn: z.boolean().default(false),
+	pendingWakeup: PendingWakeup.nullable(),
+	pendingPromptKind: z.string().nullable(),
+	pendingPromptDetail: PendingPromptDetail.nullable().default(null),
+	hasPlan: z.boolean().default(false),
+	mergeStatus: z.string().nullable(),
+	mergeReason: z.string().nullable(),
+	worktreeNotice: z.string().nullable(),
+	effectiveBase: z.string().nullable(),
+	auditLog: z.array(z.unknown())
+}).passthrough();
+function isSamePromptQuestion(left, right) {
+	if (!left || !right) return !left && !right;
+	return left.text === right.text && left.multiSelect === right.multiSelect && left.options.length === right.options.length && left.options.every((option, index) => option === right.options[index]);
+}
+var AGENT_URL_ENV = "GLIMMERVOID_AGENT_URL";
+var AGENT_API_VERBS = [
+	"spawn",
+	"attention",
+	"board"
+];
+var AgentSpawnRequest = z.object({
+	prompt: z.string({ error: "prompt must be a string" }).min(1, { error: "prompt must not be empty" }).max(2e4, { error: "prompt must be at most 20000 characters" }).refine((prompt) => !prompt.trimStart().startsWith("-"), { message: "prompt must not start with a dash, which the agent CLI would read as an option" }),
+	name: z.string({ error: "name must be a string" }).min(1, { error: "name must not be empty" }).max(200, { error: "name must be at most 200 characters" }).optional(),
+	agent: z.string({ error: "agent must be a string" }).min(1, { error: "agent must not be empty" }).max(40, { error: "agent must be at most 40 characters" }).optional()
+}).strict();
+var AgentAttentionRequest = z.object({ note: z.string({ error: "note must be a string" }).min(1, { error: "note must not be empty" }).max(500, { error: "note must be at most 500 characters" }) }).strict();
+z.union([z.object({
+	ok: z.literal(true),
+	pending: z.boolean()
+}).strict(), z.object({
+	ok: z.literal(false),
+	error: z.string()
+}).strict()]);
+z.object({
+	id: SessionSnapshot.shape.id,
+	name: SessionSnapshot.shape.name,
+	agent: SessionSnapshot.shape.agent,
+	state: SessionSnapshot.shape.state,
+	ephemeral: SessionSnapshot.shape.ephemeral
+}).strict();
+//#endregion
+export { toolDetailLine as _, AgentSpawnRequest as a, RESTARTABLE_STATES as b, PendingPromptQuestion as c, SessionState as d, TASK_TITLE_CONTROL_CHARACTERS as f, toolDetailFieldValue as g, firstDetailLine as h, AgentAttentionRequest as i, PendingWakeup as l, isSamePromptQuestion as m, AGENT_URL_ENV as n, PROMPT_DETAIL_HIDDEN_CHARACTERS as o, TaskTitle as p, ASK_USER_QUESTION_TOOL_NAME as r, PendingPromptDetail as s, AGENT_API_VERBS as t, SessionSnapshot as u, KILLABLE_STATES as v, STATES as x, MERGEABLE_LIVE_STATES as y };

package/dist/chunks/spawn-command-Cc40FiZI.js

@@ -0,0 +1,134 @@
+import path from "node:path";
+//#region session/core/spawn-command.ts
+function classifyCommandKind(resolvedPath) {
+	if (!resolvedPath) return "unresolved";
+	const ext = (resolvedPath.match(/\.[^.\\/]+$/) || [""])[0].toLowerCase();
+	return ext === ".exe" || ext === ".com" ? "exe" : "shim";
+}
+function dedupePathMatches(matches, platform = process.platform) {
+	const pathApi = platform === "win32" ? path.win32 : path.posix;
+	const seen = /* @__PURE__ */ new Set();
+	const unique = [];
+	for (const candidate of matches) {
+		let normalized = pathApi.normalize(candidate.trim());
+		if (normalized.length > 1) normalized = normalized.replace(/[\\/]+$/, "");
+		const key = platform === "win32" ? normalized.toLowerCase() : normalized;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		unique.push(normalized);
+	}
+	return unique;
+}
+var PATH_PROBE_OPTIONS = {
+	encoding: "utf8",
+	stdio: [
+		"ignore",
+		"pipe",
+		"ignore"
+	],
+	timeout: 2e3
+};
+function pathProbesFor(name, platform) {
+	if (platform === "win32") return [{
+		shellCommand: `where ${name}`,
+		file: "where",
+		args: [name]
+	}];
+	return [{
+		shellCommand: `which -a ${name}`,
+		file: "which",
+		args: ["-a", name]
+	}, {
+		shellCommand: `sh -c "command -v ${name}"`,
+		file: "sh",
+		args: [
+			"-c",
+			"command -v \"$1\"",
+			"sh",
+			name
+		]
+	}];
+}
+function resolveCommandMatches(name, { platform, runProbe }) {
+	for (const probe of pathProbesFor(name, platform)) {
+		let matches = [];
+		try {
+			matches = dedupePathMatches(runProbe(probe).split(/\r?\n/).filter((line) => line.trim()), platform);
+		} catch {
+			matches = [];
+		}
+		if (matches.length > 0) return matches;
+	}
+	return [];
+}
+function resolvePathCommandMatches(name, { platform, exec }) {
+	return resolveCommandMatches(name, {
+		platform,
+		runProbe: (probe) => exec(probe.shellCommand, PATH_PROBE_OPTIONS)
+	});
+}
+function resolveArgvCommandMatches(name, { platform, execFile }) {
+	return resolveCommandMatches(name, {
+		platform,
+		runProbe: (probe) => execFile(probe.file, probe.args, PATH_PROBE_OPTIONS)
+	});
+}
+function isAbsoluteCommandPath(name, platform) {
+	return (platform === "win32" ? path.win32 : path.posix).isAbsolute(name);
+}
+function resolveAgentCommand({ name, platform = process.platform, execFile, pathExists }) {
+	if (isAbsoluteCommandPath(name, platform)) {
+		if (typeof pathExists !== "function") throw new TypeError("resolveAgentCommand requires a pathExists probe for an absolute command");
+		if (pathExists(name)) return {
+			path: name,
+			kind: classifyCommandKind(name)
+		};
+		console.warn(`[glimmervoid] could not resolve '${name}'`);
+		return {
+			path: null,
+			kind: "unresolved"
+		};
+	}
+	if (typeof execFile !== "function") throw new TypeError("resolveAgentCommand requires an execFile function");
+	const matches = resolveArgvCommandMatches(name, {
+		platform,
+		execFile
+	});
+	if (matches.length === 0) {
+		console.warn(`[glimmervoid] could not resolve '${name}'`);
+		return {
+			path: null,
+			kind: "unresolved"
+		};
+	}
+	const resolvedPath = matches[0];
+	if (process.env.GLIMMERVOID_DEBUG_SPAWN) console.log(`[glimmervoid] resolved '${name}' (first match wins): ${resolvedPath}`);
+	if (matches.length > 1) console.warn(`[glimmervoid] multiple '${name}' on PATH (Bun shim risk):\n  ${matches.join("\n  ")}`);
+	const kind = classifyCommandKind(resolvedPath);
+	if (platform === "win32") console.log(`[glimmervoid] ${name} spawn strategy: ${kind === "exe" ? "direct exe" : "cmd.exe shim fallback"}`);
+	return {
+		path: resolvedPath,
+		kind
+	};
+}
+function buildAgentSpawnCommand({ name, platform, resolved, argGroups = [] }) {
+	const childArgs = argGroups.flatMap((group) => group || []);
+	if (platform !== "win32") return {
+		file: name,
+		args: childArgs
+	};
+	if (resolved && resolved.kind === "exe" && resolved.path) return {
+		file: resolved.path,
+		args: childArgs
+	};
+	return {
+		file: "cmd.exe",
+		args: [
+			"/c",
+			name,
+			...childArgs
+		]
+	};
+}
+//#endregion
+export { resolveAgentCommand as n, resolvePathCommandMatches as r, buildAgentSpawnCommand as t };

package/dist/chunks/visions-cli-DUZnopGY.js

@@ -0,0 +1,98 @@
+import { t as renderTable } from "./ascii-figure-core-pDAwtlKO.js";
+import { a as relayInvocationOptions, c as unwireEverything, d as extensionIdOf, f as buildSetupGuide, h as isExtensionInstalled, i as packVsix, l as wireEverything, m as recipeIds, o as resolveRelayInvocation, p as commandLine, r as editorExtensions, s as resolvedEditorPaths, t as RELAY_PATH, u as editorTargets } from "./visions-setup-C_kJobsy.js";
+import fs from "node:fs";
+//#region server/visions-cli.ts
+function fileOutcomeRows(files) {
+	return files.map((file) => [file.label, `${file.action}: ${file.filePath}`]);
+}
+async function runInstall(args) {
+	const requestedIndex = args.indexOf("--editor");
+	const requested = requestedIndex >= 0 ? args[requestedIndex + 1] || null : null;
+	const report = await wireEverything({ requested });
+	if (!report.ok) {
+		console.error(`visions install: ${report.reason}`);
+		return 1;
+	}
+	const rows = [];
+	for (const result of report.extensions.results) rows.push([result.label, result.ok ? "extension installed" : `FAILED: ${result.detail}`]);
+	if (report.extensions.results.length === 0) rows.push(["VS Code family", report.extensions.reason]);
+	rows.push(...fileOutcomeRows(report.files));
+	console.log(renderTable({
+		title: "Visions install",
+		rows,
+		terminalColumns: process.stdout.columns
+	}));
+	console.log(`\nrelay ${report.invocation ? commandLine(report.invocation) : "(unresolved)"}`);
+	console.log("reload any open editor window, then open a markdown file inside a project the daemon knows.");
+	return report.extensions.results.some((result) => !result.ok) ? 1 : 0;
+}
+async function runUninstall() {
+	const report = await unwireEverything();
+	const rows = [];
+	for (const result of report.extensions.results) rows.push([result.label, result.ok ? `extension ${result.detail}` : `FAILED: ${result.detail}`]);
+	rows.push(...fileOutcomeRows(report.files));
+	console.log(renderTable({
+		title: "Visions uninstall",
+		rows,
+		terminalColumns: process.stdout.columns
+	}));
+	return 0;
+}
+async function runStatus() {
+	const { manifest } = packVsix();
+	const extensionId = extensionIdOf(manifest);
+	const editors = Object.entries(resolvedEditorPaths());
+	const rows = [["relay", fs.existsSync(RELAY_PATH) ? commandLine(resolveRelayInvocation()) : `MISSING: ${RELAY_PATH}`], ["extension", `${extensionId} ${manifest.version}`]];
+	if (editors.length === 0) rows.push(["VS Code family", "none found on PATH or on disk"]);
+	for (const [command, commandPath] of editors) {
+		const installed = isExtensionInstalled(await editorExtensions(commandPath), extensionId);
+		rows.push([command, installed ? "extension installed" : "not installed"]);
+	}
+	for (const target of editorTargets()) rows.push([target.label, `${fs.existsSync(target.filePath) ? "wired" : "not wired"}: ${target.filePath}`]);
+	console.log(renderTable({
+		title: "Visions status",
+		rows,
+		terminalColumns: process.stdout.columns
+	}));
+	return 0;
+}
+async function runRelay() {
+	const { createRelay } = await import("../session/visions-relay.js");
+	createRelay().start();
+	return new Promise(() => {});
+}
+function runSetup(args) {
+	const editorIndex = args.indexOf("--editor");
+	const editorId = editorIndex >= 0 ? args[editorIndex + 1] || null : null;
+	const { chosen: invocation, absolute, onPath } = relayInvocationOptions();
+	const guide = buildSetupGuide({
+		editorId,
+		invocation
+	});
+	if (!guide.ok) {
+		console.error(`visions setup: ${guide.reason} (known: ${recipeIds().join(", ")})`);
+		return 1;
+	}
+	console.log(`The Visions relay is one stdio LSP server: ${commandLine(invocation)}`);
+	if (onPath) console.log(`An editor launched from a desktop menu may not see your PATH; there, use: ${commandLine(absolute)}`);
+	console.log("Turning Visions on wires these for you; this is the manual form.\n");
+	for (const section of guide.sections) {
+		console.log(`${section.label}  (${section.where})`);
+		console.log(`${section.snippet}\n`);
+	}
+	console.log("Findings reach the dashboard Visions tab whichever client mirrors the buffer.");
+	console.log("The relay tries port 5173 then 3000; GLIMMERVOID_PORT or --port names another one.");
+	return 0;
+}
+async function runVisionsCli(args = []) {
+	const command = args[0];
+	if (command === "relay") return runRelay();
+	if (command === "install") return runInstall(args.slice(1));
+	if (command === "uninstall") return runUninstall();
+	if (command === "setup") return runSetup(args.slice(1));
+	if (command === "status") return runStatus();
+	console.error("Usage: glimmervoid visions relay\n       glimmervoid visions install [--editor <command>]\n       glimmervoid visions uninstall\n       glimmervoid visions setup [--editor <id>]\n       glimmervoid visions status");
+	return 1;
+}
+//#endregion
+export { runVisionsCli };