@konomi-app/k2 2.1.5 → 3.0.0

package/dist/plugin.js

@@ -1,32 +1,40 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/plugin.ts
 import { program as program11 } from "commander";
 
 // src/commands/plugin-build.ts
 import { program } from "commander";
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 import path5 from "path";
-import "webpack";
+import chalk2 from "chalk";
 
 // src/lib/constants.ts
 import path from "path";
 var WORKSPACE_DIRECTORY = ".k2";
 var DEVELOPMENT_DIRECTORY = path.join(WORKSPACE_DIRECTORY, "dev");
+var PRODUCTION_DIRECTORY = path.join(WORKSPACE_DIRECTORY, "prod");
 var PLUGIN_CONFIG_FILE_NAME = "plugin.config.mjs";
 var PLUGIN_WORKSPACE_DIRECTORY = ".plugin";
 var PLUGIN_CONTENTS_DIRECTORY = path.join(PLUGIN_WORKSPACE_DIRECTORY, "contents");
 var PLUGIN_DEVELOPMENT_DIRECTORY = path.join(PLUGIN_WORKSPACE_DIRECTORY, "dev");
+var PLUGIN_PRODUCTION_DIRECTORY = path.join(PLUGIN_WORKSPACE_DIRECTORY, "prod");
 var DEFAULT_PORT = 32767;
 
 // src/lib/import.ts
 import { pathToFileURL } from "url";
 import path2 from "path";
-var esmImport = (path19) => {
+var esmImport = (path18) => {
   if (process.platform === "win32") {
-    return import(pathToFileURL(path19).toString());
+    return import(pathToFileURL(path18).toString());
   } else {
-    return import(path19);
+    return import(path18);
   }
 };
 var importK2PluginConfig = async (configFileName) => {
@@ -106,106 +114,21 @@ var watchTailwindCSS = async (params) => {
   watcher.on("error", (error) => {
     console.error("Error watching Tailwind CSS:", error);
   });
-  watcher.on("add", (path19) => {
+  watcher.on("add", (path18) => {
     debouncedProcessChanges.call("add");
   });
-  watcher.on("change", (path19) => {
+  watcher.on("change", (path18) => {
     debouncedProcessChanges.call("change");
   });
-  watcher.on("unlink", (path19) => {
+  watcher.on("unlink", (path18) => {
     debouncedProcessChanges.call("unlink");
   });
-  watcher.on("unlinkDir", (path19) => {
+  watcher.on("unlinkDir", (path18) => {
     debouncedProcessChanges.call("unlink");
   });
   return watcher;
 };
 
-// src/commands/build-base.ts
-import "webpack";
-
-// src/lib/webpack.ts
-import MiniCssExtractPlugin from "mini-css-extract-plugin";
-import path4 from "path";
-import { cwd } from "process";
-import TerserPlugin from "terser-webpack-plugin";
-import webpack from "webpack";
-import chalk from "chalk";
-import { TsconfigPathsPlugin } from "tsconfig-paths-webpack-plugin";
-var buildWithWebpack = async (props) => {
-  const { entries, outDir } = props;
-  const exclude = /node_modules/;
-  const styleLoader = MiniCssExtractPlugin.loader;
-  const tsConfigPath = path4.join(cwd(), "tsconfig.json");
-  console.group(chalk.blue("\u{1F680} Building with Webpack..."));
-  console.log("\u{1F527} tsconfig.json path:", tsConfigPath);
-  console.groupEnd();
-  return new Promise((resolve, reject) => {
-    webpack(
-      {
-        mode: "production",
-        target: ["web", "es2023"],
-        entry: entries,
-        resolve: {
-          extensions: [".ts", ".tsx", ".js", ".json"],
-          fallback: {
-            path: false
-          },
-          plugins: [new TsconfigPathsPlugin({ configFile: tsConfigPath })]
-        },
-        cache: { type: "filesystem" },
-        output: { filename: "[name].js", path: path4.resolve(outDir) },
-        module: {
-          rules: [
-            { test: /\.tsx?$/, exclude, loader: "ts-loader" },
-            { test: /\.css$/, use: [styleLoader, "css-loader"] },
-            {
-              test: /\.scss$/,
-              use: [
-                styleLoader,
-                "css-loader",
-                { loader: "sass-loader", options: { sassOptions: { outputStyle: "expanded" } } }
-              ]
-            }
-          ]
-        },
-        plugins: [new MiniCssExtractPlugin()],
-        optimization: {
-          minimize: true,
-          minimizer: [
-            new TerserPlugin({
-              terserOptions: { format: { comments: false } },
-              extractComments: false
-            })
-          ]
-        }
-      },
-      (err, stats) => {
-        if (err) {
-          reject(err);
-        } else {
-          if (stats?.compilation.errors.length) {
-            reject(
-              [
-                chalk.red("\u26A0 Build failed."),
-                ...stats.compilation.errors.map((error) => error.message)
-              ].join("\n")
-            );
-          } else {
-            resolve();
-          }
-        }
-      }
-    );
-  });
-};
-
-// src/commands/build-base.ts
-async function action(params) {
-  const { entries, outDir } = params;
-  return buildWithWebpack({ entries, outDir });
-}
-
 // src/lib/lint.ts
 import { ESLint } from "eslint";
 import globals from "globals";
@@ -235,11 +158,118 @@ async function lint() {
   }
 }
 
+// src/lib/vite.ts
+import path4 from "path";
+import fs2 from "fs-extra";
+import { build as viteBuild } from "vite";
+import chalk from "chalk";
+var createViteConfig = (config2 = {}) => {
+  const plugins = [...config2.plugins ?? []];
+  try {
+    const tsconfigPaths = __require("vite-tsconfig-paths");
+    plugins.push(tsconfigPaths.default ? tsconfigPaths.default() : tsconfigPaths());
+  } catch {
+  }
+  return {
+    ...config2,
+    configFile: false,
+    build: {
+      ...config2.build,
+      cssCodeSplit: false,
+      rollupOptions: {
+        ...config2.build?.rollupOptions,
+        onwarn: (warning, warn) => {
+          if (["MODULE_LEVEL_DIRECTIVE"].includes(warning.code ?? "")) {
+            return;
+          }
+          warn(warning);
+        }
+      }
+    },
+    plugins,
+    resolve: {
+      ...config2.resolve,
+      alias: {
+        "@": path4.resolve(process.cwd(), "src"),
+        ...config2.resolve?.alias
+      }
+    }
+  };
+};
+async function buildEntriesWithVite(params) {
+  const {
+    entries,
+    outDir,
+    mode = "production",
+    sourcemap = false,
+    minify = true,
+    viteConfig = {}
+  } = params;
+  for (const name of Object.keys(entries)) {
+    const entryPath = entries[name];
+    const config2 = createViteConfig({
+      ...viteConfig,
+      mode,
+      build: {
+        ...viteConfig.build,
+        lib: {
+          entry: entryPath,
+          name,
+          fileName: () => `${name}.js`,
+          formats: ["iife"]
+        },
+        rollupOptions: {
+          ...viteConfig.build?.rollupOptions,
+          output: {
+            assetFileNames: `${name}.[ext]`,
+            ...viteConfig.build?.rollupOptions?.output
+          }
+        },
+        outDir,
+        emptyOutDir: false,
+        sourcemap,
+        minify,
+        cssCodeSplit: false
+      }
+    });
+    await viteBuild(config2);
+  }
+}
+var ENTRY_FILE_NAMES = ["index.ts", "index.tsx", "index.js", "index.jsx", "index.mjs"];
+function findEntryPoint(basePath) {
+  for (const filename of ENTRY_FILE_NAMES) {
+    const entryPath = path4.join(basePath, filename);
+    if (fs2.existsSync(entryPath)) {
+      return entryPath;
+    }
+  }
+  if (fs2.existsSync(basePath) && fs2.statSync(basePath).isFile()) {
+    return basePath;
+  }
+  return null;
+}
+function getPluginEntryPoints(options) {
+  const entries = {};
+  const configPath = findEntryPoint(options.configEntry);
+  if (configPath) {
+    entries["config"] = configPath;
+  } else {
+    console.log(chalk.yellow(`  \u26A0 Config entry not found: ${options.configEntry}`));
+  }
+  const desktopPath = findEntryPoint(options.desktopEntry);
+  if (desktopPath) {
+    entries["desktop"] = desktopPath;
+  } else {
+    console.log(chalk.yellow(`  \u26A0 Desktop entry not found: ${options.desktopEntry}`));
+  }
+  return entries;
+}
+
 // src/commands/plugin-build.ts
 function command() {
-  program.command("build").description("Build the project for production. (It's a wrapper of webpack build command.)").action(action2);
+  program.command("build").description("Build the project for production with Vite.").action(action);
 }
-async function action2() {
+async function action() {
   console.group("\u{1F373} Build the project for production");
   try {
     const config2 = await importK2PluginConfig();
@@ -247,13 +277,19 @@ async function action2() {
       await lint();
       console.log("\u2728 Lint success.");
     }
-    if (!fs2.existsSync(PLUGIN_CONTENTS_DIRECTORY)) {
-      await fs2.mkdir(PLUGIN_CONTENTS_DIRECTORY, { recursive: true });
+    if (!fs3.existsSync(PLUGIN_CONTENTS_DIRECTORY)) {
+      await fs3.mkdir(PLUGIN_CONTENTS_DIRECTORY, { recursive: true });
+    }
+    await fs3.emptyDir(PLUGIN_CONTENTS_DIRECTORY);
+    const entries = getPluginEntryPoints({
+      configEntry: path5.resolve("src", "config"),
+      desktopEntry: path5.resolve("src", "desktop")
+    });
+    const entryNames = Object.keys(entries);
+    if (entryNames.length === 0) {
+      throw new Error("No entry points found for plugin. Check src/config and src/desktop paths.");
     }
-    const entries = {
-      desktop: path5.join("src", "desktop", "index.ts"),
-      config: path5.join("src", "config", "index.ts")
-    };
+    console.log(chalk2.gray(`  Entry points: ${entryNames.join(", ")}`));
     if (config2.tailwind?.css && config2.tailwind?.config) {
       const tailwindConfig = await getTailwindConfig(config2.tailwind);
       const inputFile = getTailwindInputCss(config2.tailwind);
@@ -272,7 +308,13 @@ async function action2() {
       });
       console.log("\u2728 Built desktop.css");
     }
-    await action({ entries, outDir: PLUGIN_CONTENTS_DIRECTORY });
+    await buildEntriesWithVite({
+      entries,
+      outDir: PLUGIN_CONTENTS_DIRECTORY,
+      mode: "production",
+      sourcemap: false,
+      minify: true
+    });
     console.log("\u2728 Built desktop.js and config.js");
     console.log("\u2728 Build success.");
   } catch (error) {
@@ -284,56 +326,13 @@ async function action2() {
 
 // src/commands/plugin-esbuild.ts
 import { program as program2 } from "commander";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 import path6 from "path";
-import "esbuild";
-
-// src/lib/esbuild.ts
-import chalk2 from "chalk";
-import esbuild from "esbuild";
-var completeBuildOptions = (params) => {
-  return {
-    bundle: true,
-    platform: "browser",
-    ...params,
-    plugins: [...params.plugins ?? []]
-  };
-};
-var completeDevBuildOptions = (params) => {
-  return completeBuildOptions({
-    ...params,
-    plugins: [
-      ...params.plugins ?? [],
-      {
-        name: "on-end",
-        setup: ({ onEnd }) => onEnd(
-          () => console.log(
-            chalk2.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk2.cyan(`[js] `) + `rebuilt`
-          )
-        )
-      }
-    ]
-  });
-};
-var getEsbuildContext = async (params) => {
-  return esbuild.context(completeDevBuildOptions(params));
-};
-var buildWithEsbuild = async (params) => {
-  const { watch = false, ...rest } = params;
-  if (watch) {
-    const context = await getEsbuildContext(rest);
-    context.watch();
-  } else {
-    const options = completeBuildOptions(rest);
-    await esbuild.build(options);
-  }
-};
-
-// src/commands/plugin-esbuild.ts
+import chalk3 from "chalk";
 function command2() {
-  program2.command("esbuild").description("Build the project for production. (It's a wrapper of webpack build command.)").action(action3);
+  program2.command("esbuild").description("Build the project for production with Vite. (Legacy command name, now uses Vite)").action(action2);
 }
-async function action3() {
+async function action2() {
   console.group("\u{1F373} Build the project for production");
   try {
     const config2 = await importK2PluginConfig();
@@ -341,9 +340,10 @@ async function action3() {
       await lint();
       console.log("\u2728 Lint success.");
     }
-    if (!fs3.existsSync(PLUGIN_CONTENTS_DIRECTORY)) {
-      await fs3.mkdir(PLUGIN_CONTENTS_DIRECTORY, { recursive: true });
+    if (!fs4.existsSync(PLUGIN_CONTENTS_DIRECTORY)) {
+      await fs4.mkdir(PLUGIN_CONTENTS_DIRECTORY, { recursive: true });
     }
+    await fs4.emptyDir(PLUGIN_CONTENTS_DIRECTORY);
     if (config2.tailwind?.css && config2.tailwind?.config) {
       const tailwindConfig = await getTailwindConfig(config2.tailwind);
       const inputFile = getTailwindInputCss(config2.tailwind);
@@ -362,16 +362,21 @@ async function action3() {
       });
       console.log("\u2728 Built desktop.css");
     }
-    const entryPoints = ["desktop", "config"].map((dir) => ({
-      in: path6.join("src", dir, "index.ts"),
-      out: dir
-    }));
-    await buildWithEsbuild({
-      entryPoints,
-      outdir: PLUGIN_CONTENTS_DIRECTORY,
-      minify: true,
+    const entries = getPluginEntryPoints({
+      configEntry: path6.resolve("src", "config"),
+      desktopEntry: path6.resolve("src", "desktop")
+    });
+    const entryNames = Object.keys(entries);
+    if (entryNames.length === 0) {
+      throw new Error("No entry points found for plugin. Check src/config and src/desktop paths.");
+    }
+    console.log(chalk3.gray(`  Entry points: ${entryNames.join(", ")}`));
+    await buildEntriesWithVite({
+      entries,
+      outDir: PLUGIN_CONTENTS_DIRECTORY,
+      mode: "production",
       sourcemap: false,
-      legalComments: "none"
+      minify: true
     });
     console.log("\u2728 Built desktop.js and config.js");
     console.log("\u2728 Build success.");
@@ -384,37 +389,55 @@ async function action3() {
 
 // src/commands/plugin-dev/index.ts
 import { program as program3 } from "commander";
-import "esbuild";
-import fs9 from "fs-extra";
+import { createServer } from "vite";
+import fs11 from "fs-extra";
 import path14 from "path";
+import chalk6 from "chalk";
+
+// src/lib/exec.ts
+import { exec as defaultExec } from "child_process";
+import { promisify } from "util";
+var exec = promisify(defaultExec);
 
-// src/commands/dev-base-esbuild.ts
-import "esbuild";
+// src/lib/cert.ts
+import fs5 from "fs-extra";
 import path7 from "path";
-async function action4(params) {
-  const { entryPoints, staticDir: outdir, certDir, port } = params;
-  const context = await getEsbuildContext({ sourcemap: "inline", entryPoints, outdir });
-  const [_, serveResult] = await Promise.all([
-    context.watch(),
-    context.serve({
-      port,
-      keyfile: path7.join(certDir, "localhost-key.pem"),
-      certfile: path7.join(certDir, "localhost-cert.pem"),
-      servedir: outdir
-    })
-  ]);
-  console.log(`\u{1F680} Start development server at https://localhost:${serveResult.port}`);
+var CERT_KEY_FILENAME = "localhost-key.pem";
+var CERT_FILENAME = "localhost-cert.pem";
+var generateCert = async (outDir) => {
+  await fs5.ensureDir(outDir);
+  const { stdout } = await exec(`mkcert localhost 127.0.0.1 ::1`);
+  [
+    { input: "localhost+2.pem", output: CERT_FILENAME },
+    { input: "localhost+2-key.pem", output: CERT_KEY_FILENAME }
+  ].forEach(({ input, output }) => {
+    if (fs5.existsSync(input)) {
+      fs5.moveSync(`./${input}`, path7.join(outDir, output), {
+        overwrite: true
+      });
+    }
+  });
+  return { stdout };
+};
+function hasCertificates(certDir) {
+  return fs5.existsSync(path7.join(certDir, CERT_KEY_FILENAME)) && fs5.existsSync(path7.join(certDir, CERT_FILENAME));
+}
+function loadCertificates(certDir) {
+  return {
+    key: fs5.readFileSync(path7.join(certDir, CERT_KEY_FILENAME)),
+    cert: fs5.readFileSync(path7.join(certDir, CERT_FILENAME))
+  };
 }
 
 // src/lib/plugin-manifest.ts
-import fs4 from "fs-extra";
+import fs6 from "fs-extra";
 import path8 from "path";
 import merge from "deepmerge";
 var outputManifest = async (env, options) => {
   const config2 = options?.config || await importK2PluginConfig();
   const merged = merge(config2.manifest.base, config2.manifest[env] || {});
-  await fs4.mkdirs(PLUGIN_CONTENTS_DIRECTORY);
-  await fs4.writeJson(path8.join(PLUGIN_CONTENTS_DIRECTORY, "manifest.json"), merged);
+  await fs6.mkdirs(PLUGIN_CONTENTS_DIRECTORY);
+  await fs6.writeJson(path8.join(PLUGIN_CONTENTS_DIRECTORY, "manifest.json"), merged);
   return merged;
 };
 
@@ -451,7 +474,7 @@ var getManifest = async (params) => {
 // src/commands/plugin-dev/tailwind.ts
 import path9 from "path";
 import "tailwindcss";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 async function buildTailwindCSS(params) {
   const { inputFile, outputFileName, config: config2 } = params;
   const inputPath = path9.resolve(inputFile);
@@ -463,7 +486,7 @@ async function buildTailwindCSS(params) {
     onChanges: ({ output, type }) => {
       const outputFileName2 = path9.basename(output);
       console.log(
-        chalk3.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk3.cyan(`[css] `) + outputFileName2 + (type === "init" ? " init" : ` rebuilt`)
+        chalk4.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk4.cyan(`[css] `) + outputFileName2 + (type === "init" ? " init" : ` rebuilt`)
       );
     }
   });
@@ -492,20 +515,20 @@ var watchCss = async (pluginConfig) => {
 import packer from "@kintone/plugin-packer";
 
 // src/lib/plugin-contents.ts
-import fs5 from "fs-extra";
+import fs7 from "fs-extra";
 import path10 from "path";
 import htmlMinifier from "html-minifier";
 var copyPluginContents = async (params = {}) => {
   const { inputDir = path10.join("src", "contents"), outputDir = PLUGIN_CONTENTS_DIRECTORY } = params;
-  if (!fs5.existsSync(inputDir)) {
-    await fs5.mkdir(inputDir, { recursive: true });
+  if (!fs7.existsSync(inputDir)) {
+    await fs7.mkdir(inputDir, { recursive: true });
   }
-  await fs5.copy(inputDir, outputDir, { overwrite: true });
+  await fs7.copy(inputDir, outputDir, { overwrite: true });
   const configHtmlPath = path10.join(outputDir, "config.html");
-  if (!fs5.existsSync(configHtmlPath)) {
+  if (!fs7.existsSync(configHtmlPath)) {
     throw new Error(`Plugin HTML file not found. Create "config.html" in ${inputDir}.`);
   }
-  const html = await fs5.readFile(configHtmlPath, "utf8");
+  const html = await fs7.readFile(configHtmlPath, "utf8");
   const minified = htmlMinifier.minify(html, {
     minifyCSS: true,
     collapseWhitespace: true,
@@ -516,12 +539,12 @@ var copyPluginContents = async (params = {}) => {
     removeTagWhitespace: true,
     useShortDoctype: true
   });
-  await fs5.writeFile(configHtmlPath, minified);
+  await fs7.writeFile(configHtmlPath, minified);
 };
 
 // src/lib/zip.ts
 import archiver from "archiver";
-import fs6 from "fs-extra";
+import fs8 from "fs-extra";
 import path11 from "path";
 import invariant2 from "tiny-invariant";
 var outputContentsZip = async (manifest) => {
@@ -534,7 +557,7 @@ var outputContentsZip = async (manifest) => {
     }
   });
   const outputZipPath = path11.join(PLUGIN_WORKSPACE_DIRECTORY, "contents.zip");
-  const outputZipStream = fs6.createWriteStream(outputZipPath);
+  const outputZipStream = fs8.createWriteStream(outputZipPath);
   outputZipStream.on("close", () => {
     console.log(`\u{1F4E6} ${archive.pointer()} total bytes`);
   });
@@ -566,7 +589,7 @@ var outputContentsZip = async (manifest) => {
   console.groupEnd();
   for (const file of targetFiles) {
     const filePath = path11.join(PLUGIN_CONTENTS_DIRECTORY, file);
-    if (!fs6.existsSync(filePath)) {
+    if (!fs8.existsSync(filePath)) {
       throw new Error(`${filePath} does not exist`);
     }
     archive.file(filePath, { name: file });
@@ -577,14 +600,14 @@ var outputContentsZip = async (manifest) => {
 };
 var getContentsZipBuffer = async () => {
   const outputZipPath = path11.join(PLUGIN_WORKSPACE_DIRECTORY, "contents.zip");
-  return fs6.readFile(outputZipPath);
+  return fs8.readFile(outputZipPath);
 };
 var getZipFileNameSuffix = (env) => {
   return env === "prod" ? "" : `-${env}`;
 };
 
 // src/commands/plugin-dev/upload.ts
-import fs8 from "fs-extra";
+import fs10 from "fs-extra";
 import path13 from "path";
 
 // src/lib/kintone-api-client.ts
@@ -620,8 +643,8 @@ KINTONE_PASSWORD`);
     this.#baseUrl = KINTONE_BASE_URL;
     this.#authHeader = authHeader;
   }
-  getEndpointUrl(path19) {
-    return `${this.#baseUrl}${path19}`;
+  getEndpointUrl(path18) {
+    return `${this.#baseUrl}${path18}`;
   }
   async upload(params) {
     const { blob, fileName } = params;
@@ -692,7 +715,7 @@ KINTONE_PASSWORD`);
 };
 
 // src/lib/utils.ts
-import fs7 from "fs-extra";
+import fs9 from "fs-extra";
 import path12 from "path";
 var isEnv = (env) => {
   return ["prod", "dev", "standalone"].includes(env);
@@ -701,7 +724,7 @@ var apiUploadZip = async (params) => {
   const { env, pluginId } = params;
   const kc = new KintoneApiClient();
   const zipFileName = `plugin${getZipFileNameSuffix(env)}.zip`;
-  const zipFile = new Blob([await fs7.readFile(path12.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName))]);
+  const zipFile = new Blob([await fs9.readFile(path12.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName))]);
   const fileKey = await kc.upload({ blob: zipFile, fileName: zipFileName });
   const plugins = await kc.getAllPlugins();
   const plugin = plugins.find((p) => p.id === pluginId);
@@ -721,7 +744,7 @@ var apiUploadZip = async (params) => {
 
 // src/commands/plugin-dev/upload.ts
 import chokider from "chokidar";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 var watchContentsAndUploadZip = async (params) => {
   const { manifest, ppkPath } = params;
   let initialScanComplete = false;
@@ -732,7 +755,7 @@ var watchContentsAndUploadZip = async (params) => {
       }
       await copyPluginContents();
       console.log(
-        chalk4.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk4.cyan(`[contents] `) + `updated`
+        chalk5.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk5.cyan(`[contents] `) + `updated`
       );
     } catch (error) {
       console.error("Error copying plugin contents:", error);
@@ -741,17 +764,17 @@ var watchContentsAndUploadZip = async (params) => {
     try {
       await outputContentsZip(manifest);
       const buffer = await getContentsZipBuffer();
-      const pluginPrivateKey = await fs8.readFile(path13.resolve(ppkPath), "utf8");
+      const pluginPrivateKey = await fs10.readFile(path13.resolve(ppkPath), "utf8");
       const output = await packer(buffer, pluginPrivateKey);
       const zipFileName = `plugin${getZipFileNameSuffix("dev")}.zip`;
-      await fs8.writeFile(path13.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName), output.plugin);
+      await fs10.writeFile(path13.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName), output.plugin);
       const { method } = await apiUploadZip({ env: "dev", pluginId: output.id });
       console.log(
-        chalk4.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk4.cyan(`[upload] `) + `uploaded ${method === "POST" ? "(new)" : "(update)"}`
+        chalk5.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk5.cyan(`[upload] `) + `uploaded ${method === "POST" ? "(new)" : "(update)"}`
       );
     } catch (error) {
       console.log(
-        chalk4.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk4.cyan(`[upload] `) + chalk4.red(`failed`) + chalk4.hex("#e5e7eb")(`: ${error?.message ?? "Unknown error"}`)
+        chalk5.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk5.cyan(`[upload] `) + chalk5.red(`failed`) + chalk5.hex("#e5e7eb")(`: ${error?.message ?? "Unknown error"}`)
       );
     }
   };
@@ -774,64 +797,103 @@ function command3() {
     "-p, --ppk <ppk>",
     ".ppk file path",
     path14.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk")
-  ).option("-c, --cert-dir <certDir>", "Certificate directory", PLUGIN_WORKSPACE_DIRECTORY).description("Start development server.").action(action5);
+  ).option("-c, --cert-dir <certDir>", "Certificate directory", PLUGIN_WORKSPACE_DIRECTORY).description("Start development server with Vite.").action(action3);
 }
-async function action5(options) {
+async function action3(options) {
   console.group("\u{1F373} Start development server");
   try {
     const { ppk: ppkPath, certDir } = options;
     const config2 = await importK2PluginConfig();
-    if (!fs9.existsSync(PLUGIN_DEVELOPMENT_DIRECTORY)) {
-      await fs9.mkdir(PLUGIN_DEVELOPMENT_DIRECTORY, { recursive: true });
+    const certDirPath = path14.resolve(certDir);
+    const outputDir = path14.resolve(PLUGIN_DEVELOPMENT_DIRECTORY);
+    if (!fs11.existsSync(PLUGIN_DEVELOPMENT_DIRECTORY)) {
+      await fs11.mkdir(PLUGIN_DEVELOPMENT_DIRECTORY, { recursive: true });
     }
     const port = config2.server?.port ?? DEFAULT_PORT;
+    if (!hasCertificates(certDirPath)) {
+      console.log(chalk6.yellow("\u{1F4DC} SSL certificates not found. Generating..."));
+      try {
+        await generateCert(certDirPath);
+        console.log(chalk6.green("\u2705 SSL certificates generated successfully"));
+      } catch (error) {
+        console.log(
+          chalk6.red("\u274C Failed to generate SSL certificates. Make sure mkcert is installed.")
+        );
+        console.log(chalk6.gray("   Install mkcert: https://github.com/FiloSottile/mkcert"));
+        throw error;
+      }
+    }
     const manifest = await getManifest({ config: config2, port });
     console.log(`\u{1F4DD} manifest.json generated`);
-    Promise.all([
-      watchContentsAndUploadZip({ manifest, ppkPath }),
-      watchCss(config2),
-      build(port, certDir)
-    ]);
+    const entries = getPluginEntryPoints({
+      configEntry: path14.resolve("src", "config"),
+      desktopEntry: path14.resolve("src", "desktop")
+    });
+    const entryNames = Object.keys(entries);
+    if (entryNames.length === 0) {
+      throw new Error("No entry points found for plugin. Check src/config and src/desktop paths.");
+    }
+    console.log(chalk6.gray(`  Entry points: ${entryNames.join(", ")}`));
+    await fs11.emptyDir(outputDir);
+    const { key, cert } = loadCertificates(certDirPath);
+    console.log(chalk6.gray("  Building..."));
+    await buildEntriesWithVite({
+      entries,
+      outDir: outputDir,
+      mode: "development",
+      sourcemap: "inline",
+      minify: false
+    });
+    const serverConfig = createViteConfig({
+      root: outputDir,
+      server: {
+        port,
+        https: { key, cert }
+      }
+    });
+    const server = await createServer(serverConfig);
+    await server.listen();
+    console.log(chalk6.green(`
+\u2728 Plugin development server ready!`));
+    console.log(chalk6.cyan(`   Local: https://localhost:${port}`));
+    console.log(chalk6.gray(`   Output: ${outputDir}`));
+    console.log(chalk6.gray(`   Files: config.js, desktop.js`));
+    console.log(chalk6.gray("\n   Watching for changes...\n"));
+    const chokidar2 = await import("chokidar");
+    const watchPaths = [
+      "src/config/**/*.{ts,tsx,js,jsx,css,scss}",
+      "src/desktop/**/*.{ts,tsx,js,jsx,css,scss}"
+    ];
+    const watcher = chokidar2.watch(watchPaths, {
+      ignored: /node_modules/,
+      persistent: true
+    });
+    const rebuild = async () => {
+      console.log(chalk6.gray("  Rebuilding..."));
+      await buildEntriesWithVite({
+        entries,
+        outDir: outputDir,
+        mode: "development",
+        sourcemap: "inline",
+        minify: false
+      });
+    };
+    watcher.on("change", rebuild);
+    watcher.on("add", rebuild);
+    watcher.on("unlink", rebuild);
+    Promise.all([watchContentsAndUploadZip({ manifest, ppkPath }), watchCss(config2)]);
   } catch (error) {
     throw error;
   } finally {
     console.groupEnd();
   }
 }
-async function build(port, certDir = PLUGIN_WORKSPACE_DIRECTORY, staticDir = PLUGIN_DEVELOPMENT_DIRECTORY) {
-  const entryPoints = ["desktop", "config"].map((dir) => ({
-    in: path14.join("src", dir, "index.ts"),
-    out: dir
-  }));
-  action4({ port, entryPoints, certDir, staticDir });
-}
 
 // src/commands/plugin-genkey.ts
 import { program as program4 } from "commander";
 
-// src/lib/exec.ts
-import { exec as defaultExec } from "child_process";
-import { promisify } from "util";
-var exec = promisify(defaultExec);
-
-// src/lib/cert.ts
-import fs10 from "fs-extra";
-import path15 from "path";
-var generateCert = async (outDir) => {
-  const { stdout } = await exec(`mkcert localhost 127.0.0.1 ::1`);
-  [
-    { input: "localhost+2.pem", output: "localhost-cert.pem" },
-    { input: "localhost+2-key.pem", output: "localhost-key.pem" }
-  ].forEach(({ input, output }) => {
-    fs10.moveSync(`./${input}`, path15.join(outDir, output), {
-      overwrite: true
-    });
-  });
-  return { stdout };
-};
-
 // src/commands/genkey-base.ts
-async function action6(options) {
+async function action4(options) {
   const { output } = options;
   console.group("\u{1F373} Generate SSL key for localhost");
   try {
@@ -849,21 +911,21 @@ async function action6(options) {
 
 // src/commands/plugin-genkey.ts
 function command4() {
-  program4.command("genkey").description("Generate SSL key for localhost. (Require mkcert)").action(action7);
+  program4.command("genkey").description("Generate SSL key for localhost. (Require mkcert)").action(action5);
 }
-async function action7() {
-  await action6({ output: PLUGIN_WORKSPACE_DIRECTORY });
+async function action5() {
+  await action4({ output: PLUGIN_WORKSPACE_DIRECTORY });
 }
 
 // src/commands/plugin-init.ts
 import { program as program5 } from "commander";
-import fs11 from "fs-extra";
-import path16 from "path";
+import fs12 from "fs-extra";
+import path15 from "path";
 import packer2 from "@kintone/plugin-packer";
 function command5() {
-  program5.command("init").description("generate private.ppk and kitting config").action(action8);
+  program5.command("init").description("generate private.ppk and kitting config").action(action6);
 }
-async function action8() {
+async function action6() {
   console.group("\u{1F373} Executing plugin initialization setup");
   try {
     const manifest = await outputManifest("dev");
@@ -871,20 +933,20 @@ async function action8() {
     await copyPluginContents();
     console.log("\u{1F4C1} contents copied");
     let privateKey;
-    const keyPath = path16.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk");
-    if (fs11.existsSync(keyPath)) {
-      privateKey = await fs11.readFile(keyPath, "utf8");
+    const keyPath = path15.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk");
+    if (fs12.existsSync(keyPath)) {
+      privateKey = await fs12.readFile(keyPath, "utf8");
     }
     await outputContentsZip(manifest);
     const buffer = await getContentsZipBuffer();
     const output = await packer2(buffer, privateKey);
     if (!privateKey) {
-      await fs11.writeFile(path16.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk"), output.privateKey);
+      await fs12.writeFile(path15.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk"), output.privateKey);
       console.log("\u{1F511} private.ppk generated");
     } else {
       console.log("\u{1F511} private.ppk already exists. The existing private.ppk will be used.");
     }
-    await fs11.writeFile(path16.join(PLUGIN_WORKSPACE_DIRECTORY, "plugin.zip"), output.plugin);
+    await fs12.writeFile(path15.join(PLUGIN_WORKSPACE_DIRECTORY, "plugin.zip"), output.plugin);
     console.log("\u{1F4E6} plugin.zip generated");
     console.log("\u2728 Plugin initialization setup completed! zip file path is ./.plugin/plugin.zip");
   } catch (error) {
@@ -897,9 +959,9 @@ async function action8() {
 // src/commands/manifest/index.ts
 import { program as program6 } from "commander";
 function command6() {
-  program6.command("manifest").option("-e, --env <env>", "create manifest", "prod").action(action9);
+  program6.command("manifest").option("-e, --env <env>", "create manifest", "prod").action(action7);
 }
-async function action9(options) {
+async function action7(options) {
   console.group("\u{1F680} Executing manifest generation");
   try {
     const { env } = options;
@@ -919,13 +981,13 @@ async function action9(options) {
 
 // src/commands/test/index.ts
 import { program as program7 } from "commander";
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 function command7() {
-  program7.command("test").description("test").action(action10);
+  program7.command("test").description("test").action(action8);
 }
-async function action10() {
+async function action8() {
   console.group("package.json");
-  const packageJson = fs12.readJSONSync("package.json");
+  const packageJson = fs13.readJSONSync("package.json");
   console.log("package.json detected");
   console.groupEnd();
   console.group("Config");
@@ -936,17 +998,17 @@ async function action10() {
 
 // src/commands/plugin-zip.ts
 import { program as program8 } from "commander";
-import fs13 from "fs-extra";
-import path17 from "path";
+import fs14 from "fs-extra";
+import path16 from "path";
 import packer3 from "@kintone/plugin-packer";
 function command8() {
   program8.command("zip").description("generate plugin zip").option("-e, --env <env>", "plugin environment (dev, prod, standalone)", "prod").option(
     "-p, --ppk <ppk>",
     ".ppk file path",
-    path17.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk")
-  ).action(action11);
+    path16.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk")
+  ).action(action9);
 }
-async function action11(options) {
+async function action9(options) {
   console.group("\u{1F373} Executing plugin zip generation");
   try {
     const { env, ppk: ppkPath } = options;
@@ -960,13 +1022,13 @@ async function action11(options) {
     await outputContentsZip(manifest);
     console.log("\u{1F4E6} contents.zip generated");
     const buffer = await getContentsZipBuffer();
-    const privateKey = await fs13.readFile(path17.resolve(ppkPath), "utf8");
+    const privateKey = await fs14.readFile(path16.resolve(ppkPath), "utf8");
     const output = await packer3(buffer, privateKey);
     const zipFileName = `plugin${getZipFileNameSuffix(env)}.zip`;
-    await fs13.writeFile(path17.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName), output.plugin);
+    await fs14.writeFile(path16.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName), output.plugin);
     console.log("\u{1F4E6} plugin.zip generated");
     const version = String(manifest.version);
-    await fs13.writeFile(path17.join(PLUGIN_WORKSPACE_DIRECTORY, "version"), version);
+    await fs14.writeFile(path16.join(PLUGIN_WORKSPACE_DIRECTORY, "version"), version);
     console.log(`\u{1F4DD} version file generated (${version})`);
     console.log(`\u2728 Plugin zip generation completed! zip file path is ./.plugin/${zipFileName}`);
   } catch (error) {
@@ -979,9 +1041,9 @@ async function action11(options) {
 // src/commands/lint.ts
 import { program as program9 } from "commander";
 function command9() {
-  program9.command("lint").description("Lint source files").option("-c, --config <config>", "Config file path").action(action12);
+  program9.command("lint").description("Lint source files").option("-c, --config <config>", "Config file path").action(action10);
 }
-async function action12(options) {
+async function action10(options) {
   try {
     lint();
   } catch (error) {
@@ -992,12 +1054,12 @@ async function action12(options) {
 
 // src/commands/plugin-tsup.ts
 import { program as program10 } from "commander";
-import fs14 from "fs-extra";
-import path18 from "path";
+import fs15 from "fs-extra";
+import path17 from "path";
 
 // src/lib/tsup.ts
-import { build as build2 } from "tsup";
-var completeBuildOptions2 = (params) => {
+import { build } from "tsup";
+var completeBuildOptions = (params) => {
   return {
     bundle: true,
     minify: "terser",
@@ -1012,15 +1074,15 @@ var completeBuildOptions2 = (params) => {
   };
 };
 var buildWithTsup = async (buildOptions) => {
-  const options = completeBuildOptions2(buildOptions);
-  await build2(options);
+  const options = completeBuildOptions(buildOptions);
+  await build(options);
 };
 
 // src/commands/plugin-tsup.ts
 function command10() {
-  program10.command("tsup").description("Build the project for production. (It's a wrapper of webpack build command.)").action(action13);
+  program10.command("tsup").description("Build the project for production. (It's a wrapper of webpack build command.)").action(action11);
 }
-async function action13() {
+async function action11() {
   console.group("\u{1F373} Build the project for production");
   try {
     const config2 = await importK2PluginConfig();
@@ -1028,22 +1090,22 @@ async function action13() {
       await lint();
       console.log("\u2728 Lint success.");
     }
-    if (!fs14.existsSync(PLUGIN_CONTENTS_DIRECTORY)) {
-      await fs14.mkdir(PLUGIN_CONTENTS_DIRECTORY, { recursive: true });
+    if (!fs15.existsSync(PLUGIN_CONTENTS_DIRECTORY)) {
+      await fs15.mkdir(PLUGIN_CONTENTS_DIRECTORY, { recursive: true });
     }
     if (config2.tailwind?.css && config2.tailwind?.config) {
       const tailwindConfig = await getTailwindConfig(config2.tailwind);
       const inputFile = getTailwindInputCss(config2.tailwind);
       await outputCss({
         inputPath: inputFile.config,
-        outputPath: path18.join(PLUGIN_CONTENTS_DIRECTORY, "config.css"),
+        outputPath: path17.join(PLUGIN_CONTENTS_DIRECTORY, "config.css"),
         config: tailwindConfig.config,
         minify: true
       });
       console.log("\u2728 Built config.css");
       await outputCss({
         inputPath: inputFile.desktop,
-        outputPath: path18.join(PLUGIN_CONTENTS_DIRECTORY, "desktop.css"),
+        outputPath: path17.join(PLUGIN_CONTENTS_DIRECTORY, "desktop.css"),
         config: tailwindConfig.desktop,
         minify: true
       });
@@ -1052,7 +1114,7 @@ async function action13() {
     const entryPoints = ["desktop", "config"].reduce(
       (acc, dir) => ({
         ...acc,
-        [dir]: path18.join("src", dir, "index.ts")
+        [dir]: path17.join("src", dir, "index.ts")
       }),
       {}
     );