@buding0904/vitepad 0.3.1 → 0.3.2

package/dist/cli.js

@@ -1,775 +1,46 @@
 #!/usr/bin/env node
-import fs2 from 'fs/promises';
-import os from 'os';
-import path2 from 'path';
-import process2 from 'process';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { createServer, mergeConfig, normalizePath, createLogger } from 'vite';
-import pc2 from 'picocolors';
-import { spawn } from 'child_process';
-import { createRequire } from 'module';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
-var packageRoot = path2.resolve(fileURLToPath(new URL("..", import.meta.url)));
-var requireFromPackage = createRequire(path2.join(packageRoot, "package.json"));
-var linkedPeerPackages = ["vite"];
-var log = {
-  framework(requested, resolved) {
-    console.log(`
-${pc2.cyan("vitepad")} ${pc2.bold("framework")} ${pc2.gray(requested)} ${pc2.gray("->")} ${pc2.green(resolved)}`);
-  },
-  install(packages) {
-    console.log(`  ${pc2.gray("install")} ${packages.map((pkg) => pc2.cyan(pkg)).join(pc2.gray(", "))}`);
-  },
-  done(message) {
-    console.log(`  ${pc2.green(message)}`);
-  }
-};
-async function resolveFramework(spec, options) {
-  if (spec.name === "auto") {
-    throw new Error("Internal error: unresolved framework auto.");
-  }
-  if (spec.name === "vanilla") {
-    return {
-      name: "vanilla",
-      version: "local",
-      requested: "vanilla",
-      cacheStatus: "local",
-      aliases: [],
-      packageLinks: packageLinks(["unocss"]),
-      editorPackageLinks: []
-    };
-  }
-  const resolved = await resolveFrameworkPackages(spec.name, spec.version);
-  const cacheDir = frameworkCacheDir(spec.name, resolved.version);
-  const nodeModules = path2.join(cacheDir, "node_modules");
-  const installed = await isInstalled(cacheDir, resolved.packages);
-  if (options.forceInstall && await pathExists(cacheDir)) {
-    await fs2.rm(cacheDir, { recursive: true, force: true });
-  }
-  log.framework(`${spec.name}@${spec.version}`, `${spec.name}@${resolved.version}`);
-  const cacheStatus = options.forceInstall ? "miss" : installed ? "hit" : "miss";
-  if (options.forceInstall || !installed) {
-    log.install(resolved.packages);
-    await installFrameworkCache(cacheDir, resolved.packages);
-  }
-  await linkPeerPackages(cacheDir);
-  return {
-    name: spec.name,
-    version: resolved.version,
-    requested: `${spec.name}@${spec.version}`,
-    cacheStatus,
-    cacheDir,
-    aliases: [],
-    packageLinks: [
-      ...packageLinks(["unocss"]),
-      ...packageLinks(nodeModules, frameworkRuntimePackages(spec.name))
-    ],
-    editorPackageLinks: packageLinks(nodeModules, frameworkEditorPackages(spec.name))
-  };
-}
-async function resolveFrameworkPackages(framework, version) {
-  const specs = frameworkPackageSpecs(framework, version);
-  const resolved = await Promise.all(specs.map(async (spec) => {
-    const parsed = splitPackageSpec(spec);
-    const resolvedVersion = await resolvePackageVersion(parsed.name, parsed.version);
-    return {
-      name: parsed.name,
-      version: resolvedVersion,
-      spec: `${parsed.name}@${resolvedVersion}`
-    };
-  }));
-  const primary = splitPackageSpec(specs[0]).name;
-  const primaryVersion = resolved.find((pkg) => pkg.name === primary)?.version;
-  if (!primaryVersion) {
-    throw new Error(`Failed to resolve ${framework}@${version}.`);
-  }
-  return {
-    version: primaryVersion,
-    packages: resolved.map((pkg) => pkg.spec)
-  };
-}
-function frameworkDedupe(framework) {
-  return frameworkRuntimePackages(framework);
-}
-function frameworkOptimizeDeps(framework) {
-  switch (framework) {
-    case "react":
-      return ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"];
-    case "preact":
-      return ["preact", "preact/jsx-runtime", "preact/hooks"];
-    case "solid":
-      return ["solid-js", "solid-js/web"];
-    case "vue":
-      return ["vue"];
-    case "svelte":
-    case "vanilla":
-      return [];
-  }
-}
-async function loadFrameworkPlugins(framework) {
-  if (framework.name === "vanilla") {
-    return [];
-  }
-  if (!framework.cacheDir) {
-    throw new Error(`Missing framework cache for ${framework.name}.`);
-  }
-  const plugins = [];
-  for (const pluginPackage of frameworkPluginPackages(framework.name)) {
-    const mod = await importCachePackage(framework.cacheDir, pluginPackage);
-    appendPlugin(plugins, createFrameworkPlugin(pluginPackage, mod));
-  }
-  return plugins;
+async function packageVersion() {
+  const packageJson = await readPackageJson();
+  if (typeof packageJson.version === "string") return packageJson.version;
+  throw new Error("Failed to read vitepad version from package.json.");
 }
-function createFrameworkPlugin(pluginPackage, mod) {
-  const factory = frameworkPluginFactory(pluginPackage, mod);
-  return factory();
-}
-function frameworkPluginFactory(pluginPackage, mod) {
-  if (pluginPackage === "@sveltejs/vite-plugin-svelte" && typeof mod.svelte === "function") {
-    return mod.svelte;
-  }
-  if (pluginPackage === "@preact/preset-vite" && typeof mod.preact === "function") {
-    return mod.preact;
-  }
-  if (typeof mod.default === "function") {
-    return mod.default;
-  }
-  if (mod.default && typeof mod.default.default === "function") {
-    return mod.default.default;
-  }
-  throw new Error(`Failed to load Vite plugin ${pluginPackage}: no callable plugin export found.`);
-}
-function appendPlugin(plugins, plugin) {
-  if (Array.isArray(plugin)) {
-    plugins.push(...plugin);
-  } else {
-    plugins.push(plugin);
-  }
-}
-function frameworkPackageSpecs(framework, version) {
-  switch (framework) {
-    case "react":
-      return [
-        `react@${version}`,
-        `react-dom@${version}`,
-        `@types/react@${reactTypesVersion(version)}`,
-        `@types/react-dom@${reactTypesVersion(version)}`,
-        "@vitejs/plugin-react@latest"
-      ];
-    case "preact":
-      return [`preact@${version}`, "@preact/preset-vite@latest"];
-    case "solid":
-      return [`solid-js@${version}`, "vite-plugin-solid@latest"];
-    case "vue":
-      return [`vue@${version}`, "@vitejs/plugin-vue@latest", "@vitejs/plugin-vue-jsx@latest"];
-    case "svelte":
-      return [`svelte@${version}`, "@sveltejs/vite-plugin-svelte@latest"];
-    case "vanilla":
-      return [];
-  }
-}
-function reactTypesVersion(version) {
-  const major = version.match(/^\D*(\d+)/)?.[1];
-  return major || "latest";
-}
-function resolvePackageVersion(name, range) {
-  return new Promise((resolve, reject) => {
-    const child = spawn("npm", ["view", `${name}@${range}`, "version", "--json"], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code !== 0) {
-        reject(new Error(`npm view failed for ${name}@${range}
-${stderr.trim()}`));
-        return;
-      }
-      try {
-        const parsed = JSON.parse(stdout.trim());
-        const version = Array.isArray(parsed) ? parsed[parsed.length - 1] : parsed;
-        if (typeof version !== "string" || !version) {
-          throw new Error(`Unexpected npm view output: ${stdout}`);
-        }
-        resolve(version);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  });
-}
-function frameworkRuntimePackages(framework) {
-  switch (framework) {
-    case "react":
-      return ["react", "react-dom"];
-    case "preact":
-      return ["preact"];
-    case "solid":
-      return ["solid-js"];
-    case "vue":
-      return ["vue"];
-    case "svelte":
-      return ["svelte"];
-    case "vanilla":
-      return [];
-  }
-}
-function frameworkEditorPackages(framework) {
-  switch (framework) {
-    case "react":
-      return ["react", "react-dom", "@types/react", "@types/react-dom"];
-    case "preact":
-    case "solid":
-    case "vue":
-    case "svelte":
-    case "vanilla":
-      return frameworkRuntimePackages(framework);
-  }
-}
-function frameworkPluginPackages(framework) {
-  switch (framework) {
-    case "react":
-      return ["@vitejs/plugin-react"];
-    case "preact":
-      return ["@preact/preset-vite"];
-    case "solid":
-      return ["vite-plugin-solid"];
-    case "vue":
-      return ["@vitejs/plugin-vue", "@vitejs/plugin-vue-jsx"];
-    case "svelte":
-      return ["@sveltejs/vite-plugin-svelte"];
-    case "vanilla":
-      return [];
-  }
-}
-function packageLinks(nodeModulesOrPackageNames, maybePackageNames) {
-  if (Array.isArray(nodeModulesOrPackageNames)) {
-    return nodeModulesOrPackageNames.map((packageName) => ({
-      name: packageName,
-      source: resolveInstalledPackageDir(packageName)
-    }));
-  }
-  const nodeModules = nodeModulesOrPackageNames;
-  const packageNames = maybePackageNames ?? [];
-  return packageNames.map((packageName) => ({
-    name: packageName,
-    source: path2.join(nodeModules, packageName)
-  }));
-}
-function resolveInstalledPackageDir(packageName) {
-  const packageJson = requireFromPackage.resolve(`${packageName}/package.json`);
-  return path2.dirname(packageJson);
-}
-function frameworkCacheDir(framework, version) {
-  const base = process.env.VITEPAD_CACHE_DIR || (process.env.XDG_CACHE_HOME ? path2.join(process.env.XDG_CACHE_HOME, "vitepad") : path2.join(os.homedir(), ".cache", "vitepad"));
-  return path2.join(base, "frameworks", `${framework}-${sanitizeCacheKey(version)}`);
-}
-function sanitizeCacheKey(value) {
-  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
-async function isInstalled(cacheDir, packages) {
-  if (!await pathExists(path2.join(cacheDir, "node_modules"))) return false;
-  for (const pkg of packages) {
-    const { name } = splitPackageSpec(pkg);
-    if (!await pathExists(path2.join(cacheDir, "node_modules", name))) {
-      return false;
+async function readPackageJson() {
+  let current = path.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const packageJsonPath = path.join(current, "package.json");
+    const source = await fs.readFile(packageJsonPath, "utf8").catch(() => null);
+    if (source) {
+      const packageJson = JSON.parse(source);
+      if (packageJson.name === "@buding0904/vitepad") return packageJson;
     }
-  }
-  return true;
-}
-async function installFrameworkCache(cacheDir, packages) {
-  await fs2.mkdir(cacheDir, { recursive: true });
-  await fs2.writeFile(path2.join(cacheDir, "package.json"), JSON.stringify({
-    private: true,
-    type: "module",
-    dependencies: Object.fromEntries(packages.map((pkg) => packageToDependency(pkg)))
-  }, null, 2));
-  await runInstall(cacheDir);
-}
-function runInstall(cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn("npm", ["install", "--legacy-peer-deps", "--no-audit", "--no-fund", "--loglevel=notice"], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const progress = createProgress("vitepad: installing framework packages");
-    let output = "";
-    child.stdout.on("data", (chunk) => {
-      output += chunk;
-      progress.tick();
-    });
-    child.stderr.on("data", (chunk) => {
-      output += chunk;
-      progress.tick();
-    });
-    child.on("error", (error) => {
-      progress.stop();
-      reject(error);
-    });
-    child.on("exit", (code) => {
-      progress.stop();
-      if (code === 0) {
-        log.done("install complete");
-        resolve();
-      } else {
-        reject(new Error(`npm install failed with exit code ${code}
-${output.trim()}`));
-      }
-    });
-  });
-}
-async function linkPeerPackages(cacheDir) {
-  await fs2.mkdir(path2.join(cacheDir, "node_modules"), { recursive: true });
-  for (const packageName of linkedPeerPackages) {
-    try {
-      await linkPackage({
-        source: resolveInstalledPackageDir(packageName),
-        target: path2.join(cacheDir, "node_modules", packageName)
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to link ${packageName} into vitepad cache at ${cacheDir}.
-${message}`);
-    }
-  }
-}
-async function linkPackage(input) {
-  const source = await fs2.realpath(input.source);
-  const existing = await fs2.lstat(input.target).catch(() => null);
-  if (existing) {
-    if (existing.isSymbolicLink()) {
-      const current = await fs2.realpath(input.target).catch(() => null);
-      if (current === source) return;
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new Error("Failed to locate vitepad package.json.");
     }
-    await fs2.rm(input.target, { recursive: true, force: true });
+    current = parent;
   }
-  await fs2.symlink(source, input.target, "dir");
-}
-function createProgress(label) {
-  const width = 18;
-  let frame = 0;
-  const render = () => {
-    const position = frame % width;
-    const bar = Array.from({ length: width }, (_, index) => index === position ? "=" : "-").join("");
-    process.stderr.write(`\r${label} [${bar}]`);
-    frame += 1;
-  };
-  const timer = setInterval(render, 120);
-  render();
-  return {
-    tick: render,
-    stop() {
-      clearInterval(timer);
-      process.stderr.write(`\r${" ".repeat(label.length + width + 4)}\r`);
-    }
-  };
-}
-function packageToDependency(pkg) {
-  const parsed = splitPackageSpec(pkg);
-  return [parsed.name, parsed.version];
-}
-function splitPackageSpec(spec) {
-  if (spec.startsWith("@")) {
-    const secondAt = spec.indexOf("@", 1);
-    if (secondAt === -1) return { name: spec, version: "latest" };
-    return { name: spec.slice(0, secondAt), version: spec.slice(secondAt + 1) };
-  }
-  const at = spec.indexOf("@");
-  if (at === -1) return { name: spec, version: "latest" };
-  return { name: spec.slice(0, at), version: spec.slice(at + 1) };
-}
-async function importCachePackage(cacheDir, packageName) {
-  const requireFromCache = createRequire(path2.join(cacheDir, "package.json"));
-  const resolved = requireFromCache.resolve(packageName);
-  return import(pathToFileURL(resolved).href);
-}
-async function pathExists(file) {
-  return fs2.access(file).then(() => true, () => false);
 }
 
-// src/runtime/index.ts
-var rootDir = path2.resolve(fileURLToPath(new URL("..", import.meta.url)));
-var supportedComponentExts = /* @__PURE__ */ new Set([".jsx", ".tsx", ".vue", ".svelte"]);
-var supportedMainExts = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]);
-var frameworkValues = /* @__PURE__ */ new Set(["auto", "react", "preact", "solid", "vue", "svelte", "vanilla"]);
-async function run(argv) {
-  const options = parseArgs(argv);
-  if (options.help) {
-    console.log(helpText());
-    return;
-  }
-  if (!options.entry) {
-    throw new Error(helpText("Missing entry file."));
-  }
-  const entry = path2.resolve(process2.cwd(), options.entry);
-  const stat = await fs2.stat(entry).catch(() => null);
-  if (!stat?.isFile()) {
-    throw new Error(`Entry file does not exist: ${entry}`);
-  }
-  const extension = path2.extname(entry).toLowerCase();
-  const mode = inferMode(extension);
-  const source = await fs2.readFile(entry, "utf8");
-  const framework = inferFramework({
-    extension,
-    source,
-    requested: options.framework,
-    version: options.frameworkVersion
-  });
-  validateCombination({ mode, framework: framework.name, extension });
-  const resolvedFramework = await resolveFramework(framework, { forceInstall: options.forceInstall });
-  await setupEditorPackages(path2.dirname(entry), resolvedFramework.editorPackageLinks);
-  const workspace = await createWorkspace({
-    entry,
-    mode,
-    framework: resolvedFramework.name,
-    packageLinks: resolvedFramework.packageLinks
-  });
-  const config = await loadUserConfig(options.config);
-  const server = await createServer(mergeConfig({
-    root: workspace,
-    configFile: false,
-    server: {
-      host: options.host,
-      port: options.port,
-      open: options.open,
-      watch: {
-        ignored: (file) => normalizePath(file).startsWith(`${normalizePath(workspace)}/`)
-      },
-      fs: {
-        allow: [
-          rootDir,
-          process2.cwd(),
-          path2.dirname(entry),
-          workspace,
-          ...resolvedFramework.cacheDir ? [resolvedFramework.cacheDir] : []
-        ]
-      }
-    },
-    plugins: await loadPlugins(resolvedFramework),
-    resolve: {
-      alias: [
-        ...resolvedFramework.aliases,
-        {
-          find: "@",
-          replacement: path2.dirname(entry)
-        }
-      ],
-      dedupe: frameworkDedupe(resolvedFramework.name)
-    },
-    optimizeDeps: {
-      entries: [path2.join(workspace, "src/main.js")],
-      include: frameworkOptimizeDeps(resolvedFramework.name)
-    },
-    customLogger: createVitepadLogger()
-  }, config));
-  await server.listen();
-  printReady({
-    entry,
-    framework: resolvedFramework,
-    urls: server.resolvedUrls
+// src/cli.ts
+var argv = process.argv.slice(2);
+var runtimeEntry = "./cli-runtime.js";
+if (argv.includes("-v") || argv.includes("--version")) {
+  packageVersion().then((version) => {
+    console.log(version);
+  }).catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
   });
-  const close = async () => {
-    await server.close();
-    process2.exit(0);
-  };
-  process2.once("SIGINT", close);
-  process2.once("SIGTERM", close);
-}
-function parseArgs(argv) {
-  const options = {
-    framework: "auto",
-    frameworkVersion: "latest",
-    forceInstall: false,
-    port: 8e3,
-    host: "0.0.0.0",
-    open: "/",
-    help: false
-  };
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (arg === "-h" || arg === "--help") {
-      options.help = true;
-    } else if (arg === "--framework" || arg === "-f") {
-      Object.assign(options, parseFramework(readValue(argv, ++index, arg)));
-    } else if (arg.startsWith("--framework=")) {
-      Object.assign(options, parseFramework(arg.slice("--framework=".length)));
-    } else if (arg === "--force-install") {
-      options.forceInstall = true;
-    } else if (arg === "--port" || arg === "-p") {
-      options.port = Number(readValue(argv, ++index, arg));
-    } else if (arg.startsWith("--port=")) {
-      options.port = Number(arg.slice("--port=".length));
-    } else if (arg === "--host") {
-      options.host = readValue(argv, ++index, arg);
-    } else if (arg.startsWith("--host=")) {
-      options.host = arg.slice("--host=".length);
-    } else if (arg === "--no-open") {
-      options.open = false;
-    } else if (arg === "--open") {
-      options.open = "/";
-    } else if (arg === "--config" || arg === "-c") {
-      options.config = readValue(argv, ++index, arg);
-    } else if (arg.startsWith("--config=")) {
-      options.config = arg.slice("--config=".length);
-    } else if (arg.startsWith("-")) {
-      throw new Error(`Unknown option: ${arg}`);
-    } else if (!options.entry) {
-      options.entry = arg;
-    } else {
-      throw new Error(`Unexpected argument: ${arg}`);
-    }
-  }
-  if (!Number.isInteger(options.port) || options.port < 0 || options.port > 65535) {
-    throw new Error(`Invalid port: ${options.port}`);
-  }
-  return options;
-}
-function parseFramework(value) {
-  const match = value.match(/^([^@]+)(?:@(.+))?$/);
-  const name = match?.[1];
-  const version = match?.[2] || "latest";
-  if (name && frameworkValues.has(name)) {
-    return { framework: name, frameworkVersion: version };
-  }
-  throw new Error(`Unsupported framework "${value}". Use one of: ${[...frameworkValues].join(", ")}, optionally with @version.`);
-}
-function readValue(argv, index, option) {
-  const value = argv[index];
-  if (!value || value.startsWith("-")) {
-    throw new Error(`Missing value for ${option}`);
-  }
-  return value;
-}
-function inferMode(extension) {
-  if (supportedMainExts.has(extension)) return "main";
-  if (supportedComponentExts.has(extension)) return "component";
-  throw new Error(`Unsupported entry extension "${extension}". Supported: js, ts, jsx, tsx, vue, svelte.`);
-}
-function inferFramework(input) {
-  const { extension, source, requested, version } = input;
-  if (requested !== "auto") return { name: requested, version };
-  if (extension === ".vue") return { name: "vue", version };
-  if (extension === ".svelte") return { name: "svelte", version };
-  if (/\bfrom\s+['"]solid-js\b|\bfrom\s+['"]solid-js\/web\b|\bsolid-js\b/.test(source)) return { name: "solid", version };
-  if (/\bfrom\s+['"]preact\b|\bfrom\s+['"]preact\/compat\b|\bfrom\s+['"]preact\/hooks\b/.test(source)) return { name: "preact", version };
-  if (/\bfrom\s+['"]vue\b/.test(source)) return { name: "vue", version };
-  if (/\bfrom\s+['"]svelte\b|\bfrom\s+['"]svelte\//.test(source)) return { name: "svelte", version };
-  if (extension === ".jsx" || extension === ".tsx") return { name: "react", version };
-  return { name: "vanilla", version: "local" };
-}
-function validateCombination(input) {
-  const { mode, framework, extension } = input;
-  if (mode === "component" && framework === "vanilla") {
-    throw new Error(`Component entry ${extension} needs a framework. Try --framework react, vue, svelte, preact, or solid.`);
-  }
-  if (extension === ".vue" && framework !== "vue") {
-    throw new Error(".vue entries must use --framework vue.");
-  }
-  if (extension === ".svelte" && framework !== "svelte") {
-    throw new Error(".svelte entries must use --framework svelte.");
-  }
-}
-async function createWorkspace(input) {
-  const workspace = await fs2.mkdtemp(path2.join(await fs2.realpath(os.tmpdir()), "vitepad-"));
-  const srcDir = path2.join(workspace, "src");
-  const nodeModulesDir = path2.join(workspace, "node_modules");
-  await fs2.mkdir(srcDir, { recursive: true });
-  await fs2.mkdir(nodeModulesDir, { recursive: true });
-  await Promise.all([
-    fs2.writeFile(path2.join(workspace, "index.html"), htmlTemplate()),
-    fs2.writeFile(path2.join(srcDir, "main.js"), mainTemplate(input)),
-    ...input.packageLinks.map((link) => linkWorkspacePackage(nodeModulesDir, link))
-  ]);
-  return workspace;
-}
-async function linkWorkspacePackage(nodeModulesDir, link) {
-  const source = await fs2.realpath(link.source);
-  const target = path2.join(nodeModulesDir, link.name);
-  await fs2.mkdir(path2.dirname(target), { recursive: true });
-  await fs2.symlink(source, target, "dir");
-}
-async function setupEditorPackages(projectDir, links) {
-  if (links.length === 0) return;
-  const nodeModulesDir = path2.join(projectDir, "node_modules");
-  await fs2.mkdir(nodeModulesDir, { recursive: true });
-  const linked = [];
-  for (const link of links) {
-    const result = await linkEditorPackage(nodeModulesDir, link);
-    if (result === "linked") {
-      linked.push(link.name);
-    }
-  }
-  if (linked.length > 0) {
-    console.log(`${pc2.cyan("vitepad")} ${pc2.green("editor")} linked ${linked.map((name) => pc2.cyan(name)).join(pc2.gray(", "))}`);
-  }
-}
-async function linkEditorPackage(nodeModulesDir, link) {
-  const source = await fs2.realpath(link.source);
-  const target = path2.join(nodeModulesDir, link.name);
-  await fs2.mkdir(path2.dirname(target), { recursive: true });
-  const existing = await fs2.lstat(target).catch(() => null);
-  if (existing) {
-    if (existing.isSymbolicLink()) {
-      const current = await fs2.realpath(target).catch(() => null);
-      if (current === source) return "skipped";
-    }
-    return "skipped";
-  }
-  await fs2.symlink(source, target, "dir");
-  return "linked";
+} else {
+  import(runtimeEntry).catch(handleError);
 }
-function htmlTemplate() {
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>vitepad</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.js"></script>
-  </body>
-</html>
-`;
-}
-function mainTemplate(input) {
-  const { entry, mode, framework } = input;
-  const importPath = `/@fs/${normalizePath(entry)}`;
-  if (mode === "main") {
-    return `import 'virtual:uno.css'
-import ${JSON.stringify(importPath)}
-`;
-  }
-  switch (framework) {
-    case "react":
-      return `import 'virtual:uno.css'
-import React from 'react'
-import { createRoot } from 'react-dom/client'
-import App from ${JSON.stringify(importPath)}
-
-createRoot(document.getElementById('root')).render(React.createElement(App))
-`;
-    case "preact":
-      return `import 'virtual:uno.css'
-import { h, render } from 'preact'
-import App from ${JSON.stringify(importPath)}
-
-render(h(App, null), document.getElementById('root'))
-`;
-    case "solid":
-      return `import 'virtual:uno.css'
-import { render } from 'solid-js/web'
-import App from ${JSON.stringify(importPath)}
-
-render(() => App({}), document.getElementById('root'))
-`;
-    case "vue":
-      return `import 'virtual:uno.css'
-import { createApp } from 'vue'
-import App from ${JSON.stringify(importPath)}
-
-createApp(App).mount('#root')
-`;
-    case "svelte":
-      return `import 'virtual:uno.css'
-import { mount } from 'svelte'
-import App from ${JSON.stringify(importPath)}
-
-const target = document.getElementById('root')
-const app = mount(App, { target })
-export default app
-`;
-    case "vanilla":
-      throw new Error("Vanilla entries cannot be used as component entries.");
-  }
-}
-async function loadUserConfig(configFile) {
-  if (!configFile) return {};
-  const resolved = path2.resolve(process2.cwd(), configFile);
-  const configModule = await import(pathToFileURL(resolved).href);
-  return configModule.default ?? configModule;
-}
-async function loadPlugins(framework) {
-  const [{ default: unocss }, { presetUno }, frameworkPlugins] = await Promise.all([
-    import('unocss/vite'),
-    import('unocss'),
-    loadFrameworkPlugins(framework)
-  ]);
-  const plugins = [];
-  appendPlugin(plugins, unocss({ presets: [presetUno()] }));
-  plugins.push(...frameworkPlugins);
-  return plugins;
-}
-function printReady(input) {
-  const { entry, framework, urls } = input;
-  const frameworkLabel = `${framework.name}@${framework.version}`;
-  console.log(`${pc2.cyan("vitepad")} ${pc2.green("ready")} ${pc2.green(frameworkLabel)}`);
-  console.log(`  ${pc2.gray("entry")}     ${pc2.gray(entry)}`);
-  if (framework.cacheDir) {
-    console.log(`  ${pc2.gray("cache")}     ${pc2.gray(framework.cacheDir)}`);
-  }
-  printUrls(urls);
-}
-function printUrls(urls) {
-  if (!urls) return;
-  for (const url of urls.local) {
-    console.log(`  ${pc2.green("\u279C")}  ${pc2.bold("Local:")}   ${pc2.bold(url)}`);
-  }
-  for (const url of urls.network) {
-    console.log(`  ${pc2.green("\u279C")}  ${pc2.bold("Network:")} ${pc2.bold(url)}`);
-  }
-}
-function createVitepadLogger() {
-  const logger = createLogger("info");
-  const info = logger.info.bind(logger);
-  return {
-    ...logger,
-    info(message, options) {
-      if (isNoisyViteInfo(message)) return;
-      info(message, options);
-    }
-  };
-}
-function isNoisyViteInfo(message) {
-  return /\[vite\]\s+\(client\)\s+(hmr update|page reload)\b/.test(stripAnsi(message));
-}
-function stripAnsi(value) {
-  return value.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
-}
-function helpText(prefix) {
-  return `${prefix ? `${prefix}
-
-` : ""}Usage:
-  vitepad <entry> [options]
-
-Entries:
-  .js, .ts                  Treated as main entry files.
-  .jsx, .tsx, .vue, .svelte Treated as App component files.
-
-Options:
-  -f, --framework <name>    auto, react, preact, solid, vue, svelte, vanilla
-                            Version specs are supported, e.g. react@18, vue@3.4.
-  --force-install           Reinstall the selected framework cache.
-  -p, --port <number>       Dev server port. Default: 8000
-  --host <host>             Dev server host. Default: 0.0.0.0
-  --no-open                 Do not open the browser automatically.
-  -c, --config <file>       Merge an extra Vite config file.
-  -h, --help                Show help.
-`;
-}
-
-// src/cli.ts
-run(process.argv.slice(2)).catch((error) => {
+function handleError(error) {
   console.error(error instanceof Error ? error.message : error);
   process.exit(1);
-});
+}
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map