@konomi-app/k2 3.4.0 → 4.0.0

package/dist/plugin.js

@@ -1,19 +1,13 @@
 #!/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 program10 } from "commander";
+import { program as program9 } from "commander";
 
 // src/commands/plugin-build.ts
 import { program } from "commander";
 import fs3 from "fs-extra";
 import path5 from "path";
-import chalk2 from "chalk";
+import chalk from "chalk";
 
 // src/lib/constants.ts
 import path from "path";
@@ -30,11 +24,11 @@ var DEFAULT_PORT = 32767;
 // src/lib/import.ts
 import { pathToFileURL } from "url";
 import path2 from "path";
-var esmImport = (path16) => {
+var esmImport = (path17) => {
   if (process.platform === "win32") {
-    return import(pathToFileURL(path16).toString());
+    return import(pathToFileURL(path17).toString());
   } else {
-    return import(path16);
+    return import(path17);
   }
 };
 var importK2PluginConfig = async (configFileName) => {
@@ -114,16 +108,16 @@ var watchTailwindCSS = async (params) => {
   watcher.on("error", (error) => {
     console.error("Error watching Tailwind CSS:", error);
   });
-  watcher.on("add", (path16) => {
+  watcher.on("add", (path17) => {
     debouncedProcessChanges.call("add");
   });
-  watcher.on("change", (path16) => {
+  watcher.on("change", (path17) => {
     debouncedProcessChanges.call("change");
   });
-  watcher.on("unlink", (path16) => {
+  watcher.on("unlink", (path17) => {
     debouncedProcessChanges.call("unlink");
   });
-  watcher.on("unlinkDir", (path16) => {
+  watcher.on("unlinkDir", (path17) => {
     debouncedProcessChanges.call("unlink");
   });
   return watcher;
@@ -158,179 +152,115 @@ async function lint() {
   }
 }
 
-// src/lib/vite.ts
-import chalk from "chalk";
-import fs2 from "fs-extra";
-import os from "os";
+// src/lib/rsbuild.ts
+import { createRsbuild } from "@rsbuild/core";
 import path4 from "path";
-import { build as viteBuild } from "vite";
-var DEFAULT_CONCURRENCY = Math.max(1, os.cpus().length - 1);
-async function parallelLimit(items, concurrency, fn) {
-  const results = [];
-  const executing = [];
-  for (const item of items) {
-    const promise = fn(item).then((result) => {
-      results.push(result);
-    });
-    const e = promise.then(() => {
-      executing.splice(executing.indexOf(e), 1);
-    });
-    executing.push(e);
-    if (executing.length >= concurrency) {
-      await Promise.race(executing);
+import fs2 from "fs-extra";
+async function buildWithRsbuild(params) {
+  const { entries, outDir, minify = true, sourcemap = false, injectStyles = true } = params;
+  const sourceMapConfig = sourcemap === "inline" ? "cheap-module-source-map" : sourcemap ? "source-map" : false;
+  const rsbuild = await createRsbuild({
+    rsbuildConfig: {
+      source: { entry: entries },
+      output: {
+        target: "web",
+        distPath: { root: outDir, js: "" },
+        filename: { js: "[name].js" },
+        filenameHash: false,
+        cleanDistPath: true,
+        injectStyles,
+        sourceMap: { js: sourceMapConfig },
+        minify
+      },
+      performance: {
+        chunkSplit: { strategy: "all-in-one" }
+      },
+      tools: {
+        htmlPlugin: false
+      }
     }
-  }
-  await Promise.all(executing);
-  return results;
+  });
+  await rsbuild.build();
 }
-var createViteConfig = (config2 = {}) => {
-  const plugins = [...config2.plugins ?? []];
-  try {
-    const tsconfigPaths = __require("vite-tsconfig-paths");
-    plugins.push(tsconfigPaths.default ? tsconfigPaths.default() : tsconfigPaths());
-  } catch {
-  }
-  const mode = config2.mode ?? "production";
-  return {
-    ...config2,
-    configFile: false,
-    // ソースマップ関連のエラーメッセージを抑制
-    logLevel: config2.logLevel ?? "warn",
-    // ブラウザ向けにNode.js固有のオブジェクトをビルド時に解決
-    define: {
-      "process.env.NODE_ENV": JSON.stringify(mode),
-      "process.env": JSON.stringify({}),
-      ...config2.define
+async function startRsbuildDevServer(params) {
+  const { entries, outDir, port, https, publicDir, onFirstCompile, onRecompile } = params;
+  const rsbuildConfig = {
+    source: { entry: entries },
+    output: {
+      target: "web",
+      distPath: { root: outDir, js: "" },
+      filename: { js: "[name].js" },
+      filenameHash: false,
+      cleanDistPath: false,
+      injectStyles: true,
+      sourceMap: { js: "cheap-module-source-map" },
+      minify: false
     },
-    build: {
-      ...config2.build,
-      // ブラウザ向けターゲット
-      target: config2.build?.target ?? "es2020",
-      cssCodeSplit: false,
-      rollupOptions: {
-        ...config2.build?.rollupOptions,
-        onwarn: (warning, warn) => {
-          if (["MODULE_LEVEL_DIRECTIVE"].includes(warning.code ?? "")) {
-            return;
-          }
-          if (warning.message?.includes("sourcemap") || warning.code === "SOURCEMAP_ERROR") {
-            return;
-          }
-          warn(warning);
-        }
-      }
+    performance: {
+      chunkSplit: { strategy: "all-in-one" }
     },
-    plugins,
-    resolve: {
-      ...config2.resolve,
-      alias: {
-        "@": path4.resolve(process.cwd(), "src"),
-        ...config2.resolve?.alias
-      }
+    tools: {
+      htmlPlugin: false
+    },
+    server: {
+      port,
+      host: "0.0.0.0",
+      ...https ? { https } : {},
+      ...publicDir && fs2.existsSync(publicDir) ? { publicDir: { name: publicDir } } : {}
+    },
+    dev: {
+      writeToDisk: true
     }
   };
-};
-async function buildEntriesWithVite(params) {
-  const {
-    entries,
-    outDir,
-    mode = "production",
-    sourcemap = false,
-    minify = true,
-    viteConfig = {},
-    concurrency = DEFAULT_CONCURRENCY
-  } = params;
-  const entryNames = Object.keys(entries);
-  if (entryNames.length === 1) {
-    const name = entryNames[0];
-    await buildSingleEntry({
-      name,
-      entryPath: entries[name],
-      outDir,
-      mode,
-      sourcemap,
-      minify,
-      viteConfig
-    });
-    return;
-  }
-  await parallelLimit(entryNames, concurrency, async (name) => {
-    await buildSingleEntry({
-      name,
-      entryPath: entries[name],
-      outDir,
-      mode,
-      sourcemap,
-      minify,
-      viteConfig
-    });
-  });
-}
-async function buildSingleEntry(params) {
-  const { name, entryPath, outDir, mode, sourcemap, minify, viteConfig } = params;
-  const config2 = createViteConfig({
-    ...viteConfig,
-    mode,
-    build: {
-      ...viteConfig.build,
-      rollupOptions: {
-        ...viteConfig.build?.rollupOptions,
-        input: entryPath,
-        output: {
-          entryFileNames: `${name}.js`,
-          assetFileNames: `${name}.[ext]`,
-          // 外部ライブラリのソースマップを無視して警告を抑制
-          sourcemapIgnoreList: (relativeSourcePath) => {
-            return relativeSourcePath.includes("node_modules");
-          },
-          ...viteConfig.build?.rollupOptions?.output
+  const rsbuild = await createRsbuild({ rsbuildConfig });
+  if (onFirstCompile || onRecompile) {
+    rsbuild.addPlugins([
+      {
+        name: "k2-dev-hooks",
+        setup(api) {
+          api.onDevCompileDone(async ({ isFirstCompile }) => {
+            if (isFirstCompile && onFirstCompile) {
+              await onFirstCompile();
+            } else if (!isFirstCompile && onRecompile) {
+              await onRecompile();
+            }
+          });
         }
-      },
-      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;
+  const result = await rsbuild.startDevServer();
+  return {
+    port: result.port,
+    close: result.server.close
+  };
 }
-function getPluginEntryPoints(options) {
+function getPluginEntryPoints(params) {
+  const { configEntry, desktopEntry } = params;
   const entries = {};
-  const configPath = findEntryPoint(options.configEntry);
-  if (configPath) {
-    entries["config"] = configPath;
-  } else {
-    console.log(chalk.yellow(`  \u26A0 Config entry not found: ${options.configEntry}`));
+  for (const ext of ["index.ts", "index.tsx", "index.js", "index.jsx"]) {
+    const configPath = path4.join(configEntry, ext);
+    if (fs2.existsSync(configPath)) {
+      entries.config = configPath;
+      break;
+    }
   }
-  const desktopPath = findEntryPoint(options.desktopEntry);
-  if (desktopPath) {
-    entries["desktop"] = desktopPath;
-  } else {
-    console.log(chalk.yellow(`  \u26A0 Desktop entry not found: ${options.desktopEntry}`));
+  for (const ext of ["index.ts", "index.tsx", "index.js", "index.jsx"]) {
+    const desktopPath = path4.join(desktopEntry, ext);
+    if (fs2.existsSync(desktopPath)) {
+      entries.desktop = desktopPath;
+      break;
+    }
   }
   return entries;
 }
 
 // src/commands/plugin-build.ts
 function command() {
-  program.command("build").description("Build the project for production with Vite.").action(action);
+  program.command("build").description("Build the plugin for production with rsbuild.").action(action);
 }
 async function action() {
-  console.group("\u{1F373} Build the project for production");
+  console.group("\u{1F373} Build the plugin for production");
   try {
     const config2 = await importK2PluginConfig();
     if (config2?.lint?.build) {
@@ -340,6 +270,24 @@ async function action() {
     if (!fs3.existsSync(PLUGIN_CONTENTS_DIRECTORY)) {
       await fs3.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: path5.join(PLUGIN_CONTENTS_DIRECTORY, "config.css"),
+        config: tailwindConfig.config,
+        minify: true
+      });
+      console.log("\u2728 Built config.css");
+      await outputCss({
+        inputPath: inputFile.desktop,
+        outputPath: path5.join(PLUGIN_CONTENTS_DIRECTORY, "desktop.css"),
+        config: tailwindConfig.desktop,
+        minify: true
+      });
+      console.log("\u2728 Built desktop.css");
+    }
     const entries = getPluginEntryPoints({
       configEntry: path5.resolve("src", "config"),
       desktopEntry: path5.resolve("src", "desktop")
@@ -348,36 +296,15 @@ async function action() {
     if (entryNames.length === 0) {
       throw new Error("No entry points found for plugin. Check src/config and src/desktop paths.");
     }
-    console.log(chalk2.gray(`  Entry points: ${entryNames.join(", ")}`));
-    const buildTasks = [];
-    if (config2.tailwind?.css && config2.tailwind?.config) {
-      const tailwindConfig = await getTailwindConfig(config2.tailwind);
-      const inputFile = getTailwindInputCss(config2.tailwind);
-      buildTasks.push(
-        outputCss({
-          inputPath: inputFile.config,
-          outputPath: path5.join(PLUGIN_CONTENTS_DIRECTORY, "config.css"),
-          config: tailwindConfig.config,
-          minify: true
-        }).then(() => console.log("\u2728 Built config.css")),
-        outputCss({
-          inputPath: inputFile.desktop,
-          outputPath: path5.join(PLUGIN_CONTENTS_DIRECTORY, "desktop.css"),
-          config: tailwindConfig.desktop,
-          minify: true
-        }).then(() => console.log("\u2728 Built desktop.css"))
-      );
-    }
-    buildTasks.push(
-      buildEntriesWithVite({
-        entries,
-        outDir: PLUGIN_CONTENTS_DIRECTORY,
-        mode: "production",
-        sourcemap: false,
-        minify: true
-      }).then(() => console.log("\u2728 Built desktop.js and config.js"))
-    );
-    await Promise.all(buildTasks);
+    console.log(chalk.gray(`  Entry points: ${entryNames.join(", ")}`));
+    await buildWithRsbuild({
+      entries,
+      outDir: PLUGIN_CONTENTS_DIRECTORY,
+      minify: true,
+      sourcemap: false,
+      injectStyles: true
+    });
+    console.log("\u2728 Built desktop.js and config.js");
     console.log("\u2728 Build success.");
   } catch (error) {
     throw error;
@@ -386,65 +313,245 @@ async function action() {
   }
 }
 
-// src/commands/plugin-esbuild.ts
-import { program as program2 } from "commander";
-function command2() {
-  program2.command("esbuild").description(
-    "[DEPRECATED] Build the project for production with esbuild. (Use `plugin build` instead.)"
-  ).action(action);
-}
-
 // src/commands/plugin-dev/index.ts
-import { program as program3 } from "commander";
-import { createServer } from "vite";
+import { program as program2 } from "commander";
 import fs10 from "fs-extra";
 import path13 from "path";
-import chalk5 from "chalk";
-
-// src/lib/exec.ts
-import { exec as defaultExec } from "child_process";
-import { promisify } from "util";
-var exec = promisify(defaultExec);
+import chalk4 from "chalk";
 
-// src/lib/cert.ts
+// src/lib/cert/index.ts
 import fs4 from "fs-extra";
+import path7 from "path";
+
+// src/lib/cert/cert.ts
+import forge from "node-forge";
+import net from "net";
+var { md, pki } = forge;
+function createCertificate(serial, publicKey, subject, issuer, extensions, validity, signWith) {
+  const cert = pki.createCertificate();
+  cert.serialNumber = Buffer.from(serial).toString("hex");
+  cert.publicKey = publicKey;
+  cert.setSubject(subject);
+  cert.setIssuer(issuer);
+  cert.setExtensions(extensions);
+  cert.validity.notBefore = /* @__PURE__ */ new Date();
+  cert.validity.notAfter = /* @__PURE__ */ new Date();
+  cert.validity.notAfter.setDate(cert.validity.notAfter.getDate() + validity);
+  cert.sign(signWith, md.sha256.create());
+  return cert;
+}
+function generateCertInternal(params) {
+  const { subject, issuer, extensions, validity, signWith } = params;
+  const serial = Math.floor(Math.random() * 95e3 + 5e4).toString();
+  const keyPair = pki.rsa.generateKeyPair(2048);
+  const privateKey = signWith ? pki.privateKeyFromPem(signWith) : keyPair.privateKey;
+  const cert = createCertificate(
+    serial,
+    keyPair.publicKey,
+    subject,
+    issuer,
+    extensions,
+    validity,
+    privateKey
+  );
+  return {
+    key: pki.privateKeyToPem(keyPair.privateKey),
+    cert: pki.certificateToPem(cert)
+  };
+}
+function createCA(params = {}) {
+  const {
+    organization = "K2 Development CA",
+    countryCode = "JP",
+    state = "Tokyo",
+    locality = "Tokyo",
+    validity = 7300
+  } = params;
+  const attributes = [
+    { name: "commonName", value: organization },
+    { name: "countryName", value: countryCode },
+    { name: "stateOrProvinceName", value: state },
+    { name: "localityName", value: locality },
+    { name: "organizationName", value: organization }
+  ];
+  const extensions = [
+    { name: "basicConstraints", cA: true, critical: true },
+    { name: "keyUsage", keyCertSign: true, critical: true }
+  ];
+  return generateCertInternal({
+    subject: attributes,
+    issuer: attributes,
+    extensions,
+    validity
+  });
+}
+function createCert(params) {
+  const { ca, domains, validity = 7300 } = params;
+  const attributes = [{ name: "commonName", value: domains[0] }];
+  const extensions = [
+    { name: "basicConstraints", cA: false, critical: true },
+    {
+      name: "keyUsage",
+      digitalSignature: true,
+      keyEncipherment: true,
+      critical: true
+    },
+    { name: "extKeyUsage", serverAuth: true, clientAuth: true },
+    {
+      name: "subjectAltName",
+      altNames: domains.map((domain) => {
+        const TYPE_DOMAIN = 2;
+        const TYPE_IP = 7;
+        return net.isIP(domain) ? { type: TYPE_IP, ip: domain } : { type: TYPE_DOMAIN, value: domain };
+      })
+    }
+  ];
+  const caCert = pki.certificateFromPem(ca.cert.toString());
+  return generateCertInternal({
+    subject: attributes,
+    issuer: caCert.subject.attributes,
+    extensions,
+    validity,
+    signWith: ca.key.toString()
+  });
+}
+
+// src/lib/cert/constants.ts
 import path6 from "path";
+var PKG_NAME = "k2";
+var isSupported = process.platform === "darwin" || process.platform === "linux" || process.platform === "win32";
+function getApplicationConfigPath(name) {
+  if (process.platform === "darwin") {
+    return path6.join(process.env.HOME, "Library", "Application Support", name);
+  }
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA ? path6.join(process.env.LOCALAPPDATA, name) : path6.join(process.env.USERPROFILE, "Local Settings", "Application Data", name);
+  }
+  return process.env.XDG_CONFIG_HOME ? path6.join(process.env.XDG_CONFIG_HOME, name) : path6.join(process.env.HOME, ".config", name);
+}
+var pkgDir = getApplicationConfigPath(PKG_NAME);
+var rootCAPath = path6.resolve(pkgDir, "rootCA.pem");
+var rootCAKeyPath = path6.resolve(pkgDir, "rootCA-key.pem");
+
+// src/lib/cert/platforms.ts
+import { spawnSync } from "child_process";
+
+// src/lib/logger.ts
+var PKG_NAME2 = "@konomi-app/k2";
+function createLogger(prefix = PKG_NAME2) {
+  return {
+    log: (...args) => console.log(`[${prefix}]`, ...args),
+    info: (...args) => console.info(`[${prefix}]`, ...args),
+    warn: (...args) => console.warn(`[${prefix}]`, ...args),
+    error: (...args) => console.error(`[${prefix}]`, ...args)
+  };
+}
+var logger_default = createLogger();
+
+// src/lib/cert/platforms.ts
+function addToTrustStoresDarwin(certPath) {
+  logger_default.log("Adding certificate to trusted store. Admin rights may be required.");
+  spawnSync(
+    "sudo",
+    [
+      "security",
+      "add-trusted-cert",
+      "-d",
+      "-r",
+      "trustRoot",
+      "-k",
+      "/Library/Keychains/System.keychain",
+      "-p",
+      "ssl",
+      "-p",
+      "basic",
+      certPath
+    ],
+    { stdio: "inherit" }
+  );
+}
+var targetCA = `/usr/local/share/ca-certificates/${PKG_NAME}.crt`;
+function addToTrustStoresLinux(certPath) {
+  logger_default.log("Adding certificate to trusted store. Admin rights may be required.");
+  spawnSync("sudo", ["cp", certPath, targetCA]);
+  spawnSync("sudo", ["update-ca-certificates"]);
+}
+function addToTrustStoresWin32(certPath) {
+  spawnSync("certutil", ["-addstore", "-user", "root", certPath], {
+    stdio: "inherit"
+  });
+}
+function addToTrustStores(certPath) {
+  switch (process.platform) {
+    case "darwin":
+      return addToTrustStoresDarwin(certPath);
+    case "linux":
+      return addToTrustStoresLinux(certPath);
+    case "win32":
+      return addToTrustStoresWin32(certPath);
+  }
+}
+
+// src/lib/cert/index.ts
 var CERT_KEY_FILENAME = "localhost-key.pem";
 var CERT_FILENAME = "localhost-cert.pem";
-var generateCert = async (outDir) => {
-  await fs4.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 (fs4.existsSync(input)) {
-      fs4.moveSync(`./${input}`, path6.join(outDir, output), {
-        overwrite: true
-      });
+function install(options = {}) {
+  const { validity = 7300 } = options;
+  if (!isSupported) {
+    throw new Error(`Platform not supported: "${process.platform}"`);
+  }
+  if (!fs4.existsSync(rootCAPath) && !fs4.existsSync(rootCAKeyPath)) {
+    const ca = createCA({ validity });
+    fs4.outputFileSync(rootCAPath, ca.cert);
+    fs4.outputFileSync(rootCAKeyPath, ca.key);
+    try {
+      addToTrustStores(rootCAPath);
+    } catch {
+      console.warn(
+        "\u26A0 Failed to add CA to system trust store. You may need to trust the certificate manually."
+      );
     }
-  });
-  return { stdout };
-};
+  }
+}
+function certificateFor(requestedDomains = []) {
+  const validity = 7300;
+  install({ validity });
+  const requests = Array.isArray(requestedDomains) ? requestedDomains : [requestedDomains];
+  const domains = [
+    .../* @__PURE__ */ new Set(["localhost", "localhost.localdomain", "127.0.0.1", "0.0.0.0", "::1", ...requests])
+  ];
+  const ca = {
+    cert: fs4.readFileSync(rootCAPath),
+    key: fs4.readFileSync(rootCAKeyPath)
+  };
+  return createCert({ ca, domains, validity });
+}
+function generateCert(outDir) {
+  fs4.ensureDirSync(outDir);
+  const result = certificateFor();
+  fs4.outputFileSync(path7.join(outDir, CERT_FILENAME), result.cert);
+  fs4.outputFileSync(path7.join(outDir, CERT_KEY_FILENAME), result.key);
+  return result;
+}
 function hasCertificates(certDir) {
-  return fs4.existsSync(path6.join(certDir, CERT_KEY_FILENAME)) && fs4.existsSync(path6.join(certDir, CERT_FILENAME));
+  return fs4.existsSync(path7.join(certDir, CERT_KEY_FILENAME)) && fs4.existsSync(path7.join(certDir, CERT_FILENAME));
 }
 function loadCertificates(certDir) {
   return {
-    key: fs4.readFileSync(path6.join(certDir, CERT_KEY_FILENAME)),
-    cert: fs4.readFileSync(path6.join(certDir, CERT_FILENAME))
+    key: fs4.readFileSync(path7.join(certDir, CERT_KEY_FILENAME)),
+    cert: fs4.readFileSync(path7.join(certDir, CERT_FILENAME))
   };
 }
 
 // src/lib/plugin-manifest.ts
 import fs5 from "fs-extra";
-import path7 from "path";
+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 fs5.mkdirs(PLUGIN_CONTENTS_DIRECTORY);
-  await fs5.writeJson(path7.join(PLUGIN_CONTENTS_DIRECTORY, "manifest.json"), merged);
+  await fs5.writeJson(path8.join(PLUGIN_CONTENTS_DIRECTORY, "manifest.json"), merged);
   return merged;
 };
 
@@ -479,21 +586,21 @@ var getManifest = async (params) => {
 };
 
 // src/commands/plugin-dev/tailwind.ts
-import path8 from "path";
+import path9 from "path";
 import "tailwindcss";
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 async function buildTailwindCSS(params) {
   const { inputFile, outputFileName, config: config2 } = params;
-  const inputPath = path8.resolve(inputFile);
-  const outputPath = path8.join(PLUGIN_DEVELOPMENT_DIRECTORY, outputFileName);
+  const inputPath = path9.resolve(inputFile);
+  const outputPath = path9.join(PLUGIN_DEVELOPMENT_DIRECTORY, outputFileName);
   return watchTailwindCSS({
     input: inputPath,
     output: outputPath,
     config: config2,
     onChanges: ({ output, type }) => {
-      const outputFileName2 = path8.basename(output);
+      const outputFileName2 = path9.basename(output);
       console.log(
-        chalk3.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk3.cyan(`[css] `) + outputFileName2 + (type === "init" ? " init" : ` rebuilt`)
+        chalk2.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk2.cyan(`[css] `) + outputFileName2 + (type === "init" ? " init" : ` rebuilt`)
       );
     }
   });
@@ -518,20 +625,17 @@ var watchCss = async (pluginConfig) => {
   ]);
 };
 
-// src/commands/plugin-dev/upload.ts
-import packer from "@kintone/plugin-packer";
-
 // src/lib/plugin-contents.ts
 import fs6 from "fs-extra";
-import path9 from "path";
+import path10 from "path";
 import htmlMinifier from "html-minifier";
 var copyPluginContents = async (params = {}) => {
-  const { inputDir = path9.join("src", "contents"), outputDir = PLUGIN_CONTENTS_DIRECTORY } = params;
+  const { inputDir = path10.join("src", "contents"), outputDir = PLUGIN_CONTENTS_DIRECTORY } = params;
   if (!fs6.existsSync(inputDir)) {
     await fs6.mkdir(inputDir, { recursive: true });
   }
   await fs6.copy(inputDir, outputDir, { overwrite: true });
-  const configHtmlPath = path9.join(outputDir, "config.html");
+  const configHtmlPath = path10.join(outputDir, "config.html");
   if (!fs6.existsSync(configHtmlPath)) {
     throw new Error(`Plugin HTML file not found. Create "config.html" in ${inputDir}.`);
   }
@@ -550,208 +654,165 @@ var copyPluginContents = async (params = {}) => {
 };
 
 // src/lib/zip.ts
-import archiver from "archiver";
+import fs8 from "fs-extra";
+import path11 from "path";
+import { zipSync } from "fflate";
+
+// src/lib/rsa.ts
+import forge2 from "node-forge";
 import fs7 from "fs-extra";
-import path10 from "path";
-import invariant2 from "tiny-invariant";
-var outputContentsZip = async (manifest) => {
-  const archive = archiver("zip", { zlib: { level: 9 } });
-  archive.on("warning", (error) => {
-    if (error.code === "ENOENT") {
-      console.warn(error);
+function sign(contents, privateKeyPem) {
+  const key = forge2.pki.privateKeyFromPem(privateKeyPem);
+  const md2 = forge2.md.sha1.create();
+  md2.update(contents.toString("binary"));
+  const signature = key.sign(md2);
+  return Buffer.from(signature, "binary");
+}
+function getPublicKeyDer(privateKeyPem) {
+  const privateKey = forge2.pki.privateKeyFromPem(privateKeyPem);
+  const publicKey = forge2.pki.rsa.setPublicKey(privateKey.n, privateKey.e);
+  const publicKeyAsn1 = forge2.pki.publicKeyToAsn1(publicKey);
+  const publicKeyDerBytes = forge2.asn1.toDer(publicKeyAsn1).getBytes();
+  return Buffer.from(publicKeyDerBytes, "binary");
+}
+function generatePPK(ppkPath) {
+  const keypair = forge2.pki.rsa.generateKeyPair(1024);
+  const privateKey = forge2.pki.privateKeyToPem(keypair.privateKey);
+  fs7.outputFileSync(ppkPath, privateKey);
+  return privateKey;
+}
+function generatePluginId(publicKeyDer) {
+  const md2 = forge2.md.sha256.create();
+  md2.update(publicKeyDer.toString("binary"));
+  const hash = Buffer.from(md2.digest().bytes(), "binary");
+  const hexDigest = hash.subarray(0, 16).toString("hex");
+  return hexDigest.replace(/[0-9a-f]/g, (c) => "abcdefghijklmnop"["0123456789abcdef".indexOf(c)]);
+}
+
+// src/lib/zip.ts
+function sourceList(manifest) {
+  const sourceTypes = [
+    ["desktop", "js"],
+    ["desktop", "css"],
+    ["mobile", "js"],
+    ["mobile", "css"],
+    ["config", "js"],
+    ["config", "css"]
+  ];
+  const list = sourceTypes.map(([type, ext]) => manifest[type]?.[ext]).filter(Boolean).reduce((a, b) => a.concat(b), []).filter((file) => !/^https?:\/\//.test(file));
+  if (manifest.config?.html) list.push(manifest.config.html);
+  list.push(manifest.icon);
+  return Array.from(new Set(list));
+}
+function zipFiles(files) {
+  const zipObj = {};
+  for (const [fileName, fileContent] of Object.entries(files)) {
+    let content;
+    if (Buffer.isBuffer(fileContent)) {
+      content = new Uint8Array(fileContent);
+    } else if (typeof fileContent === "string") {
+      const fileData = fs8.readFileSync(fileContent);
+      content = new Uint8Array(fileData);
     } else {
-      throw error;
+      throw new Error(`Unsupported file content type for file: ${fileName}`);
     }
-  });
-  const outputZipPath = path10.join(PLUGIN_WORKSPACE_DIRECTORY, "contents.zip");
-  const outputZipStream = fs7.createWriteStream(outputZipPath);
-  outputZipStream.on("close", () => {
-    console.log(`\u{1F4E6} ${archive.pointer()} total bytes`);
-  });
-  outputZipStream.on("end", function() {
-    console.log("\u{1F4E6} Data has been drained");
-  });
-  const filterLocalContent = (file) => {
-    return !/^https?:\/\//.test(file);
-  };
-  invariant2(manifest.config?.html, "manifest.config.html is required");
-  const targetFiles = [
-    "manifest.json",
-    .../* @__PURE__ */ new Set([
-      manifest.icon,
-      manifest.config.html,
-      ...(manifest.desktop?.js || []).filter(filterLocalContent),
-      ...(manifest.desktop?.css || []).filter(filterLocalContent),
-      ...(manifest.mobile?.js || []).filter(filterLocalContent),
-      ...(manifest.mobile?.css || []).filter(filterLocalContent),
-      ...(manifest.config.js || []).filter(filterLocalContent),
-      ...(manifest.config.css || []).filter(filterLocalContent)
-    ])
-  ];
+    zipObj[fileName] = content;
+  }
+  const zipped = zipSync(zipObj);
+  return Buffer.from(zipped);
+}
+function createContentsZip(contentsDir, manifest, fileContents = {}) {
+  const files = sourceList(manifest).reduce((acc, file) => {
+    acc[file] = fileContents[file] || path11.join(contentsDir, file);
+    return acc;
+  }, {});
+  files["manifest.json"] = Buffer.from(JSON.stringify(manifest, null, 2));
+  const targetFiles = Object.keys(files);
   console.group("\u{1F4C1} Target files");
   targetFiles.forEach((file, i) => {
     const prefix = i === targetFiles.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
     console.log(`${prefix} \u{1F4C4} ${file}`);
   });
   console.groupEnd();
-  for (const file of targetFiles) {
-    const filePath = path10.join(PLUGIN_CONTENTS_DIRECTORY, file);
-    if (!fs7.existsSync(filePath)) {
-      throw new Error(`${filePath} does not exist`);
-    }
-    archive.file(filePath, { name: file });
+  return zipFiles(files);
+}
+function createContentsZipFromDir(manifest) {
+  return createContentsZip(PLUGIN_CONTENTS_DIRECTORY, manifest);
+}
+function createPluginZip(params) {
+  const { ppkPath, contentsZip } = params;
+  let ppkContent;
+  if (fs8.existsSync(ppkPath)) {
+    ppkContent = fs8.readFileSync(ppkPath, "utf-8");
+  } else {
+    ppkContent = generatePPK(ppkPath);
   }
-  archive.pipe(outputZipStream);
-  await archive.finalize();
-  await new Promise((resolve) => outputZipStream.on("close", resolve));
-};
-var getContentsZipBuffer = async () => {
-  const outputZipPath = path10.join(PLUGIN_WORKSPACE_DIRECTORY, "contents.zip");
-  return fs7.readFile(outputZipPath);
-};
+  const signature = sign(contentsZip, ppkContent);
+  const publicKeyDer = getPublicKeyDer(ppkContent);
+  const pluginId = generatePluginId(publicKeyDer);
+  const pluginZip = zipFiles({
+    "contents.zip": contentsZip,
+    PUBKEY: publicKeyDer,
+    SIGNATURE: signature
+  });
+  return { zip: pluginZip, id: pluginId, privateKey: ppkContent };
+}
 var getZipFileNameSuffix = (env) => {
   return env === "prod" ? "" : `-${env}`;
 };
 
-// src/commands/plugin-dev/upload.ts
-import fs9 from "fs-extra";
-import path12 from "path";
-
 // src/lib/kintone-api-client.ts
 import { config } from "dotenv";
-var KintoneApiClient = class {
-  #baseUrl;
-  #authHeader;
-  constructor() {
-    config();
-    const {
-      KINTONE_BASE_URL,
-      KINTONE_USERNAME,
-      KINTONE_PASSWORD,
-      KINTONE_BASIC_AUTH_USERNAME = "",
-      KINTONE_BASIC_AUTH_PASSWORD = ""
-    } = process.env;
-    if (!KINTONE_BASE_URL || !KINTONE_USERNAME || !KINTONE_PASSWORD) {
-      throw new Error(`.env\u306E\u8A2D\u5B9A\u304C\u4E0D\u5341\u5206\u3067\u3059\u3002\u4EE5\u4E0B\u306E\u30D1\u30E9\u30E1\u30FC\u30BF\u306F\u5FC5\u9808\u3067\u3059
+import { KintoneRestAPIClient } from "@kintone/rest-api-client";
+function createKintoneClient() {
+  config();
+  const {
+    KINTONE_BASE_URL,
+    KINTONE_USERNAME,
+    KINTONE_PASSWORD,
+    KINTONE_BASIC_AUTH_USERNAME,
+    KINTONE_BASIC_AUTH_PASSWORD
+  } = process.env;
+  if (!KINTONE_BASE_URL || !KINTONE_USERNAME || !KINTONE_PASSWORD) {
+    throw new Error(`.env\u306E\u8A2D\u5B9A\u304C\u4E0D\u5341\u5206\u3067\u3059\u3002\u4EE5\u4E0B\u306E\u30D1\u30E9\u30E1\u30FC\u30BF\u306F\u5FC5\u9808\u3067\u3059
 KINTONE_BASE_URL
 KINTONE_USERNAME
 KINTONE_PASSWORD`);
-    }
-    const authHeader = {
-      "X-Cybozu-Authorization": Buffer.from(`${KINTONE_USERNAME}:${KINTONE_PASSWORD}`).toString(
-        "base64"
-      ),
-      ...KINTONE_BASIC_AUTH_USERNAME && KINTONE_BASIC_AUTH_PASSWORD && {
-        Authorization: `Basic ${Buffer.from(
-          `${KINTONE_BASIC_AUTH_USERNAME}:${KINTONE_BASIC_AUTH_PASSWORD}`
-        ).toString("base64")}`
-      }
-    };
-    this.#baseUrl = KINTONE_BASE_URL;
-    this.#authHeader = authHeader;
   }
-  getEndpointUrl(path16) {
-    return `${this.#baseUrl}${path16}`;
-  }
-  async upload(params) {
-    const { blob, fileName } = params;
-    const form = new FormData();
-    form.append("file", blob, fileName);
-    const uploadResult = await fetch(this.getEndpointUrl("/k/v1/file.json"), {
-      method: "POST",
-      headers: this.#authHeader,
-      body: form
-    });
-    const { fileKey } = await uploadResult.json();
-    return fileKey;
-  }
-  async getPlugins(params = {}) {
-    const url = new URL(this.getEndpointUrl("/k/v1/plugins.json"));
-    if (params.offset) {
-      url.searchParams.set("offset", String(params.offset));
-    }
-    if (params.limit) {
-      url.searchParams.set("limit", String(params.limit));
-    }
-    const pluginResponse = await fetch(url.toString(), {
-      headers: this.#authHeader
-    });
-    return pluginResponse.json();
-  }
-  async getAllPlugins() {
-    const plugins = [];
-    let offset = 0;
-    let limit = 100;
-    let hasMore = true;
-    while (hasMore) {
-      const { plugins: currentPlugins } = await this.getPlugins({ offset, limit });
-      plugins.push(...currentPlugins);
-      if (currentPlugins.length < limit) {
-        hasMore = false;
-      } else {
-        offset += limit;
+  return new KintoneRestAPIClient({
+    baseUrl: KINTONE_BASE_URL,
+    auth: {
+      username: KINTONE_USERNAME,
+      password: KINTONE_PASSWORD
+    },
+    ...KINTONE_BASIC_AUTH_USERNAME && KINTONE_BASIC_AUTH_PASSWORD ? {
+      basicAuth: {
+        username: KINTONE_BASIC_AUTH_USERNAME,
+        password: KINTONE_BASIC_AUTH_PASSWORD
       }
-    }
-    return plugins;
-  }
-  async addPlugin(params) {
-    const { fileKey } = params;
-    const pluginResponse = await fetch(this.getEndpointUrl("/k/v1/plugin.json"), {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.#authHeader
-      },
-      body: JSON.stringify({
-        fileKey
-      })
-    });
-    return pluginResponse.json();
-  }
-  async updatePlugin(params) {
-    const pluginResponse = await fetch(this.getEndpointUrl("/k/v1/plugin.json"), {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.#authHeader
-      },
-      body: JSON.stringify(params)
-    });
-    return pluginResponse.json();
-  }
-};
-
-// src/lib/utils.ts
-import fs8 from "fs-extra";
-import path11 from "path";
-var isEnv = (env) => {
-  return ["prod", "dev", "standalone"].includes(env);
-};
-var apiUploadZip = async (params) => {
-  const { env, pluginId } = params;
-  const kc = new KintoneApiClient();
-  const zipFileName = `plugin${getZipFileNameSuffix(env)}.zip`;
-  const zipFile = new Blob([await fs8.readFile(path11.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);
-  if (plugin) {
-    const json = await kc.updatePlugin({ id: pluginId, fileKey });
-    if ("errors" in json && json.errors) {
-      console.error((json.errors.id?.messages ?? []).map((m) => `Error: ${m}`).join("\n"));
-    }
+    } : {}
+  });
+}
+async function uploadPlugin(params) {
+  const client = createKintoneClient();
+  const { fileKey } = await client.file.uploadFile({
+    file: { name: params.file.name, data: new Uint8Array(params.file.data) }
+  });
+  const { plugins } = await client.plugin.getPlugins({ offset: 0, limit: 100 });
+  const isUpdate = plugins.some(({ id }) => id === params.pluginId);
+  if (isUpdate) {
+    await client.plugin.updatePlugin({ id: params.pluginId, fileKey });
     return { method: "PUT" };
   }
-  const result = await kc.addPlugin({ fileKey });
-  if ("code" in result) {
-    console.error(`Error: ${result.message}`);
-  }
+  await client.plugin.installPlugin({ fileKey });
   return { method: "POST" };
-};
+}
 
 // src/commands/plugin-dev/upload.ts
-import chokider from "chokidar";
-import chalk4 from "chalk";
+import fs9 from "fs-extra";
+import path12 from "path";
+import chokidar2 from "chokidar";
+import chalk3 from "chalk";
 var watchContentsAndUploadZip = async (params) => {
   const { manifest, ppkPath } = params;
   let initialScanComplete = false;
@@ -762,30 +823,34 @@ var watchContentsAndUploadZip = async (params) => {
       }
       await copyPluginContents();
       console.log(
-        chalk4.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk4.cyan(`[contents] `) + `updated`
+        chalk3.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk3.cyan(`[contents] `) + `updated`
       );
     } catch (error) {
       console.error("Error copying plugin contents:", error);
       return;
     }
     try {
-      await outputContentsZip(manifest);
-      const buffer = await getContentsZipBuffer();
-      const pluginPrivateKey = await fs9.readFile(path12.resolve(ppkPath), "utf8");
-      const output = await packer(buffer, pluginPrivateKey);
+      const contentsZip = createContentsZipFromDir(manifest);
+      const { zip, id: pluginId } = createPluginZip({
+        ppkPath: path12.resolve(ppkPath),
+        contentsZip
+      });
       const zipFileName = `plugin${getZipFileNameSuffix("dev")}.zip`;
-      await fs9.writeFile(path12.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName), output.plugin);
-      const { method } = await apiUploadZip({ env: "dev", pluginId: output.id });
+      await fs9.writeFile(path12.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName), zip);
+      const { method } = await uploadPlugin({
+        pluginId,
+        file: { name: zipFileName, data: zip }
+      });
       console.log(
-        chalk4.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk4.cyan(`[upload] `) + `uploaded ${method === "POST" ? "(new)" : "(update)"}`
+        chalk3.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk3.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"}`)
+        chalk3.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk3.cyan(`[upload] `) + chalk3.red(`failed`) + chalk3.hex("#e5e7eb")(`: ${error?.message ?? "Unknown error"}`)
       );
     }
   };
-  const contentsWatcher = chokider.watch(["src/contents/**/*"], {
+  const contentsWatcher = chokidar2.watch(["src/contents/**/*"], {
     ignored: /node_modules/,
     persistent: true
   });
@@ -799,12 +864,12 @@ var watchContentsAndUploadZip = async (params) => {
 };
 
 // src/commands/plugin-dev/index.ts
-function command3() {
-  program3.command("dev").option(
+function command2() {
+  program2.command("dev").option(
     "-p, --ppk <ppk>",
     ".ppk file path",
     path13.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk")
-  ).option("-c, --cert-dir <certDir>", "Certificate directory", PLUGIN_WORKSPACE_DIRECTORY).description("Start development server with Vite.").action(action2);
+  ).option("-c, --cert-dir <certDir>", "Certificate directory", PLUGIN_WORKSPACE_DIRECTORY).description("Start development server with rsbuild.").action(action2);
 }
 async function action2(options) {
   console.group("\u{1F373} Start development server");
@@ -818,15 +883,12 @@ async function action2(options) {
     }
     const port = config2.server?.port ?? DEFAULT_PORT;
     if (!hasCertificates(certDirPath)) {
-      console.log(chalk5.yellow("\u{1F4DC} SSL certificates not found. Generating..."));
+      console.log(chalk4.yellow("\u{1F4DC} SSL certificates not found. Generating with node-forge..."));
       try {
-        await generateCert(certDirPath);
-        console.log(chalk5.green("\u2705 SSL certificates generated successfully"));
+        generateCert(certDirPath);
+        console.log(chalk4.green("\u2705 SSL certificates generated successfully"));
       } catch (error) {
-        console.log(
-          chalk5.red("\u274C Failed to generate SSL certificates. Make sure mkcert is installed.")
-        );
-        console.log(chalk5.gray("   Install mkcert: https://github.com/FiloSottile/mkcert"));
+        console.log(chalk4.red("\u274C Failed to generate SSL certificates."));
         throw error;
       }
     }
@@ -840,83 +902,28 @@ async function action2(options) {
     if (entryNames.length === 0) {
       throw new Error("No entry points found for plugin. Check src/config and src/desktop paths.");
     }
-    console.log(chalk5.gray(`  Entry points: ${entryNames.join(", ")}`));
+    console.log(chalk4.gray(`  Entry points: ${entryNames.join(", ")}`));
     const { key, cert } = loadCertificates(certDirPath);
-    console.log(chalk5.gray("  Building..."));
-    await buildEntriesWithVite({
+    const { port: actualPort } = await startRsbuildDevServer({
       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(chalk5.green(`
+      port,
+      https: { key, cert },
+      publicDir: outputDir,
+      onFirstCompile: () => {
+        console.log(chalk4.green(`
 \u2728 Plugin development server ready!`));
-    console.log(chalk5.cyan(`   Local: https://localhost:${port}`));
-    console.log(chalk5.gray(`   Output: ${outputDir}`));
-    console.log(chalk5.gray(`   Files: config.js, desktop.js`));
-    console.log(chalk5.gray("\n   Watching for changes...\n"));
-    const chokidar2 = await import("chokidar");
-    const watchDirs = [
-      path13.resolve("src", "config"),
-      path13.resolve("src", "desktop"),
-      path13.resolve("src", "lib")
-    ].filter((dir) => fs10.existsSync(dir));
-    console.log(chalk5.gray(`  Watching directories: ${watchDirs.join(", ")}`));
-    const watcher = chokidar2.watch(watchDirs, {
-      ignored: /node_modules/,
-      persistent: true,
-      ignoreInitial: true
-    });
-    const watchExtensions = [".ts", ".tsx", ".js", ".jsx", ".css", ".scss"];
-    const shouldRebuild = (filePath) => {
-      const ext = path13.extname(filePath).toLowerCase();
-      return watchExtensions.includes(ext);
-    };
-    const rebuild = async () => {
-      console.log(chalk5.gray(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} Rebuilding...`));
-      await buildEntriesWithVite({
-        entries,
-        outDir: outputDir,
-        mode: "development",
-        sourcemap: "inline",
-        minify: false
-      });
-      console.log(chalk5.gray(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} Rebuild complete`));
-    };
-    watcher.on("ready", () => {
-      console.log(chalk5.green("  \u2713 File watcher ready"));
-    });
-    watcher.on("change", (filePath) => {
-      if (shouldRebuild(filePath)) {
-        console.log(chalk5.cyan(`  [change] ${filePath}`));
-        rebuild();
-      }
-    });
-    watcher.on("add", (filePath) => {
-      if (shouldRebuild(filePath)) {
-        console.log(chalk5.cyan(`  [add] ${filePath}`));
-        rebuild();
-      }
-    });
-    watcher.on("unlink", (filePath) => {
-      if (shouldRebuild(filePath)) {
-        console.log(chalk5.cyan(`  [unlink] ${filePath}`));
-        rebuild();
+        console.log(chalk4.cyan(`   Local: https://localhost:${actualPort}`));
+        console.log(chalk4.gray(`   Output: ${outputDir}`));
+        console.log(chalk4.gray(`   Files: config.js, desktop.js`));
+        console.log(chalk4.gray("\n   Watching for changes...\n"));
+      },
+      onRecompile: () => {
+        console.log(
+          chalk4.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk4.cyan(`[rsbuild] `) + `rebuild complete`
+        );
       }
     });
-    watcher.on("error", (error) => {
-      console.error(chalk5.red(`  Watcher error: ${error}`));
-    });
     Promise.all([watchContentsAndUploadZip({ manifest, ppkPath }), watchCss(config2)]);
   } catch (error) {
     throw error;
@@ -926,18 +933,15 @@ async function action2(options) {
 }
 
 // src/commands/plugin-genkey.ts
-import { program as program4 } from "commander";
-
-// src/commands/genkey-base.ts
-async function action3(options) {
-  const { output } = options;
-  console.group("\u{1F373} Generate SSL key for localhost");
+import { program as program3 } from "commander";
+function command3() {
+  program3.command("genkey").description("Generate SSL certificate for localhost using node-forge.").action(action3);
+}
+async function action3() {
+  console.group("\u{1F373} Generate SSL certificate for localhost");
   try {
-    const { stdout } = await generateCert(output);
-    if (stdout) {
-      console.log(stdout);
-    }
-    console.log(`\u{1F511} key generation success. Output to ./${output}`);
+    generateCert(PLUGIN_WORKSPACE_DIRECTORY);
+    console.log(`\u{1F511} Certificate generated. Output to ./${PLUGIN_WORKSPACE_DIRECTORY}`);
   } catch (error) {
     throw error;
   } finally {
@@ -945,44 +949,29 @@ async function action3(options) {
   }
 }
 
-// src/commands/plugin-genkey.ts
-function command4() {
-  program4.command("genkey").description("Generate SSL key for localhost. (Require mkcert)").action(action4);
-}
-async function action4() {
-  await action3({ output: PLUGIN_WORKSPACE_DIRECTORY });
-}
-
 // src/commands/plugin-init.ts
-import { program as program5 } from "commander";
+import { program as program4 } from "commander";
 import fs11 from "fs-extra";
 import path14 from "path";
-import packer2 from "@kintone/plugin-packer";
-function command5() {
-  program5.command("init").description("generate private.ppk and kitting config").action(action5);
+function command4() {
+  program4.command("init").description("generate private.ppk and kitting config").action(action4);
 }
-async function action5() {
+async function action4() {
   console.group("\u{1F373} Executing plugin initialization setup");
   try {
     const manifest = await outputManifest("dev");
     console.log("\u{1F4DD} manifest.json generated");
     await copyPluginContents();
     console.log("\u{1F4C1} contents copied");
-    let privateKey;
-    const keyPath = path14.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk");
-    if (fs11.existsSync(keyPath)) {
-      privateKey = await fs11.readFile(keyPath, "utf8");
-    }
-    await outputContentsZip(manifest);
-    const buffer = await getContentsZipBuffer();
-    const output = await packer2(buffer, privateKey);
-    if (!privateKey) {
-      await fs11.writeFile(path14.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk"), output.privateKey);
+    const ppkPath = path14.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk");
+    const contentsZip = createContentsZipFromDir(manifest);
+    const { zip, privateKey } = createPluginZip({ ppkPath, contentsZip });
+    if (!fs11.existsSync(ppkPath)) {
       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(path14.join(PLUGIN_WORKSPACE_DIRECTORY, "plugin.zip"), output.plugin);
+    await fs11.writeFile(path14.join(PLUGIN_WORKSPACE_DIRECTORY, "plugin.zip"), zip);
     console.log("\u{1F4E6} plugin.zip generated");
     console.log("\u2728 Plugin initialization setup completed! zip file path is ./.plugin/plugin.zip");
   } catch (error) {
@@ -993,11 +982,11 @@ async function action5() {
 }
 
 // src/commands/manifest/index.ts
-import { program as program6 } from "commander";
-function command6() {
-  program6.command("manifest").option("-e, --env <env>", "create manifest", "prod").action(action6);
+import { program as program5 } from "commander";
+function command5() {
+  program5.command("manifest").option("-e, --env <env>", "create manifest", "prod").action(action5);
 }
-async function action6(options) {
+async function action5(options) {
   console.group("\u{1F680} Executing manifest generation");
   try {
     const { env } = options;
@@ -1016,12 +1005,12 @@ async function action6(options) {
 }
 
 // src/commands/test/index.ts
-import { program as program7 } from "commander";
+import { program as program6 } from "commander";
 import fs12 from "fs-extra";
-function command7() {
-  program7.command("test").description("test").action(action7);
+function command6() {
+  program6.command("test").description("test").action(action6);
 }
-async function action7() {
+async function action6() {
   console.group("package.json");
   const packageJson = fs12.readJSONSync("package.json");
   console.log("package.json detected");
@@ -1033,18 +1022,26 @@ async function action7() {
 }
 
 // src/commands/plugin-zip.ts
-import { program as program8 } from "commander";
+import { program as program7 } from "commander";
+import fs14 from "fs-extra";
+import path16 from "path";
+
+// src/lib/utils.ts
 import fs13 from "fs-extra";
 import path15 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(
+var isEnv = (env) => {
+  return ["prod", "dev", "standalone"].includes(env);
+};
+
+// src/commands/plugin-zip.ts
+function command7() {
+  program7.command("zip").description("generate plugin zip").option("-e, --env <env>", "plugin environment (dev, prod, standalone)", "prod").option(
     "-p, --ppk <ppk>",
     ".ppk file path",
-    path15.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk")
-  ).action(action8);
+    path16.join(PLUGIN_WORKSPACE_DIRECTORY, "private.ppk")
+  ).action(action7);
 }
-async function action8(options) {
+async function action7(options) {
   console.group("\u{1F373} Executing plugin zip generation");
   try {
     const { env, ppk: ppkPath } = options;
@@ -1055,18 +1052,17 @@ async function action8(options) {
     console.log("\u{1F4C1} contents copied");
     const manifest = await outputManifest(env);
     console.log(`\u{1F4DD} manifest.json generated (${env})`);
-    await outputContentsZip(manifest);
+    const contentsZip = createContentsZipFromDir(manifest);
     console.log("\u{1F4E6} contents.zip generated");
-    const buffer = await getContentsZipBuffer();
-    const privateKey = await fs13.readFile(path15.resolve(ppkPath), "utf8");
-    const output = await packer3(buffer, privateKey);
+    const { zip, id } = createPluginZip({ ppkPath: path16.resolve(ppkPath), contentsZip });
     const zipFileName = `plugin${getZipFileNameSuffix(env)}.zip`;
-    await fs13.writeFile(path15.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName), output.plugin);
+    await fs14.writeFile(path16.join(PLUGIN_WORKSPACE_DIRECTORY, zipFileName), zip);
     console.log("\u{1F4E6} plugin.zip generated");
     const version = String(manifest.version);
-    await fs13.writeFile(path15.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}`);
+    console.log(`   Plugin ID: ${id}`);
   } catch (error) {
     throw error;
   } finally {
@@ -1075,11 +1071,11 @@ async function action8(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(action9);
+import { program as program8 } from "commander";
+function command8() {
+  program8.command("lint").description("Lint source files").option("-c, --config <config>", "Config file path").action(action8);
 }
-async function action9(options) {
+async function action8(options) {
   try {
     lint();
   } catch (error) {
@@ -1089,7 +1085,7 @@ async function action9(options) {
 }
 
 // src/plugin.ts
-program10.name("plugin").version("1.12.0").description("\u{1F373} kintone kitchen \u{1F373} for kintone plugin");
+program9.name("plugin").version("4.0.0").description("\u{1F373} kintone kitchen \u{1F373} for kintone plugin");
 command();
 command2();
 command3();
@@ -1098,6 +1094,5 @@ command5();
 command6();
 command7();
 command8();
-command9();
-program10.parse(process.argv);
+program9.parse(process.argv);
 //# sourceMappingURL=plugin.js.map