glimmervoid 0.0.0-stage → 0.29.1

package/dist/tools/vscode-visions/extension.js

@@ -0,0 +1,289 @@
+//#region tools/vscode-visions/extension.ts
+var fs = require("node:fs");
+var path = require("node:path");
+var { spawn } = require("node:child_process");
+var vscode = require("vscode");
+var { createParserState, feedFrameBytes, serializeFrame } = require("./visions-lsp-core.js");
+var { decideEditFreshness, toCodeActions, toDiagnostics, toWorkspaceEdit } = require("./lsp-convert.js");
+var LANGUAGE_ID = "markdown";
+var ACTIVITY_METHOD = "visions/editorActivity";
+var CODE_ACTION_TIMEOUT_MS = 2e3;
+var INITIAL_RESTART_MS = 1e3;
+var MAX_RESTART_MS = 15e3;
+function stampedRelayPath() {
+	try {
+		const stamp = JSON.parse(fs.readFileSync(path.join(__dirname, "relay-path.json"), "utf8"));
+		if (typeof stamp !== "object" || stamp === null) return "";
+		if (!("relayPath" in stamp) || typeof stamp.relayPath !== "string") return "";
+		return stamp.relayPath;
+	} catch {
+		return "";
+	}
+}
+function resolveRelayPath(settings, env) {
+	const candidates = [
+		settings.get("relayPath", ""),
+		env.GLIMMERVOID_RELAY_PATH || "",
+		stampedRelayPath()
+	];
+	for (const candidate of candidates) if (candidate && fs.existsSync(candidate)) return candidate;
+	return "";
+}
+function relayArgs(relayPath, port) {
+	if (!Number.isInteger(port) || port <= 0) return [relayPath];
+	return [
+		relayPath,
+		"--port",
+		String(port)
+	];
+}
+function activate(context) {
+	const output = vscode.window.createOutputChannel("Glimmervoid Visions");
+	const diagnostics = vscode.languages.createDiagnosticCollection("glimmervoid-visions");
+	context.subscriptions.push(output, diagnostics);
+	const settings = vscode.workspace.getConfiguration("glimmervoidVisions");
+	const relayPath = resolveRelayPath(settings, process.env);
+	if (!relayPath) {
+		output.appendLine("no relay found: reinstall with `glimmervoid visions install`, or set glimmervoidVisions.relayPath");
+		vscode.window.showErrorMessage("Glimmervoid Visions found no relay. Run `glimmervoid visions install` again, or set glimmervoidVisions.relayPath.");
+		return;
+	}
+	const client = createRelayClient({
+		relayPath,
+		port: settings.get("port", 0),
+		output,
+		diagnostics
+	});
+	context.subscriptions.push({ dispose: () => client.stop() });
+	client.start();
+	context.subscriptions.push(vscode.workspace.onDidOpenTextDocument((document) => client.didOpen(document)), vscode.workspace.onDidChangeTextDocument((event) => client.didChange(event.document)), vscode.workspace.onDidSaveTextDocument((document) => client.didSave(document)), vscode.workspace.onDidCloseTextDocument((document) => client.didClose(document)), vscode.languages.registerCodeActionsProvider({ language: LANGUAGE_ID }, { provideCodeActions: (document, range, actionContext) => client.codeActions(document, range, actionContext) }, { providedCodeActionKinds: [vscode.CodeActionKind.QuickFix] }));
+}
+function createRelayClient({ relayPath, port, output, diagnostics }) {
+	let child = null;
+	let parserState = createParserState();
+	let nextRequestId = 1;
+	let restartMs = INITIAL_RESTART_MS;
+	let restartTimer = null;
+	let isStopping = false;
+	const pendingById = /* @__PURE__ */ new Map();
+	const openVersionByUri = /* @__PURE__ */ new Map();
+	function send(message) {
+		if (!child || child.killed || !child.stdin.writable) return false;
+		child.stdin.write(serializeFrame(message));
+		return true;
+	}
+	function notify(method, params) {
+		return send({
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	}
+	function request(method, params, timeoutMs) {
+		return new Promise((resolve) => {
+			const id = nextRequestId;
+			nextRequestId += 1;
+			const timer = setTimeout(() => settle(id, null), timeoutMs);
+			pendingById.set(id, {
+				resolve,
+				timer
+			});
+			if (!send({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			})) settle(id, null);
+		});
+	}
+	function settle(id, result) {
+		const pending = pendingById.get(id);
+		if (!pending) return;
+		pendingById.delete(id);
+		clearTimeout(pending.timer);
+		pending.resolve(result);
+	}
+	function failPending() {
+		for (const id of [...pendingById.keys()]) settle(id, null);
+	}
+	function isMirrored(document) {
+		return document.languageId === LANGUAGE_ID;
+	}
+	function reportActivity(document, method) {
+		if (document.uri.scheme !== "file") return;
+		notify(ACTIVITY_METHOD, {
+			uri: document.uri.toString(),
+			method
+		});
+	}
+	function didOpen(document) {
+		if (!isMirrored(document)) {
+			reportActivity(document, "textDocument/didOpen");
+			return;
+		}
+		openVersionByUri.set(document.uri.toString(), document.version);
+		notify("textDocument/didOpen", { textDocument: {
+			uri: document.uri.toString(),
+			languageId: document.languageId,
+			version: document.version,
+			text: document.getText()
+		} });
+	}
+	function didChange(document) {
+		if (!isMirrored(document)) return;
+		if (!openVersionByUri.has(document.uri.toString())) {
+			didOpen(document);
+			return;
+		}
+		openVersionByUri.set(document.uri.toString(), document.version);
+		notify("textDocument/didChange", {
+			textDocument: {
+				uri: document.uri.toString(),
+				version: document.version
+			},
+			contentChanges: [{ text: document.getText() }]
+		});
+	}
+	function didSave(document) {
+		if (!isMirrored(document)) {
+			reportActivity(document, "textDocument/didSave");
+			return;
+		}
+		notify("textDocument/didSave", { textDocument: { uri: document.uri.toString() } });
+	}
+	function didClose(document) {
+		if (!isMirrored(document)) {
+			reportActivity(document, "textDocument/didClose");
+			return;
+		}
+		openVersionByUri.delete(document.uri.toString());
+		diagnostics.delete(document.uri);
+		notify("textDocument/didClose", { textDocument: { uri: document.uri.toString() } });
+	}
+	async function codeActions(document, range, actionContext) {
+		if (!isMirrored(document)) return [];
+		return toCodeActions(vscode, await request("textDocument/codeAction", {
+			textDocument: { uri: document.uri.toString() },
+			range: {
+				start: range.start,
+				end: range.end
+			},
+			context: {
+				diagnostics: [],
+				triggerKind: actionContext?.triggerKind
+			}
+		}, CODE_ACTION_TIMEOUT_MS));
+	}
+	function versionOfUri(uri) {
+		if (!openVersionByUri.has(uri)) return null;
+		return openVersionByUri.get(uri) ?? null;
+	}
+	async function handleApplyEdit(id, params) {
+		const edit = params?.edit;
+		const freshness = decideEditFreshness(edit, versionOfUri);
+		if (!freshness.fresh) {
+			output.appendLine(`applyEdit refused: ${freshness.reason}`);
+			return send({
+				jsonrpc: "2.0",
+				id,
+				result: { applied: false }
+			});
+		}
+		return send({
+			jsonrpc: "2.0",
+			id,
+			result: { applied: await vscode.workspace.applyEdit(toWorkspaceEdit(vscode, edit)) }
+		});
+	}
+	function handleMessage(message) {
+		if (message?.method === "textDocument/publishDiagnostics") {
+			const uri = message.params?.uri;
+			if (typeof uri !== "string") return;
+			diagnostics.set(vscode.Uri.parse(uri), toDiagnostics(vscode, message.params?.diagnostics));
+			return;
+		}
+		if (message?.method === "workspace/applyEdit" && message.id !== void 0) {
+			handleApplyEdit(message.id, message.params);
+			return;
+		}
+		if (message?.id !== void 0 && message.method === void 0) settle(message.id, message.result ?? null);
+	}
+	function openMirroredDocuments() {
+		for (const document of vscode.workspace.textDocuments) didOpen(document);
+	}
+	async function handshake() {
+		await request("initialize", {
+			processId: process.pid,
+			rootUri: null,
+			capabilities: {},
+			clientInfo: { name: "glimmervoid-visions-extension" }
+		}, CODE_ACTION_TIMEOUT_MS);
+		notify("initialized", {});
+		openMirroredDocuments();
+	}
+	function scheduleRestart() {
+		if (isStopping || restartTimer) return;
+		output.appendLine(`relay exited; restarting in ${restartMs}ms`);
+		restartTimer = setTimeout(() => {
+			restartTimer = null;
+			start();
+		}, restartMs);
+		restartMs = Math.min(restartMs * 2, MAX_RESTART_MS);
+	}
+	function start() {
+		if (isStopping) return;
+		parserState = createParserState();
+		openVersionByUri.clear();
+		const relay = spawn(process.execPath, relayArgs(relayPath, port), {
+			env: {
+				...process.env,
+				ELECTRON_RUN_AS_NODE: "1"
+			},
+			windowsHide: true
+		});
+		child = relay;
+		output.appendLine(`relay started: ${relayPath}`);
+		relay.stdout.on("data", (chunk) => {
+			const parsed = feedFrameBytes(parserState, Buffer.from(chunk));
+			parserState = parsed.state;
+			for (const message of parsed.messages) handleMessage(message);
+		});
+		relay.stderr.on("data", (chunk) => output.append(String(chunk)));
+		relay.on("error", (error) => output.appendLine(`relay failed to start: ${error.message}`));
+		relay.on("exit", (code) => {
+			failPending();
+			diagnostics.clear();
+			output.appendLine(`relay exit code ${code}`);
+			scheduleRestart();
+		});
+		handshake();
+	}
+	function stop() {
+		isStopping = true;
+		if (restartTimer) clearTimeout(restartTimer);
+		restartTimer = null;
+		failPending();
+		if (!child) return;
+		notify("shutdown", {});
+		notify("exit", {});
+		child.kill();
+		child = null;
+	}
+	return {
+		codeActions,
+		didChange,
+		didClose,
+		didOpen,
+		didSave,
+		start,
+		stop
+	};
+}
+function deactivate() {}
+module.exports = {
+	activate,
+	deactivate,
+	resolveRelayPath,
+	relayArgs
+};
+//#endregion

package/dist/tools/vscode-visions/lsp-convert.js

@@ -0,0 +1,80 @@
+//#region tools/vscode-visions/lsp-convert.ts
+var SEVERITY_BY_LSP = {
+	1: "Error",
+	2: "Warning",
+	3: "Information",
+	4: "Hint"
+};
+function toPosition(vscodeApi, position) {
+	const line = Number.isInteger(position?.line) ? Number(position?.line) : 0;
+	const character = Number.isInteger(position?.character) ? Number(position?.character) : 0;
+	return new vscodeApi.Position(line, character);
+}
+function toRange(vscodeApi, range) {
+	return new vscodeApi.Range(toPosition(vscodeApi, range?.start), toPosition(vscodeApi, range?.end));
+}
+function toDiagnostic(vscodeApi, diagnostic) {
+	const converted = new vscodeApi.Diagnostic(toRange(vscodeApi, diagnostic?.range), typeof diagnostic?.message === "string" ? diagnostic.message : "", vscodeApi.DiagnosticSeverity[SEVERITY_BY_LSP[Number(diagnostic?.severity)] || "Warning"]);
+	if (diagnostic?.code !== void 0) converted.code = diagnostic.code;
+	if (typeof diagnostic?.source === "string") converted.source = diagnostic.source;
+	return converted;
+}
+function toDiagnostics(vscodeApi, diagnostics) {
+	if (!Array.isArray(diagnostics)) return [];
+	return diagnostics.map((diagnostic) => toDiagnostic(vscodeApi, diagnostic));
+}
+function documentChangesOf(edit) {
+	const changes = edit?.documentChanges;
+	if (!Array.isArray(changes)) return [];
+	return changes.filter((change) => typeof change?.textDocument?.uri === "string");
+}
+function toWorkspaceEdit(vscodeApi, edit) {
+	const workspaceEdit = new vscodeApi.WorkspaceEdit();
+	for (const change of documentChangesOf(edit)) {
+		const uri = vscodeApi.Uri.parse(change.textDocument.uri);
+		for (const textEdit of Array.isArray(change.edits) ? change.edits : []) workspaceEdit.replace(uri, toRange(vscodeApi, textEdit?.range), typeof textEdit?.newText === "string" ? textEdit.newText : "");
+	}
+	return workspaceEdit;
+}
+function toCodeAction(vscodeApi, action) {
+	const converted = new vscodeApi.CodeAction(typeof action?.title === "string" ? action.title : "Visions fix", vscodeApi.CodeActionKind.QuickFix);
+	if (action?.edit) converted.edit = toWorkspaceEdit(vscodeApi, action.edit);
+	const diagnostics = action?.diagnostics;
+	if (Array.isArray(diagnostics)) converted.diagnostics = toDiagnostics(vscodeApi, diagnostics);
+	return converted;
+}
+function toCodeActions(vscodeApi, actions) {
+	if (!Array.isArray(actions)) return [];
+	return actions.map((action) => toCodeAction(vscodeApi, action));
+}
+function decideEditFreshness(edit, versionOfUri) {
+	const changes = documentChangesOf(edit);
+	if (changes.length === 0) return {
+		fresh: false,
+		reason: "no-document-changes"
+	};
+	for (const change of changes) {
+		const expected = change.textDocument.version;
+		if (expected === null || expected === void 0) continue;
+		const current = versionOfUri(change.textDocument.uri);
+		if (current === null || current === void 0) continue;
+		if (current !== expected) return {
+			fresh: false,
+			reason: "stale-version"
+		};
+	}
+	return {
+		fresh: true,
+		reason: "ok"
+	};
+}
+module.exports = {
+	decideEditFreshness,
+	toCodeAction,
+	toCodeActions,
+	toDiagnostic,
+	toDiagnostics,
+	toRange,
+	toWorkspaceEdit
+};
+//#endregion

package/dist/tools/vscode-visions/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "glimmervoid-visions",
+  "displayName": "Glimmervoid Visions",
+  "publisher": "johnwaters",
+  "version": "0.3.0",
+  "private": true,
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "main": "./extension.js",
+  "activationEvents": [
+    "onStartupFinished"
+  ],
+  "contributes": {
+    "configuration": {
+      "title": "Glimmervoid Visions",
+      "properties": {
+        "glimmervoidVisions.relayPath": {
+          "type": "string",
+          "default": "",
+          "description": "Absolute path to the visions relay (dist/session/visions-relay.js in an installed package, session/visions-relay.ts in a source checkout). Empty uses the path stamped at install time."
+        },
+        "glimmervoidVisions.port": {
+          "type": "number",
+          "default": 0,
+          "description": "Relay port. Use 0 to let the relay choose its fallback."
+        }
+      }
+    }
+  },
+  "description": "Mirrors markdown buffers to the Glimmervoid daemon and shows its findings and silent fixes."
+}

package/dist/tools/vscode-visions/visions-lsp-core.js

@@ -0,0 +1,112 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.classifyMessage = classifyMessage;
+exports.createParserState = createParserState;
+exports.feedFrameBytes = feedFrameBytes;
+exports.serializeFrame = serializeFrame;

package/package.json

@@ -1,6 +1,97 @@
 {
   "name": "glimmervoid",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.29.1",
+  "description": "Mission control for coding agents: run and supervise Claude Code, Codex and Grok sessions in parallel git worktrees from one local browser dashboard",
+  "main": "dist/server/index.js",
+  "type": "module",
+  "imports": {
+    "#shared/*": "./shared/*"
+  },
+  "bin": {
+    "glimmervoid": "dist/bin/glimmervoid.js"
+  },
+  "files": [
+    "dist/",
+    "!dist/client/pictures/",
+    "!dist/client/AGENTS.md",
+    "scripts/postinstall.mjs",
+    "scripts/recover-handoff.mjs",
+    "scripts/prepare-build.js"
+  ],
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "John C. Waters <john@johncwaters.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johncwaters/glimmervoid.git"
+  },
+  "homepage": "https://github.com/johncwaters/glimmervoid#readme",
+  "bugs": {
+    "url": "https://github.com/johncwaters/glimmervoid/issues"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "codex",
+    "coding-agents",
+    "ai-agents",
+    "agent-orchestrator",
+    "agent-manager",
+    "parallel-agents",
+    "git-worktree",
+    "terminal",
+    "dashboard",
+    "session-manager",
+    "xterm",
+    "windows",
+    "linux",
+    "macos"
+  ],
+  "scripts": {
+    "start": "node dist/server/index.js",
+    "lint": "biome check .",
+    "test": "node --import ./tests/helpers/isolate-home.ts --test \"tests/**/*.test.ts\"",
+    "typecheck": "tsc --project tsconfig.json && tsc --project tsconfig.public.json && tsc --project tsconfig.browser-harness.json",
+    "test:browser": "node test/browser/harness.ts",
+    "site:capture": "node test/site-capture/capture.ts",
+    "site:record": "node test/site-capture/record.ts",
+    "site:dev": "npm --prefix site run dev",
+    "site:build": "npm --prefix site run build",
+    "test:container": "docker build -f test/container/Dockerfile -t glimmervoid-remote-test . && docker run --rm glimmervoid-remote-test",
+    "dev": "vite",
+    "build": "node scripts/build.mjs",
+    "postinstall": "node scripts/postinstall.mjs",
+    "prepare": "node scripts/prepare-build.js",
+    "release": "node scripts/release.ts",
+    "docs:config": "node scripts/generate-config-docs.ts"
+  },
+  "dependencies": {
+    "@parcel/watcher": "^2.6.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-serialize": "^0.14.0",
+    "@xterm/addon-webgl": "^0.19.0",
+    "@xterm/headless": "^6.0.0",
+    "@xterm/xterm": "^6.0.0",
+    "express": "^5.2.1",
+    "node-pty": "^1.1.0",
+    "ws": "^8.22.0",
+    "zod": "^4.6.5"
+  },
+  "allowScripts": {
+    "node-pty": true
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.14",
+    "@tailwindcss/vite": "^4.3.3",
+    "@types/node": "^26.6.3",
+    "playwright-core": "1.63.0",
+    "tailwindcss": "^4.3.3",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.1"
+  }
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,4 @@
+try {
+  await import('../dist/scripts/postinstall-path-check.js');
+} catch {
+}

package/scripts/prepare-build.js

@@ -0,0 +1,38 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const viteBin = path.join(import.meta.dirname, '..', 'node_modules', '.bin', process.platform === 'win32' ? 'vite.cmd' : 'vite');
+
+function npmInvocation(args) {
+  const npmExecPath = process.env.npm_execpath;
+  if (npmExecPath && /\.[cm]?js$/.test(npmExecPath)) {
+    return { command: process.execPath, args: [npmExecPath, ...args], shell: false };
+  }
+  if (process.platform === 'win32') {
+    return { command: 'npm', args, shell: true };
+  }
+  return { command: 'npm', args, shell: false };
+}
+
+function runNpm(args, env = {}) {
+  const invocation = npmInvocation(args);
+  const child = spawnSync(invocation.command, invocation.args, {
+    env: { ...process.env, ...env, npm_config_global: 'false' },
+    stdio: 'inherit',
+    shell: invocation.shell,
+  });
+  if (child.error) {
+    console.error(`prepare-build: npm failed to start: ${child.error.message}`);
+    process.exit(1);
+  }
+  if (child.status === 0) return;
+  process.exit(child.status || 1);
+}
+
+if (!fs.existsSync(viteBin)) {
+  runNpm(['ci', '--include=dev', '--ignore-scripts', '--no-audit', '--no-fund']);
+}
+runNpm(['run', 'build']);
+
+spawnSync(process.execPath, [path.join(import.meta.dirname, 'postinstall.mjs')], { stdio: 'inherit' });