glimmervoid 0.0.0-stage → 0.30.0

package/dist/session/visions-relay.js

@@ -0,0 +1,627 @@
+import { n as glimmervoidHomeDir, t as decideConfigPath } from "../chunks/config-path-core-DFt-TemS.js";
+import { _ as listDocs, b as uriOfParams, c as applyDidChange, d as createDocStore, l as applyDidClose, m as getDoc, p as formatRange, t as ACTIVITY_METHOD, u as applyDidOpen } from "../chunks/ingest-editor-core-BuI1gMF_.js";
+import fs from "node:fs";
+import os from "node:os";
+import WebSocket from "ws";
+//#region server/core/visions-lsp-core.ts
+var HEADER_END = "\r\n\r\n";
+var CONTENT_LENGTH_RE = /^content-length:\s*(\d+)\s*$/i;
+function createParserState() {
+	return {
+		buffer: Buffer.alloc(0),
+		neededBodyBytes: null
+	};
+}
+function feedFrameBytes(state, chunk) {
+	const nextState = state || createParserState();
+	nextState.buffer = Buffer.concat([nextState.buffer, chunk]);
+	const messages = [];
+	while (true) {
+		const bodyBytes = readNeededBodyBytes(nextState);
+		if (bodyBytes === null) break;
+		if (typeof bodyBytes !== "number") {
+			messages.push(bodyBytes);
+			nextState.neededBodyBytes = null;
+			continue;
+		}
+		if (nextState.buffer.length < bodyBytes) break;
+		const body = nextState.buffer.subarray(0, bodyBytes);
+		nextState.buffer = nextState.buffer.subarray(bodyBytes);
+		nextState.neededBodyBytes = null;
+		messages.push(parseBody(body));
+	}
+	return {
+		state: nextState,
+		messages
+	};
+}
+function readNeededBodyBytes(state) {
+	if (state.neededBodyBytes !== null) return state.neededBodyBytes;
+	const headerEndAt = state.buffer.indexOf(HEADER_END);
+	if (headerEndAt === -1) return null;
+	const headerText = state.buffer.subarray(0, headerEndAt).toString("ascii");
+	state.buffer = state.buffer.subarray(headerEndAt + 4);
+	const contentLength = contentLengthFromHeader(headerText);
+	if (contentLength === null) {
+		state.buffer = Buffer.alloc(0);
+		return {
+			parseError: true,
+			reason: "missing-content-length",
+			raw: headerText
+		};
+	}
+	state.neededBodyBytes = contentLength;
+	return state.neededBodyBytes;
+}
+function contentLengthFromHeader(headerText) {
+	const lines = headerText.split("\r\n");
+	for (const line of lines) {
+		const match = line.match(CONTENT_LENGTH_RE);
+		if (!match) continue;
+		return Number(match[1]);
+	}
+	return null;
+}
+function parseBody(body) {
+	const raw = body.toString("utf8");
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return {
+			parseError: true,
+			raw
+		};
+	}
+}
+function serializeFrame(messageObject) {
+	const body = JSON.stringify(messageObject);
+	const bodyBytes = Buffer.byteLength(body, "utf8");
+	return Buffer.from(`Content-Length: ${bodyBytes}\r\n\r\n${body}`, "utf8");
+}
+function classifyMessage(msg) {
+	if (!msg || typeof msg !== "object") return {
+		kind: "invalid",
+		method: void 0,
+		id: void 0
+	};
+	const fields = msg;
+	const hasMethod = typeof fields.method === "string";
+	const hasId = Object.hasOwn(msg, "id");
+	const method = typeof fields.method === "string" ? fields.method : void 0;
+	if (hasMethod && hasId) return {
+		kind: "request",
+		method,
+		id: fields.id
+	};
+	if (hasMethod) return {
+		kind: "notification",
+		method,
+		id: void 0
+	};
+	if (hasId) return {
+		kind: "response",
+		method: void 0,
+		id: fields.id
+	};
+	return {
+		kind: "invalid",
+		method: void 0,
+		id: void 0
+	};
+}
+//#endregion
+//#region session/core/visions-relay-core.ts
+var MAX_DAEMON_FRAME_BYTES = 2097152;
+function daemonMessage(method, params) {
+	return {
+		type: "lsp",
+		method,
+		params
+	};
+}
+function replayDidOpenMessage(doc) {
+	return daemonMessage("textDocument/didOpen", { textDocument: {
+		uri: doc.uri,
+		languageId: doc.languageId,
+		version: doc.version,
+		text: doc.text
+	} });
+}
+function decideDaemonFrame(payload, maxFrameBytes = MAX_DAEMON_FRAME_BYTES) {
+	const serialized = JSON.stringify(payload);
+	const frameBytes = Buffer.byteLength(serialized, "utf8");
+	return {
+		send: frameBytes <= maxFrameBytes,
+		serialized,
+		frameBytes
+	};
+}
+function planMirrorReplay(documents, maxFrameBytes = MAX_DAEMON_FRAME_BYTES) {
+	const frames = [];
+	const skipped = [];
+	const mirrorDocuments = Array.isArray(documents) ? documents : [];
+	for (const doc of mirrorDocuments) {
+		const message = replayDidOpenMessage(doc);
+		const decision = decideDaemonFrame(message, maxFrameBytes);
+		if (!decision.send) {
+			skipped.push({
+				uri: doc.uri,
+				frameBytes: decision.frameBytes
+			});
+			continue;
+		}
+		frames.push({
+			uri: doc.uri,
+			message,
+			serialized: decision.serialized
+		});
+	}
+	return {
+		frames,
+		skipped
+	};
+}
+function decideMirrorSync({ method, isUnsynced, originalFrameFits, fullFrameFits }) {
+	if (method === "textDocument/didClose") return {
+		actions: isUnsynced ? [] : ["original"],
+		forgetUnsynced: true,
+		markUnsynced: false,
+		shouldLog: false
+	};
+	if (isUnsynced && !fullFrameFits) return {
+		actions: [],
+		forgetUnsynced: false,
+		markUnsynced: false,
+		shouldLog: false
+	};
+	if (isUnsynced) return {
+		actions: ["full-open"],
+		forgetUnsynced: false,
+		markUnsynced: false,
+		shouldLog: false
+	};
+	if (originalFrameFits) return {
+		actions: ["original"],
+		forgetUnsynced: false,
+		markUnsynced: false,
+		shouldLog: false
+	};
+	return {
+		actions: fullFrameFits ? ["close", "full-open"] : ["close"],
+		forgetUnsynced: false,
+		markUnsynced: true,
+		shouldLog: true
+	};
+}
+//#endregion
+//#region session/visions-relay.ts
+var DEFAULT_PORTS = [5173, 3e3];
+var MAX_PENDING_FORWARDS = 50;
+var INITIAL_RETRY_MS = 500;
+var MAX_RETRY_MS = 5e3;
+var STABLE_CONNECTION_MS = 5e3;
+var METHOD_NOT_FOUND = -32601;
+var MIRROR_METHODS = /* @__PURE__ */ new Set([
+	"textDocument/didOpen",
+	"textDocument/didChange",
+	"textDocument/didClose"
+]);
+var FORWARDED_METHODS = /* @__PURE__ */ new Set([
+	...MIRROR_METHODS,
+	"textDocument/didSave",
+	ACTIVITY_METHOD
+]);
+var CODE_ACTION_METHOD = "textDocument/codeAction";
+var APPLY_EDIT_METHOD = "workspace/applyEdit";
+var CODE_ACTION_TIMEOUT_MS = 2e3;
+function asDocumentParams(params) {
+	if (params && typeof params === "object" && !Array.isArray(params)) return params;
+	return null;
+}
+function parsePortValue(value) {
+	const port = Number(value);
+	if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+	return port;
+}
+function resolvePortPlan(argv = [], env = process.env, configPort = null) {
+	const flagIndex = argv.indexOf("--port");
+	const flagPort = flagIndex >= 0 ? parsePortValue(argv[flagIndex + 1]) : null;
+	if (flagPort !== null) return {
+		ports: [flagPort],
+		isFixed: true
+	};
+	const envPort = parsePortValue(env.GLIMMERVOID_PORT);
+	if (envPort !== null) return {
+		ports: [envPort],
+		isFixed: true
+	};
+	const configured = parsePortValue(configPort);
+	if (configured === null) return {
+		ports: DEFAULT_PORTS.slice(),
+		isFixed: false
+	};
+	return {
+		ports: [configured, ...DEFAULT_PORTS.filter((port) => port !== configured)],
+		isFixed: false
+	};
+}
+function readConfiguredPort(env = process.env, fsApi = fs) {
+	const decided = decideConfigPath({
+		env,
+		homeDir: glimmervoidHomeDir(os.homedir(), env)
+	}, (candidate) => {
+		try {
+			return fsApi.existsSync(candidate);
+		} catch {
+			return false;
+		}
+	});
+	if (!decided.path) return null;
+	try {
+		const parsed = JSON.parse(fsApi.readFileSync(decided.path, "utf8"));
+		if (parsed && typeof parsed === "object") return parsed.port ?? null;
+		return null;
+	} catch {
+		return null;
+	}
+}
+function nextDelayMs(currentDelayMs) {
+	return Math.min(currentDelayMs * 2, MAX_RETRY_MS);
+}
+var SYNC_KIND_INCREMENTAL = 2;
+function initializeResult() {
+	return {
+		capabilities: {
+			textDocumentSync: {
+				openClose: true,
+				change: 2
+			},
+			codeActionProvider: true
+		},
+		serverInfo: { name: "glimmervoid-visions" }
+	};
+}
+function methodNotFoundResponse(id, method) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: {
+			code: METHOD_NOT_FOUND,
+			message: "Method not found",
+			data: { method }
+		}
+	};
+}
+function responseMessage(id, result) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result
+	};
+}
+function editorNotification(method, params) {
+	return {
+		jsonrpc: "2.0",
+		method,
+		params
+	};
+}
+function daemonRequest(id, method, params) {
+	return {
+		type: "lsp-request",
+		id,
+		method,
+		params
+	};
+}
+function daemonResponse(id, result) {
+	return {
+		type: "lsp-response",
+		id,
+		result
+	};
+}
+function editorRequest(id, method, params) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		method,
+		params
+	};
+}
+function mirrorFailureDetail(update) {
+	if (update.reason === "invalid-range" || update.reason === "invalid-text") return ` change=${update.index} range=${formatRange(update.range)}`;
+	if (update.reason === "stale-version") return ` version=${update.version} current=${update.currentVersion}`;
+	return "";
+}
+function sendWsFrame(ws, decision) {
+	if (!ws || ws.readyState !== WebSocket.OPEN) return false;
+	if (!decision.send) return false;
+	ws.send(decision.serialized);
+	return true;
+}
+function sendWsJson(ws, payload) {
+	return sendWsFrame(ws, {
+		send: true,
+		serialized: JSON.stringify(payload)
+	});
+}
+function createRelay({ argv = process.argv.slice(2), env = process.env, stdin = process.stdin, stdout = process.stdout, stderr = process.stderr } = {}) {
+	const portPlan = resolvePortPlan(argv, env, readConfiguredPort(env));
+	const docStore = createDocStore();
+	let parserState = createParserState();
+	let ws = null;
+	let retryTimer = null;
+	let stableConnectionTimer = null;
+	let retryMs = INITIAL_RETRY_MS;
+	let nextPortIndex = 0;
+	let isStopping = false;
+	const pendingCodeActionById = /* @__PURE__ */ new Map();
+	const applyEditDaemonIdByEditorId = /* @__PURE__ */ new Map();
+	const unsyncedUris = /* @__PURE__ */ new Set();
+	const pendingForwards = [];
+	let nextEditorRequestId = 1;
+	function note(message) {
+		stderr.write(`[visions-relay] ${message}\n`);
+	}
+	function writeEditorMessage(message) {
+		stdout.write(serializeFrame(message));
+	}
+	function currentPort() {
+		const port = portPlan.ports[nextPortIndex % portPlan.ports.length];
+		nextPortIndex++;
+		return port;
+	}
+	function clearRetryTimer() {
+		if (!retryTimer) return;
+		clearTimeout(retryTimer);
+		retryTimer = null;
+	}
+	function clearStableConnectionTimer() {
+		if (!stableConnectionTimer) return;
+		clearTimeout(stableConnectionTimer);
+		stableConnectionTimer = null;
+	}
+	function scheduleReconnect(port) {
+		if (isStopping || retryTimer) return;
+		note(`lost the daemon on port ${port}; reconnecting in ${retryMs}ms`);
+		retryTimer = setTimeout(() => {
+			retryTimer = null;
+			connect();
+		}, retryMs);
+		retryTimer.unref?.();
+		retryMs = nextDelayMs(retryMs);
+	}
+	function forwardNotification(method, params) {
+		const message = daemonMessage(method, params);
+		if (sendWsJson(ws, message)) return true;
+		pendingForwards.push(message);
+		if (pendingForwards.length > MAX_PENDING_FORWARDS) pendingForwards.shift();
+		return false;
+	}
+	function flushPendingForwards() {
+		let sent = 0;
+		while (pendingForwards.length > 0) {
+			if (!sendWsJson(ws, pendingForwards[0])) return sent;
+			pendingForwards.shift();
+			sent += 1;
+		}
+		return sent;
+	}
+	function replayMirror(socket) {
+		const replay = planMirrorReplay(listDocs(docStore));
+		for (const frame of replay.frames) {
+			socket.send(frame.serialized);
+			unsyncedUris.delete(frame.uri);
+		}
+		for (const skipped of replay.skipped) {
+			sendWsJson(socket, daemonMessage("textDocument/didClose", { textDocument: { uri: skipped.uri } }));
+			if (!unsyncedUris.has(skipped.uri)) note(`mirror unsynced uri=${skipped.uri}: ${skipped.frameBytes} bytes exceeds ${MAX_DAEMON_FRAME_BYTES}`);
+			unsyncedUris.add(skipped.uri);
+		}
+		return replay;
+	}
+	function connect() {
+		if (isStopping) return;
+		const port = currentPort();
+		const socket = new WebSocket(`ws://127.0.0.1:${port}/visions`);
+		ws = socket;
+		socket.on("open", () => {
+			if (ws !== socket) return;
+			clearStableConnectionTimer();
+			stableConnectionTimer = setTimeout(() => {
+				if (ws !== socket) return;
+				retryMs = INITIAL_RETRY_MS;
+				stableConnectionTimer = null;
+			}, STABLE_CONNECTION_MS);
+			stableConnectionTimer.unref?.();
+			const replay = replayMirror(socket);
+			const forwarded = flushPendingForwards();
+			note(`connected to the daemon on port ${port} (replayed ${replay.frames.length} mirrored documents, skipped ${replay.skipped.length}, ${forwarded} held markers)`);
+		});
+		socket.on("message", (data, isBinary) => {
+			if (isBinary) return;
+			handleDaemonText(data.toString("utf8"));
+		});
+		socket.on("error", () => {});
+		socket.on("close", () => {
+			if (ws === socket) ws = null;
+			clearStableConnectionTimer();
+			failPendingCodeActions();
+			applyEditDaemonIdByEditorId.clear();
+			scheduleReconnect(port);
+		});
+	}
+	function settleCodeAction(id, result) {
+		if (!pendingCodeActionById.has(id)) return false;
+		const timer = pendingCodeActionById.get(id);
+		pendingCodeActionById.delete(id);
+		if (timer) clearTimeout(timer);
+		writeEditorMessage(responseMessage(id, result));
+		return true;
+	}
+	function failPendingCodeActions() {
+		for (const id of [...pendingCodeActionById.keys()]) settleCodeAction(id, null);
+	}
+	function forwardCodeAction(id, params) {
+		if (!sendWsJson(ws, daemonRequest(id, "textDocument/codeAction", params))) {
+			writeEditorMessage(responseMessage(id, null));
+			return;
+		}
+		const timer = setTimeout(() => settleCodeAction(id, null), CODE_ACTION_TIMEOUT_MS);
+		timer.unref?.();
+		pendingCodeActionById.set(id, timer);
+	}
+	function forwardApplyEdit(daemonId, params) {
+		const editorId = `glimmervoid-visions-${nextEditorRequestId}`;
+		nextEditorRequestId += 1;
+		applyEditDaemonIdByEditorId.set(editorId, daemonId);
+		writeEditorMessage(editorRequest(editorId, APPLY_EDIT_METHOD, params));
+	}
+	function handleEditorResponse(editorId, msg) {
+		if (typeof editorId !== "string" || !applyEditDaemonIdByEditorId.has(editorId)) return;
+		const daemonId = applyEditDaemonIdByEditorId.get(editorId);
+		applyEditDaemonIdByEditorId.delete(editorId);
+		const refused = "error" in msg ? msg.error : void 0;
+		const result = "result" in msg ? msg.result : void 0;
+		sendWsJson(ws, daemonResponse(daemonId, refused ? { applied: false } : result));
+	}
+	function stop(exitCode = 0) {
+		if (isStopping) return;
+		isStopping = true;
+		note(`shutting down (exit ${exitCode})`);
+		clearRetryTimer();
+		clearStableConnectionTimer();
+		stdin.pause();
+		if (ws) ws.close();
+		setImmediate(() => process.exit(exitCode));
+	}
+	function handleDaemonText(text) {
+		let msg = null;
+		try {
+			msg = JSON.parse(text);
+		} catch {
+			return;
+		}
+		if (!msg || typeof msg !== "object") return;
+		if (msg.type === "publishDiagnostics") {
+			writeEditorMessage(editorNotification("textDocument/publishDiagnostics", msg.params));
+			return;
+		}
+		if (msg.type === "lsp-response") {
+			settleCodeAction(msg.id, msg.result);
+			return;
+		}
+		if (msg.type === "lsp-request" && msg.method === "workspace/applyEdit") forwardApplyEdit(msg.id, msg.params);
+	}
+	function updateMirror(method, params) {
+		const documentParams = asDocumentParams(params);
+		if (method === "textDocument/didOpen") return applyDidOpen(docStore, documentParams);
+		if (method === "textDocument/didChange") return applyDidChange(docStore, documentParams);
+		if (method === "textDocument/didClose") return applyDidClose(docStore, documentParams);
+		return {
+			applied: false,
+			reason: "not-buffer-method"
+		};
+	}
+	function sendMirrorNotification(method, params, mirrorUpdate) {
+		const uri = uriOfParams(asDocumentParams(params));
+		const originalMessage = daemonMessage(method, params);
+		if (!uri) return sendWsJson(ws, originalMessage);
+		const isUnsynced = unsyncedUris.has(uri);
+		if (!mirrorUpdate.applied && !isUnsynced) return sendWsJson(ws, originalMessage);
+		if (!mirrorUpdate.applied && method === "textDocument/didClose") {
+			unsyncedUris.delete(uri);
+			return false;
+		}
+		if (!mirrorUpdate.applied) return false;
+		const originalFrame = decideDaemonFrame(originalMessage);
+		const doc = method !== "textDocument/didClose" && (isUnsynced || !originalFrame.send) ? getDoc(docStore, uri) : null;
+		const fullOpenMessage = doc ? replayDidOpenMessage(doc) : null;
+		const fullOpenFrame = fullOpenMessage ? decideDaemonFrame(fullOpenMessage) : null;
+		const syncPlan = decideMirrorSync({
+			method,
+			isUnsynced,
+			originalFrameFits: originalFrame.send,
+			fullFrameFits: fullOpenFrame?.send === true
+		});
+		if (syncPlan.markUnsynced) unsyncedUris.add(uri);
+		if (syncPlan.shouldLog) note(`mirror unsynced uri=${uri}: ${originalFrame.frameBytes} bytes exceeds ${MAX_DAEMON_FRAME_BYTES}`);
+		let didSend = false;
+		for (const action of syncPlan.actions) {
+			if (action === "original") didSend = sendWsFrame(ws, originalFrame) || didSend;
+			if (action === "close") {
+				const closeMessage = daemonMessage("textDocument/didClose", { textDocument: { uri } });
+				didSend = sendWsJson(ws, closeMessage) || didSend;
+			}
+			if (action === "full-open" && fullOpenFrame && sendWsFrame(ws, fullOpenFrame)) {
+				unsyncedUris.delete(uri);
+				didSend = true;
+			}
+		}
+		if (syncPlan.forgetUnsynced) unsyncedUris.delete(uri);
+		return didSend;
+	}
+	function handleNotification(method, params) {
+		if (MIRROR_METHODS.has(method)) {
+			const mirrorUpdate = updateMirror(method, params);
+			if (!mirrorUpdate.applied) note(`mirror update failed method=${method} uri=${uriOfParams(asDocumentParams(params)) || "<unknown>"} reason=${mirrorUpdate.reason}${mirrorFailureDetail(mirrorUpdate)}`);
+			return sendMirrorNotification(method, params, mirrorUpdate);
+		}
+		if (FORWARDED_METHODS.has(method)) return forwardNotification(method, params);
+		if (method === "exit") stop(0);
+		return false;
+	}
+	function handleRequest(id, method, params) {
+		if (method === "textDocument/codeAction") {
+			forwardCodeAction(id, params);
+			return;
+		}
+		if (method === "initialize") {
+			note(`initialize answered: textDocumentSync change=2 (incremental)`);
+			writeEditorMessage(responseMessage(id, initializeResult()));
+			return;
+		}
+		if (method === "shutdown") {
+			note("shutdown requested by the editor");
+			writeEditorMessage(responseMessage(id, null));
+			return;
+		}
+		writeEditorMessage(methodNotFoundResponse(id, method));
+	}
+	function handleEditorMessage(msg) {
+		const classification = classifyMessage(msg);
+		const params = "params" in msg ? msg.params : void 0;
+		if (classification.kind === "request") {
+			handleRequest(classification.id, classification.method, params);
+			return false;
+		}
+		if (classification.kind === "notification" && classification.method) return handleNotification(classification.method, params);
+		if (classification.kind === "response") handleEditorResponse(classification.id, msg);
+		return false;
+	}
+	function handleStdinChunk(chunk) {
+		const bytes = typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk);
+		const parsed = feedFrameBytes(parserState, bytes);
+		parserState = parsed.state;
+		for (const msg of parsed.messages) handleEditorMessage(msg);
+	}
+	function start() {
+		connect();
+		stdin.on("data", handleStdinChunk);
+		stdin.on("end", () => stop(0));
+	}
+	return {
+		start,
+		stop,
+		handleEditorMessage,
+		handleDaemonText,
+		portPlan
+	};
+}
+function main() {
+	createRelay().start();
+}
+if (process.argv[1] === import.meta.filename) main();
+//#endregion
+export { ACTIVITY_METHOD, APPLY_EDIT_METHOD, CODE_ACTION_METHOD, CODE_ACTION_TIMEOUT_MS, MAX_DAEMON_FRAME_BYTES, STABLE_CONNECTION_MS, SYNC_KIND_INCREMENTAL, createRelay, daemonMessage, decideDaemonFrame, initializeResult, methodNotFoundResponse, nextDelayMs, planMirrorReplay, readConfiguredPort, replayDidOpenMessage, resolvePortPlan, sendWsFrame, sendWsJson };