@lark-apaas/fullstack-cli 1.1.59-alpha.20260717075919 → 1.1.59-alpha.20260717162925

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs29 from "fs";
-import path25 from "path";
+import fs30 from "fs";
+import path26 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -4921,7 +4921,7 @@ var PROMPT_PATTERNS = [
   { pattern: /proceed\?/i, answer: "y\n" }
 ];
 async function executeShadcnAdd(registryItemPath) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let output = "";
     const args = ["--yes", "shadcn@3.8.2", "add", registryItemPath];
     const ptyProcess = pty.spawn("npx", args, {
@@ -4947,7 +4947,7 @@ async function executeShadcnAdd(registryItemPath) {
     });
     const timeoutId = setTimeout(() => {
       ptyProcess.kill();
-      resolve2({
+      resolve3({
         success: false,
         files: [],
         error: "\u6267\u884C\u8D85\u65F6"
@@ -4958,7 +4958,7 @@ async function executeShadcnAdd(registryItemPath) {
       const success = exitCode === 0;
       const filePaths = parseOutput(output);
       const files = filePaths.map(toFileInfo);
-      resolve2({
+      resolve3({
         success,
         files,
         error: success ? void 0 : output || `Process exited with code ${exitCode}`
@@ -4969,12 +4969,12 @@ async function executeShadcnAdd(registryItemPath) {
 
 // src/commands/component/add.handler.ts
 function runActionPluginInit() {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     execFile("fullstack-cli", ["action-plugin", "init"], { cwd: process.cwd(), stdio: "ignore" }, (error) => {
       if (error) {
         debug("action-plugin init \u5931\u8D25: %s", error.message);
       }
-      resolve2();
+      resolve3();
     });
   });
 }
@@ -8098,6 +8098,527 @@ async function preUploadStatic(options) {
   }
 }
 
+// src/commands/build/preview-server-artifact.handler.ts
+import * as fs29 from "fs";
+import * as os3 from "os";
+import * as path25 from "path";
+import { builtinModules, createRequire as createRequire3 } from "module";
+import { build } from "esbuild";
+import { parse as parse2 } from "acorn";
+import { simple as walkSimple } from "acorn-walk";
+var STATIC_PLUGIN_REGISTRY_SYMBOL = "@lark-apaas/nestjs-capability/static-plugin-registry";
+var STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION = 1;
+var OPTIONAL_DEPENDENCY_STUBS = [
+  "@nestjs/microservices",
+  "@nestjs/microservices/microservices-module",
+  "@nestjs/websockets/socket-module",
+  "fsevents"
+];
+var BUILTIN_MODULES = /* @__PURE__ */ new Set([
+  ...builtinModules,
+  ...builtinModules.map((moduleName) => `node:${moduleName}`)
+]);
+function toAbsolutePath(projectRoot, candidate) {
+  return path25.isAbsolute(candidate) ? candidate : path25.resolve(projectRoot, candidate);
+}
+function readJson(filePath) {
+  return JSON.parse(fs29.readFileSync(filePath, "utf8"));
+}
+function findPackageRoot(entryPath) {
+  let current = path25.dirname(entryPath);
+  const filesystemRoot = path25.parse(current).root;
+  while (current !== filesystemRoot) {
+    if (fs29.existsSync(path25.join(current, "package.json"))) {
+      return current;
+    }
+    current = path25.dirname(current);
+  }
+  return null;
+}
+function findNativeAddons(root) {
+  const nativeAddons = [];
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current) {
+      continue;
+    }
+    for (const entry of fs29.readdirSync(current, { withFileTypes: true })) {
+      const entryPath = path25.join(current, entry.name);
+      if (entry.isSymbolicLink()) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        pending.push(entryPath);
+      } else if (entry.isFile() && entry.name.endsWith(".node")) {
+        nativeAddons.push(entryPath);
+      }
+    }
+  }
+  return nativeAddons.sort();
+}
+function resolveActionPlugins(projectRoot, packageJson) {
+  const configuredPlugins = packageJson.actionPlugins;
+  if (!configuredPlugins || typeof configuredPlugins !== "object") {
+    return { plugins: [], reasons: [] };
+  }
+  const projectRequire = createRequire3(path25.join(projectRoot, "package.json"));
+  const plugins = [];
+  const reasons = [];
+  for (const name of Object.keys(configuredPlugins).sort()) {
+    let entryPath;
+    try {
+      entryPath = projectRequire.resolve(name);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      reasons.push(`Action Plugin ${name} \u65E0\u6CD5\u89E3\u6790: ${message}`);
+      continue;
+    }
+    const packageRoot = findPackageRoot(entryPath);
+    if (!packageRoot) {
+      reasons.push(`Action Plugin ${name} \u65E0\u6CD5\u5B9A\u4F4D package.json: ${entryPath}`);
+      continue;
+    }
+    const nativeAddons = findNativeAddons(packageRoot);
+    if (nativeAddons.length > 0) {
+      const relativeAddons = nativeAddons.map(
+        (filePath) => path25.relative(packageRoot, filePath)
+      );
+      reasons.push(
+        `Action Plugin ${name} \u5305\u542B\u539F\u751F\u6269\u5C55\uFF0C\u4E0D\u80FD\u751F\u6210\u8DE8\u6C99\u7BB1\u5355 bundle: ${relativeAddons.join(", ")}`
+      );
+      continue;
+    }
+    const manifestPath = path25.join(packageRoot, "manifest.json");
+    let manifest;
+    if (fs29.existsSync(manifestPath)) {
+      try {
+        manifest = readJson(manifestPath);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        reasons.push(
+          `Action Plugin ${name} \u7684 manifest.json \u65E0\u6CD5\u89E3\u6790: ${message}`
+        );
+        continue;
+      }
+    }
+    plugins.push({ name, entryPath, manifest });
+  }
+  if (reasons.length === 0 && plugins.length > 0) {
+    try {
+      const capabilityRuntime = projectRequire(
+        "@lark-apaas/nestjs-capability"
+      );
+      if (capabilityRuntime.STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION !== STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION) {
+        reasons.push(
+          `@lark-apaas/nestjs-capability \u672A\u63D0\u4F9B\u517C\u5BB9\u7684 STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION=${STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION}`
+        );
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      reasons.push(
+        `@lark-apaas/nestjs-capability \u65E0\u6CD5\u52A0\u8F7D\uFF0C\u7F3A\u5C11 STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION=${STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION}: ${message}`
+      );
+    }
+  }
+  return { plugins, reasons };
+}
+function generateBootstrap(entryPath, plugins) {
+  const lines = [`'use strict';`, `const __staticPluginRegistry = new Map();`];
+  plugins.forEach((plugin, index) => {
+    const moduleVariable = `__staticPlugin${index}`;
+    lines.push(
+      `const ${moduleVariable} = require(${JSON.stringify(plugin.entryPath)});`
+    );
+    lines.push(
+      `__staticPluginRegistry.set(${JSON.stringify(plugin.name)}, { module: ${moduleVariable}, manifest: ${JSON.stringify(plugin.manifest ?? null)} });`
+    );
+  });
+  lines.push(
+    `globalThis[Symbol.for(${JSON.stringify(STATIC_PLUGIN_REGISTRY_SYMBOL)})] = __staticPluginRegistry;`,
+    `require(${JSON.stringify(entryPath)});`,
+    ""
+  );
+  return lines.join("\n");
+}
+function classTransformerStorageResolver(projectRoot) {
+  const projectRequire = createRequire3(path25.join(projectRoot, "package.json"));
+  return {
+    name: "class-transformer-storage-resolver",
+    setup(esbuild) {
+      esbuild.onResolve({ filter: /^class-transformer\/storage$/ }, () => {
+        try {
+          return {
+            path: projectRequire.resolve("class-transformer/cjs/storage.js")
+          };
+        } catch {
+          return void 0;
+        }
+      });
+    }
+  };
+}
+function optionalDependencyStubPlugin() {
+  const stubbedDependencies = /* @__PURE__ */ new Set();
+  const escapedNames = OPTIONAL_DEPENDENCY_STUBS.map(
+    (name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  );
+  const filter = new RegExp(`^(?:${escapedNames.join("|")})$`);
+  return {
+    stubbedDependencies,
+    plugin: {
+      name: "preview-optional-dependency-stubs",
+      setup(esbuild) {
+        esbuild.onResolve({ filter }, (args) => {
+          stubbedDependencies.add(args.path);
+          return {
+            path: args.path,
+            namespace: "preview-optional-dependency"
+          };
+        });
+        esbuild.onLoad(
+          { filter: /.*/, namespace: "preview-optional-dependency" },
+          (args) => ({
+            contents: `
+              const error = new Error(${JSON.stringify(
+              `Optional dependency is unavailable in Preview Artifact: ${args.path}`
+            )});
+              error.code = 'MODULE_NOT_FOUND';
+              throw error;
+            `,
+            loader: "js"
+          })
+        );
+      }
+    }
+  };
+}
+function isStaticString(node) {
+  if (!node) {
+    return false;
+  }
+  if (node.type === "Literal") {
+    return typeof node.value === "string";
+  }
+  return node.type === "TemplateLiteral" && node.expressions.length === 0;
+}
+function staticPropertyName(node) {
+  if (node.type !== "MemberExpression") {
+    return void 0;
+  }
+  if (!node.computed && node.property.type === "Identifier") {
+    return node.property.name;
+  }
+  if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
+    return node.property.value;
+  }
+  return void 0;
+}
+function auditBundleClosure(outfile, stubbedDependencies) {
+  const ast = parse2(fs29.readFileSync(outfile, "utf8"), {
+    ecmaVersion: "latest",
+    sourceType: "script",
+    allowHashBang: true
+  });
+  let dynamicRequireCount = 0;
+  let dynamicImportCount = 0;
+  let createRequireCount = 0;
+  let requireResolveCount = 0;
+  let runtimeFileReadCount = 0;
+  const runtimeFileReads = /* @__PURE__ */ new Set([
+    "access",
+    "accessSync",
+    "createReadStream",
+    "open",
+    "openSync",
+    "readFile",
+    "readFileSync",
+    "readdir",
+    "readdirSync",
+    "stat",
+    "statSync"
+  ]);
+  walkSimple(ast, {
+    CallExpression(node) {
+      if (node.callee.type === "Identifier" && node.callee.name === "require" && !isStaticString(node.arguments[0])) {
+        dynamicRequireCount += 1;
+      }
+      if (node.callee.type === "Identifier" && node.callee.name === "createRequire" || staticPropertyName(node.callee) === "createRequire") {
+        createRequireCount += 1;
+      }
+      const propertyName = staticPropertyName(node.callee);
+      if (propertyName === "resolve" && node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "require") {
+        requireResolveCount += 1;
+      }
+      if (propertyName && runtimeFileReads.has(propertyName)) {
+        runtimeFileReadCount += 1;
+      }
+    },
+    ImportExpression(node) {
+      if (!isStaticString(node.source)) {
+        dynamicImportCount += 1;
+      }
+    }
+  });
+  const risks = [];
+  if (dynamicRequireCount > 0) {
+    risks.push(`bundle retains ${dynamicRequireCount} dynamic require call(s)`);
+  }
+  if (dynamicImportCount > 0) {
+    risks.push(`bundle retains ${dynamicImportCount} dynamic import call(s)`);
+  }
+  if (createRequireCount > 0 || requireResolveCount > 0) {
+    risks.push(
+      `bundle retains runtime module resolution (createRequire=${createRequireCount}, require.resolve=${requireResolveCount})`
+    );
+  }
+  if (runtimeFileReadCount > 0) {
+    risks.push(
+      `bundle retains ${runtimeFileReadCount} runtime filesystem read call(s)`
+    );
+  }
+  if (stubbedDependencies.length > 0) {
+    risks.push(
+      `bundle stubs optional dependencies: ${stubbedDependencies.join(", ")}`
+    );
+  }
+  return risks;
+}
+function collectExternalImports(metafile, outfile) {
+  const normalizedOutfile = path25.resolve(outfile);
+  const output = Object.entries(metafile.outputs).find(
+    ([outputPath]) => path25.resolve(outputPath) === normalizedOutfile
+  )?.[1];
+  if (!output) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      output.imports.filter((importRecord) => importRecord.external).map((importRecord) => importRecord.path).filter(
+        (importPath) => !BUILTIN_MODULES.has(importPath) && !importPath.startsWith("node:")
+      )
+    )
+  ).sort();
+}
+function formatBuildError(error) {
+  if (!error || typeof error !== "object" || !("errors" in error)) {
+    return [error instanceof Error ? error.message : String(error)];
+  }
+  const errors = error.errors;
+  if (!errors || errors.length === 0) {
+    return [error instanceof Error ? error.message : String(error)];
+  }
+  return errors.map((item) => {
+    const location = item.location?.file ? `${item.location.file}${item.location.line ? `:${item.location.line}` : ""}: ` : "";
+    return `${location}${item.text ?? "unknown esbuild error"}`;
+  });
+}
+function removePublishedArtifact(outfile, metadataFile) {
+  fs29.rmSync(outfile, { force: true });
+  fs29.rmSync(metadataFile, { force: true });
+}
+function bestEffortRemove(targetPath, options = {}) {
+  if (!targetPath) {
+    return;
+  }
+  try {
+    fs29.rmSync(targetPath, { force: true, recursive: options.recursive });
+  } catch {
+  }
+}
+function outputPathConflicts(entryPath, packageJsonPath, outfile, metadataFile) {
+  const reasons = [];
+  if (outfile === metadataFile) {
+    reasons.push("bundle \u4E0E metadata \u8F93\u51FA\u8DEF\u5F84\u4E0D\u80FD\u76F8\u540C");
+  }
+  const protectedInputs = /* @__PURE__ */ new Map([
+    [entryPath, "Nest \u7F16\u8BD1\u5165\u53E3"],
+    [packageJsonPath, "package.json"]
+  ]);
+  for (const [outputPath, outputName] of [
+    [outfile, "bundle"],
+    [metadataFile, "metadata"]
+  ]) {
+    const protectedName = protectedInputs.get(outputPath);
+    if (protectedName) {
+      reasons.push(
+        `${outputName} \u8F93\u51FA\u8DEF\u5F84\u4E0D\u80FD\u8986\u76D6 ${protectedName}: ${outputPath}`
+      );
+    }
+  }
+  return reasons;
+}
+async function buildPreviewServerArtifact(options) {
+  const startedAt = Date.now();
+  const projectRoot = path25.resolve(options.projectRoot);
+  const entryPath = toAbsolutePath(
+    projectRoot,
+    options.entry ?? "dist/main.js"
+  );
+  const outfile = toAbsolutePath(
+    projectRoot,
+    options.outfile ?? ".preview-artifact/server.bundle.cjs"
+  );
+  const metadataFile = toAbsolutePath(
+    projectRoot,
+    options.metadataFile ?? `${outfile}.meta.json`
+  );
+  const packageJsonPath = path25.join(projectRoot, "package.json");
+  let pluginCount = 0;
+  let outputCleared = false;
+  let phase = "\u6821\u9A8C\u8F93\u5165";
+  let tempRoot;
+  let tempOutputRoot;
+  let tempMetadataFile;
+  const failed = (reasons) => ({
+    built: false,
+    elapsedMs: Date.now() - startedAt,
+    pluginCount,
+    reasons
+  });
+  const pathConflicts = outputPathConflicts(
+    entryPath,
+    packageJsonPath,
+    outfile,
+    metadataFile
+  );
+  if (pathConflicts.length > 0) {
+    return failed(pathConflicts);
+  }
+  if (!fs29.existsSync(entryPath)) {
+    return failed([`Nest \u7F16\u8BD1\u5165\u53E3\u4E0D\u5B58\u5728: ${entryPath}`]);
+  }
+  if (!fs29.existsSync(packageJsonPath)) {
+    return failed([`package.json \u4E0D\u5B58\u5728: ${packageJsonPath}`]);
+  }
+  try {
+    phase = `\u89E3\u6790 ${packageJsonPath}`;
+    const packageJson = readJson(packageJsonPath);
+    phase = "\u89E3\u6790 Action Plugin";
+    const { plugins, reasons } = resolveActionPlugins(projectRoot, packageJson);
+    pluginCount = plugins.length;
+    phase = "\u6E05\u7406\u65E7 Preview Artifact";
+    removePublishedArtifact(outfile, metadataFile);
+    outputCleared = true;
+    if (reasons.length > 0) {
+      return failed(reasons);
+    }
+    phase = "\u521B\u5EFA Preview Artifact \u4E34\u65F6\u76EE\u5F55";
+    fs29.mkdirSync(path25.dirname(outfile), { recursive: true });
+    fs29.mkdirSync(path25.dirname(metadataFile), { recursive: true });
+    tempRoot = fs29.mkdtempSync(
+      path25.join(os3.tmpdir(), "preview-server-artifact-")
+    );
+    tempOutputRoot = fs29.mkdtempSync(
+      path25.join(path25.dirname(outfile), ".preview-server-artifact-")
+    );
+    const bootstrapPath = path25.join(tempRoot, "bootstrap.cjs");
+    const tempOutfile = path25.join(tempOutputRoot, path25.basename(outfile));
+    tempMetadataFile = path25.join(
+      path25.dirname(metadataFile),
+      `.${path25.basename(metadataFile)}.${process.pid}.${Date.now()}.tmp`
+    );
+    fs29.writeFileSync(bootstrapPath, generateBootstrap(entryPath, plugins));
+    const optionalDependencies = optionalDependencyStubPlugin();
+    const buildOptions = {
+      absWorkingDir: projectRoot,
+      entryPoints: [bootstrapPath],
+      outfile: tempOutfile,
+      bundle: true,
+      platform: "node",
+      format: "cjs",
+      target: "node22",
+      treeShaking: true,
+      keepNames: true,
+      legalComments: "none",
+      sourcemap: false,
+      metafile: true,
+      logLevel: "silent",
+      plugins: [
+        classTransformerStorageResolver(projectRoot),
+        optionalDependencies.plugin
+      ]
+    };
+    phase = "\u6267\u884C esbuild";
+    const buildResult2 = await build(buildOptions);
+    if (!buildResult2.metafile) {
+      throw new Error("esbuild \u672A\u8FD4\u56DE metafile");
+    }
+    const externalImports = collectExternalImports(
+      buildResult2.metafile,
+      tempOutfile
+    );
+    if (externalImports.length > 0) {
+      return failed([`bundle \u6B8B\u7559\u8FD0\u884C\u65F6\u4F9D\u8D56: ${externalImports.join(", ")}`]);
+    }
+    phase = "\u5BA1\u8BA1 bundle \u8FD0\u884C\u65F6\u95ED\u5305";
+    const stubbedOptionalDependencies = Array.from(
+      optionalDependencies.stubbedDependencies
+    ).sort();
+    const closureRisks = auditBundleClosure(
+      tempOutfile,
+      stubbedOptionalDependencies
+    );
+    const closureStatus = closureRisks.length === 0 ? "static-audit-clean" : "runtime-validation-required";
+    const metadata = {
+      version: 1,
+      entry: entryPath,
+      outfile,
+      bundleBytes: fs29.statSync(tempOutfile).size,
+      inputFiles: Object.keys(buildResult2.metafile.inputs).length,
+      externalImports,
+      actionPlugins: plugins.map((plugin) => plugin.name),
+      closureStatus,
+      closureRisks,
+      stubbedOptionalDependencies,
+      runtimeProbeStatus: "not-run",
+      consumable: false,
+      elapsedMs: Date.now() - startedAt
+    };
+    phase = "\u53D1\u5E03 bundle \u4E0E metadata";
+    fs29.writeFileSync(
+      tempMetadataFile,
+      `${JSON.stringify(metadata, null, 2)}
+`
+    );
+    fs29.renameSync(tempOutfile, outfile);
+    fs29.renameSync(tempMetadataFile, metadataFile);
+    return {
+      built: true,
+      outfile,
+      metadataFile,
+      bundleBytes: metadata.bundleBytes,
+      inputFiles: metadata.inputFiles,
+      externalImports,
+      pluginCount,
+      closureStatus,
+      closureRisks,
+      stubbedOptionalDependencies,
+      runtimeProbeStatus: "not-run",
+      consumable: false,
+      elapsedMs: metadata.elapsedMs
+    };
+  } catch (error) {
+    const reasons = formatBuildError(error).map(
+      (reason) => `${phase}: ${reason}`
+    );
+    if (outputCleared) {
+      try {
+        removePublishedArtifact(outfile, metadataFile);
+      } catch (cleanupError) {
+        reasons.push(
+          `\u6E05\u7406\u5931\u8D25\u4EA7\u7269: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
+        );
+      }
+    }
+    return failed(reasons);
+  } finally {
+    bestEffortRemove(tempRoot, { recursive: true });
+    bestEffortRemove(tempOutputRoot, { recursive: true });
+    bestEffortRemove(tempMetadataFile);
+  }
+}
+
 // src/commands/build/index.ts
 var getTokenCommand = {
   name: "get-token",
@@ -8126,10 +8647,34 @@ var preUploadStaticCommand = {
     });
   }
 };
+var previewServerArtifactCommand = {
+  name: "preview-server-artifact",
+  description: "Build and audit a single-file Nest preview server artifact",
+  register(program) {
+    program.command(this.name).description(this.description).option("--project-root <dir>", "Application project root", process.cwd()).option("--entry <file>", "Compiled Nest entry", "dist/main.js").option(
+      "--outfile <file>",
+      "Output bundle",
+      ".preview-artifact/server.bundle.cjs"
+    ).option("--metadata-file <file>", "Output build metadata file").action(
+      async (options) => {
+        const result = await buildPreviewServerArtifact(options);
+        console.log(JSON.stringify(result));
+        if (!result.built) {
+          process.exitCode = 2;
+        }
+      }
+    );
+  }
+};
 var buildCommandGroup = {
   name: "build",
   description: "Build related commands",
-  commands: [getTokenCommand, uploadStaticCommand, preUploadStaticCommand]
+  commands: [
+    getTokenCommand,
+    uploadStaticCommand,
+    preUploadStaticCommand,
+    previewServerArtifactCommand
+  ]
 };
 
 // src/commands/index.ts
@@ -8146,12 +8691,12 @@ var commands = [
 ];
 
 // src/index.ts
-var envPath = path25.join(process.cwd(), ".env");
-if (fs29.existsSync(envPath)) {
+var envPath = path26.join(process.cwd(), ".env");
+if (fs30.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path25.dirname(fileURLToPath5(import.meta.url));
-var pkg = JSON.parse(fs29.readFileSync(path25.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path26.dirname(fileURLToPath5(import.meta.url));
+var pkg = JSON.parse(fs30.readFileSync(path26.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.59-alpha.20260717075919",
+  "version": "1.1.59-alpha.20260717162925",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",
@@ -34,12 +34,15 @@
     "@lark-apaas/http-client": "^0.1.7",
     "@lydell/node-pty": "1.1.0",
     "@vercel/nft": "^0.30.3",
+    "acorn": "^8.16.0",
+    "acorn-walk": "^8.3.5",
     "commander": "^13.0.0",
     "debug": "^4.4.3",
     "dotenv": "^16.0.0",
     "drizzle-kit": "0.31.5",
     "drizzle-orm": "0.44.6",
     "es-toolkit": "^1.44.0",
+    "esbuild": "^0.27.0",
     "inflection": "^3.0.2",
     "pinyin-pro": "^3.27.0",
     "postgres": "^3.4.3",