@kohryan/moodui 0.0.8 → 0.0.9

package/dist/cli.js

@@ -23,8 +23,525 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __toESM(require("path"));
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var import_node_url2 = require("url");
+var import_node_http = __toESM(require("http"));
+
+// node_modules/open/index.js
+var import_node_process6 = __toESM(require("process"), 1);
+var import_node_buffer = require("buffer");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_node_util5 = require("util");
+var import_node_child_process5 = __toESM(require("child_process"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+
+// node_modules/wsl-utils/index.js
+var import_node_process2 = __toESM(require("process"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+
+// node_modules/is-wsl/index.js
+var import_node_process = __toESM(require("process"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+
+// node_modules/is-inside-container/index.js
+var import_node_fs2 = __toESM(require("fs"), 1);
+
+// node_modules/is-docker/index.js
+var import_node_fs = __toESM(require("fs"), 1);
+var isDockerCached;
+function hasDockerEnv() {
+  try {
+    import_node_fs.default.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return import_node_fs.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === void 0) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+
+// node_modules/is-inside-container/index.js
+var cachedResult;
+var hasContainerEnv = () => {
+  try {
+    import_node_fs2.default.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+function isInsideContainer() {
+  if (cachedResult === void 0) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+
+// node_modules/is-wsl/index.js
+var isWsl = () => {
+  if (import_node_process.default.platform !== "linux") {
+    return false;
+  }
+  if (import_node_os.default.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    if (import_node_fs3.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+      return !isInsideContainer();
+    }
+  } catch {
+  }
+  if (import_node_fs3.default.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || import_node_fs3.default.existsSync("/run/WSL")) {
+    return !isInsideContainer();
+  }
+  return false;
+};
+var is_wsl_default = import_node_process.default.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+
+// node_modules/wsl-utils/index.js
+var wslDrivesMountPoint = /* @__PURE__ */ (() => {
+  const defaultMountPoint = "/mnt/";
+  let mountPoint;
+  return async function() {
+    if (mountPoint) {
+      return mountPoint;
+    }
+    const configFilePath = "/etc/wsl.conf";
+    let isConfigFileExists = false;
+    try {
+      await import_promises.default.access(configFilePath, import_promises.constants.F_OK);
+      isConfigFileExists = true;
+    } catch {
+    }
+    if (!isConfigFileExists) {
+      return defaultMountPoint;
+    }
+    const configContent = await import_promises.default.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;
+  };
+})();
+var powerShellPathFromWsl = async () => {
+  const mountPoint = await wslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+var powerShellPath = async () => {
+  if (is_wsl_default) {
+    return powerShellPathFromWsl();
+  }
+  return `${import_node_process2.default.env.SYSTEMROOT || import_node_process2.default.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+};
+
+// 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;
+}
+
+// node_modules/default-browser/index.js
+var import_node_util4 = require("util");
+var import_node_process5 = __toESM(require("process"), 1);
+var import_node_child_process4 = require("child_process");
+
+// node_modules/default-browser-id/index.js
+var import_node_util = require("util");
+var import_node_process3 = __toESM(require("process"), 1);
+var import_node_child_process = require("child_process");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+async function defaultBrowserId() {
+  if (import_node_process3.default.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+
+// node_modules/run-applescript/index.js
+var import_node_process4 = __toESM(require("process"), 1);
+var import_node_util2 = require("util");
+var import_node_child_process2 = require("child_process");
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (import_node_process4.default.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+
+// 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
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+
+// node_modules/default-browser/windows.js
+var import_node_util3 = require("util");
+var import_node_child_process3 = require("child_process");
+var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
+var windowsBrowserProgIds = {
+  MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+  // The missing `L` is correct.
+  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" }
+};
+var _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+var UnknownBrowserError = class extends Error {
+};
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  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 dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? void 0 : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? void 0 : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
+}
+
+// node_modules/default-browser/index.js
+var execFileAsync4 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
+var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+async function defaultBrowser2() {
+  if (import_node_process5.default.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (import_node_process5.default.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (import_node_process5.default.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+
+// node_modules/open/index.js
+var import_meta = {};
+var execFile5 = (0, import_node_util5.promisify)(import_node_child_process5.default.execFile);
+var __dirname = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+var localXdgOpenPath = import_node_path.default.join(__dirname, "xdg-open");
+var { platform, arch } = import_node_process6.default;
+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 encodedCommand = import_node_buffer.Buffer.from(rawCommand, "utf16le").toString("base64");
+  const { stdout } = await execFile5(
+    powershellPath,
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand",
+      encodedCommand
+    ],
+    { 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] } : {};
+}
+var pTryEach = async (array, mapper) => {
+  let latestError;
+  for (const item of array) {
+    try {
+      return await mapper(item);
+    } catch (error) {
+      latestError = error;
+    }
+  }
+  throw latestError;
+};
+var 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 defaultBrowser2();
+    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 = import_node_buffer.Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname || __dirname === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await import_promises2.default.access(localXdgOpenPath, import_promises2.constants.X_OK);
+        exeLocalXdgOpen = true;
+      } catch {
+      }
+      const useSystemXdgOpen = import_node_process6.default.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      command = useSystemXdgOpen ? "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 = import_node_child_process5.default.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(new Error(`Exited with code ${exitCode}`));
+          return;
+        }
+        resolve(subprocess);
+      });
+    });
+  }
+  subprocess.unref();
+  return subprocess;
+};
+var 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);
+}
+var 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;
 
 // src/validate.ts
 function validateMoodUISpec(input) {
@@ -48,21 +565,21 @@ function assertMoodUISpec(input) {
   }
   return result.value;
 }
-function validateNode(input, path2) {
+function validateNode(input, path3) {
   const errors = [];
-  if (!isObject(input)) return { ok: false, errors: [`${path2} must be an object`] };
+  if (!isObject(input)) return { ok: false, errors: [`${path3} must be an object`] };
   const type = input.type;
-  if (!isString(type)) return { ok: false, errors: [`${path2}.type must be a string`] };
+  if (!isString(type)) return { ok: false, errors: [`${path3}.type must be a string`] };
   switch (type) {
     case "box": {
       const children = input.children;
       if (children != null) {
         if (!Array.isArray(children)) {
-          errors.push(`${path2}.children must be an array`);
+          errors.push(`${path3}.children must be an array`);
         } else {
           for (let i = 0; i < children.length; i += 1) {
             const child = children[i];
-            const childResult = validateNode(child, `${path2}.children[${i}]`);
+            const childResult = validateNode(child, `${path3}.children[${i}]`);
             if (!childResult.ok) errors.push(...childResult.errors);
           }
         }
@@ -71,34 +588,34 @@ function validateNode(input, path2) {
     }
     case "text": {
       const props = input.props;
-      if (!isObject(props)) errors.push(`${path2}.props must be an object`);
-      else if (!isString(props.value)) errors.push(`${path2}.props.value must be a string`);
+      if (!isObject(props)) errors.push(`${path3}.props must be an object`);
+      else if (!isString(props.value)) errors.push(`${path3}.props.value must be a string`);
       break;
     }
     case "button": {
       const props = input.props;
-      if (!isObject(props)) errors.push(`${path2}.props must be an object`);
-      else if (!isString(props.label)) errors.push(`${path2}.props.label must be a string`);
+      if (!isObject(props)) errors.push(`${path3}.props must be an object`);
+      else if (!isString(props.label)) errors.push(`${path3}.props.label must be a string`);
       break;
     }
     case "input": {
       const props = input.props;
-      if (props != null && !isObject(props)) errors.push(`${path2}.props must be an object if provided`);
+      if (props != null && !isObject(props)) errors.push(`${path3}.props must be an object if provided`);
       break;
     }
     case "image": {
       const props = input.props;
-      if (!isObject(props)) errors.push(`${path2}.props must be an object`);
-      else if (!isString(props.src)) errors.push(`${path2}.props.src must be a string`);
+      if (!isObject(props)) errors.push(`${path3}.props must be an object`);
+      else if (!isString(props.src)) errors.push(`${path3}.props.src must be a string`);
       break;
     }
     case "spacer": {
       const props = input.props;
-      if (props != null && !isObject(props)) errors.push(`${path2}.props must be an object if provided`);
+      if (props != null && !isObject(props)) errors.push(`${path3}.props must be an object if provided`);
       break;
     }
     default:
-      errors.push(`${path2}.type must be one of: box | text | button | input | image | spacer`);
+      errors.push(`${path3}.type must be one of: box | text | button | input | image | spacer`);
   }
   if (errors.length > 0) return { ok: false, errors };
   return { ok: true, value: input };
@@ -280,11 +797,11 @@ function renderNode(node, ctx) {
 function renderElement(tag, node, ctx, renderChildren, extraProps) {
   const children = renderChildren();
   const propParts = buildProps(tag, node, extraProps);
-  const open = `<${tag}${propParts.length ? " " + propParts.join(" ") : ""}>`;
+  const open2 = `<${tag}${propParts.length ? " " + propParts.join(" ") : ""}>`;
   const close = `</${tag}>`;
-  if (children.length === 0) return indent(ctx.indent) + open + close;
+  if (children.length === 0) return indent(ctx.indent) + open2 + close;
   return [
-    indent(ctx.indent) + open,
+    indent(ctx.indent) + open2,
     ...children,
     indent(ctx.indent) + close
   ].join("\n");
@@ -583,6 +1100,8 @@ async function generateReactFromPrompt(options) {
 }
 
 // src/cli.ts
+var import_meta2 = {};
+var __dirname2 = import_node_path2.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
 async function main() {
   const argv = process.argv.slice(2);
   const command = argv[0] ?? "help";
@@ -590,6 +1109,10 @@ async function main() {
     printHelp();
     return;
   }
+  if (command === "ui") {
+    await runUI();
+    return;
+  }
   if (command !== "generate") {
     console.error(`Unknown command: ${command}`);
     printHelp();
@@ -652,17 +1175,65 @@ async function main() {
     temperature,
     maxAttempts
   });
-  const resolvedOut = import_node_path.default.resolve(process.cwd(), outFile);
-  await import_promises.default.mkdir(import_node_path.default.dirname(resolvedOut), { recursive: true });
-  await import_promises.default.writeFile(resolvedOut, result.code, "utf8");
+  const resolvedOut = import_node_path2.default.resolve(process.cwd(), outFile);
+  await import_promises3.default.mkdir(import_node_path2.default.dirname(resolvedOut), { recursive: true });
+  await import_promises3.default.writeFile(resolvedOut, result.code, "utf8");
   console.log(`OK: wrote ${resolvedOut}`);
 }
+async function runUI() {
+  let uiDir = import_node_path2.default.join(__dirname2, "ui");
+  try {
+    await import_promises3.default.access(uiDir);
+  } catch {
+    uiDir = import_node_path2.default.join(__dirname2, "..", "dist", "ui");
+  }
+  const PORT = 3e3;
+  console.log(`Starting MoodUI UI...`);
+  const server = import_node_http.default.createServer(async (req, res) => {
+    let filePath = import_node_path2.default.join(uiDir, req.url === "/" ? "index.html" : req.url);
+    const extname = String(import_node_path2.default.extname(filePath)).toLowerCase();
+    const mimeTypes = {
+      ".html": "text/html",
+      ".js": "text/javascript",
+      ".css": "text/css",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".ico": "image/x-icon"
+    };
+    const contentType = mimeTypes[extname] || "application/octet-stream";
+    try {
+      const content = await import_promises3.default.readFile(filePath);
+      res.writeHead(200, { "Content-Type": contentType });
+      res.end(content, "utf-8");
+    } catch (err) {
+      res.writeHead(404);
+      res.end("Not Found", "utf-8");
+    }
+  });
+  server.listen(PORT, () => {
+    const url = `http://localhost:${PORT}`;
+    console.log(`MoodUI UI running at ${url}`);
+    open_default(url);
+  });
+  process.on("SIGINT", () => {
+    server.close();
+    process.exit(0);
+  });
+}
 function printHelp() {
   console.log(
     [
-      "moodui generate [options] <prompt...>",
+      "moodui <command>",
       "",
-      "Options:",
+      "Commands:",
+      "  generate [options] <prompt...>  Generate component via CLI",
+      "  ui                             Launch Web UI for generating components",
+      "  help, --help, -h              Show this help message",
+      "",
+      "Generate Options:",
       "  --provider gemini|ollama|openai-compatible   default: gemini",
       "  --model <name>                               required (default for gemini: gemini-3-flash-preview)",
       "  --out <path>                                 path lengkap ke file output (termasuk direktori), default: src/generated/MoodScreen.tsx",
@@ -678,6 +1249,9 @@ function printHelp() {
       "  OPENAI_COMPATIBLE_API_KEY",
       "",
       "Examples:",
+      "  # Launch Web UI",
+      "  npx @kohryan/moodui ui",
+      "",
       "  # Generate ke src/generated/MoodScreen.tsx (default)",
       '  GEMINI_API_KEY=... npx @kohryan/moodui generate --model gemini-3-flash-preview "Buat UI login sederhana"',
       "",