openspecui 2.0.2 → 2.1.1

package/dist/cli.mjs

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
-import { a as SchemaInfoSchema, c as toOpsxDisplayPath, d as DEFAULT_CONFIG, f as OpenSpecAdapter, i as SchemaDetailSchema, l as CliExecutor, m as __toESM, o as SchemaResolutionSchema, p as __commonJS, r as require_dist, s as TemplatesSchema, t as startServer, u as ConfigManager } from "./src-Cx7GJTGT.mjs";
+import { a as SchemaInfoSchema, c as toOpsxDisplayPath, d as CliExecutor, f as ConfigManager, g as __toESM, h as __commonJS, i as SchemaDetailSchema, l as buildHostedLaunchUrl, m as OpenSpecAdapter, o as SchemaResolutionSchema, p as DEFAULT_CONFIG, r as require_dist, s as TemplatesSchema, t as startServer, u as resolveHostedAppBaseUrl } from "./src-Nn_MJz41.mjs";
 import { createRequire } from "node:module";
+import { createServer } from "node:net";
 import { basename, dirname, extname, join, normalize, relative, resolve } from "path";
 import { readFile } from "node:fs/promises";
 import { dirname as dirname$1, join as join$1, resolve as resolve$1 } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { readFileSync as readFileSync$1, readdirSync as readdirSync$1, statSync as statSync$1, writeFile as writeFile$1 } from "fs";
 import { format, inspect } from "util";
-import { fileURLToPath } from "url";
+import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath$1 } from "url";
 import { execFile, spawn } from "node:child_process";
 import { promisify as promisify$1 } from "node:util";
-import { fileURLToPath as fileURLToPath$1 } from "node:url";
 import { notStrictEqual, strictEqual } from "assert";
 
 //#region ../../node_modules/.pnpm/cliui@9.0.1/node_modules/cliui/build/lib/index.js
@@ -1606,7 +1607,7 @@ var require_get_caller_file = /* @__PURE__ */ __commonJS({ "../../node_modules/.
 //#endregion
 //#region ../../node_modules/.pnpm/yargs@18.0.0/node_modules/yargs/lib/platform-shims/esm.mjs
 var import_get_caller_file = /* @__PURE__ */ __toESM(require_get_caller_file(), 1);
-const __dirname$2 = fileURLToPath(import.meta.url);
+const __dirname$2 = fileURLToPath$1(import.meta.url);
 const mainFilename = __dirname$2.substring(0, __dirname$2.lastIndexOf("node_modules"));
 const require = createRequire(import.meta.url);
 var esm_default = {
@@ -1647,7 +1648,7 @@ var esm_default = {
 	require,
 	getCallerFile: () => {
 		const callerFile = (0, import_get_caller_file.default)(3);
-		return callerFile.match(/^file:\/\//) ? fileURLToPath(callerFile) : callerFile;
+		return callerFile.match(/^file:\/\//) ? fileURLToPath$1(callerFile) : callerFile;
 	},
 	stringWidth,
 	y18n: y18n_default({
@@ -4507,11 +4508,11 @@ var yargs_default = Yargs;
 //#endregion
 //#region package.json
 var import_dist = require_dist();
-var version = "2.0.2";
+var version = "2.1.1";
 
 //#endregion
 //#region src/export.ts
-const __dirname$1 = dirname$1(fileURLToPath$1(import.meta.url));
+const __dirname$1 = dirname$1(fileURLToPath(import.meta.url));
 const execFileAsync = promisify$1(execFile);
 function parseCliJson(raw, schema, label) {
 	const trimmed = raw.trim();
@@ -4943,7 +4944,7 @@ function findLocalWebPackage() {
 /**
 * Run a command and wait for it to complete
 */
-function runCommand(cmd, args, cwd) {
+function runCommand$1(cmd, args, cwd) {
 	return new Promise((resolvePromise, reject) => {
 		const child = spawn(cmd, args, {
 			stdio: "inherit",
@@ -5110,7 +5111,7 @@ async function exportHtml(options) {
 	if (isLocalPackageRange(webPackageRange)) {
 		if (!localWebPkg) throw new Error(`Detected local/dev @openspecui/web range "${webPackageRange}" but local web package was not found`);
 		console.log("\n[Local dev mode] Running SSG from local web package...");
-		await runCommand("pnpm", [
+		await runCommand$1("pnpm", [
 			"tsx",
 			join$1(localWebPkg, "src", "ssg", "cli.ts"),
 			"--data",
@@ -5125,7 +5126,7 @@ async function exportHtml(options) {
 		const pm = detectPackageManager();
 		const execCmd = getExecCommand(pm, `@openspecui/web@${webPackageRange || version}`);
 		try {
-			await runCommand(execCmd.cmd, [
+			await runCommand$1(execCmd.cmd, [
 				...execCmd.args,
 				"--data",
 				dataJsonPath,
@@ -5152,7 +5153,7 @@ async function exportHtml(options) {
 		if (previewHost) viteArgs.push("--host", previewHost);
 		viteArgs.push("--open");
 		const { cmd, args } = getRunCommand(detectPackageManager(), "vite");
-		await runCommand(cmd, [...args, ...viteArgs], outputDir);
+		await runCommand$1(cmd, [...args, ...viteArgs], outputDir);
 	}
 }
 /**
@@ -5166,12 +5167,210 @@ async function exportStaticSite(options) {
 	else await exportHtml(options);
 }
 
+//#endregion
+//#region src/hosted-app.ts
+function buildHostedAppLaunchUrl(options) {
+	return buildHostedLaunchUrl({
+		baseUrl: options.baseUrl,
+		apiBaseUrl: options.apiBaseUrl
+	});
+}
+function resolveEffectiveHostedAppBaseUrl(options) {
+	return resolveHostedAppBaseUrl(options);
+}
+
+//#endregion
+//#region src/local-hosted-app-dev.ts
+const LOCAL_HOSTED_APP_DEV_DEFAULT_PORT = 13005;
+function resolveLocalHostedAppWorkspace(cliDir) {
+	const repoRoot = resolve$1(cliDir, "..", "..", "..");
+	const rootPackageJson = join$1(repoRoot, "package.json");
+	const appPackageJson = join$1(repoRoot, "packages", "app", "package.json");
+	if (!existsSync(rootPackageJson) || !existsSync(appPackageJson)) return null;
+	return {
+		repoRoot,
+		appDir: join$1(repoRoot, "packages", "app"),
+		webDistDir: join$1(repoRoot, "packages", "web", "dist")
+	};
+}
+function shouldUseLocalHostedAppDevMode(options) {
+	return options.appValue === "" && options.workspace !== null;
+}
+function createHostedAppWebBuildCommand(workspace) {
+	return {
+		command: resolvePnpmCommand(),
+		args: [
+			"--filter",
+			"@openspecui/web",
+			"build"
+		],
+		cwd: workspace.repoRoot,
+		env: { ...process.env }
+	};
+}
+function createLocalHostedAppDevCommand(options) {
+	return {
+		command: resolvePnpmCommand(),
+		args: [
+			"--filter",
+			"@openspecui/app",
+			"exec",
+			"vite",
+			"--host",
+			"127.0.0.1",
+			"--port",
+			String(options.port),
+			"--strictPort"
+		],
+		cwd: options.workspace.repoRoot,
+		env: {
+			...process.env,
+			OPENSPECUI_APP_DEV_MODE: "1",
+			OPENSPECUI_APP_DEV_WEB_DIST: options.workspace.webDistDir,
+			OPENSPECUI_APP_DEV_VERSION: options.resolvedVersion
+		}
+	};
+}
+async function startLocalHostedAppDev(options) {
+	await ensureLocalHostedAppWebDist(options.workspace);
+	const port = await findAvailablePort(options.preferredPort ?? LOCAL_HOSTED_APP_DEV_DEFAULT_PORT);
+	const command$1 = createLocalHostedAppDevCommand({
+		workspace: options.workspace,
+		port,
+		resolvedVersion: options.resolvedVersion
+	});
+	const child = spawn(command$1.command, command$1.args, {
+		cwd: command$1.cwd,
+		env: command$1.env,
+		stdio: "inherit",
+		detached: process.platform !== "win32"
+	});
+	const baseUrl = `http://127.0.0.1:${port}`;
+	try {
+		await waitForHostedAppDevReady({
+			baseUrl,
+			child,
+			timeoutMs: options.readinessTimeoutMs ?? 15e3
+		});
+	} catch (error) {
+		await stopChildProcess(child);
+		throw error;
+	}
+	return {
+		baseUrl,
+		close: () => stopChildProcess(child)
+	};
+}
+async function ensureLocalHostedAppWebDist(workspace) {
+	const command$1 = createHostedAppWebBuildCommand(workspace);
+	console.log("🛠️  Building packages/web for local hosted app dev...");
+	await runCommand(command$1);
+}
+function resolvePnpmCommand() {
+	return process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+}
+async function runCommand(command$1) {
+	await new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(command$1.command, command$1.args, {
+			cwd: command$1.cwd,
+			env: command$1.env,
+			stdio: "inherit"
+		});
+		child.once("error", (error) => {
+			rejectPromise(error);
+		});
+		child.once("exit", (code, signal) => {
+			if (code === 0) {
+				resolvePromise();
+				return;
+			}
+			rejectPromise(/* @__PURE__ */ new Error(`Command failed: ${command$1.command} ${command$1.args.join(" ")} (${signal ? `signal ${signal}` : `exit ${code ?? "unknown"}`})`));
+		});
+	});
+}
+async function waitForHostedAppDevReady(options) {
+	let exitMessage = null;
+	let startupError = null;
+	options.child.once("error", (error) => {
+		startupError = error;
+	});
+	options.child.once("exit", (code, signal) => {
+		exitMessage = signal ? `signal ${signal}` : `exit ${code ?? "unknown"}`;
+	});
+	const deadline = Date.now() + options.timeoutMs;
+	while (Date.now() < deadline) {
+		if (startupError) throw startupError;
+		if (exitMessage) throw new Error(`Local hosted app dev server exited before becoming ready (${exitMessage})`);
+		try {
+			if ((await fetch(`${options.baseUrl}/version.json`, {
+				headers: { accept: "application/json" },
+				cache: "no-store"
+			})).ok) return;
+		} catch {}
+		await delay(250);
+	}
+	throw new Error(`Timed out waiting for local hosted app dev server at ${options.baseUrl}`);
+}
+async function stopChildProcess(child) {
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	killChildProcess(child, "SIGTERM");
+	if (await waitForChildExit(child, 5e3)) return;
+	killChildProcess(child, "SIGKILL");
+	await waitForChildExit(child, 1e3);
+}
+function killChildProcess(child, signal) {
+	if (process.platform !== "win32" && child.pid) try {
+		process.kill(-child.pid, signal);
+		return;
+	} catch {}
+	child.kill(signal);
+}
+function waitForChildExit(child, timeoutMs) {
+	return new Promise((resolvePromise) => {
+		const timer = setTimeout(() => {
+			cleanup();
+			resolvePromise(false);
+		}, timeoutMs);
+		const onExit = () => {
+			cleanup();
+			resolvePromise(true);
+		};
+		const cleanup = () => {
+			clearTimeout(timer);
+			child.off("exit", onExit);
+		};
+		child.once("exit", onExit);
+	});
+}
+function delay(ms) {
+	return new Promise((resolve$2) => {
+		setTimeout(resolve$2, ms);
+	});
+}
+async function isPortAvailable(port) {
+	return await new Promise((resolve$2) => {
+		const server = createServer();
+		server.once("error", () => {
+			resolve$2(false);
+		});
+		server.once("listening", () => {
+			server.close(() => resolve$2(true));
+		});
+		server.listen(port, "127.0.0.1");
+	});
+}
+async function findAvailablePort(startPort, maxAttempts = 10) {
+	for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+		const port = startPort + attempt;
+		if (await isPortAvailable(port)) return port;
+	}
+	throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1}`);
+}
+
 //#endregion
 //#region src/cli.ts
-const __dirname = dirname$1(fileURLToPath$1(import.meta.url));
-/**
-* Read version from package.json
-*/
+const __dirname = dirname$1(fileURLToPath(import.meta.url));
+const DEFAULT_HOSTED_CORS_ORIGINS = ["http://localhost:5173", "http://localhost:3000"];
 function getVersion() {
 	try {
 		const pkgPath = join$1(__dirname, "..", "package.json");
@@ -5180,6 +5379,11 @@ function getVersion() {
 		return "0.0.0";
 	}
 }
+function buildHostedCorsOrigins(baseUrl) {
+	const origins = new Set(DEFAULT_HOSTED_CORS_ORIGINS);
+	origins.add(new URL(baseUrl).origin);
+	return [...origins];
+}
 async function main() {
 	const originalCwd = process.env.INIT_CWD || process.cwd();
 	await yargs_default(hideBin(process.argv)).scriptName("openspecui").command(["$0 [project-dir]", "start [project-dir]"], "Start the OpenSpec UI server", (yargs) => {
@@ -5199,9 +5403,13 @@ async function main() {
 			describe: "Automatically open the browser",
 			type: "boolean",
 			default: true
+		}).option("app", {
+			describe: "Open the hosted app at the official or custom base URL. Supports --app and --app=<baseUrl>.",
+			type: "string"
 		});
 	}, async (argv) => {
 		const projectDir = resolve$1(originalCwd, argv["project-dir"] || argv.dir || ".");
+		const useHostedApp = argv.app !== void 0;
 		console.log(`
 ┌─────────────────────────────────────────────┐
 │           OpenSpec UI                       │
@@ -5210,31 +5418,69 @@ async function main() {
 `);
 		console.log(`📁 Project: ${projectDir}`);
 		console.log("");
+		let server = null;
+		let localHostedApp = null;
 		try {
-			const server = await startServer({
+			const localVersion = getVersion();
+			let hostedBaseUrl = null;
+			if (useHostedApp) {
+				const workspace = resolveLocalHostedAppWorkspace(__dirname);
+				const localHostedAppMode = {
+					appValue: argv.app,
+					workspace
+				};
+				if (shouldUseLocalHostedAppDevMode(localHostedAppMode)) {
+					localHostedApp = await startLocalHostedAppDev({
+						workspace: localHostedAppMode.workspace,
+						resolvedVersion: localVersion
+					});
+					hostedBaseUrl = localHostedApp.baseUrl;
+				} else {
+					const config = await new ConfigManager(projectDir).readConfig();
+					hostedBaseUrl = resolveEffectiveHostedAppBaseUrl({
+						override: argv.app,
+						configured: config.appBaseUrl
+					});
+				}
+			}
+			server = await startServer({
 				projectDir,
 				port: argv.port,
-				open: argv.open
+				open: false,
+				corsOrigins: hostedBaseUrl ? buildHostedCorsOrigins(hostedBaseUrl) : void 0
 			});
 			if (server.port !== server.preferredPort) console.log(`⚠️  Port ${server.preferredPort} is in use, using ${server.port} instead`);
 			console.log(`✅ Server running at ${server.url}`);
+			let browserUrl = server.url;
+			if (useHostedApp && hostedBaseUrl) {
+				browserUrl = buildHostedAppLaunchUrl({
+					baseUrl: hostedBaseUrl,
+					apiBaseUrl: server.url
+				});
+				console.log(`🌐 Hosted app base: ${hostedBaseUrl}`);
+				console.log(`🔗 Hosted URL: ${browserUrl}`);
+			}
 			console.log("");
 			if (argv.open) {
-				await (await import("./open-DDagk2eo.mjs")).default(server.url);
-				console.log("🌐 Browser opened");
+				await (await import("./open-DfwCb8mL.mjs")).default(browserUrl);
+				console.log(useHostedApp ? "🌐 Hosted app opened" : "🌐 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();
+				await localHostedApp?.close();
+				await server?.close();
 				process.exit(0);
 			});
 			process.on("SIGTERM", async () => {
-				await server.close();
+				await localHostedApp?.close();
+				await server?.close();
 				process.exit(0);
 			});
 		} catch (error) {
+			await localHostedApp?.close();
+			await server?.close();
 			console.error("❌ Failed to start server:", error);
 			process.exit(1);
 		}
@@ -5297,9 +5543,12 @@ async function main() {
 			console.error("❌ Export failed:", error);
 			process.exit(1);
 		}
-	}).example("$0", "Start server in current directory").example("$0 ./my-project", "Start server with specific project").example("$0 -p 8080", "Start server on custom port").example("$0 export -o ./dist", "Export HTML to ./dist directory").example("$0 export -o ./dist -f json", "Export JSON data only").example("$0 export -o ./dist -p 8092", "Export and open preview on port 8092").example("$0 export -o ./dist --base-path=/docs/", "Export for subdirectory deployment").example("$0 export -o ./dist --clean", "Clean output directory before export").version(getVersion()).alias("v", "version").help().alias("h", "help").parse();
+	}).help().alias("help", "h").version(getVersion()).alias("version", "v").strict().parseAsync();
 }
-main();
+main().catch((error) => {
+	console.error("Fatal error:", error);
+	process.exit(1);
+});
 
 //#endregion
 export {  };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { n as createServer, t as startServer } from "./src-Cx7GJTGT.mjs";
+import { n as createServer, t as startServer } from "./src-Nn_MJz41.mjs";
 
 export { createServer, startServer };

package/dist/{open-DDagk2eo.mjs → open-DfwCb8mL.mjs}

@@ -1,9 +1,9 @@
 import fs, { constants } from "node:fs/promises";
 import path from "node:path";
 import fs$1 from "node:fs";
+import { fileURLToPath } from "node:url";
 import childProcess, { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { fileURLToPath } from "node:url";
 import process from "node:process";
 import { Buffer } from "node:buffer";
 import os from "node:os";