@fluid-app/fluid-cli-widget 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1405 @@
+import { Command } from "commander";
+import { buildSharedWidgetPackage, createAuthenticatedWidgetPackageClient, loadSourceWidgetPackages, printDryRunSessionPayload, printRuntimeOnlyNotice, printWidgetPublishSummary, publishWidgetRuntimeArtifacts, validateSingleSourceWidgetPackage, validateWidgetPublishOutDir } from "@fluid-app/fluid-cli-portal";
+import chalk from "chalk";
+import ora from "ora";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, readFile, readdir, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import prompts from "prompts";
+//#region src/utils/config.ts
+const WIDGET_CONFIG_FILE = "fluid.widget.config.ts";
+var WidgetConfigParseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "WidgetConfigParseError";
+	}
+};
+function resolveWidgetConfigPath(projectDir) {
+	return path.join(projectDir, WIDGET_CONFIG_FILE);
+}
+async function loadWidgetConfig(projectDir) {
+	const configPath = resolveWidgetConfigPath(projectDir);
+	let source;
+	try {
+		source = await readFile(configPath, "utf-8");
+	} catch (err) {
+		if (isNodeError$1(err) && err.code === "ENOENT") return {
+			path: configPath,
+			config: {}
+		};
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Unable to read ${WIDGET_CONFIG_FILE}: ${message}`);
+	}
+	return {
+		path: configPath,
+		config: parseWidgetConfigSource(source)
+	};
+}
+async function writeWidgetConfig(projectDir, config) {
+	await writeFile(resolveWidgetConfigPath(projectDir), formatWidgetConfig(config), "utf-8");
+}
+function formatWidgetConfig(config) {
+	const lines = [
+		"import type { FluidWidgetConfig } from \"@fluid-app/fluid-cli-widget\";",
+		"",
+		"const config = {"
+	];
+	if (config.droplet) lines.push(`  droplet: ${JSON.stringify(config.droplet)},`);
+	lines.push("} satisfies FluidWidgetConfig;", "", "const widgetConfig: FluidWidgetConfig = config;", "", "export default config;", "export const droplet = widgetConfig.droplet;", "export { widgetPackage, widgetPackages } from \"./manifest\";", "");
+	return lines.join("\n");
+}
+function parseWidgetConfigSource(source) {
+	return parseConfigObjectProperties(extractConfigObjectLiteral(source));
+}
+function mergeWidgetConfig(current, updates) {
+	const droplet = normalizeOptionalString(updates.droplet) ?? normalizeOptionalString(current.droplet);
+	return droplet ? { droplet } : {};
+}
+function validateDropletUuid(dropletUuid) {
+	if (!dropletUuid) return "Droplet UUID is required.";
+	if (dropletUuid.length > MAX_DROPLET_UUID_LENGTH) return `Droplet UUID must be ${MAX_DROPLET_UUID_LENGTH} characters or fewer.`;
+	if (!URL_SAFE_IDENTIFIER_PATTERN.test(dropletUuid)) return "Droplet UUID must be URL-safe text: letters, numbers, '_', '~', and '-' only.";
+}
+function extractConfigObjectLiteral(source) {
+	const configStart = /\bconst\s+config\s*=\s*\{/.exec(source);
+	if (!configStart) throw new WidgetConfigParseError(`${WIDGET_CONFIG_FILE} must declare \`const config = { ... } satisfies FluidWidgetConfig\`.`);
+	const openBraceIndex = source.indexOf("{", configStart.index);
+	const closeBraceIndex = findMatchingBrace(source, openBraceIndex);
+	const suffix = stripComments(source.slice(closeBraceIndex + 1));
+	if (!/^\s*(?:as\s+const\s+)?satisfies\s+FluidWidgetConfig\s*;/.test(suffix)) throw new WidgetConfigParseError(`${WIDGET_CONFIG_FILE} config object must use \`satisfies FluidWidgetConfig\` or \`as const satisfies FluidWidgetConfig\`.`);
+	return stripComments(source.slice(openBraceIndex + 1, closeBraceIndex));
+}
+function parseConfigObjectProperties(objectSource) {
+	const config = {};
+	for (const member of splitTopLevelMembers(objectSource)) {
+		const trimmedMember = member.trim();
+		if (!trimmedMember) continue;
+		const propertyMatch = /^(droplet)\s*:\s*([\s\S]+)$/.exec(trimmedMember);
+		if (!propertyMatch) {
+			const propertyName = /^([A-Za-z_$][\w$]*)\s*:/.exec(trimmedMember)?.[1];
+			throw new WidgetConfigParseError(propertyName ? `${WIDGET_CONFIG_FILE} does not support config field ${propertyName}. Supported field is droplet.` : `${WIDGET_CONFIG_FILE} config fields must use optional droplet: "..." string literal.`);
+		}
+		const propertyName = propertyMatch[1];
+		if (propertyName !== "droplet") throw new WidgetConfigParseError(`${WIDGET_CONFIG_FILE} config field could not be parsed.`);
+		const value = parseStringLiteralValue(propertyMatch[2]?.trim() ?? "", propertyName);
+		if (!value.trim()) throw new WidgetConfigParseError(`${WIDGET_CONFIG_FILE} field ${propertyName} must be a non-empty string literal.`);
+		if (config.droplet !== void 0) throw new WidgetConfigParseError(`${WIDGET_CONFIG_FILE} field droplet must only be declared once.`);
+		config.droplet = value;
+	}
+	return config;
+}
+function parseStringLiteralValue(valueSource, propertyName) {
+	if (valueSource.startsWith("\"") && valueSource.endsWith("\"")) try {
+		const parsed = JSON.parse(valueSource);
+		if (typeof parsed === "string") return parsed;
+	} catch {}
+	if (valueSource.startsWith("'") && valueSource.endsWith("'")) return parseSingleQuotedStringLiteral(valueSource);
+	throw new WidgetConfigParseError(`${WIDGET_CONFIG_FILE} field ${propertyName} must be a string literal (for example ${propertyName}: "value").`);
+}
+function parseSingleQuotedStringLiteral(valueSource) {
+	let value = "";
+	for (let index = 1; index < valueSource.length - 1; index += 1) {
+		const char = valueSource[index];
+		if (char !== "\\") {
+			value += char;
+			continue;
+		}
+		index += 1;
+		const escaped = valueSource[index];
+		switch (escaped) {
+			case "\\":
+			case "'":
+			case "\"":
+				value += escaped;
+				break;
+			case "n":
+				value += "\n";
+				break;
+			case "r":
+				value += "\r";
+				break;
+			case "t":
+				value += "	";
+				break;
+			case "b":
+				value += "\b";
+				break;
+			case "f":
+				value += "\f";
+				break;
+			case "v":
+				value += "\v";
+				break;
+			default:
+				value += escaped ?? "";
+				break;
+		}
+	}
+	return value;
+}
+function stripComments(source) {
+	let result = "";
+	let stringQuote;
+	let escaped = false;
+	let lineComment = false;
+	let blockComment = false;
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index];
+		const nextChar = source[index + 1];
+		if (lineComment) {
+			if (char === "\n" || char === "\r") {
+				lineComment = false;
+				result += char;
+			} else result += " ";
+			continue;
+		}
+		if (blockComment) {
+			if (char === "*" && nextChar === "/") {
+				blockComment = false;
+				result += "  ";
+				index += 1;
+			} else if (char === "\n" || char === "\r") result += char;
+			else result += " ";
+			continue;
+		}
+		if (stringQuote) {
+			result += char;
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === stringQuote) stringQuote = void 0;
+			continue;
+		}
+		if (char === "/" && nextChar === "/") {
+			lineComment = true;
+			result += "  ";
+			index += 1;
+			continue;
+		}
+		if (char === "/" && nextChar === "*") {
+			blockComment = true;
+			result += "  ";
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") stringQuote = char;
+		result += char;
+	}
+	return result;
+}
+function splitTopLevelMembers(objectSource) {
+	const members = [];
+	let memberStart = 0;
+	let stringQuote;
+	let escaped = false;
+	let nestedDepth = 0;
+	for (let index = 0; index < objectSource.length; index += 1) {
+		const char = objectSource[index];
+		if (stringQuote) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === stringQuote) stringQuote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			stringQuote = char;
+			continue;
+		}
+		if (char === "{" || char === "[" || char === "(") {
+			nestedDepth += 1;
+			continue;
+		}
+		if (char === "}" || char === "]" || char === ")") {
+			nestedDepth -= 1;
+			continue;
+		}
+		if (char === "," && nestedDepth === 0) {
+			members.push(objectSource.slice(memberStart, index));
+			memberStart = index + 1;
+		}
+	}
+	members.push(objectSource.slice(memberStart));
+	return members;
+}
+function findMatchingBrace(source, openBraceIndex) {
+	let depth = 0;
+	let stringQuote;
+	let escaped = false;
+	let lineComment = false;
+	let blockComment = false;
+	for (let index = openBraceIndex; index < source.length; index += 1) {
+		const char = source[index];
+		const nextChar = source[index + 1];
+		if (lineComment) {
+			if (char === "\n" || char === "\r") lineComment = false;
+			continue;
+		}
+		if (blockComment) {
+			if (char === "*" && nextChar === "/") {
+				blockComment = false;
+				index += 1;
+			}
+			continue;
+		}
+		if (stringQuote) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === stringQuote) stringQuote = void 0;
+			continue;
+		}
+		if (char === "/" && nextChar === "/") {
+			lineComment = true;
+			index += 1;
+			continue;
+		}
+		if (char === "/" && nextChar === "*") {
+			blockComment = true;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			stringQuote = char;
+			continue;
+		}
+		if (char === "{") depth += 1;
+		if (char === "}") {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+	}
+	throw new WidgetConfigParseError(`${WIDGET_CONFIG_FILE} config object is missing a closing brace.`);
+}
+function normalizeOptionalString(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function isNodeError$1(error) {
+	return error instanceof Error && "code" in error;
+}
+const MAX_DROPLET_UUID_LENGTH = 256;
+const URL_SAFE_IDENTIFIER_PATTERN = new RegExp(`^[A-Za-z0-9][A-Za-z0-9_~-]*$`);
+//#endregion
+//#region src/utils/validation.ts
+function formatValidationErrors(errors) {
+	if (errors.length === 0) return "Validation failed.";
+	return ["Validation failed:", ...errors.map((error) => {
+		return `  - ${error.path ? `${error.path}: ` : ""}${error.message}`;
+	})].join("\n");
+}
+//#endregion
+//#region src/utils/source-package.ts
+const DEFAULT_WIDGET_OUT_DIR = ".fluid/widget-dist";
+const ROOT_WIDGET_CONFIG_FILE = WIDGET_CONFIG_FILE;
+const SOURCE_CONFIG_CANDIDATES = [
+	"src/widgets.config.ts",
+	"src/portal.config.ts",
+	"portal.config.ts"
+];
+var WidgetValidationError = class extends Error {
+	errors;
+	constructor(errors) {
+		super(formatValidationErrors(errors));
+		this.name = "WidgetValidationError";
+		this.errors = errors;
+	}
+};
+async function validateDropletWidgetProject(projectDir, packageKeyOverride) {
+	const resolvedProjectDir = path.resolve(projectDir);
+	const sourceConfig = resolveWidgetSourceConfig(resolvedProjectDir);
+	if (!sourceConfig) throw new WidgetValidationError([{
+		code: "NO_SOURCE_PACKAGE",
+		path: ROOT_WIDGET_CONFIG_FILE,
+		message: `No widget package config found. Create ${ROOT_WIDGET_CONFIG_FILE} or src/widgets.config.ts that exports defineWidgetPackage(...).`
+	}]);
+	const configErrors = await validateRootWidgetConfig(resolvedProjectDir, packageKeyOverride);
+	if (configErrors.length > 0) throw new WidgetValidationError(configErrors);
+	const sourcePackages = await withRootWidgetConfigBridge(resolvedProjectDir, async () => {
+		const loadResult = await loadSourceWidgetPackages(resolvedProjectDir);
+		if (!loadResult.success) throw new WidgetValidationError([{
+			code: "INVALID_SOURCE_PACKAGE",
+			path: sourceConfig.relativePath,
+			message: appendDetails(loadResult.error.message, loadResult.error.details)
+		}]);
+		return loadResult.value;
+	}, packageKeyOverride);
+	const validation = validateSingleSourceWidgetPackage(sourcePackages, { owner: "droplet" });
+	const errors = [...validation.errors, ...validateDropletMetadata(sourcePackages)];
+	if (!validation.success || !validation.value || errors.length > 0) throw new WidgetValidationError(errors);
+	return {
+		projectDir: resolvedProjectDir,
+		sourceConfigPath: sourceConfig.relativePath,
+		validated: validation.value
+	};
+}
+async function withRootWidgetConfigBridge(projectDir, callback, packageKeyOverride) {
+	if (!existsSync(path.join(projectDir, ROOT_WIDGET_CONFIG_FILE)) || resolvePortalSourceConfig(projectDir)) return callback();
+	const packageKey = packageKeyOverride?.trim() || (await loadWidgetConfig(projectDir)).config.droplet;
+	if (!packageKey) throw new Error("fluid.widget.config.ts must set droplet before validating, building, or publishing.");
+	const srcDir = path.join(projectDir, "src");
+	const bridgePath = path.join(srcDir, "widgets.config.ts");
+	const srcDirExisted = existsSync(srcDir);
+	await mkdir(srcDir, { recursive: true });
+	try {
+		await writeFile(bridgePath, createRootWidgetConfigBridgeSource(packageKey), {
+			encoding: "utf-8",
+			flag: "wx"
+		});
+	} catch (err) {
+		if (isNodeError(err) && err.code === "EEXIST") throw new Error(`${path.relative(projectDir, bridgePath)} already exists. Remove this stale Fluid widget CLI bridge file and try again.`);
+		throw err;
+	}
+	try {
+		return await callback();
+	} finally {
+		await rm(bridgePath, { force: true }).catch(() => {});
+		if (!srcDirExisted) await rmdir(srcDir).catch(() => {});
+	}
+}
+function createRootWidgetConfigBridgeSource(packageKey) {
+	return `import { widgetPackage as sourceWidgetPackage } from "../manifest";
+
+const packageKey = ${JSON.stringify(packageKey)};
+const packageId = sourceWidgetPackage.scope + "." + packageKey;
+
+export const widgetPackage = {
+  ...sourceWidgetPackage,
+  packageStableId: packageKey,
+  packageId,
+};
+
+export const widgetPackages = [widgetPackage] as const;
+export default widgetPackage;
+`;
+}
+function resolveWidgetSourceConfig(projectDir) {
+	const rootConfig = path.join(projectDir, ROOT_WIDGET_CONFIG_FILE);
+	if (existsSync(rootConfig)) return {
+		path: rootConfig,
+		relativePath: ROOT_WIDGET_CONFIG_FILE
+	};
+	return resolvePortalSourceConfig(projectDir);
+}
+function formatValidationSuccess(result) {
+	return [
+		"Widget package is valid.",
+		`Config:  ${result.sourceConfigPath ?? "unknown"}`,
+		`Package: ${result.validated.packageId}`,
+		`Version: ${result.validated.version}`,
+		`Widgets: ${result.validated.widgets.length}`
+	].join("\n");
+}
+async function validateRootWidgetConfig(projectDir, packageKeyOverride) {
+	if (!existsSync(path.join(projectDir, ROOT_WIDGET_CONFIG_FILE))) return [];
+	try {
+		const loaded = await loadWidgetConfig(projectDir);
+		const packageKeyError = validateDropletUuid(packageKeyOverride ?? loaded.config.droplet ?? "");
+		if (!packageKeyError) return [];
+		return [{
+			code: "INVALID_PACKAGE_KEY",
+			path: ROOT_WIDGET_CONFIG_FILE,
+			message: packageKeyError
+		}];
+	} catch (err) {
+		return [{
+			code: "INVALID_SOURCE_PACKAGE",
+			path: ROOT_WIDGET_CONFIG_FILE,
+			message: err instanceof Error ? err.message : String(err)
+		}];
+	}
+}
+function validateDropletMetadata(sourcePackages) {
+	if (sourcePackages.length !== 1) return [];
+	const sourcePackage = sourcePackages[0];
+	if (!isRecord$5(sourcePackage)) return [];
+	const errors = [];
+	if (sourcePackage["packageType"] !== "droplet") errors.push({
+		code: "UNSUPPORTED_OWNER",
+		path: "packageType",
+		message: "Droplet widget packages must set packageType: \"droplet\" in package metadata."
+	});
+	if (!isNonEmptyString(sourcePackage["packageStableId"])) errors.push({
+		code: "INVALID_PACKAGE_KEY",
+		path: "packageStableId",
+		message: "Droplet widget packages must set packageStableId so published widget types remain stable across builds."
+	});
+	const widgets = sourcePackage["widgets"];
+	if (Array.isArray(widgets)) widgets.forEach((widget, index) => {
+		if (!isRecord$5(widget)) return;
+		validateJsonSerializable(widget["propertySchema"], `widgets[${index}].propertySchema`, errors);
+		validateJsonSerializable(widget["defaultProps"], `widgets[${index}].defaultProps`, errors);
+	});
+	return errors;
+}
+function resolvePortalSourceConfig(projectDir) {
+	for (const relativePath of SOURCE_CONFIG_CANDIDATES) {
+		const candidate = path.join(projectDir, relativePath);
+		if (existsSync(candidate)) return {
+			path: candidate,
+			relativePath
+		};
+	}
+}
+function validateJsonSerializable(value, pathLabel, errors) {
+	if (value === void 0) return;
+	try {
+		assertJsonSerializable(value, pathLabel);
+	} catch (err) {
+		errors.push({
+			code: "INVALID_WIDGET_METADATA",
+			path: pathLabel,
+			message: err instanceof Error ? err.message : String(err)
+		});
+	}
+}
+function assertJsonSerializable(value, pathLabel) {
+	if (value === null) return;
+	const valueType = typeof value;
+	if (valueType === "string" || valueType === "boolean") return;
+	if (valueType === "number") {
+		if (Number.isFinite(value)) return;
+		throw new Error(`${pathLabel} must not contain NaN or Infinity.`);
+	}
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => {
+			assertJsonSerializable(item, `${pathLabel}[${index}]`);
+		});
+		return;
+	}
+	if (isRecord$5(value)) {
+		for (const [key, item] of Object.entries(value)) {
+			if (item === void 0) throw new Error(`${pathLabel}.${key} must not be undefined.`);
+			assertJsonSerializable(item, `${pathLabel}.${key}`);
+		}
+		return;
+	}
+	throw new Error(`${pathLabel} must contain only JSON-serializable values.`);
+}
+function appendDetails(message, details) {
+	return details ? `${message}\n${details}` : message;
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isRecord$5(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+//#endregion
+//#region src/utils/command.ts
+async function runCliAction(action) {
+	try {
+		await action();
+	} catch (err) {
+		console.error(chalk.red("Error:") + " " + formatUnknownError(err));
+		process.exit(1);
+	}
+}
+function formatUnknownError(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/utils/package-manager.ts
+function getRunCommand(script, cwd = process.cwd()) {
+	return `${detectPackageManager(cwd)} run ${script}`;
+}
+function getInstallCommand(cwd = process.cwd()) {
+	return `${detectPackageManager(cwd)} install`;
+}
+async function installDependencies(cwd) {
+	await runPackageManager(detectPackageManager(cwd), ["install"], cwd);
+}
+function detectPackageManager(cwd) {
+	if (existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+	if (existsSync(path.join(cwd, "bun.lockb"))) return "bun";
+	if (existsSync(path.join(cwd, "package-lock.json"))) return "npm";
+	const invokingPackageManager = readInvokingPackageManager();
+	if (invokingPackageManager) return invokingPackageManager;
+	const declaredPackageManager = readDeclaredPackageManager(cwd);
+	if (declaredPackageManager && isCommandAvailable(declaredPackageManager)) return declaredPackageManager;
+	return findAvailablePackageManager() ?? "pnpm";
+}
+function runPackageManager(command, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, [...args], {
+			cwd,
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.once("error", (error) => {
+			reject(error);
+		});
+		child.once("exit", (code) => {
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}`));
+		});
+	});
+}
+function readInvokingPackageManager() {
+	const userAgent = process.env["npm_config_user_agent"];
+	if (!userAgent) return void 0;
+	const name = userAgent.split("/")[0];
+	if (isPackageManager(name)) return name;
+}
+function readDeclaredPackageManager(cwd) {
+	const packageJsonPath = path.join(cwd, "package.json");
+	if (!existsSync(packageJsonPath)) return void 0;
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+		if (!isRecord$4(packageJson)) return void 0;
+		const packageManager = packageJson["packageManager"];
+		if (typeof packageManager !== "string") return void 0;
+		const name = packageManager.split("@")[0];
+		if (isPackageManager(name)) return name;
+	} catch {}
+}
+function findAvailablePackageManager() {
+	for (const packageManager of [
+		"pnpm",
+		"yarn",
+		"bun",
+		"npm"
+	]) if (isCommandAvailable(packageManager)) return packageManager;
+}
+function isCommandAvailable(command) {
+	return spawnSync(command, ["--version"], {
+		shell: process.platform === "win32",
+		stdio: "ignore"
+	}).status === 0;
+}
+function isPackageManager(value) {
+	return value === "pnpm" || value === "yarn" || value === "bun" || value === "npm";
+}
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/utils/package-scripts.ts
+async function runPackageScriptIfAvailable(options) {
+	const packageJsonPath = path.join(options.projectDir, "package.json");
+	if (!existsSync(packageJsonPath)) return { ran: false };
+	if (!hasPackageScript(await readPackageJson$1(packageJsonPath), options.scriptName)) return { ran: false };
+	const packageManager = detectPackageManager(options.projectDir);
+	const args = ["run", options.scriptName];
+	await runCommand(packageManager, args, options.projectDir);
+	return {
+		ran: true,
+		command: `${packageManager} ${args.join(" ")}`
+	};
+}
+function runCommand(command, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd,
+			stdio: "inherit",
+			env: process.env,
+			shell: process.platform === "win32"
+		});
+		child.on("error", reject);
+		child.on("exit", (code, signal) => {
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(signal ? `${command} ${args.join(" ")} exited with signal ${signal}.` : `${command} ${args.join(" ")} exited with code ${code ?? "unknown"}.`));
+		});
+	});
+}
+async function readPackageJson$1(packageJsonPath) {
+	const source = await readFile(packageJsonPath, "utf-8");
+	try {
+		return JSON.parse(source);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Unable to parse package.json: ${message}`);
+	}
+}
+function hasPackageScript(value, scriptName) {
+	if (!isRecord$3(value)) return false;
+	const scripts = value["scripts"];
+	if (!isRecord$3(scripts)) return false;
+	return typeof scripts[scriptName] === "string";
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/commands/build.ts
+async function buildWidgetPackage(options) {
+	await validateDropletWidgetProject(options.projectDir);
+	if (options.skipTypecheck !== true) await runPackageScriptIfAvailable({
+		projectDir: options.projectDir,
+		scriptName: "typecheck"
+	});
+	const outDir = validateWidgetPublishOutDir(options.projectDir, options.outDir);
+	const buildResult = await withRootWidgetConfigBridge(options.projectDir, () => buildSharedWidgetPackage({
+		projectDir: options.projectDir,
+		publishDir: outDir,
+		owner: "droplet"
+	}));
+	if (!buildResult.success) {
+		const details = buildResult.error.details ? `\n${buildResult.error.details}` : "";
+		throw new Error(`${buildResult.error.message}${details}`);
+	}
+	return {
+		outDir: buildResult.value.publishDir,
+		packageId: buildResult.value.packageId,
+		version: buildResult.value.version
+	};
+}
+const buildCommand = new Command("build").description("Validate and build the current droplet widget package").option("-o, --out-dir <dir>", "Widget artifact output directory", DEFAULT_WIDGET_OUT_DIR).option("--skip-typecheck", "Skip package typecheck script when present").action((options) => {
+	return runCliAction(async () => {
+		const outDir = options.outDir ?? ".fluid/widget-dist";
+		console.log(chalk.blue.bold("Building Fluid widget package"));
+		console.log();
+		const spinner = ora("Validating and building widget artifacts...").start();
+		const result = await buildWidgetPackage({
+			projectDir: process.cwd(),
+			outDir,
+			skipTypecheck: options.skipTypecheck
+		});
+		spinner.succeed("Built widget runtime artifacts");
+		console.log();
+		console.log(chalk.gray("Package: ") + chalk.white(result.packageId));
+		console.log(chalk.gray("Version: ") + chalk.white(result.version));
+		console.log(chalk.gray("Output:  ") + chalk.cyan(outDir));
+	});
+});
+//#endregion
+//#region src/utils/template.ts
+function getDefaultTemplatePath() {
+	return path.join(findPackageRoot(), "templates", "default");
+}
+async function directoryExists(filePath) {
+	try {
+		return (await stat(filePath)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function copyWidgetTemplate(templatePath, targetPath, variables) {
+	const files = await getFiles(templatePath);
+	for (const file of files) {
+		const sourcePath = path.join(templatePath, file);
+		const outputFile = getOutputFilename(file);
+		const destinationPath = path.join(targetPath, outputFile);
+		await mkdir(path.dirname(destinationPath), { recursive: true });
+		await writeFile(destinationPath, renderTemplate(await readFile(sourcePath, "utf-8"), variables), "utf-8");
+	}
+}
+async function getPortalSdkVersion(options = {}) {
+	return getWorkspacePackageVersion(["portal", "sdk"], "^0.1.0", options);
+}
+async function getPortalCoreVersion(options = {}) {
+	return getWorkspacePackageVersion(["portal", "core"], "^0.1.0", options);
+}
+async function getCliVersion(options = {}) {
+	return getWorkspacePackageVersion(["cli", "core"], "^0.1.0", options);
+}
+async function getWidgetCliVersion(options = {}) {
+	return getWorkspacePackageVersion(["cli", "widget"], "^0.1.0", options);
+}
+async function getWorkspacePackageVersion(packagePathSegments, fallback, options) {
+	try {
+		const packageRoot = findPackageRoot();
+		const packagesRoot = path.join(packageRoot, "..", "..");
+		const targetPackageRoot = path.join(packagesRoot, ...packagePathSegments);
+		if (options.local) return `file:${(options.targetPath ? path.relative(options.targetPath, targetPackageRoot) : targetPackageRoot) || "."}`;
+		const content = await readFile(path.join(targetPackageRoot, "package.json"), "utf-8");
+		return `^${JSON.parse(content).version ?? fallback.replace(/^\^/, "")}`;
+	} catch {
+		return fallback;
+	}
+}
+async function getFiles(dir, baseDir = dir) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) files.push(...await getFiles(fullPath, baseDir));
+		else files.push(path.relative(baseDir, fullPath));
+	}
+	return files;
+}
+function renderTemplate(content, variables) {
+	return content.replace(/{{\s*([a-zA-Z0-9_]+)\s*}}/g, (match, key) => {
+		if (isTemplateVariableKey(key)) return variables[key] ?? "";
+		return match;
+	});
+}
+function isTemplateVariableKey(key) {
+	return [
+		"projectName",
+		"widgetScope",
+		"widgetPackageVersion",
+		"sdkVersion",
+		"coreVersion",
+		"fluidCliVersion",
+		"widgetCliVersion",
+		"droplet"
+	].includes(key);
+}
+function getOutputFilename(filename) {
+	return filename.endsWith(".template") ? filename.slice(0, -9) : filename;
+}
+function findPackageRoot() {
+	let dir = path.dirname(fileURLToPath(import.meta.url));
+	while (!existsSync(path.join(dir, "package.json"))) {
+		const parent = path.dirname(dir);
+		if (parent === dir) throw new Error("Could not find widget CLI package root");
+		dir = parent;
+	}
+	return dir;
+}
+//#endregion
+//#region src/commands/create.ts
+const DEFAULT_WIDGET_PACKAGE_VERSION = "0.1.0";
+const DEFAULT_WIDGET_SCOPE = "droplet";
+const createCommand = new Command("create").description("Create a standalone Fluid widget project").argument("<project-name>", "Name of the widget project to create").option("--skip-install", "Skip dependency installation").option("-o, --output-dir <dir>", "Directory to create the project in (defaults to cwd)").option("--scope <scope>", "Widget package scope/namespace", DEFAULT_WIDGET_SCOPE).option("--package-version <version>", "Initial widget package version", DEFAULT_WIDGET_PACKAGE_VERSION).option("--local", "Use local monorepo packages via file: links (for development testing)").option("--droplet <uuid>", "Existing droplet UUID that owns the package").action(async (projectName, options) => {
+	try {
+		await createWidgetProject(projectName, options);
+	} catch (err) {
+		console.log();
+		console.error(chalk.red("Error:") + " " + (err instanceof Error ? err.message : String(err)));
+		console.log();
+		process.exit(1);
+	}
+});
+async function createWidgetProject(projectName, options) {
+	console.log();
+	console.log(chalk.bold("Creating a new Fluid widget project"));
+	console.log();
+	const projectNameError = validateProjectName(projectName);
+	if (projectNameError) throw new Error(projectNameError);
+	const droplet = options.droplet?.trim();
+	if (droplet) {
+		const dropletError = validateDropletUuid(droplet);
+		if (dropletError) throw new Error(dropletError);
+	}
+	const outputDir = path.resolve(options.outputDir ?? process.cwd());
+	const targetPath = path.join(outputDir, projectName);
+	if (await directoryExists(targetPath)) throw new Error(`Directory already exists: ${targetPath}`);
+	const templatePath = getDefaultTemplatePath();
+	if (!await directoryExists(templatePath)) throw new Error("Default widget template not found.");
+	const config = mergeWidgetConfig({}, { droplet });
+	const widgetScope = options.scope ?? DEFAULT_WIDGET_SCOPE;
+	const localOptions = {
+		local: options.local === true,
+		targetPath
+	};
+	const variables = {
+		projectName,
+		droplet: config.droplet,
+		widgetScope,
+		widgetPackageVersion: options.packageVersion ?? DEFAULT_WIDGET_PACKAGE_VERSION,
+		sdkVersion: await getPortalSdkVersion(localOptions),
+		coreVersion: await getPortalCoreVersion(localOptions),
+		fluidCliVersion: await getCliVersion(localOptions),
+		widgetCliVersion: await getWidgetCliVersion(localOptions)
+	};
+	const spinner = ora("Copying widget template...").start();
+	try {
+		await copyWidgetTemplate(templatePath, targetPath, variables);
+		await writeWidgetConfig(targetPath, config);
+		spinner.succeed("Copied widget template");
+	} catch (err) {
+		spinner.fail("Failed to create widget project");
+		throw err;
+	}
+	const installCommand = getInstallCommand(targetPath);
+	if (options.skipInstall !== true) {
+		spinner.start(`Installing dependencies with ${installCommand}...`);
+		try {
+			await installDependencies(targetPath);
+			spinner.succeed("Installed dependencies");
+		} catch {
+			spinner.fail("Failed to install dependencies");
+			console.log();
+			console.log(chalk.yellow("You can install dependencies manually:"));
+			console.log(chalk.cyan(`  cd ${formatCdPath(targetPath)}`));
+			console.log(chalk.cyan(`  ${installCommand}`));
+		}
+	}
+	console.log();
+	console.log(chalk.green.bold("Success!") + ` Created ${chalk.cyan(projectName)}`);
+	console.log();
+	console.log("Next steps:");
+	console.log(chalk.cyan(`  cd ${formatCdPath(targetPath)}`));
+	if (options.skipInstall === true) console.log(chalk.cyan(`  ${installCommand}`));
+	if (!config.droplet) console.log(chalk.cyan("  fluid widget link"));
+	console.log(chalk.cyan(`  ${getRunCommand("dev", targetPath)}`));
+	console.log();
+	console.log("Edit " + chalk.cyan("manifest.ts") + " to customize your widget package.");
+	console.log(chalk.dim("This command only creates local project files; it does not create a droplet."));
+	console.log();
+}
+function validateProjectName(projectName) {
+	if (!projectName) return "Project name is required.";
+	if (!/^[a-z0-9][a-z0-9-]*$/.test(projectName)) return "Project name must contain only lowercase letters, numbers, and hyphens.";
+}
+function formatCdPath(targetPath) {
+	return path.relative(process.cwd(), targetPath) || ".";
+}
+//#endregion
+//#region src/commands/dev.ts
+const DEFAULT_WIDGET_DEV_PORT = 5174;
+const WIDGET_DEV_ROUTES = [
+	"/",
+	"/builder-preview",
+	"/__manifests__",
+	"/__preview__",
+	"/__runtime-entry__"
+];
+const devCommand = new Command("dev").description("Start the local Fluid widget preview development server").option("-p, --port <port>", "Port to run the widget dev server on", String(DEFAULT_WIDGET_DEV_PORT)).option("--host [host]", "Expose the dev server to the network").option("--mode <mode>", "Vite mode to run", "development").action((options) => {
+	return runCliAction(async () => {
+		const projectDir = process.cwd();
+		printWidgetDevSummary(await resolveWidgetDevProject(projectDir, options));
+		await runViteDevServer(projectDir, options);
+	});
+});
+async function resolveWidgetDevProject(projectDir, options = {}) {
+	const resolvedProjectDir = path.resolve(projectDir);
+	const packageJsonPath = path.join(resolvedProjectDir, "package.json");
+	if (!existsSync(packageJsonPath)) throw new Error("No package.json found. Run this command from a Fluid widget project directory.");
+	const packageName = readPackageName(await readPackageJson(packageJsonPath)) ?? path.basename(projectDir);
+	const viteConfigPath = path.join(resolvedProjectDir, "vite.config.ts");
+	if (!existsSync(viteConfigPath)) throw new Error("No vite.config.ts found. Run this command from a Fluid widget project directory.");
+	const port = parsePort(options.port ?? String(5174));
+	const host = normalizeHostOption(options.host);
+	const mode = normalizeMode(options.mode);
+	return {
+		projectDir: resolvedProjectDir,
+		packageName,
+		viteConfigPath,
+		localUrl: formatLocalUrl(port, host),
+		target: packageName,
+		mode,
+		routes: WIDGET_DEV_ROUTES
+	};
+}
+function buildViteDevArgs(options = {}) {
+	const port = parsePort(options.port ?? String(5174));
+	const host = normalizeHostOption(options.host);
+	const mode = normalizeMode(options.mode);
+	const args = [
+		"--port",
+		String(port),
+		"--mode",
+		mode
+	];
+	if (host) args.push("--host", host);
+	return args;
+}
+function printWidgetDevSummary(summary) {
+	console.log();
+	console.log(chalk.blue.bold("Fluid Widget Dev"));
+	console.log(chalk.gray("Local:  ") + chalk.cyan(summary.localUrl));
+	console.log(chalk.gray("Target: ") + chalk.white(summary.target));
+	console.log(chalk.gray("Mode:   ") + chalk.white(summary.mode));
+	console.log(chalk.gray("Routes:"));
+	for (const route of summary.routes) console.log(chalk.gray("  - ") + chalk.cyan(route));
+	console.log();
+}
+async function runViteDevServer(projectDir, options = {}) {
+	const viteCliPath = resolveViteCliPath(projectDir);
+	if (!viteCliPath) throw new Error("Unable to find Vite in node_modules. Run your package manager install command before starting widget dev.");
+	await runNodeScript(viteCliPath, buildViteDevArgs(options), projectDir);
+}
+function resolveViteCliPath(projectDir) {
+	const viteCliPath = path.join(projectDir, "node_modules", "vite", "bin", "vite.js");
+	return existsSync(viteCliPath) ? viteCliPath : void 0;
+}
+async function readPackageJson(packageJsonPath) {
+	try {
+		return JSON.parse(await readFile(packageJsonPath, "utf-8"));
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Unable to read package.json: ${message}`);
+	}
+}
+function readPackageName(packageJson) {
+	if (!isRecord$2(packageJson)) return void 0;
+	const name = packageJson["name"];
+	if (typeof name !== "string") return void 0;
+	const trimmed = name.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function parsePort(value) {
+	const port = Number(value);
+	if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Port must be an integer between 1 and 65535.");
+	return port;
+}
+function normalizeHostOption(host) {
+	if (host === void 0 || host === false) return void 0;
+	if (host === true) return "0.0.0.0";
+	const trimmed = host.trim();
+	return trimmed.length > 0 ? trimmed : "0.0.0.0";
+}
+function normalizeMode(mode) {
+	const trimmed = mode?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : "development";
+}
+function formatLocalUrl(port, host) {
+	return `http://${host && host !== "0.0.0.0" ? host : "localhost"}:${port}`;
+}
+function runNodeScript(scriptPath, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, [scriptPath, ...args], {
+			cwd,
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.on("error", reject);
+		child.on("exit", (code, signal) => {
+			if (code === 0 || signal === "SIGINT" || signal === "SIGTERM") {
+				resolve();
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(signal ? `Vite dev server exited with signal ${signal}.` : `Vite dev server exited with code ${code ?? "unknown"}.`));
+		});
+	});
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/utils/auth-client.ts
+function createAuthenticatedClient() {
+	return { client: createAuthenticatedWidgetPackageClient() };
+}
+//#endregion
+//#region src/utils/droplets.ts
+async function promptForDroplet(client) {
+	const droplets = await listDroplets(client);
+	if (droplets.length === 0) throw new Error("No droplets were found for this account. Create a droplet in Fluid first, then run this command again.");
+	return (await prompts({
+		type: "autocomplete",
+		name: "droplet",
+		message: "Select the droplet that owns this widget package",
+		choices: droplets.map((droplet) => ({
+			title: `${droplet.name} (${droplet.uuid})`,
+			value: droplet.uuid
+		})),
+		suggest: (input, choices) => Promise.resolve(input ? choices.filter((choice) => choice.title.toLowerCase().includes(input.toLowerCase())) : choices)
+	}))["droplet"];
+}
+async function listDroplets(client) {
+	try {
+		return normalizeDropletsResponse(await client.get("/api/droplets"));
+	} catch (err) {
+		if (isApiLikeError(err)) {
+			if (err.status === 401 || err.status === 403) throw new Error("Your Fluid session has expired. Run `fluid login` and try again.");
+			throw new Error(`Could not fetch droplets from Fluid (HTTP ${err.status}). ${err.message}`);
+		}
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Could not fetch droplets from Fluid. ${message}`);
+	}
+}
+function normalizeDropletsResponse(response) {
+	return extractDropletArray(response).map(normalizeDroplet).filter((droplet) => droplet !== void 0);
+}
+function extractDropletArray(response) {
+	if (Array.isArray(response)) return response;
+	if (!isRecord$1(response)) return [];
+	const directDroplets = response["droplets"];
+	if (Array.isArray(directDroplets)) return directDroplets;
+	const data = response["data"];
+	if (Array.isArray(data)) return data;
+	if (isRecord$1(data) && Array.isArray(data["droplets"])) return data["droplets"];
+	return [];
+}
+function normalizeDroplet(value) {
+	if (!isRecord$1(value)) return void 0;
+	const uuid = readString(value, "uuid") ?? readString(value, "id");
+	if (!uuid) return void 0;
+	return {
+		uuid,
+		name: readString(value, "name") ?? readString(value, "title") ?? readString(value, "slug") ?? uuid
+	};
+}
+function readString(record, key) {
+	const value = record[key];
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+function isApiLikeError(error) {
+	return error instanceof Error && "status" in error && typeof error.status === "number";
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/commands/link.ts
+const linkCommand = new Command("link").description("Link this widget project to an existing Fluid droplet").option("--droplet <uuid>", "Droplet UUID that owns the widget package").action(async (options) => {
+	try {
+		const projectDir = process.cwd();
+		const loaded = await loadWidgetConfig(projectDir);
+		let droplet = options.droplet?.trim() || void 0;
+		if (!droplet) {
+			const spinner = ora("Fetching droplets...").start();
+			try {
+				const { client } = createAuthenticatedClient();
+				spinner.stop();
+				droplet = await promptForDroplet(client);
+			} catch (err) {
+				spinner.fail("Unable to load droplets");
+				throw err;
+			}
+			if (!droplet) {
+				console.log(chalk.dim("Cancelled."));
+				return;
+			}
+		}
+		const nextConfig = mergeWidgetConfig(loaded.config, { droplet });
+		const nextDropletError = validateDropletUuid(nextConfig.droplet ?? "");
+		if (nextDropletError) throw new Error(nextDropletError);
+		await writeWidgetConfig(projectDir, nextConfig);
+		console.log();
+		console.log(chalk.green("Linked widget project."));
+		console.log(chalk.gray("Config:       ") + chalk.cyan(path.relative(projectDir, loaded.path) || "fluid.widget.config.ts"));
+		console.log(chalk.gray("Droplet:      ") + chalk.white(nextConfig.droplet));
+		console.log(chalk.gray("Package key:  ") + chalk.white(`${nextConfig.droplet} (derived from droplet)`));
+		console.log();
+	} catch (err) {
+		console.log();
+		console.error(chalk.red("Error:") + " " + (err instanceof Error ? err.message : String(err)));
+		console.log();
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/utils/droplet-api.ts
+async function fetchDropletWidgetStatus(options) {
+	return extractArray(await options.client.get(`/api/droplets/${encodeURIComponent(options.droplet)}/widget_package_versions`)).map(normalizeVersionSummary);
+}
+async function fetchDropletWidgetLogs(options) {
+	return extractArray(await options.client.get(`/api/droplets/${encodeURIComponent(options.droplet)}/widget_package_versions/logs`, options.limit ? { limit: options.limit } : void 0)).map(normalizeLogEntry);
+}
+function formatStatusRows(versions) {
+	if (versions.length === 0) return "No widget package versions found.";
+	return versions.map((version) => {
+		const identity = version.packageId ?? version.packageKey ?? "unknown-package";
+		const release = version.version ?? "unknown-version";
+		const status = version.status ?? "unknown";
+		const updated = version.updatedAt ?? version.createdAt ?? "unknown time";
+		return `${identity}@${release} — ${status} — ${version.artifactCount === void 0 ? "unknown artifacts" : `${version.artifactCount} artifact${version.artifactCount === 1 ? "" : "s"}`} — ${updated}`;
+	}).join("\n");
+}
+function formatLogRows(logs) {
+	if (logs.length === 0) return "No widget package logs found.";
+	return logs.map((entry) => {
+		return `[${entry.timestamp ?? "unknown time"}] ${entry.level ? entry.level.toUpperCase() : "INFO"} ${entry.message}`;
+	}).join("\n");
+}
+function normalizeVersionSummary(value) {
+	const record = unwrapKnownNestedRecord(value);
+	const artifacts = readArray(record, "artifacts");
+	return {
+		packageKey: readFirstString(record, ["package_key", "packageKey"]),
+		packageId: readFirstString(record, ["package_id", "packageId"]),
+		version: readFirstString(record, ["version", "name"]),
+		status: readFirstString(record, ["status", "state"]),
+		createdAt: readFirstString(record, ["created_at", "createdAt"]),
+		updatedAt: readFirstString(record, ["updated_at", "updatedAt"]),
+		...artifacts ? { artifactCount: artifacts.length } : {},
+		raw: value
+	};
+}
+function normalizeLogEntry(value) {
+	const record = unwrapKnownNestedRecord(value);
+	return {
+		timestamp: readFirstString(record, [
+			"timestamp",
+			"created_at",
+			"createdAt"
+		]),
+		level: readFirstString(record, ["level", "severity"]),
+		message: readFirstString(record, [
+			"message",
+			"event",
+			"status",
+			"state"
+		]) ?? JSON.stringify(value),
+		raw: value
+	};
+}
+function extractArray(value) {
+	if (Array.isArray(value)) return value;
+	if (!isRecord(value)) return [];
+	for (const key of [
+		"widget_package_versions",
+		"widgetPackageVersions",
+		"versions",
+		"logs",
+		"events",
+		"data"
+	]) {
+		const nested = value[key];
+		if (Array.isArray(nested)) return nested;
+	}
+	return [value];
+}
+function unwrapKnownNestedRecord(value) {
+	if (!isRecord(value)) return {};
+	for (const key of [
+		"widget_package_version",
+		"widgetPackageVersion",
+		"version",
+		"log",
+		"event"
+	]) {
+		const nested = value[key];
+		if (isRecord(nested)) return nested;
+	}
+	return value;
+}
+function readArray(record, key) {
+	const value = record[key];
+	return Array.isArray(value) ? value : void 0;
+}
+function readFirstString(record, keys) {
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim().length > 0) return value;
+		if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/commands/logs.ts
+const logsCommand = new Command("logs").description("Show recent widget package publish logs for a Droplet").option("--droplet <uuid>", "Droplet UUID that owns the widget package").option("--limit <number>", "Maximum number of log entries to request", "50").option("--json", "Print raw log response as JSON").action((options) => {
+	return runCliAction(async () => {
+		const droplet = await resolveDroplet$1(process.cwd(), options.droplet);
+		const limit = parseLimit(options.limit);
+		const logs = await fetchDropletWidgetLogs({
+			client: createAuthenticatedWidgetPackageClient(),
+			droplet,
+			limit
+		});
+		if (options.json === true) {
+			console.log(JSON.stringify(logs.map((entry) => entry.raw), null, 2));
+			return;
+		}
+		console.log(chalk.blue.bold(`Widget logs for droplet ${droplet}`));
+		console.log();
+		console.log(formatLogRows(logs));
+	});
+});
+async function resolveDroplet$1(projectDir, override) {
+	const droplet = override?.trim() || (await loadWidgetConfig(projectDir)).config.droplet;
+	if (droplet?.trim()) {
+		const trimmedDroplet = droplet.trim();
+		const dropletError = validateDropletUuid(trimmedDroplet);
+		if (dropletError) throw new Error(dropletError);
+		return trimmedDroplet;
+	}
+	throw new Error("Missing droplet UUID. Pass --droplet <uuid> or set droplet in fluid.widget.config.ts.");
+}
+function parseLimit(value) {
+	if (!value) return void 0;
+	const parsed = Number(value);
+	if (Number.isInteger(parsed) && parsed > 0 && parsed <= 500) return parsed;
+	throw new Error("--limit must be an integer between 1 and 500.");
+}
+//#endregion
+//#region src/commands/publish.ts
+async function publishWidgetPackage(options, dependencies) {
+	if (dependencies) {
+		await dependencies.buildWidgetPackage({
+			projectDir: options.projectDir,
+			outDir: options.outDir
+		});
+		const dryRun = options.dryRun === true;
+		if (dryRun) return {
+			dryRun,
+			uploaded: false,
+			outDir: options.outDir
+		};
+		await dependencies.uploadWidgetPackage({
+			outDir: options.outDir,
+			droplet: options.droplet,
+			client: options.client
+		});
+		return {
+			dryRun,
+			uploaded: true,
+			outDir: options.outDir
+		};
+	}
+	const droplet = await resolvePublishDroplet(options.projectDir, options.droplet);
+	await validateDropletWidgetProject(options.projectDir, droplet);
+	if (options.skipTypecheck !== true) await runPackageScriptIfAvailable({
+		projectDir: options.projectDir,
+		scriptName: "typecheck"
+	});
+	const dryRun = options.dryRun === true;
+	await withRootWidgetConfigBridge(options.projectDir, () => publishWidgetRuntimeArtifacts({
+		projectDir: options.projectDir,
+		outDir: options.outDir,
+		buildOwner: "droplet",
+		uploadOwner: {
+			kind: "droplet",
+			uuid: droplet
+		},
+		dryRun,
+		...dryRun ? {} : { client: createAuthenticatedWidgetPackageClient() }
+	}), droplet);
+	return {
+		dryRun,
+		uploaded: !dryRun,
+		outDir: options.outDir,
+		droplet
+	};
+}
+const publishCommand = new Command("publish").description("Publish a Fluid widget package").option("-o, --out-dir <dir>", "Widget artifact output directory", DEFAULT_WIDGET_OUT_DIR).option("--droplet <uuid>", "Droplet UUID that owns the widget package").option("--dry-run", "Build and validate without uploading").option("--skip-typecheck", "Skip package typecheck script when present").action((options) => {
+	return runCliAction(async () => {
+		const projectDir = process.cwd();
+		const outDir = options.outDir ?? ".fluid/widget-dist";
+		const droplet = await resolvePublishDroplet(projectDir, options.droplet);
+		const dryRun = options.dryRun === true;
+		console.log();
+		console.log(chalk.blue.bold("Fluid Widget Publish"));
+		console.log();
+		printRuntimeOnlyNotice();
+		console.log(chalk.gray("Droplet: ") + chalk.white(droplet));
+		console.log(chalk.gray("Output:  ") + chalk.cyan(outDir));
+		if (dryRun) console.log(chalk.yellow("Dry run: no upload will be created."));
+		console.log();
+		const validateSpinner = ora("Validating widget package...").start();
+		await validateDropletWidgetProject(projectDir, droplet);
+		validateSpinner.succeed("Validated widget package");
+		if (options.skipTypecheck !== true) {
+			const typecheckSpinner = ora("Running package typecheck...").start();
+			if ((await runPackageScriptIfAvailable({
+				projectDir,
+				scriptName: "typecheck"
+			})).ran) typecheckSpinner.succeed("Package typecheck passed");
+			else typecheckSpinner.info("No typecheck script found; skipping");
+		}
+		const publishSpinner = ora(dryRun ? "Building and preparing dry-run upload payload..." : "Building and publishing widget artifacts...").start();
+		const result = await withRootWidgetConfigBridge(projectDir, () => publishWidgetRuntimeArtifacts({
+			projectDir,
+			outDir,
+			buildOwner: "droplet",
+			uploadOwner: {
+				kind: "droplet",
+				uuid: droplet
+			},
+			dryRun,
+			...dryRun ? {} : { client: createAuthenticatedWidgetPackageClient() }
+		}), droplet);
+		publishSpinner.succeed(dryRun ? "Prepared dry-run upload payload" : "Published widget package");
+		if (dryRun) {
+			console.log(chalk.yellow("Dry run complete — upload session was not requested."));
+			console.log();
+			printDryRunSessionPayload(result);
+		}
+		printWidgetPublishSummary({
+			title: dryRun ? "Widget publish dry run" : "Widget publish",
+			ownerLabel: `droplet ${droplet}`,
+			outDir,
+			result
+		});
+	});
+});
+async function resolvePublishDroplet(projectDir, override) {
+	const droplet = override?.trim() || (await loadWidgetConfig(projectDir)).config.droplet;
+	if (droplet?.trim()) {
+		const trimmedDroplet = droplet.trim();
+		const dropletError = validateDropletUuid(trimmedDroplet);
+		if (dropletError) throw new Error(dropletError);
+		return trimmedDroplet;
+	}
+	throw new Error("Missing droplet UUID. Pass --droplet <uuid> or set droplet in fluid.widget.config.ts.");
+}
+//#endregion
+//#region src/commands/status.ts
+const statusCommand = new Command("status").description("Show published widget package status for a Droplet").option("--droplet <uuid>", "Droplet UUID that owns the widget package").option("--json", "Print raw status response as JSON").action((options) => {
+	return runCliAction(async () => {
+		const droplet = await resolveDroplet(process.cwd(), options.droplet);
+		const versions = await fetchDropletWidgetStatus({
+			client: createAuthenticatedWidgetPackageClient(),
+			droplet
+		});
+		if (options.json === true) {
+			console.log(JSON.stringify(versions.map((version) => version.raw), null, 2));
+			return;
+		}
+		console.log(chalk.blue.bold(`Widget status for droplet ${droplet}`));
+		console.log();
+		console.log(formatStatusRows(versions));
+	});
+});
+async function resolveDroplet(projectDir, override) {
+	const droplet = override?.trim() || (await loadWidgetConfig(projectDir)).config.droplet;
+	if (droplet?.trim()) {
+		const trimmedDroplet = droplet.trim();
+		const dropletError = validateDropletUuid(trimmedDroplet);
+		if (dropletError) throw new Error(dropletError);
+		return trimmedDroplet;
+	}
+	throw new Error("Missing droplet UUID. Pass --droplet <uuid> or set droplet in fluid.widget.config.ts.");
+}
+//#endregion
+//#region src/commands/validate.ts
+const validateCommand = new Command("validate").description("Validate the current droplet widget package").option("--json", "Print machine-readable validation output").action((options) => {
+	return runCliAction(async () => {
+		const result = await validateDropletWidgetProject(process.cwd());
+		if (options.json === true) {
+			console.log(JSON.stringify({
+				valid: true,
+				config: result.sourceConfigPath,
+				packageId: result.validated.packageId,
+				version: result.validated.version,
+				widgets: result.validated.widgets.map((widget) => ({
+					name: widget.name,
+					type: widget.type
+				}))
+			}, null, 2));
+			return;
+		}
+		console.log(chalk.green(formatValidationSuccess(result)));
+	});
+});
+//#endregion
+//#region src/index.ts
+const widgetCommand = new Command("widget").description("Create, preview, link, validate, build, and publish standalone Fluid widgets").addCommand(createCommand).addCommand(devCommand).addCommand(linkCommand).addCommand(validateCommand).addCommand(buildCommand).addCommand(publishCommand).addCommand(statusCommand).addCommand(logsCommand);
+const plugin = {
+	name: "@fluid-app/fluid-cli-widget",
+	version: "0.1.0",
+	register(ctx) {
+		const existingWidgetCommand = findCommand(ctx.program, "widget");
+		if (existingWidgetCommand) {
+			addCommandIfMissing(existingWidgetCommand, createCommand);
+			addCommandIfMissing(existingWidgetCommand, devCommand);
+			addCommandIfMissing(existingWidgetCommand, linkCommand);
+			addCommandIfMissing(existingWidgetCommand, validateCommand);
+			addCommandIfMissing(existingWidgetCommand, buildCommand);
+			addCommandIfMissing(existingWidgetCommand, publishCommand);
+			addCommandIfMissing(existingWidgetCommand, statusCommand);
+			addCommandIfMissing(existingWidgetCommand, logsCommand);
+			return;
+		}
+		ctx.program.addCommand(widgetCommand);
+	}
+};
+function addCommandIfMissing(parent, child) {
+	if (findCommand(parent, child.name())) return;
+	parent.addCommand(child);
+}
+function findCommand(parent, name) {
+	return parent.commands?.find((command) => command.name() === name);
+}
+//#endregion
+export { DEFAULT_WIDGET_DEV_PORT, DEFAULT_WIDGET_OUT_DIR, ROOT_WIDGET_CONFIG_FILE, WIDGET_CONFIG_FILE, WIDGET_DEV_ROUTES, WidgetValidationError, buildCommand, buildViteDevArgs, buildWidgetPackage, createCommand, createWidgetProject, plugin as default, devCommand, formatValidationErrors, formatValidationSuccess, formatWidgetConfig, linkCommand, loadWidgetConfig, logsCommand, mergeWidgetConfig, parseWidgetConfigSource, printWidgetDevSummary, publishCommand, publishWidgetPackage, resolveWidgetConfigPath, resolveWidgetDevProject, resolveWidgetSourceConfig, runViteDevServer, statusCommand, validateCommand, validateDropletUuid, validateDropletWidgetProject, widgetCommand, withRootWidgetConfigBridge, writeWidgetConfig };
+
+//# sourceMappingURL=index.mjs.map