@konomi-app/k2 2.1.3 → 2.1.4

package/dist/plugin.js

@@ -1,25 +1,1088 @@
 #!/usr/bin/env node
-import { program } from 'commander';
-import build from './commands/plugin-build.js';
-import esbuild from './commands/plugin-esbuild.js';
-import dev from './commands/plugin-dev/index.js';
-import genkey from './commands/plugin-genkey.js';
-import init from './commands/plugin-init.js';
-import manifest from './commands/manifest/index.js';
-import test from './commands/test/index.js';
-import zip from './commands/plugin-zip.js';
-import lint from './commands/lint.js';
-import tsup from './commands/plugin-tsup.js';
-program.name('plugin').version('1.12.0').description('🍳 kintone kitchen 🍳 for kintone plugin');
-build();
-esbuild();
-dev();
-genkey();
-init();
-manifest();
-test();
-zip();
-lint();
-tsup();
-program.parse(process.argv);
+
+// src/plugin.ts
+import { program as program11 } from "commander";
+
+// src/commands/plugin-build.ts
+import { program } from "commander";
+import fs2 from "fs-extra";
+import path5 from "path";
+import "webpack";
+
+// src/lib/constants.ts
+import path from "path";
+var WORKSPACE_DIRECTORY = ".k2";
+var DEVELOPMENT_DIRECTORY = path.join(WORKSPACE_DIRECTORY, "dev");
+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 DEFAULT_PORT = 32767;
+
+// src/lib/import.ts
+import { pathToFileURL } from "url";
+import path2 from "path";
+var esmImport = (path19) => {
+  if (process.platform === "win32") {
+    return import(pathToFileURL(path19).toString());
+  } else {
+    return import(path19);
+  }
+};
+var importK2PluginConfig = async (configFileName) => {
+  return (await esmImport(path2.resolve(configFileName ?? PLUGIN_CONFIG_FILE_NAME))).default;
+};
+
+// src/lib/tailwind.ts
+import chokidar from "chokidar";
+import cssnanoPlugin from "cssnano";
+import fs from "fs-extra";
+import { glob } from "glob";
+import path3 from "path";
+import postcss from "postcss";
+import { debounce } from "remeda";
+import tailwindcss from "tailwindcss";
+import invariant from "tiny-invariant";
+var getTailwindInputCss = (config2) => {
+  invariant(config2?.css, "tailwind.css is required");
+  const { css } = config2;
+  if (typeof css === "string") {
+    const resolved = path3.resolve(css);
+    return { desktop: resolved, config: resolved };
+  }
+  return {
+    desktop: path3.resolve(css.desktop),
+    config: path3.resolve(css.config)
+  };
+};
+var getTailwindConfig = async (config2) => {
+  invariant(config2?.config, "tailwind.config is required");
+  const { config: configPath } = config2;
+  const configPathForDesktop = typeof configPath === "string" ? configPath : configPath.desktop;
+  const configPathForConfig = typeof configPath === "string" ? configPath : configPath.config;
+  const desktopConfig = (await esmImport(path3.resolve(configPathForDesktop))).default;
+  const configConfig = (await esmImport(path3.resolve(configPathForConfig))).default;
+  return { desktop: desktopConfig, config: configConfig };
+};
+var outputCss = async (params) => {
+  const { inputPath, outputPath, config: config2, minify = false } = params;
+  const css = await fs.readFile(inputPath, "utf8");
+  const result = await postcss([tailwindcss(config2), ...minify ? [cssnanoPlugin()] : []]).process(
+    css,
+    {
+      from: inputPath,
+      to: outputPath
+    }
+  );
+  await fs.writeFile(outputPath, result.css);
+  if (result.map) {
+    await fs.writeFile(`${outputPath}.map`, result.map.toString());
+  }
+};
+var watchTailwindCSS = async (params) => {
+  const { input, output, config: config2 } = params;
+  const content = config2.content ?? ["./src/**/*.{ts,tsx}"];
+  const files = await glob([...content, input], { ignore: ["**/node_modules/**"] });
+  const watcher = chokidar.watch(files, {
+    persistent: true,
+    ignoreInitial: true
+  });
+  let isInitialized = false;
+  const processChanges = async (type) => {
+    try {
+      await outputCss({ inputPath: input, outputPath: output, config: config2 });
+      params.onChanges?.({ input, output, type });
+    } catch (error) {
+      console.error("Error building Tailwind CSS:", error);
+    }
+  };
+  const debouncedProcessChanges = debounce(processChanges, { waitMs: 1e3 });
+  watcher.on("ready", async () => {
+    if (!isInitialized) {
+      isInitialized = true;
+      await processChanges("init");
+    }
+  });
+  watcher.on("error", (error) => {
+    console.error("Error watching Tailwind CSS:", error);
+  });
+  watcher.on("add", (path19) => {
+    debouncedProcessChanges.call("add");
+  });
+  watcher.on("change", (path19) => {
+    debouncedProcessChanges.call("change");
+  });
+  watcher.on("unlink", (path19) => {
+    debouncedProcessChanges.call("unlink");
+  });
+  watcher.on("unlinkDir", (path19) => {
+    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";
+import pluginJs from "@eslint/js";
+import "typescript-eslint";
+import pluginReact from "eslint-plugin-react";
+async function lint() {
+  const eslint = new ESLint({
+    baseConfig: [
+      { files: ["**/*.{js,mjs,cjs,ts,jsx,tsx}"] },
+      { languageOptions: { globals: globals.browser } },
+      pluginJs.configs.recommended,
+      // ...tseslint.configs.recommended,
+      ...pluginReact.configs.flat?.recommended ? [pluginReact.configs.flat.recommended] : []
+    ]
+  });
+  const results = await eslint.lintFiles(["src/**/*.{ts,tsx?}"]);
+  const formatter = await eslint.loadFormatter("stylish");
+  const resultText = formatter.format(results);
+  console.group("\u{1F455} Lint Results");
+  console.log(resultText);
+  console.groupEnd();
+  const hasErrors = results.some((result) => result.errorCount > 0);
+  if (hasErrors) {
+    console.error("\u{1F6A8} Lint errors found");
+    process.exit(1);
+  }
+}
+
+// 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);
+}
+async function action2() {
+  console.group("\u{1F373} Build the project for production");
+  try {
+    const config2 = await importK2PluginConfig();
+    if (config2?.lint?.build) {
+      await lint();
+      console.log("\u2728 Lint success.");
+    }
+    if (!fs2.existsSync(PLUGIN_CONTENTS_DIRECTORY)) {
+      await fs2.mkdir(PLUGIN_CONTENTS_DIRECTORY, { recursive: true });
+    }
+    const entries = {
+      desktop: path5.join("src", "desktop", "index.ts"),
+      config: path5.join("src", "config", "index.ts")
+    };
+    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");
+    }
+    await action({ entries, outDir: PLUGIN_CONTENTS_DIRECTORY });
+    console.log("\u2728 Built desktop.js and config.js");
+    console.log("\u2728 Build success.");
+  } catch (error) {
+    throw error;
+  } finally {
+    console.groupEnd();
+  }
+}
+
+// src/commands/plugin-esbuild.ts
+import { program as program2 } from "commander";
+import fs3 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
+function command2() {
+  program2.command("esbuild").description("Build the project for production. (It's a wrapper of webpack build command.)").action(action3);
+}
+async function action3() {
+  console.group("\u{1F373} Build the project for production");
+  try {
+    const config2 = await importK2PluginConfig();
+    if (config2?.lint?.build) {
+      await lint();
+      console.log("\u2728 Lint success.");
+    }
+    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: path6.join(PLUGIN_CONTENTS_DIRECTORY, "config.css"),
+        config: tailwindConfig.config,
+        minify: true
+      });
+      console.log("\u2728 Built config.css");
+      await outputCss({
+        inputPath: inputFile.desktop,
+        outputPath: path6.join(PLUGIN_CONTENTS_DIRECTORY, "desktop.css"),
+        config: tailwindConfig.desktop,
+        minify: true
+      });
+      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,
+      sourcemap: false,
+      legalComments: "none"
+    });
+    console.log("\u2728 Built desktop.js and config.js");
+    console.log("\u2728 Build success.");
+  } catch (error) {
+    throw error;
+  } finally {
+    console.groupEnd();
+  }
+}
+
+// src/commands/plugin-dev/index.ts
+import { program as program3 } from "commander";
+import "esbuild";
+import fs9 from "fs-extra";
+import path14 from "path";
+
+// src/commands/dev-base-esbuild.ts
+import "esbuild";
+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}`);
+}
+
+// src/lib/plugin-manifest.ts
+import fs4 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);
+  return merged;
+};
+
+// src/commands/plugin-dev/create-manifest.ts
+var getManifest = async (params) => {
+  const { config: config2, port } = params;
+  return outputManifest("dev", {
+    config: {
+      ...config2,
+      manifest: {
+        ...config2.manifest,
+        dev: {
+          config: {
+            ...config2.manifest?.dev?.config,
+            js: [`https://localhost:${port}/config.js`],
+            css: [`https://localhost:${port}/config.css`]
+          },
+          desktop: {
+            ...config2.manifest?.dev?.desktop,
+            js: [`https://localhost:${port}/desktop.js`],
+            css: [`https://localhost:${port}/desktop.css`]
+          },
+          mobile: {
+            ...config2.manifest?.dev?.mobile,
+            js: [`https://localhost:${port}/desktop.js`],
+            css: [`https://localhost:${port}/desktop.css`]
+          }
+        }
+      }
+    }
+  });
+};
+
+// src/commands/plugin-dev/tailwind.ts
+import path9 from "path";
+import "tailwindcss";
+import chalk3 from "chalk";
+async function buildTailwindCSS(params) {
+  const { inputFile, outputFileName, config: config2 } = params;
+  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 = path9.basename(output);
+      console.log(
+        chalk3.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk3.cyan(`[css] `) + outputFileName2 + (type === "init" ? " init" : ` rebuilt`)
+      );
+    }
+  });
+}
+var watchCss = async (pluginConfig) => {
+  if (!pluginConfig.tailwind?.css || !pluginConfig.tailwind?.config) {
+    return;
+  }
+  const tailwindConfig = await getTailwindConfig(pluginConfig.tailwind);
+  const inputFile = getTailwindInputCss(pluginConfig.tailwind);
+  return Promise.all([
+    buildTailwindCSS({
+      inputFile: inputFile.desktop,
+      outputFileName: "desktop.css",
+      config: tailwindConfig.desktop
+    }),
+    buildTailwindCSS({
+      inputFile: inputFile.config,
+      outputFileName: "config.css",
+      config: tailwindConfig.config
+    })
+  ]);
+};
+
+// src/commands/plugin-dev/upload.ts
+import packer from "@kintone/plugin-packer";
+
+// src/lib/plugin-contents.ts
+import fs5 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 });
+  }
+  await fs5.copy(inputDir, outputDir, { overwrite: true });
+  const configHtmlPath = path10.join(outputDir, "config.html");
+  if (!fs5.existsSync(configHtmlPath)) {
+    throw new Error(`Plugin HTML file not found. Create "config.html" in ${inputDir}.`);
+  }
+  const html = await fs5.readFile(configHtmlPath, "utf8");
+  const minified = htmlMinifier.minify(html, {
+    minifyCSS: true,
+    collapseWhitespace: true,
+    removeComments: true,
+    removeOptionalTags: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeTagWhitespace: true,
+    useShortDoctype: true
+  });
+  await fs5.writeFile(configHtmlPath, minified);
+};
+
+// src/lib/zip.ts
+import archiver from "archiver";
+import fs6 from "fs-extra";
+import path11 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);
+    } else {
+      throw error;
+    }
+  });
+  const outputZipPath = path11.join(PLUGIN_WORKSPACE_DIRECTORY, "contents.zip");
+  const outputZipStream = fs6.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)
+    ])
+  ];
+  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 = path11.join(PLUGIN_CONTENTS_DIRECTORY, file);
+    if (!fs6.existsSync(filePath)) {
+      throw new Error(`${filePath} does not exist`);
+    }
+    archive.file(filePath, { name: file });
+  }
+  archive.pipe(outputZipStream);
+  await archive.finalize();
+  await new Promise((resolve) => outputZipStream.on("close", resolve));
+};
+var getContentsZipBuffer = async () => {
+  const outputZipPath = path11.join(PLUGIN_WORKSPACE_DIRECTORY, "contents.zip");
+  return fs6.readFile(outputZipPath);
+};
+var getZipFileNameSuffix = (env) => {
+  return env === "prod" ? "" : `-${env}`;
+};
+
+// src/commands/plugin-dev/upload.ts
+import fs8 from "fs-extra";
+import path13 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
+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(path19) {
+    return `${this.#baseUrl}${path19}`;
+  }
+  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 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 fs7 from "fs-extra";
+import path12 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 fs7.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);
+  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"));
+    }
+    return { method: "PUT" };
+  }
+  const result = await kc.addPlugin({ fileKey });
+  if ("code" in result) {
+    console.error(`Error: ${result.message}`);
+  }
+  return { method: "POST" };
+};
+
+// src/commands/plugin-dev/upload.ts
+import chokider from "chokidar";
+import chalk4 from "chalk";
+var watchContentsAndUploadZip = async (params) => {
+  const { manifest, ppkPath } = params;
+  let initialScanComplete = false;
+  const contentsListener = async () => {
+    try {
+      if (!initialScanComplete) {
+        return;
+      }
+      await copyPluginContents();
+      console.log(
+        chalk4.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk4.cyan(`[contents] `) + `updated`
+      );
+    } catch (error) {
+      console.error("Error copying plugin contents:", error);
+      return;
+    }
+    try {
+      await outputContentsZip(manifest);
+      const buffer = await getContentsZipBuffer();
+      const pluginPrivateKey = await fs8.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);
+      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)"}`
+      );
+    } catch (error) {
+      console.log(
+        chalk4.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk4.cyan(`[upload] `) + chalk4.red(`failed`) + chalk4.hex("#e5e7eb")(`: ${error?.message ?? "Unknown error"}`)
+      );
+    }
+  };
+  const contentsWatcher = chokider.watch(["src/contents/**/*"], {
+    ignored: /node_modules/,
+    persistent: true
+  });
+  contentsWatcher.on("ready", () => {
+    initialScanComplete = true;
+    contentsListener();
+  });
+  contentsWatcher.on("change", contentsListener);
+  contentsWatcher.on("add", contentsListener);
+  contentsWatcher.on("unlink", contentsListener);
+};
+
+// src/commands/plugin-dev/index.ts
+function command3() {
+  program3.command("dev").option(
+    "-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);
+}
+async function action5(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 port = config2.server?.port ?? DEFAULT_PORT;
+    const manifest = await getManifest({ config: config2, port });
+    console.log(`\u{1F4DD} manifest.json generated`);
+    Promise.all([
+      watchContentsAndUploadZip({ manifest, ppkPath }),
+      watchCss(config2),
+      build(port, certDir)
+    ]);
+  } 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) {
+  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/plugin-genkey.ts
+function command4() {
+  program4.command("genkey").description("Generate SSL key for localhost. (Require mkcert)").action(action7);
+}
+async function action7() {
+  await action6({ 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 packer2 from "@kintone/plugin-packer";
+function command5() {
+  program5.command("init").description("generate private.ppk and kitting config").action(action8);
+}
+async function action8() {
+  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 = path16.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(path16.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);
+    console.log("\u{1F4E6} plugin.zip generated");
+    console.log("\u2728 Plugin initialization setup completed! zip file path is ./.plugin/plugin.zip");
+  } catch (error) {
+    throw error;
+  } finally {
+    console.groupEnd();
+  }
+}
+
+// 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);
+}
+async function action9(options) {
+  console.group("\u{1F680} Executing manifest generation");
+  try {
+    const { env } = options;
+    if (env !== "prod" && env !== "dev" && env !== "standalone") {
+      throw new Error("Invalid environment");
+    }
+    await copyPluginContents();
+    console.log("\u{1F4C1} contents copied");
+    await outputManifest(env);
+    console.log(`\u{1F4DD} manifest.json generated (${env})`);
+  } catch (error) {
+    throw error;
+  } finally {
+    console.groupEnd();
+  }
+}
+
+// src/commands/test/index.ts
+import { program as program7 } from "commander";
+import fs12 from "fs-extra";
+function command7() {
+  program7.command("test").description("test").action(action10);
+}
+async function action10() {
+  console.group("package.json");
+  const packageJson = fs12.readJSONSync("package.json");
+  console.log("package.json detected");
+  console.groupEnd();
+  console.group("Config");
+  const config2 = await esmImport("plugin.config.mjs");
+  console.log("plugin.config.mjs detected", config2);
+  console.groupEnd();
+}
+
+// src/commands/plugin-zip.ts
+import { program as program8 } from "commander";
+import fs13 from "fs-extra";
+import path17 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);
+}
+async function action11(options) {
+  console.group("\u{1F373} Executing plugin zip generation");
+  try {
+    const { env, ppk: ppkPath } = options;
+    if (!isEnv(env)) {
+      throw new Error("Invalid environment");
+    }
+    await copyPluginContents();
+    console.log("\u{1F4C1} contents copied");
+    const manifest = await outputManifest(env);
+    console.log(`\u{1F4DD} manifest.json generated (${env})`);
+    await outputContentsZip(manifest);
+    console.log("\u{1F4E6} contents.zip generated");
+    const buffer = await getContentsZipBuffer();
+    const privateKey = await fs13.readFile(path17.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);
+    console.log("\u{1F4E6} plugin.zip generated");
+    const version = String(manifest.version);
+    await fs13.writeFile(path17.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) {
+    throw error;
+  } finally {
+    console.groupEnd();
+  }
+}
+
+// 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);
+}
+async function action12(options) {
+  try {
+    lint();
+  } catch (error) {
+    throw error;
+  } finally {
+  }
+}
+
+// src/commands/plugin-tsup.ts
+import { program as program10 } from "commander";
+import fs14 from "fs-extra";
+import path18 from "path";
+
+// src/lib/tsup.ts
+import { build as build2 } from "tsup";
+var completeBuildOptions2 = (params) => {
+  return {
+    bundle: true,
+    minify: "terser",
+    splitting: false,
+    noExternal: [/.*/],
+    platform: "browser",
+    dts: true,
+    ...params,
+    esbuildOptions(options, context) {
+      options.legalComments = "none";
+    }
+  };
+};
+var buildWithTsup = async (buildOptions) => {
+  const options = completeBuildOptions2(buildOptions);
+  await build2(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);
+}
+async function action13() {
+  console.group("\u{1F373} Build the project for production");
+  try {
+    const config2 = await importK2PluginConfig();
+    if (config2?.lint?.build) {
+      await lint();
+      console.log("\u2728 Lint success.");
+    }
+    if (!fs14.existsSync(PLUGIN_CONTENTS_DIRECTORY)) {
+      await fs14.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"),
+        config: tailwindConfig.config,
+        minify: true
+      });
+      console.log("\u2728 Built config.css");
+      await outputCss({
+        inputPath: inputFile.desktop,
+        outputPath: path18.join(PLUGIN_CONTENTS_DIRECTORY, "desktop.css"),
+        config: tailwindConfig.desktop,
+        minify: true
+      });
+      console.log("\u2728 Built desktop.css");
+    }
+    const entryPoints = ["desktop", "config"].reduce(
+      (acc, dir) => ({
+        ...acc,
+        [dir]: path18.join("src", dir, "index.ts")
+      }),
+      {}
+    );
+    await buildWithTsup({
+      entryPoints,
+      outDir: PLUGIN_CONTENTS_DIRECTORY,
+      minify: true,
+      treeshake: true,
+      sourcemap: false
+    });
+    console.log("\u2728 Built desktop.js and config.js");
+    console.log("\u2728 Build success.");
+  } catch (error) {
+    throw error;
+  } finally {
+    console.groupEnd();
+  }
+}
+
+// src/plugin.ts
+program11.name("plugin").version("1.12.0").description("\u{1F373} kintone kitchen \u{1F373} for kintone plugin");
+command();
+command2();
+command3();
+command4();
+command5();
+command6();
+command7();
+command8();
+command9();
+command10();
+program11.parse(process.argv);
 //# sourceMappingURL=plugin.js.map