openspecui 0.0.0 → 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { t as startServer } from "./src-CNuprcB-.mjs";
+
+//#region src/cli.ts
+function parseArgs(args) {
+	const result = {
+		port: 3100,
+		projectDir: process.cwd(),
+		open: true,
+		help: false
+	};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-p" || arg === "--port") {
+			const next = args[++i];
+			if (next) result.port = parseInt(next, 10);
+		} else if (arg === "-d" || arg === "--dir") {
+			const next = args[++i];
+			if (next) result.projectDir = next;
+		} else if (arg === "--no-open") result.open = false;
+		else if (arg === "-h" || arg === "--help") result.help = true;
+		else if (!arg.startsWith("-")) result.projectDir = arg;
+	}
+	return result;
+}
+function printHelp() {
+	console.log(`
+OpenSpec UI - Visual interface for OpenSpec
+
+Usage: openspecui [options] [project-dir]
+
+Options:
+  -p, --port <port>   Port to run the server on (default: 3100)
+  -d, --dir <path>    Project directory containing openspec/ (default: cwd)
+  --no-open           Don't automatically open the browser
+  -h, --help          Show this help message
+
+Examples:
+  openspecui                    # Start in current directory
+  openspecui ./my-project       # Start with specific project
+  openspecui -p 8080            # Start on custom port
+  openspecui --no-open          # Start without opening browser
+`);
+}
+async function main() {
+	const args = parseArgs(process.argv.slice(2));
+	if (args.help) {
+		printHelp();
+		process.exit(0);
+	}
+	console.log(`
+┌─────────────────────────────────────────────┐
+│           OpenSpec UI                       │
+│   Visual interface for spec-driven dev      │
+└─────────────────────────────────────────────┘
+`);
+	console.log(`📁 Project: ${args.projectDir}`);
+	console.log(`🔌 Port: ${args.port}`);
+	console.log("");
+	try {
+		const server = await startServer({
+			projectDir: args.projectDir,
+			port: args.port,
+			open: args.open
+		});
+		console.log(`✅ Server running at ${server.url}`);
+		console.log("");
+		if (args.open) {
+			await (await import("./open-CmiqsyCQ.mjs")).default(server.url);
+			console.log("🌐 Browser opened");
+		}
+		console.log("");
+		console.log("Press Ctrl+C to stop the server");
+		process.on("SIGINT", async () => {
+			console.log("\n\n👋 Shutting down...");
+			await server.close();
+			process.exit(0);
+		});
+		process.on("SIGTERM", async () => {
+			await server.close();
+			process.exit(0);
+		});
+	} catch (error) {
+		console.error("❌ Failed to start server:", error);
+		process.exit(1);
+	}
+}
+main();
+
+//#endregion
+export {  };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { i as ACPAgents, n as createServer, r as ProviderManager, t as startServer } from "./src-CNuprcB-.mjs";
+
+export { ACPAgents, ProviderManager, createServer, startServer };

package/dist/open-CmiqsyCQ.mjs

@@ -0,0 +1,473 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+import { Buffer } from "node:buffer";
+import { promisify } from "node:util";
+import childProcess, { execFile } from "node:child_process";
+import fs$1, { constants } from "node:fs/promises";
+import os from "node:os";
+
+//#region ../../node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
+let isDockerCached;
+function hasDockerEnv() {
+	try {
+		fs.statSync("/.dockerenv");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function hasDockerCGroup() {
+	try {
+		return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+	} catch {
+		return false;
+	}
+}
+function isDocker() {
+	if (isDockerCached === void 0) isDockerCached = hasDockerEnv() || hasDockerCGroup();
+	return isDockerCached;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+let cachedResult;
+const hasContainerEnv = () => {
+	try {
+		fs.statSync("/run/.containerenv");
+		return true;
+	} catch {
+		return false;
+	}
+};
+function isInsideContainer() {
+	if (cachedResult === void 0) cachedResult = hasContainerEnv() || isDocker();
+	return cachedResult;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js
+const isWsl = () => {
+	if (process.platform !== "linux") return false;
+	if (os.release().toLowerCase().includes("microsoft")) {
+		if (isInsideContainer()) return false;
+		return true;
+	}
+	try {
+		return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+	} catch {
+		return false;
+	}
+};
+var is_wsl_default = process.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+
+//#endregion
+//#region ../../node_modules/.pnpm/wsl-utils@0.1.0/node_modules/wsl-utils/index.js
+const wslDrivesMountPoint = (() => {
+	const defaultMountPoint = "/mnt/";
+	let mountPoint;
+	return async function() {
+		if (mountPoint) return mountPoint;
+		const configFilePath = "/etc/wsl.conf";
+		let isConfigFileExists = false;
+		try {
+			await fs$1.access(configFilePath, constants.F_OK);
+			isConfigFileExists = true;
+		} catch {}
+		if (!isConfigFileExists) return defaultMountPoint;
+		const configContent = await fs$1.readFile(configFilePath, { encoding: "utf8" });
+		const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+		if (!configMountPoint) return defaultMountPoint;
+		mountPoint = configMountPoint.groups.mountPoint.trim();
+		mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+		return mountPoint;
+	};
+})();
+const powerShellPathFromWsl = async () => {
+	return `${await wslDrivesMountPoint()}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+const powerShellPath = async () => {
+	if (is_wsl_default) return powerShellPathFromWsl();
+	return `${process.env.SYSTEMROOT || process.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+	const define = (value) => Object.defineProperty(object, propertyName, {
+		value,
+		enumerable: true,
+		writable: true
+	});
+	Object.defineProperty(object, propertyName, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const result = valueGetter();
+			define(result);
+			return result;
+		},
+		set(value) {
+			define(value);
+		}
+	});
+	return object;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/default-browser-id@5.0.1/node_modules/default-browser-id/index.js
+const execFileAsync$3 = promisify(execFile);
+async function defaultBrowserId() {
+	if (process.platform !== "darwin") throw new Error("macOS only");
+	const { stdout } = await execFileAsync$3("defaults", [
+		"read",
+		"com.apple.LaunchServices/com.apple.launchservices.secure",
+		"LSHandlers"
+	]);
+	const browserId = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout)?.groups.id ?? "com.apple.Safari";
+	if (browserId === "com.apple.safari") return "com.apple.Safari";
+	return browserId;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js
+const execFileAsync$2 = promisify(execFile);
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+	if (process.platform !== "darwin") throw new Error("macOS only");
+	const outputArguments = humanReadableOutput ? [] : ["-ss"];
+	const execOptions = {};
+	if (signal) execOptions.signal = signal;
+	const { stdout } = await execFileAsync$2("osascript", [
+		"-e",
+		script,
+		outputArguments
+	], execOptions);
+	return stdout.trim();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/bundle-name@4.1.0/node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+	return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/default-browser@5.4.0/node_modules/default-browser/windows.js
+const execFileAsync$1 = promisify(execFile);
+const windowsBrowserProgIds = {
+	MSEdgeHTM: {
+		name: "Edge",
+		id: "com.microsoft.edge"
+	},
+	MSEdgeBHTML: {
+		name: "Edge Beta",
+		id: "com.microsoft.edge.beta"
+	},
+	MSEdgeDHTML: {
+		name: "Edge Dev",
+		id: "com.microsoft.edge.dev"
+	},
+	AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {
+		name: "Edge",
+		id: "com.microsoft.edge.old"
+	},
+	ChromeHTML: {
+		name: "Chrome",
+		id: "com.google.chrome"
+	},
+	ChromeBHTML: {
+		name: "Chrome Beta",
+		id: "com.google.chrome.beta"
+	},
+	ChromeDHTML: {
+		name: "Chrome Dev",
+		id: "com.google.chrome.dev"
+	},
+	ChromiumHTM: {
+		name: "Chromium",
+		id: "org.chromium.Chromium"
+	},
+	BraveHTML: {
+		name: "Brave",
+		id: "com.brave.Browser"
+	},
+	BraveBHTML: {
+		name: "Brave Beta",
+		id: "com.brave.Browser.beta"
+	},
+	BraveDHTML: {
+		name: "Brave Dev",
+		id: "com.brave.Browser.dev"
+	},
+	BraveSSHTM: {
+		name: "Brave Nightly",
+		id: "com.brave.Browser.nightly"
+	},
+	FirefoxURL: {
+		name: "Firefox",
+		id: "org.mozilla.firefox"
+	},
+	OperaStable: {
+		name: "Opera",
+		id: "com.operasoftware.Opera"
+	},
+	VivaldiHTM: {
+		name: "Vivaldi",
+		id: "com.vivaldi.Vivaldi"
+	},
+	"IE.HTTP": {
+		name: "Internet Explorer",
+		id: "com.microsoft.ie"
+	}
+};
+const _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+var UnknownBrowserError = class extends Error {};
+async function defaultBrowser$1(_execFileAsync = execFileAsync$1) {
+	const { stdout } = await _execFileAsync("reg", [
+		"QUERY",
+		" HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+		"/v",
+		"ProgId"
+	]);
+	const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+	if (!match) throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+	const { id } = match.groups;
+	const browser = windowsBrowserProgIds[id];
+	if (!browser) throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
+	return browser;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/default-browser@5.4.0/node_modules/default-browser/index.js
+const execFileAsync = promisify(execFile);
+const titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+async function defaultBrowser() {
+	if (process.platform === "darwin") {
+		const id = await defaultBrowserId();
+		return {
+			name: await bundleName(id),
+			id
+		};
+	}
+	if (process.platform === "linux") {
+		const { stdout } = await execFileAsync("xdg-mime", [
+			"query",
+			"default",
+			"x-scheme-handler/http"
+		]);
+		const id = stdout.trim();
+		return {
+			name: titleize(id.replace(/.desktop$/, "").replace("-", " ")),
+			id
+		};
+	}
+	if (process.platform === "win32") return defaultBrowser$1();
+	throw new Error("Only macOS, Linux, and Windows are supported");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/open@10.2.0/node_modules/open/index.js
+const execFile$1 = promisify(childProcess.execFile);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const localXdgOpenPath = path.join(__dirname, "xdg-open");
+const { platform, arch } = process;
+/**
+Get the default browser name in Windows from WSL.
+
+@returns {Promise<string>} Browser name.
+*/
+async function getWindowsDefaultBrowserFromWsl() {
+	const powershellPath = await powerShellPath();
+	const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+	const { stdout } = await execFile$1(powershellPath, [
+		"-NoProfile",
+		"-NonInteractive",
+		"-ExecutionPolicy",
+		"Bypass",
+		"-EncodedCommand",
+		Buffer.from(rawCommand, "utf16le").toString("base64")
+	], { encoding: "utf8" });
+	const progId = stdout.trim();
+	const browserMap = {
+		ChromeHTML: "com.google.chrome",
+		BraveHTML: "com.brave.Browser",
+		MSEdgeHTM: "com.microsoft.edge",
+		FirefoxURL: "org.mozilla.firefox"
+	};
+	return browserMap[progId] ? { id: browserMap[progId] } : {};
+}
+const pTryEach = async (array, mapper) => {
+	let latestError;
+	for (const item of array) try {
+		return await mapper(item);
+	} catch (error) {
+		latestError = error;
+	}
+	throw latestError;
+};
+const baseOpen = async (options) => {
+	options = {
+		wait: false,
+		background: false,
+		newInstance: false,
+		allowNonzeroExitCode: false,
+		...options
+	};
+	if (Array.isArray(options.app)) return pTryEach(options.app, (singleApp) => baseOpen({
+		...options,
+		app: singleApp
+	}));
+	let { name: app, arguments: appArguments = [] } = options.app ?? {};
+	appArguments = [...appArguments];
+	if (Array.isArray(app)) return pTryEach(app, (appName) => baseOpen({
+		...options,
+		app: {
+			name: appName,
+			arguments: appArguments
+		}
+	}));
+	if (app === "browser" || app === "browserPrivate") {
+		const ids = {
+			"com.google.chrome": "chrome",
+			"google-chrome.desktop": "chrome",
+			"com.brave.Browser": "brave",
+			"org.mozilla.firefox": "firefox",
+			"firefox.desktop": "firefox",
+			"com.microsoft.msedge": "edge",
+			"com.microsoft.edge": "edge",
+			"com.microsoft.edgemac": "edge",
+			"microsoft-edge.desktop": "edge"
+		};
+		const flags = {
+			chrome: "--incognito",
+			brave: "--incognito",
+			firefox: "--private-window",
+			edge: "--inPrivate"
+		};
+		const browser = is_wsl_default ? await getWindowsDefaultBrowserFromWsl() : await defaultBrowser();
+		if (browser.id in ids) {
+			const browserName = ids[browser.id];
+			if (app === "browserPrivate") appArguments.push(flags[browserName]);
+			return baseOpen({
+				...options,
+				app: {
+					name: apps[browserName],
+					arguments: appArguments
+				}
+			});
+		}
+		throw new Error(`${browser.name} is not supported as a default browser`);
+	}
+	let command;
+	const cliArguments = [];
+	const childProcessOptions = {};
+	if (platform === "darwin") {
+		command = "open";
+		if (options.wait) cliArguments.push("--wait-apps");
+		if (options.background) cliArguments.push("--background");
+		if (options.newInstance) cliArguments.push("--new");
+		if (app) cliArguments.push("-a", app);
+	} else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
+		command = await powerShellPath();
+		cliArguments.push("-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand");
+		if (!is_wsl_default) childProcessOptions.windowsVerbatimArguments = true;
+		const encodedArguments = ["Start"];
+		if (options.wait) encodedArguments.push("-Wait");
+		if (app) {
+			encodedArguments.push(`"\`"${app}\`""`);
+			if (options.target) appArguments.push(options.target);
+		} else if (options.target) encodedArguments.push(`"${options.target}"`);
+		if (appArguments.length > 0) {
+			appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
+			encodedArguments.push("-ArgumentList", appArguments.join(","));
+		}
+		options.target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+	} else {
+		if (app) command = app;
+		else {
+			const isBundled = !__dirname || __dirname === "/";
+			let exeLocalXdgOpen = false;
+			try {
+				await fs$1.access(localXdgOpenPath, constants.X_OK);
+				exeLocalXdgOpen = true;
+			} catch {}
+			command = process.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen) ? "xdg-open" : localXdgOpenPath;
+		}
+		if (appArguments.length > 0) cliArguments.push(...appArguments);
+		if (!options.wait) {
+			childProcessOptions.stdio = "ignore";
+			childProcessOptions.detached = true;
+		}
+	}
+	if (platform === "darwin" && appArguments.length > 0) cliArguments.push("--args", ...appArguments);
+	if (options.target) cliArguments.push(options.target);
+	const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+	if (options.wait) return new Promise((resolve, reject) => {
+		subprocess.once("error", reject);
+		subprocess.once("close", (exitCode) => {
+			if (!options.allowNonzeroExitCode && exitCode > 0) {
+				reject(/* @__PURE__ */ new Error(`Exited with code ${exitCode}`));
+				return;
+			}
+			resolve(subprocess);
+		});
+	});
+	subprocess.unref();
+	return subprocess;
+};
+const open = (target, options) => {
+	if (typeof target !== "string") throw new TypeError("Expected a `target`");
+	return baseOpen({
+		...options,
+		target
+	});
+};
+function detectArchBinary(binary) {
+	if (typeof binary === "string" || Array.isArray(binary)) return binary;
+	const { [arch]: archBinary } = binary;
+	if (!archBinary) throw new Error(`${arch} is not supported`);
+	return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+	if (wsl && is_wsl_default) return detectArchBinary(wsl);
+	if (!platformBinary) throw new Error(`${platform} is not supported`);
+	return detectArchBinary(platformBinary);
+}
+const apps = {};
+defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+	darwin: "google chrome",
+	win32: "chrome",
+	linux: [
+		"google-chrome",
+		"google-chrome-stable",
+		"chromium"
+	]
+}, { wsl: {
+	ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+	x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+} }));
+defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+	darwin: "brave browser",
+	win32: "brave",
+	linux: ["brave-browser", "brave"]
+}, { wsl: {
+	ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+	x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+} }));
+defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+	darwin: "firefox",
+	win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+	linux: "firefox"
+}, { wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe" }));
+defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+	darwin: "microsoft edge",
+	win32: "msedge",
+	linux: ["microsoft-edge", "microsoft-edge-dev"]
+}, { wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe" }));
+defineLazyProperty(apps, "browser", () => "browser");
+defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+var open_default = open;
+
+//#endregion
+export { open_default as default };