@konomi-app/k2 3.4.1 → 4.1.0

package/dist/index.js

@@ -1,19 +1,12 @@
 #!/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/index.ts
-import { program as program6 } from "commander";
+import { program as program5 } from "commander";
 
 // src/commands/build.ts
 import { program } from "commander";
-import "fs-extra";
 import path6 from "path";
-import chalk2 from "chalk";
+import chalk from "chalk";
 
 // src/lib/constants.ts
 import path from "path";
@@ -143,198 +136,143 @@ var getDefaultK2Config = () => {
   };
 };
 
-// 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 { pluginReact } from "@rsbuild/plugin-react";
 import path5 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";
+function getRsbuildPlugins() {
+  return [
+    pluginReact({
+      swcReactOptions: {
+        runtime: "automatic"
+      }
+    })
+  ];
+}
+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: {
+      plugins: getRsbuildPlugins(),
+      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 = (config = {}) => {
-  const plugins = [...config.plugins ?? []];
-  try {
-    const tsconfigPaths = __require("vite-tsconfig-paths");
-    plugins.push(tsconfigPaths.default ? tsconfigPaths.default() : tsconfigPaths());
-  } catch {
-  }
-  const mode = config.mode ?? "production";
-  return {
-    ...config,
-    configFile: false,
-    // ソースマップ関連のエラーメッセージを抑制
-    logLevel: config.logLevel ?? "warn",
-    // ブラウザ向けにNode.js固有のオブジェクトをビルド時に解決
-    define: {
-      "process.env.NODE_ENV": JSON.stringify(mode),
-      "process.env": JSON.stringify({}),
-      ...config.define
+async function startRsbuildDevServer(params) {
+  const { entries, outDir, port, https, publicDir, onFirstCompile, onRecompile } = params;
+  const rsbuildConfig = {
+    plugins: getRsbuildPlugins(),
+    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: {
-      ...config.build,
-      // ブラウザ向けターゲット
-      target: config.build?.target ?? "es2020",
-      cssCodeSplit: false,
-      rollupOptions: {
-        ...config.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: {
-      ...config.resolve,
-      alias: {
-        "@": path5.resolve(process.cwd(), "src"),
-        ...config.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 config = createViteConfig({
-    ...viteConfig,
-    mode,
-    build: {
-      ...viteConfig.build,
-      rollupOptions: {
-        ...viteConfig.build?.rollupOptions,
-        input: entryPath,
-        output: {
-          entryFileNames: `${name}.js`,
-          assetFileNames: `${name}.[ext]`,
-          format: "iife",
-          // 外部ライブラリのソースマップを無視して警告を抑制
-          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(config);
-  const outputPath = path5.join(outDir, `${name}.js`);
-  if (fs2.existsSync(outputPath)) {
-    const content = await fs2.readFile(outputPath, "utf-8");
-    const wrapped = `(function(){
-${content}
-})();`;
-    await fs2.writeFile(outputPath, wrapped);
+      }
+    ]);
   }
+  const result = await rsbuild.startDevServer();
+  return {
+    port: result.port,
+    close: result.server.close
+  };
 }
-var ENTRY_FILE_NAMES = ["index.ts", "index.tsx", "index.js", "index.jsx", "index.mjs"];
-function getEntryPointsFromDir(inputDir) {
-  const entries = {};
+function getAppEntryPoints(inputDir) {
   if (!fs2.existsSync(inputDir)) {
-    throw new Error(`Input directory not found: ${inputDir}`);
+    return {};
   }
-  const dirs = fs2.readdirSync(inputDir, { withFileTypes: true });
-  for (const dirent of dirs) {
-    if (!dirent.isDirectory()) continue;
-    const dirName = dirent.name;
-    const dirPath = path5.join(inputDir, dirName);
-    for (const filename of ENTRY_FILE_NAMES) {
-      const entryPath = path5.join(dirPath, filename);
-      if (fs2.existsSync(entryPath)) {
-        entries[dirName] = entryPath;
-        break;
+  const allProjects = fs2.readdirSync(inputDir);
+  return allProjects.reduce((acc, dir) => {
+    const dirPath = path5.join(inputDir, dir);
+    if (!fs2.statSync(dirPath).isDirectory()) return acc;
+    for (const filename of ["index.ts", "index.tsx", "index.js", "index.jsx", "index.mjs"]) {
+      const filePath = path5.join(inputDir, dir, filename);
+      if (fs2.existsSync(filePath)) {
+        return { ...acc, [dir]: filePath };
       }
     }
-  }
-  return entries;
+    return acc;
+  }, {});
 }
 
 // src/commands/build.ts
 function command() {
-  program.command("build").option("-o, --outdir <outdir>", "Output directory.", path6.join(WORKSPACE_DIRECTORY, "prod")).option("-i, --input <input>", "Input directory.", path6.join("src", "apps")).option("--config <config>", "k2 config file path").description("Build the project for production with Vite.").action(action);
+  program.command("build").option("-o, --outdir <outdir>", "Output directory.", path6.join(WORKSPACE_DIRECTORY, "prod")).option("-i, --input <input>", "Input directory.", path6.join("src", "apps")).option("--config <config>", "k2 config file path").description("Build the project for production with rsbuild.").action(action);
 }
 async function action(options) {
   console.group("\u{1F373} Build the project for production");
   try {
     const { outdir, input, config } = options;
     const outDir = path6.resolve(outdir);
-    const entries = getEntryPointsFromDir(path6.resolve(input));
+    const entries = getAppEntryPoints(path6.resolve(input));
     const entryNames = Object.keys(entries);
     if (entryNames.length === 0) {
       throw new Error(`No entry points found in ${input}`);
     }
-    console.log(chalk2.gray(`  Entry points: ${entryNames.join(", ")}`));
+    console.log(chalk.gray(`  Entry points: ${entryNames.join(", ")}`));
     const k2Config = config ? await importK2Config(config) : getDefaultK2Config();
     const fullConfig = { ...k2Config, outDir };
     const results = await Promise.allSettled([
-      buildEntriesWithVite({
+      buildWithRsbuild({
         entries,
         outDir,
-        mode: "production",
+        minify: true,
         sourcemap: false,
-        minify: true
+        injectStyles: true
       }),
       buildTailwind(fullConfig)
     ]);
@@ -353,15 +291,14 @@ async function action(options) {
 
 // src/commands/dev/index.ts
 import { program as program2 } from "commander";
-import { createServer } from "vite";
-import fs6 from "fs-extra";
-import path9 from "path";
-import chalk4 from "chalk";
+import "fs-extra";
+import path10 from "path";
+import chalk3 from "chalk";
 
 // src/commands/dev/tailwind.ts
 import path7 from "path";
-import chalk3 from "chalk";
-import fs4 from "fs-extra";
+import chalk2 from "chalk";
+import fs3 from "fs-extra";
 var watchCss = async (params) => {
   const { k2Config, outdir } = params;
   if (!k2Config.tailwind?.css || !k2Config.tailwind?.config) {
@@ -371,8 +308,8 @@ var watchCss = async (params) => {
   const tailwindConfig = await getTailwindConfigFromK2Config(k2Config.tailwind);
   const input = path7.resolve(k2Config.tailwind.css);
   const output = path7.join(outdir, "tailwind.css");
-  if (!await fs4.pathExists(output)) {
-    await fs4.outputFile(output, "");
+  if (!await fs3.pathExists(output)) {
+    await fs3.outputFile(output, "");
   }
   return watchTailwindCSS({
     input,
@@ -381,50 +318,239 @@ var watchCss = async (params) => {
     onChanges: ({ output: output2, type }) => {
       const outputFileName = path7.basename(output2);
       console.log(
-        chalk3.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk3.cyan(`[css] `) + outputFileName + (type === "init" ? " init" : ` rebuilt(${type})`)
+        chalk2.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk2.cyan(`[css] `) + outputFileName + (type === "init" ? " init" : ` rebuilt(${type})`)
       );
     }
   });
 };
 
-// src/lib/exec.ts
-import { exec as defaultExec } from "child_process";
-import { promisify } from "util";
-var exec = promisify(defaultExec);
+// src/lib/cert/index.ts
+import fs4 from "fs-extra";
+import path9 from "path";
 
-// src/lib/cert.ts
-import fs5 from "fs-extra";
+// 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 path8 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 path8.join(process.env.HOME, "Library", "Application Support", name);
+  }
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA ? path8.join(process.env.LOCALAPPDATA, name) : path8.join(process.env.USERPROFILE, "Local Settings", "Application Data", name);
+  }
+  return process.env.XDG_CONFIG_HOME ? path8.join(process.env.XDG_CONFIG_HOME, name) : path8.join(process.env.HOME, ".config", name);
+}
+var pkgDir = getApplicationConfigPath(PKG_NAME);
+var rootCAPath = path8.resolve(pkgDir, "rootCA.pem");
+var rootCAKeyPath = path8.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 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}`, path8.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(path9.join(outDir, CERT_FILENAME), result.cert);
+  fs4.outputFileSync(path9.join(outDir, CERT_KEY_FILENAME), result.key);
+  return result;
+}
 function hasCertificates(certDir) {
-  return fs5.existsSync(path8.join(certDir, CERT_KEY_FILENAME)) && fs5.existsSync(path8.join(certDir, CERT_FILENAME));
+  return fs4.existsSync(path9.join(certDir, CERT_KEY_FILENAME)) && fs4.existsSync(path9.join(certDir, CERT_FILENAME));
 }
 function loadCertificates(certDir) {
   return {
-    key: fs5.readFileSync(path8.join(certDir, CERT_KEY_FILENAME)),
-    cert: fs5.readFileSync(path8.join(certDir, CERT_FILENAME))
+    key: fs4.readFileSync(path9.join(certDir, CERT_KEY_FILENAME)),
+    cert: fs4.readFileSync(path9.join(certDir, CERT_FILENAME))
   };
 }
 
 // src/commands/dev/index.ts
 function command2() {
-  program2.command("dev").description("Start development server with Vite.").option("-i, --input <input>", "Input directory", "src/apps").option("-o, --outdir <outdir>", "Output directory.", DEVELOPMENT_DIRECTORY).option("-c, --certdir <certdir>", "Certificate directory", WORKSPACE_DIRECTORY).option("--config <config>", "k2 config file path").option("-p, --port <port>", "Port number").action(action2);
+  program2.command("dev").description("Start development server with rsbuild.").option("-i, --input <input>", "Input directory", "src/apps").option("-o, --outdir <outdir>", "Output directory.", DEVELOPMENT_DIRECTORY).option("-c, --certdir <certdir>", "Certificate directory", WORKSPACE_DIRECTORY).option("--config <config>", "k2 config file path").option("-p, --port <port>", "Port number").action(action2);
 }
 async function action2(options) {
   const { certdir, outdir, config, port: specifiedPort, input } = options;
@@ -439,100 +565,45 @@ async function action2(options) {
       console.log(`\u2699 ${CONFIG_FILE_NAME} not found. use default settings.`);
     }
     const port = Number(specifiedPort ?? k2Config?.server?.port ?? DEFAULT_PORT);
-    const certDirPath = path9.resolve(certdir);
-    const outputDir = path9.resolve(outdir);
-    const inputDir = path9.resolve(input);
+    const certDirPath = path10.resolve(certdir);
+    const outputDir = path10.resolve(outdir);
+    const inputDir = path10.resolve(input);
     if (!hasCertificates(certDirPath)) {
-      console.log(chalk4.yellow("\u{1F4DC} SSL certificates not found. Generating..."));
+      console.log(chalk3.yellow("\u{1F4DC} SSL certificates not found. Generating with node-forge..."));
       try {
-        await generateCert(certDirPath);
-        console.log(chalk4.green("\u2705 SSL certificates generated successfully"));
+        generateCert(certDirPath);
+        console.log(chalk3.green("\u2705 SSL certificates generated successfully"));
       } catch (error) {
-        console.log(
-          chalk4.red("\u274C Failed to generate SSL certificates. Make sure mkcert is installed.")
-        );
-        console.log(chalk4.gray("   Install mkcert: https://github.com/FiloSottile/mkcert"));
+        console.log(chalk3.red("\u274C Failed to generate SSL certificates."));
         throw error;
       }
     }
-    const entries = getEntryPointsFromDir(inputDir);
+    const entries = getAppEntryPoints(inputDir);
     const entryNames = Object.keys(entries);
     if (entryNames.length === 0) {
       throw new Error(`No entry points found in ${input}`);
     }
-    console.log(chalk4.gray(`  Entry points: ${entryNames.join(", ")}`));
-    await fs6.emptyDir(outputDir);
+    console.log(chalk3.gray(`  Entry points: ${entryNames.join(", ")}`));
     const { key, cert } = loadCertificates(certDirPath);
-    console.log(chalk4.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(chalk4.green(`
+      port,
+      https: { key, cert },
+      publicDir: outputDir,
+      onFirstCompile: () => {
+        console.log(chalk3.green(`
 \u2728 Development server ready!`));
-    console.log(chalk4.cyan(`   Local: https://localhost:${port}`));
-    console.log(chalk4.gray(`   Output: ${outputDir}`));
-    console.log(chalk4.gray("\n   Watching for changes...\n"));
-    const chokidar2 = await import("chokidar");
-    const watchDirs = [inputDir, path9.resolve("src", "lib")].filter((dir) => fs6.existsSync(dir));
-    console.log(chalk4.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 = path9.extname(filePath).toLowerCase();
-      return watchExtensions.includes(ext);
-    };
-    const rebuild = async () => {
-      console.log(chalk4.gray(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} Rebuilding...`));
-      await buildEntriesWithVite({
-        entries,
-        outDir: outputDir,
-        mode: "development",
-        sourcemap: "inline",
-        minify: false
-      });
-      console.log(chalk4.gray(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} Rebuild complete`));
-    };
-    watcher.on("ready", () => {
-      console.log(chalk4.green("  \u2713 File watcher ready"));
-    });
-    watcher.on("change", (filePath) => {
-      if (shouldRebuild(filePath)) {
-        console.log(chalk4.cyan(`  [change] ${filePath}`));
-        rebuild();
-      }
-    });
-    watcher.on("add", (filePath) => {
-      if (shouldRebuild(filePath)) {
-        console.log(chalk4.cyan(`  [add] ${filePath}`));
-        rebuild();
-      }
-    });
-    watcher.on("unlink", (filePath) => {
-      if (shouldRebuild(filePath)) {
-        console.log(chalk4.cyan(`  [unlink] ${filePath}`));
-        rebuild();
+        console.log(chalk3.cyan(`   Local: https://localhost:${actualPort}`));
+        console.log(chalk3.gray(`   Output: ${outputDir}`));
+        console.log(chalk3.gray("\n   Watching for changes...\n"));
+      },
+      onRecompile: () => {
+        console.log(
+          chalk3.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk3.cyan(`[rsbuild] `) + `rebuild complete`
+        );
       }
     });
-    watcher.on("error", (error) => {
-      console.error(chalk4.red(`  Watcher error: ${error}`));
-    });
     if (k2Config) {
       await watchCss({ k2Config, outdir });
     }
@@ -545,69 +616,15 @@ async function action2(options) {
 
 // src/commands/genkey.ts
 import { program as program3 } from "commander";
-
-// src/commands/genkey-base.ts
-async function action3(options) {
-  const { output } = options;
-  console.group("\u{1F373} Generate SSL key for localhost");
-  try {
-    const { stdout } = await generateCert(output);
-    if (stdout) {
-      console.log(stdout);
-    }
-    console.log(`\u{1F511} key generation success. Output to ./${output}`);
-  } catch (error) {
-    throw error;
-  } finally {
-    console.groupEnd();
-  }
-}
-
-// src/commands/genkey.ts
 function command3() {
-  program3.command("genkey").description("Generate SSL key for localhost. (Require mkcert)").option("-o, --output <output>", "Output directory.", WORKSPACE_DIRECTORY).action(action4);
-}
-async function action4(options) {
-  await action3(options);
-}
-
-// src/commands/build-esbuild.ts
-import { program as program4 } from "commander";
-import "fs-extra";
-import path10 from "path";
-import chalk5 from "chalk";
-function command4() {
-  program4.command("esbuild-build").option("-o, --outdir <outdir>", "Output directory.", path10.join(WORKSPACE_DIRECTORY, "prod")).option("-i, --input <input>", "Input directory.", path10.join("src", "apps")).option("--config <config>", "k2 config file path").description("Build the project for production with Vite. (Legacy command name, now uses Vite)").action(action5);
+  program3.command("genkey").description("Generate SSL certificate for localhost using node-forge.").option("-o, --output <output>", "Output directory.", WORKSPACE_DIRECTORY).action(action3);
 }
-async function action5(options) {
-  console.group("\u{1F373} Build the project for production");
+async function action3(options) {
+  const { output } = options;
+  console.group("\u{1F373} Generate SSL certificate for localhost");
   try {
-    const { outdir, input, config } = options;
-    const outDir = path10.resolve(outdir);
-    const entries = getEntryPointsFromDir(path10.resolve(input));
-    const entryNames = Object.keys(entries);
-    if (entryNames.length === 0) {
-      throw new Error(`No entry points found in ${input}`);
-    }
-    console.log(chalk5.gray(`  Entry points: ${entryNames.join(", ")}`));
-    const k2Config = config ? await importK2Config(config) : getDefaultK2Config();
-    const fullConfig = { ...k2Config, outDir };
-    const results = await Promise.allSettled([
-      buildEntriesWithVite({
-        entries,
-        outDir,
-        mode: "production",
-        sourcemap: false,
-        minify: true
-      }),
-      buildTailwind(fullConfig)
-    ]);
-    for (const result of results) {
-      if (result.status === "rejected") {
-        throw result.reason;
-      }
-    }
-    console.log("\u2728 Build success.");
+    generateCert(output);
+    console.log(`\u{1F511} Certificate generated. Output to ./${output}`);
   } catch (error) {
     throw error;
   } finally {
@@ -616,14 +633,14 @@ async function action5(options) {
 }
 
 // src/commands/lint.ts
-import { program as program5 } from "commander";
+import { program as program4 } from "commander";
 
 // src/lib/lint.ts
 import { ESLint } from "eslint";
 import globals from "globals";
 import pluginJs from "@eslint/js";
 import "typescript-eslint";
-import pluginReact from "eslint-plugin-react";
+import pluginReact2 from "eslint-plugin-react";
 async function lint() {
   const eslint = new ESLint({
     baseConfig: [
@@ -631,7 +648,7 @@ async function lint() {
       { languageOptions: { globals: globals.browser } },
       pluginJs.configs.recommended,
       // ...tseslint.configs.recommended,
-      ...pluginReact.configs.flat?.recommended ? [pluginReact.configs.flat.recommended] : []
+      ...pluginReact2.configs.flat?.recommended ? [pluginReact2.configs.flat.recommended] : []
     ]
   });
   const results = await eslint.lintFiles(["src/**/*.{ts,tsx?}"]);
@@ -648,10 +665,10 @@ async function lint() {
 }
 
 // src/commands/lint.ts
-function command5() {
-  program5.command("lint").description("Lint source files").option("-c, --config <config>", "Config file path").action(action6);
+function command4() {
+  program4.command("lint").description("Lint source files").option("-c, --config <config>", "Config file path").action(action4);
 }
-async function action6(options) {
+async function action4(options) {
   try {
     lint();
   } catch (error) {
@@ -661,11 +678,10 @@ async function action6(options) {
 }
 
 // src/index.ts
-program6.name("k2").version("1.12.0").description("k2 - \u{1F373} kintone kitchen \u{1F373}");
+program5.name("k2").version("4.0.0").description("k2 - \u{1F373} kintone kitchen \u{1F373}");
 command();
-command4();
 command2();
 command3();
-command5();
-program6.parse(process.argv);
+command4();
+program5.parse(process.argv);
 //# sourceMappingURL=index.js.map