@lark-apaas/fullstack-cli 1.1.11 → 1.1.12-alpha.1

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs18 from "fs";
-import path16 from "path";
+import fs19 from "fs";
+import path17 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -116,17 +116,1157 @@ Command "${ctx.commandName}" completed in ${elapsed}ms`);
 };
 
 // src/commands/db/schema.handler.ts
-import path from "path";
-import fs from "fs";
+import path2 from "path";
+import fs2 from "fs";
 import { fileURLToPath } from "url";
 import { spawnSync } from "child_process";
-import { createRequire } from "module";
 import { config as loadEnv } from "dotenv";
-var require2 = createRequire(import.meta.url);
+
+// src/internal/postprocess-drizzle-schema.ts
+import fs from "fs";
+import path from "path";
+import { pinyin } from "pinyin-pro";
+var HEADER_COMMENT = "/** auto generated, do not edit */";
+var CUSTOM_TYPE_PATTERN = /\/\/ TODO: failed to parse database type '(?:\w+\.)?(user_profile|file_attachment)(\[\])?'/;
+var TEMPLATE_TYPES_TS = `import { sql } from 'drizzle-orm';
+import { customType } from 'drizzle-orm/pg-core';
+
+export const userProfile = customType<{
+  data: string;
+  driverData: string;
+}>({
+  dataType() {
+    return 'user_profile';
+  },
+  toDriver(value: string) {
+    return sql\`ROW(\${value})::user_profile\`;
+  },
+  fromDriver(value: string) {
+    const [userId] = value.slice(1, -1).split(',');
+    return userId.trim();
+  },
+});
+
+export type FileAttachment = {
+  bucket_id: string;
+  file_path: string;
+};
+
+export const fileAttachment = customType<{
+  data: FileAttachment;
+  driverData: string;
+}>({
+  dataType() {
+    return 'file_attachment';
+  },
+  toDriver(value: FileAttachment) {
+    return sql\`ROW(\${value.bucket_id},\${value.file_path})::file_attachment\`;
+  },
+  fromDriver(value: string): FileAttachment {
+    const [bucketId, filePath] = value.slice(1, -1).split(',');
+    return { bucket_id: bucketId.trim(), file_path: filePath.trim() };
+  },
+});
+
+export const customTimestamptz = customType<{
+  data: Date;
+  driverData: string;
+  config: { precision?: number};
+}>({
+  dataType(config) {
+    const precision = typeof config?.precision !== 'undefined'
+      ? \` (\${config.precision})\`
+      : '';
+    return \`timestamptz\${precision}\`;
+  },
+  toDriver(value: Date | string | number){
+    if(value == null) return value as any;
+    if (typeof value === 'number') {
+      return new Date(value).toISOString();
+    }
+    if(typeof value === 'string') {
+      return value;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    throw new Error('Invalid timestamp value');
+  },
+  fromDriver(value: string | Date): Date {
+    if(value instanceof Date) return value;
+    return new Date(value);
+  },
+});
+`;
+function stripLeadingNewlines(value) {
+  let current = value;
+  while (current.startsWith("\r\n") || current.startsWith("\n")) {
+    current = current.startsWith("\r\n") ? current.slice(2) : current.slice(1);
+  }
+  return current;
+}
+function ensureHeaderComment(source) {
+  let text = source.startsWith("\uFEFF") ? source.slice(1) : source;
+  while (text.startsWith(HEADER_COMMENT)) {
+    text = text.slice(HEADER_COMMENT.length);
+    text = stripLeadingNewlines(text);
+  }
+  const trimmed = stripLeadingNewlines(text);
+  if (trimmed.length === 0) {
+    return `${HEADER_COMMENT}
+`;
+  }
+  return `${HEADER_COMMENT}
+${trimmed}`;
+}
+function collapseExtraBlankLines(text) {
+  return text.replace(/\n{3,}/g, "\n\n");
+}
+function patchDrizzleKitDefects(source) {
+  let fixed = 0;
+  const text = source.replace(/\.default\('\)/g, () => {
+    fixed += 1;
+    return `.default('')`;
+  });
+  return { text, fixed };
+}
+function removePgSchemaDeclarations(source) {
+  return source.replace(/export const \w+ = pgSchema\([\s\S]*?\);\n*/g, "");
+}
+function convertSchemaTableInvocations(source) {
+  let converted = 0;
+  let text = source.replace(/([A-Za-z0-9_]+)\.table\(/g, () => {
+    converted += 1;
+    return "pgTable(";
+  });
+  text = text.replace(/([A-Za-z0-9_]+)\.view\(/g, () => {
+    converted += 1;
+    return "pgView(";
+  });
+  text = text.replace(/([A-Za-z0-9_]+)\.materializedView\(/g, () => {
+    converted += 1;
+    return "pgMaterializedView(";
+  });
+  text = text.replace(/([A-Za-z0-9_]+)\.enum\(/g, () => {
+    converted += 1;
+    return "pgEnum(";
+  });
+  text = text.replace(/([A-Za-z0-9_]+)\.sequence\(/g, () => {
+    converted += 1;
+    return "pgSequence(";
+  });
+  return { text, converted };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\//g, "\\/");
+}
+function toCamelCase(str) {
+  const words = str.split(/[_\-\s]+/).filter(Boolean);
+  if (words.length === 0) {
+    return "";
+  }
+  return words.map((word, index) => {
+    if (index === 0) {
+      return word.toLowerCase();
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  }).join("");
+}
+function toAsciiName(name) {
+  let hasNonAscii = false;
+  for (let i = 0; i < name.length; i += 1) {
+    if (name.charCodeAt(i) > 127) {
+      hasNonAscii = true;
+      break;
+    }
+  }
+  if (!hasNonAscii) {
+    return name;
+  }
+  try {
+    const transliterated = pinyin(name, { toneType: "none", type: "array" }).join("_");
+    return transliterated || name;
+  } catch {
+    return name;
+  }
+}
+function sanitizeIdentifier(name) {
+  const asciiName = toAsciiName(name);
+  let sanitized = asciiName.replace(/[^A-Za-z0-9_]/g, "_");
+  sanitized = sanitized.replace(/_+/g, "_");
+  sanitized = sanitized.replace(/^_|_$/g, "");
+  sanitized = toCamelCase(sanitized);
+  if (!sanitized) {
+    sanitized = "table";
+  }
+  if (!/^[A-Za-z_]/.test(sanitized)) {
+    sanitized = `_${sanitized}`;
+  }
+  return sanitized;
+}
+function renamePgTableConstants(source) {
+  const pgTableRegex = /export const\s+([^\s=]+)\s*=\s*(pgTable|pgView|pgMaterializedView)\(\s*["'`]([^"'`]+)["'`]/gu;
+  const renames = [];
+  const updated = source.replace(pgTableRegex, (match, currentName, factory, tableName) => {
+    const sanitized = sanitizeIdentifier(tableName);
+    if (sanitized === currentName) {
+      return match;
+    }
+    renames.push({ from: currentName, to: sanitized });
+    const equalsIndex = match.indexOf("=");
+    const suffix = equalsIndex >= 0 ? match.slice(equalsIndex) : ` = ${factory}("${tableName}"`;
+    const normalizedSuffix = suffix.trimStart();
+    return `export const ${sanitized} ${normalizedSuffix}`;
+  });
+  return { text: updated, renames };
+}
+function updateTableReferenceIdentifiers(source, renames) {
+  if (renames.length === 0) {
+    return source;
+  }
+  return renames.reduce((acc, rename) => {
+    if (!rename.from || rename.from === rename.to) {
+      return acc;
+    }
+    const pattern = new RegExp(`\\b${escapeRegExp(rename.from)}(\\s*\\.)`, "g");
+    return acc.replace(pattern, `${rename.to}$1`);
+  }, source);
+}
+function replaceFollowingUnknown(nextLine, factory) {
+  if (!nextLine || !nextLine.includes("unknown(")) {
+    return void 0;
+  }
+  return nextLine.replace("unknown(", `${factory}(`);
+}
+function replaceUnknownColumns(source) {
+  const lines = source.split("\n");
+  const result = [];
+  let replaced = 0;
+  const unmatched = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const match = line.match(CUSTOM_TYPE_PATTERN);
+    if (match) {
+      const typeName = match[1];
+      const factory = typeName === "user_profile" ? "userProfile" : "fileAttachment";
+      const replacedLine = replaceFollowingUnknown(lines[i + 1], factory);
+      if (replacedLine) {
+        result.push(replacedLine);
+        replaced += 1;
+        i += 1;
+      } else {
+        unmatched.push(line.trim());
+        result.push(line);
+      }
+      continue;
+    }
+    if (line.includes("unknown(")) {
+      unmatched.push(line.trim());
+    }
+    result.push(line);
+  }
+  return { text: result.join("\n"), replaced, unmatched };
+}
+function ensureImportIdentifier(source, packageName, identifier) {
+  const escapedPackage = packageName.replace(/\//g, "\\/");
+  const importRegex = new RegExp(`import \\{([^}]*)\\} from ["']${escapedPackage}["'];?`);
+  const match = source.match(importRegex);
+  if (!match) {
+    return source;
+  }
+  const identifiers = match[1].split(",").map((id) => id.trim()).filter(Boolean);
+  if (identifiers.includes(identifier)) {
+    return source;
+  }
+  identifiers.push(identifier);
+  const unique = Array.from(new Set(identifiers));
+  const replacement = `import { ${unique.join(", ")} } from "${packageName}"`;
+  return source.replace(importRegex, replacement);
+}
+function tweakImports(source) {
+  const importRegex = /import \{([^}]*)\} from "drizzle-orm\/pg-core";?/;
+  const match = source.match(importRegex);
+  if (!match) {
+    return source;
+  }
+  const identifiers = match[1].split(",").map((id) => id.trim()).filter(Boolean).filter((id) => id !== "pgSchema" && id !== "customType");
+  const filteredIdentifiers = identifiers.filter((id) => {
+    if (id === "timestamp") {
+      const timestampUsageRegex = /timestamp\s*\(/;
+      return timestampUsageRegex.test(source);
+    }
+    return true;
+  });
+  if (source.includes("pgTable(") && !filteredIdentifiers.includes("pgTable")) {
+    filteredIdentifiers.push("pgTable");
+  }
+  if (source.includes("pgView(") && !filteredIdentifiers.includes("pgView")) {
+    filteredIdentifiers.push("pgView");
+  }
+  if (source.includes("pgMaterializedView(") && !filteredIdentifiers.includes("pgMaterializedView")) {
+    filteredIdentifiers.push("pgMaterializedView");
+  }
+  if (source.includes("pgEnum(") && !filteredIdentifiers.includes("pgEnum")) {
+    filteredIdentifiers.push("pgEnum");
+  }
+  if (source.includes("pgSequence(") && !filteredIdentifiers.includes("pgSequence")) {
+    filteredIdentifiers.push("pgSequence");
+  }
+  const unique = Array.from(new Set(filteredIdentifiers));
+  const replacement = `import { ${unique.join(", ")} } from "drizzle-orm/pg-core"`;
+  return source.replace(importRegex, replacement);
+}
+function inlineFromTemplate(text, templateContent) {
+  const typeDefinitions = templateContent.replace(/^import\s+.*;\r?\n*/gm, "").trim();
+  const needsSql = typeDefinitions.includes("sql`") && !text.includes("from 'drizzle-orm'") && !text.includes('from "drizzle-orm"');
+  const needsCustomType = typeDefinitions.includes("customType<") && !text.includes("customType");
+  if (needsCustomType) {
+    text = ensureImportIdentifier(text, "drizzle-orm/pg-core", "customType");
+  }
+  if (needsSql && !text.includes("from 'drizzle-orm'") && !text.includes('from "drizzle-orm"')) {
+    const importMatch = text.match(/^import [\s\S]*?from ["']drizzle-orm\/pg-core["'];?\n/m);
+    if (importMatch) {
+      const insertPoint = text.indexOf(importMatch[0]) + importMatch[0].length;
+      text = text.slice(0, insertPoint) + "import { sql } from 'drizzle-orm';\n" + text.slice(insertPoint);
+    }
+  }
+  const headerPrefix = `${HEADER_COMMENT}
+`;
+  let insertionPoint = 0;
+  if (text.startsWith(headerPrefix)) {
+    insertionPoint = headerPrefix.length;
+  }
+  const importSectionMatch = text.slice(insertionPoint).match(/^(?:import [^\n]+\n)+/);
+  if (importSectionMatch) {
+    insertionPoint += importSectionMatch[0].length;
+  }
+  const typeBlock = `
+${typeDefinitions}
+
+`;
+  return text.slice(0, insertionPoint) + typeBlock + text.slice(insertionPoint);
+}
+function inlineCustomTypes(source) {
+  const text = source.replace(/import \{[^}]*\} from ["']\.\/types["'];?\n*/g, "");
+  return inlineFromTemplate(text, TEMPLATE_TYPES_TS);
+}
+function removeConflictingSystemFields(source) {
+  const systemFieldMap = {
+    _created_at: "created_at",
+    _created_by: "created_by",
+    _updated_at: "updated_at",
+    _updated_by: "updated_by"
+  };
+  const lines = source.split("\n");
+  const result = [];
+  let inTable = false;
+  let tableStartLine = -1;
+  const tableBusinessFields = /* @__PURE__ */ new Set();
+  let bracketDepth = 0;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (!inTable && /=\s*(pgTable|pgView|pgMaterializedView)\s*\(/.test(line)) {
+      inTable = true;
+      tableStartLine = result.length;
+      tableBusinessFields.clear();
+      bracketDepth = 0;
+    }
+    if (inTable) {
+      for (const char of line) {
+        if (char === "{") bracketDepth += 1;
+        if (char === "}") bracketDepth -= 1;
+      }
+      for (const businessField of Object.values(systemFieldMap)) {
+        if (line.includes(`"${businessField}"`) || line.includes(`'${businessField}'`)) {
+          tableBusinessFields.add(businessField);
+        }
+      }
+      if (bracketDepth === 0 && line.includes(");")) {
+        inTable = false;
+        const tableEndLine = result.length;
+        for (let j = tableStartLine; j <= tableEndLine; j += 1) {
+          const tableLine = result[j] || "";
+          let shouldRemove = false;
+          for (const [systemField, businessField] of Object.entries(systemFieldMap)) {
+            if (tableBusinessFields.has(businessField)) {
+              if (tableLine.includes(`"${systemField}"`) || tableLine.includes(`'${systemField}'`)) {
+                shouldRemove = true;
+                if (j > 0 && result[j - 1]?.includes("// System field:")) {
+                  result[j - 1] = null;
+                }
+                break;
+              }
+            }
+          }
+          if (shouldRemove) {
+            result[j] = null;
+          }
+        }
+      }
+    }
+    result.push(line);
+  }
+  return result.filter((line) => line !== null).join("\n");
+}
+function addSystemFieldComments(source) {
+  const commentMap = {
+    _created_at: "Creation time",
+    _created_by: "Creator",
+    _updated_at: "Update time",
+    _updated_by: "Updater"
+  };
+  const lines = source.split("\n");
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const entry = Object.entries(commentMap).find(([key]) => line.includes(`"${key}"`));
+    if (!entry) {
+      continue;
+    }
+    const [, description] = entry;
+    const previousLine = lines[i - 1]?.trim() ?? "";
+    if (previousLine.startsWith("//") && previousLine.includes("System field")) {
+      continue;
+    }
+    const indentMatch = line.match(/^\s*/);
+    const indent = indentMatch ? indentMatch[0] : "";
+    const comment = `${indent}// System field: ${description} (auto-filled, do not modify)`;
+    lines.splice(i, 0, comment);
+    i += 1;
+  }
+  return lines.join("\n");
+}
+function replaceTimestampWithCustomTypes(source) {
+  let replaced = 0;
+  const pattern = /timestamp\((['"])(.*?)\1,\s*(\{[^}]*\})\)/g;
+  const text = source.replace(pattern, (match, quote, fieldName, options) => {
+    const hasWithTimezone = /withTimezone:\s*true/.test(options);
+    const hasModeString = /mode:\s*['"]string['"]/.test(options);
+    if (hasWithTimezone && hasModeString) {
+      replaced += 1;
+      return `customTimestamptz(${quote}${fieldName}${quote})`;
+    }
+    return match;
+  });
+  return { text, replaced };
+}
+function replaceDefaultNowWithSql(source) {
+  let replaced = 0;
+  const pattern = /\.defaultNow\(\)/g;
+  const text = source.replace(pattern, () => {
+    replaced += 1;
+    return ".default(sql`CURRENT_TIMESTAMP`)";
+  });
+  return { text, replaced };
+}
+function appendTableAliases(source) {
+  const marker = "// table aliases";
+  const markerIndex = source.indexOf(`
+${marker}`);
+  const base = markerIndex === -1 ? source : source.slice(0, markerIndex);
+  const exportRegex = /export const\s+([A-Za-z_$][\w$]*)\s*=\s*pgTable\s*\(/g;
+  const tableExports = /* @__PURE__ */ new Set();
+  for (const match of base.matchAll(exportRegex)) {
+    tableExports.add(match[1]);
+  }
+  if (tableExports.size === 0) {
+    return base;
+  }
+  const aliasLines = Array.from(tableExports).sort().map((name) => `export const ${name}Table = ${name};`).join("\n");
+  const prefix = base.trimEnd();
+  return `${prefix}
+
+${marker}
+${aliasLines}
+`;
+}
+function postprocessDrizzleSchema(targetPath) {
+  const resolvedPath = path.resolve(targetPath);
+  if (!fs.existsSync(resolvedPath)) {
+    console.warn(`[postprocess-drizzle-schema] File not found: ${resolvedPath}`);
+    return void 0;
+  }
+  let text = fs.readFileSync(resolvedPath, "utf8");
+  text = ensureHeaderComment(text);
+  const patchResult = patchDrizzleKitDefects(text);
+  text = patchResult.text;
+  text = removePgSchemaDeclarations(text);
+  const tableConversion = convertSchemaTableInvocations(text);
+  text = tableConversion.text;
+  const renameResult = renamePgTableConstants(text);
+  text = renameResult.text;
+  text = updateTableReferenceIdentifiers(text, renameResult.renames);
+  const replacement = replaceUnknownColumns(text);
+  text = replacement.text;
+  const timestampReplacement = replaceTimestampWithCustomTypes(text);
+  text = timestampReplacement.text;
+  const defaultNowReplacement = replaceDefaultNowWithSql(text);
+  text = defaultNowReplacement.text;
+  text = removeConflictingSystemFields(text);
+  text = addSystemFieldComments(text);
+  text = tweakImports(text);
+  text = inlineCustomTypes(text);
+  text = appendTableAliases(text);
+  text = text.replace(/\r?\n/g, "\n");
+  text = collapseExtraBlankLines(text);
+  fs.writeFileSync(resolvedPath, text, "utf8");
+  if (patchResult.fixed > 0) {
+    console.info(`[postprocess-drizzle-schema] Patched ${patchResult.fixed} drizzle-kit defects (.default(') -> .default(''))`);
+  }
+  if (replacement.replaced > 0) {
+    console.info(`[postprocess-drizzle-schema] Replaced ${replacement.replaced} unknown columns`);
+  }
+  if (replacement.unmatched.length > 0) {
+    console.warn("[postprocess-drizzle-schema] Unmatched custom types:", replacement.unmatched.length);
+    replacement.unmatched.forEach((line) => console.warn(`  ${line}`));
+  }
+  if (tableConversion.converted > 0) {
+    console.info(`[postprocess-drizzle-schema] Converted ${tableConversion.converted} schema.table invocations to pgTable`);
+  }
+  if (timestampReplacement.replaced > 0) {
+    console.info(`[postprocess-drizzle-schema] Replaced ${timestampReplacement.replaced} timestamp fields with customTimestamptz`);
+  }
+  if (defaultNowReplacement.replaced > 0) {
+    console.info(`[postprocess-drizzle-schema] Replaced ${defaultNowReplacement.replaced} .defaultNow() with .default(sql\`CURRENT_TIMESTAMP\`)`);
+  }
+  return {
+    replacedUnknown: replacement.replaced,
+    unmatchedUnknown: replacement.unmatched,
+    patchedDefects: patchResult.fixed,
+    replacedTimestamps: timestampReplacement.replaced,
+    replacedDefaultNow: defaultNowReplacement.replaced
+  };
+}
+
+// src/internal/gen-nest-resource.ts
+import { mkdir, rm, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { pluralize } from "inflection";
+import { Project, Node } from "ts-morph";
+var DrizzleSchemaParser = class {
+  constructor(projectOptions) {
+    this.project = new Project(projectOptions);
+  }
+  parseSchemaFile(filePath) {
+    const sourceFile = this.project.addSourceFileAtPath(filePath);
+    const tables = [];
+    const variableStatements = sourceFile.getVariableStatements();
+    for (const statement of variableStatements) {
+      const declarations = statement.getDeclarations();
+      for (const declaration of declarations) {
+        const initializer = declaration.getInitializer();
+        if (!initializer || !Node.isCallExpression(initializer)) {
+          continue;
+        }
+        const expression = initializer.getExpression();
+        if (expression.getText() !== "pgTable") {
+          continue;
+        }
+        const tableInfo = this.parsePgTable(declaration.getName(), initializer);
+        if (tableInfo) {
+          tables.push(tableInfo);
+        }
+      }
+    }
+    return tables;
+  }
+  parsePgTable(variableName, callExpr) {
+    const args = callExpr.getArguments();
+    if (args.length < 2) {
+      return null;
+    }
+    const tableName = args[0].getText().replace(/['"]/g, "");
+    const fieldsArg = args[1];
+    if (!Node.isObjectLiteralExpression(fieldsArg)) {
+      return null;
+    }
+    const fields = [];
+    const properties = fieldsArg.getProperties();
+    for (const prop of properties) {
+      if (!Node.isPropertyAssignment(prop)) {
+        continue;
+      }
+      const fieldName = prop.getName();
+      const initializer = prop.getInitializer();
+      const leadingComments = prop.getLeadingCommentRanges();
+      let comment;
+      if (leadingComments.length > 0) {
+        comment = leadingComments.map((c) => c.getText()).join("\n").replace(/\/\//g, "").trim();
+      }
+      if (initializer && Node.isCallExpression(initializer)) {
+        const fieldInfo = this.parseField(fieldName, initializer, comment);
+        fields.push(fieldInfo);
+      }
+    }
+    return { tableName, variableName, fields };
+  }
+  parseField(fieldName, callExpr, comment) {
+    const fieldInfo = {
+      name: fieldName,
+      columnName: fieldName,
+      type: "",
+      nullable: true,
+      hasDefault: false,
+      notNull: false,
+      isPrimaryKey: false,
+      isUnique: false,
+      isArray: false,
+      comment
+    };
+    this.parseBaseType(callExpr, fieldInfo);
+    this.parseCallChain(callExpr, fieldInfo);
+    return fieldInfo;
+  }
+  parseBaseType(callExpr, fieldInfo) {
+    let current = callExpr;
+    let baseCall = null;
+    while (Node.isCallExpression(current)) {
+      baseCall = current;
+      const expression2 = current.getExpression();
+      if (Node.isPropertyAccessExpression(expression2)) {
+        current = expression2.getExpression();
+      } else {
+        break;
+      }
+    }
+    if (!baseCall) {
+      return;
+    }
+    const expression = baseCall.getExpression();
+    let typeName = "";
+    if (Node.isPropertyAccessExpression(expression)) {
+      typeName = expression.getName();
+    } else {
+      typeName = expression.getText();
+    }
+    fieldInfo.type = typeName;
+    const args = baseCall.getArguments();
+    if (args.length > 0) {
+      const firstArg = args[0];
+      if (Node.isStringLiteral(firstArg)) {
+        fieldInfo.columnName = firstArg.getLiteralText();
+      } else if (Node.isObjectLiteralExpression(firstArg)) {
+        this.parseTypeConfig(firstArg, fieldInfo);
+      } else if (Node.isArrayLiteralExpression(firstArg)) {
+        fieldInfo.enumValues = firstArg.getElements().map((el) => el.getText().replace(/['"]/g, ""));
+      }
+    }
+    if (args.length > 1 && Node.isObjectLiteralExpression(args[1])) {
+      this.parseTypeConfig(args[1], fieldInfo);
+    }
+  }
+  parseTypeConfig(objLiteral, fieldInfo) {
+    if (!Node.isObjectLiteralExpression(objLiteral)) {
+      return;
+    }
+    const properties = objLiteral.getProperties();
+    for (const prop of properties) {
+      if (!Node.isPropertyAssignment(prop)) {
+        continue;
+      }
+      const propName = prop.getName();
+      const value = prop.getInitializer()?.getText();
+      switch (propName) {
+        case "length":
+          fieldInfo.length = value ? parseInt(value) : void 0;
+          break;
+        case "precision":
+          fieldInfo.precision = value ? parseInt(value) : void 0;
+          break;
+        case "scale":
+          fieldInfo.scale = value ? parseInt(value) : void 0;
+          break;
+        case "default":
+          fieldInfo.hasDefault = true;
+          fieldInfo.defaultValue = value;
+          break;
+        case "withTimezone":
+          fieldInfo.withTimezone = value === "true";
+          break;
+        case "mode":
+          fieldInfo.mode = value?.replace(/['"]/g, "");
+          break;
+        default:
+          throw new Error(`Unsupported property: ${propName}`);
+      }
+    }
+  }
+  parseCallChain(callExpr, fieldInfo) {
+    let current = callExpr;
+    while (Node.isCallExpression(current)) {
+      const expression = current.getExpression();
+      if (!Node.isPropertyAccessExpression(expression)) {
+        break;
+      }
+      const methodName = expression.getName();
+      const args = current.getArguments();
+      switch (methodName) {
+        case "notNull":
+          fieldInfo.notNull = true;
+          fieldInfo.nullable = false;
+          break;
+        case "default":
+          fieldInfo.hasDefault = true;
+          if (args.length > 0) {
+            fieldInfo.defaultValue = args[0].getText();
+          }
+          break;
+        case "defaultRandom":
+          fieldInfo.hasDefault = true;
+          fieldInfo.defaultValue = "random";
+          break;
+        case "primaryKey":
+          fieldInfo.isPrimaryKey = true;
+          fieldInfo.notNull = true;
+          fieldInfo.nullable = false;
+          break;
+        case "unique":
+          fieldInfo.isUnique = true;
+          break;
+        case "array":
+          fieldInfo.isArray = true;
+          break;
+        case "references":
+          if (args.length > 0) {
+            const refArg = args[0].getText();
+            const match = refArg.match(/=>\s*(\w+)\.(\w+)/);
+            if (match) {
+              fieldInfo.references = { table: match[1], column: match[2] };
+            }
+          }
+          break;
+        default:
+          throw new Error(`Unsupported method: ${methodName}`);
+      }
+      current = expression.getExpression();
+    }
+  }
+};
+function mapDrizzleTypeToTS(field) {
+  const typeMap = {
+    char: "string",
+    varchar: "string",
+    text: "string",
+    smallint: "number",
+    integer: "number",
+    int: "number",
+    bigint: "string",
+    serial: "number",
+    smallserial: "number",
+    bigserial: "string",
+    decimal: "string",
+    numeric: "string",
+    real: "number",
+    doublePrecision: "number",
+    boolean: "boolean",
+    timestamp: "Date",
+    timestamptz: "Date",
+    date: "Date",
+    time: "string",
+    timetz: "string",
+    interval: "string",
+    uuid: "string",
+    json: "any",
+    jsonb: "any",
+    bytea: "Buffer",
+    inet: "string",
+    cidr: "string",
+    macaddr: "string",
+    macaddr8: "string",
+    point: "{ x: number; y: number }",
+    line: "string",
+    lseg: "string",
+    box: "string",
+    path: "string",
+    polygon: "string",
+    circle: "string",
+    array: "any[]",
+    customType: "any",
+    customTimestamptz: "Date",
+    userProfile: "string",
+    fileAttachment: "FileAttachment",
+    pgEnum: "string"
+  };
+  let baseType = typeMap[field.type] || "any";
+  if (field.isArray) {
+    baseType = baseType.endsWith("[]") ? baseType : `${baseType}[]`;
+  }
+  if (field.enumValues && field.enumValues.length > 0) {
+    baseType = field.enumValues.map((v) => `'${v}'`).join(" | ");
+  }
+  return baseType;
+}
+function toPascalCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[-_\s]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase().replace(/[_\s]/g, "-");
+}
+function toSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().replace(/[-\s]/g, "_");
+}
+function generateValidationDecorators(field, opts = {}) {
+  const { isUpdate = false, isResponse = false } = opts;
+  let decorators = "  // \u8BF7\u6309\u7528\u6237\u9700\u6C42\u4FEE\u6539\u4EE5\u4E0B\u88C5\u9970\u5668\u6CE8\u91CA\n";
+  if (field.nullable || !isResponse && field.hasDefault || isUpdate) {
+    decorators += `  @ApiPropertyOptional({ description: '${field.comment || field.name}' })
+`;
+    if (isResponse) {
+      return decorators;
+    }
+    decorators += "  @IsOptional()\n";
+  } else {
+    decorators += `  @ApiProperty({ description: '${field.comment || field.name}' })
+`;
+    if (isResponse) {
+      return decorators;
+    }
+    decorators += "  @IsDefined()\n";
+  }
+  switch (field.type) {
+    case "varchar":
+    case "char":
+    case "text":
+      decorators += "  @IsString()\n";
+      if (field.length) {
+        decorators += `  @MaxLength(${field.length})
+`;
+      }
+      break;
+    case "integer":
+    case "smallint":
+    case "serial":
+    case "smallserial":
+      decorators += "  @IsInt()\n";
+      break;
+    case "decimal":
+    case "numeric":
+    case "real":
+    case "doublePrecision":
+      decorators += "  @IsNumber()\n";
+      break;
+    case "boolean":
+      decorators += "  @IsBoolean()\n";
+      break;
+    case "uuid":
+      decorators += "  @IsUUID()\n";
+      break;
+    case "timestamp":
+    case "timestamptz":
+    case "date":
+    case "customTimestamptz":
+      decorators += "  @IsDate()\n";
+      break;
+    case "json":
+    case "jsonb":
+      decorators += "  @IsObject()\n";
+      break;
+  }
+  if (field.isArray) {
+    decorators += "  @IsArray()\n";
+  }
+  return decorators;
+}
+function generateDTO(table) {
+  const className = toPascalCase(table.variableName);
+  let dto = `// \u8BF7\u4FEE\u6539\u8BE5\u6587\u4EF6\u4EE3\u7801\u4EE5\u6EE1\u8DB3\u9700\u6C42
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsDefined, IsNumber, IsOptional, IsString, MaxLength, IsInt, IsBoolean, IsUUID, IsDate, IsObject, IsArray } from 'class-validator';
+import { Type } from 'class-transformer';
+import { FileAttachment } from '../../../database/schema';
+
+`;
+  dto += `export class Create${className}Dto {
+`;
+  for (const field of table.fields) {
+    if (field.isPrimaryKey || field.name === "id" || field.name.startsWith("_") || field.name.startsWith("created") || field.name.startsWith("updated")) {
+      continue;
+    }
+    const tsType = mapDrizzleTypeToTS(field);
+    const optional = field.nullable || field.hasDefault ? "?" : "";
+    const decorators = generateValidationDecorators(field);
+    if (decorators) {
+      dto += decorators;
+    }
+    dto += `  ${field.name}${optional}: ${tsType};
+
+`;
+  }
+  dto += "}\n\n";
+  dto += `export class Update${className}Dto {
+`;
+  for (const field of table.fields) {
+    if (field.name.startsWith("_") || field.name.startsWith("created") || field.name.startsWith("updated") || field.isPrimaryKey || field.name === "id") {
+      continue;
+    }
+    const tsType = mapDrizzleTypeToTS(field);
+    const decorators = generateValidationDecorators(field, { isUpdate: true });
+    if (decorators) {
+      dto += decorators;
+    }
+    dto += `  ${field.name}?: ${tsType};
+
+`;
+  }
+  dto += "}\n\n";
+  dto += `export class ${className}ResponseDto {
+`;
+  for (const field of table.fields) {
+    const tsType = mapDrizzleTypeToTS(field);
+    const optional = field.nullable ? "?" : "";
+    const decorators = generateValidationDecorators(field, { isResponse: true });
+    if (decorators) {
+      dto += decorators;
+    }
+    dto += `  ${field.name}${optional}: ${tsType};
+
+`;
+  }
+  dto += "}\n";
+  return dto;
+}
+function generateController(table) {
+  const className = toPascalCase(table.variableName);
+  const routePath = toKebabCase(pluralize(table.variableName));
+  const filePath = toSnakeCase(table.variableName);
+  const pkField = table.fields.find((f) => f.isPrimaryKey);
+  const pkType = pkField ? mapDrizzleTypeToTS(pkField) : "string";
+  const pkName = pkField ? pkField.name : "id";
+  return `
+// \u8BF7\u4FEE\u6539\u8BE5\u6587\u4EF6\u4EE3\u7801\u4EE5\u6EE1\u8DB3\u9700\u6C42
+import { 
+  Controller, 
+  Get, 
+  Post, 
+  Put, 
+  Delete, 
+  Body, 
+  Param, 
+  Query,
+} from '@nestjs/common';
+ import {
+  ApiTags,
+  ApiOperation,
+  ApiOkResponse,
+  ApiCreatedResponse,
+} from '@nestjs/swagger';
+import { 
+  Create${className}Dto, 
+  Update${className}Dto,
+  ${className}ResponseDto
+} from './dtos/${filePath}.dto';
+import { ${className}Service } from './${filePath}.service';
+
+@ApiTags('${toPascalCase(table.variableName)}')
+@Controller('api/${routePath}')
+export class ${className}Controller {
+  constructor(private readonly ${table.variableName}Service: ${className}Service) {}
+
+  @Post()
+  @ApiOperation({
+    summary: '\u521B\u5EFA\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+    description: '\u521B\u5EFA\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+  })
+  @ApiCreatedResponse({
+    description: '\u6210\u529F\u521B\u5EFA\u4E00\u6761\u8BB0\u5F55',
+    type: ${className}ResponseDto,
+  })
+  async create(
+    @Body() createDto: Create${className}Dto
+  ): Promise<${className}ResponseDto> {
+    return this.${table.variableName}Service.create(createDto);
+  }
+
+  @ApiOperation({
+    summary: '\u6839\u636E\u4E3B\u952E\u67E5\u8BE2\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+    description: '\u6839\u636E\u4E3B\u952E\u67E5\u8BE2\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+  })
+  @ApiOkResponse({
+    description: '\u6210\u529F\u67E5\u8BE2\u4E00\u6761\u8BB0\u5F55',
+    type: ${className}ResponseDto,
+  })
+  @Get(':${pkName}')
+  async findOne(
+    @Param('${pkName}') ${pkName}: ${pkType}
+  ): Promise<${className}ResponseDto> {
+    return this.${table.variableName}Service.findOne(${pkName});
+  }
+
+  @ApiOperation({
+    summary: '\u6839\u636E\u4E3B\u952E\u66F4\u65B0\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+    description: '\u6839\u636E\u4E3B\u952E\u66F4\u65B0\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+  })
+  @ApiOkResponse({
+    description: '\u6210\u529F\u66F4\u65B0\u4E00\u6761\u8BB0\u5F55',
+    type: ${className}ResponseDto,
+  })
+  @Put(':${pkName}')
+  async update(
+    @Param('${pkName}') ${pkName}: ${pkType},
+    @Body() updateDto: Update${className}Dto
+  ): Promise<${className}ResponseDto> {
+    return this.${table.variableName}Service.update(${pkName}, updateDto);
+  }
+
+  @ApiOperation({
+    summary: '\u6839\u636E\u4E3B\u952E\u5220\u9664\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+    description: '\u6839\u636E\u4E3B\u952E\u5220\u9664\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+  })
+  @ApiOkResponse({
+    description: '\u6210\u529F\u5220\u9664\u4E00\u6761\u8BB0\u5F55',
+  })
+  @Delete(':${pkName}')
+  async remove(
+    @Param('${pkName}') ${pkName}: ${pkType}
+  ): Promise<void> {
+    return this.${table.variableName}Service.remove(${pkName});
+  }
+}
+`;
+}
+function generateService(table) {
+  const className = toPascalCase(table.variableName);
+  const filePath = toSnakeCase(table.variableName);
+  const pkField = table.fields.find((f) => f.isPrimaryKey);
+  const pkType = pkField ? mapDrizzleTypeToTS(pkField) : "string";
+  const pkName = pkField ? pkField.name : "id";
+  return `
+// \u8BF7\u4FEE\u6539\u8BE5\u6587\u4EF6\u4EE3\u7801\u4EE5\u6EE1\u8DB3\u9700\u6C42
+import { Injectable, Inject, Logger, NotFoundException } from '@nestjs/common';
+import { eq } from 'drizzle-orm';
+import { DRIZZLE_DATABASE, type PostgresJsDatabase } from '@lark-apaas/fullstack-nestjs-core';
+import { ${table.variableName} } from '../../database/schema';
+import { 
+  Create${className}Dto, 
+  Update${className}Dto,
+  ${className}ResponseDto 
+} from './dtos/${filePath}.dto';
+
+@Injectable()
+export class ${className}Service {
+  private readonly logger = new Logger(${className}Service.name);
+
+  constructor(@Inject(DRIZZLE_DATABASE) private readonly db: PostgresJsDatabase) {}
+
+  async create(createDto: Create${className}Dto): Promise<${className}ResponseDto> {
+    const [result] = await this.db
+      .insert(${table.variableName})
+      .values(createDto)
+      .returning();
+
+    this.logger.log(\`Created ${className} with ${pkName} \${result.${pkName}}\`);
+    
+    return result;
+  }
+
+  async findAll(options?: { page?: number; limit?: number }): Promise<${className}ResponseDto[]> {
+    const { page = 1, limit = 10 } = options || {};
+    const offset = (page - 1) * limit;
+
+    return this.db
+      .select()
+      .from(${table.variableName})
+      .limit(limit)
+      .offset(offset);
+  }
+
+  async findOne(${pkName}: ${pkType}): Promise<${className}ResponseDto> {
+    const [result] = await this.db
+      .select()
+      .from(${table.variableName})
+      .where(eq(${table.variableName}.${pkName}, ${pkName}))
+      .limit(1);
+
+    if (!result) {
+      throw new NotFoundException(\`${className} with ${pkName} \${${pkName}} not found\`);
+    }
+
+    return result;
+  }
+
+  async update(${pkName}: ${pkType}, updateDto: Update${className}Dto): Promise<${className}ResponseDto> {
+    const [result] = await this.db
+      .update(${table.variableName})
+      .set(updateDto)
+      .where(eq(${table.variableName}.${pkName}, ${pkName}))
+      .returning();
+
+    if (!result) {
+      throw new NotFoundException(\`${className} with ${pkName} \${${pkName}} not found\`);
+    }
+
+    return result;
+  }
+
+  async remove(${pkName}: ${pkType}): Promise<void> {
+    const result = await this.db
+      .delete(${table.variableName})
+      .where(eq(${table.variableName}.${pkName}, ${pkName}))
+      .returning();
+
+    if (result.length === 0) {
+      throw new NotFoundException(\`${className} with ${pkName} \${${pkName}} not found\`);
+    }
+
+    this.logger.log(\`Deleted ${className} with ${pkName} \${${pkName}}\`);
+  }
+}
+`;
+}
+function generateModule(table) {
+  const className = toPascalCase(table.variableName);
+  const filePath = toSnakeCase(table.variableName);
+  return `
+import { Module } from '@nestjs/common';
+import { ${className}Controller } from './${filePath}.controller';
+import { ${className}Service } from './${filePath}.service';
+
+@Module({
+  controllers: [${className}Controller],
+  providers: [${className}Service],
+})
+export class ${className}Module {}
+`;
+}
+async function parseAndGenerateNestResourceTemplate(options) {
+  const parser = new DrizzleSchemaParser({ tsConfigFilePath: options.tsConfigFilePath });
+  const tables = parser.parseSchemaFile(options.schemaFilePath);
+  if (tables.length === 0) {
+    console.warn("\u672A\u89E3\u6790\u5230\u4EFB\u4F55\u6570\u636E\u5E93\u8868\uFF0C\u65E0\u9700\u751F\u6210 Nest.js \u6A21\u5757\u6A21\u677F");
+    return;
+  }
+  tables.sort((a, b) => b.variableName.length - a.variableName.length);
+  const table = tables[0];
+  console.info(`\u751F\u6210 Nest.js ${table.variableName} \u6A21\u5757`);
+  const filePath = toSnakeCase(table.variableName);
+  const moduleDir = join(options.moduleOutputDir, filePath);
+  if (existsSync(moduleDir)) {
+    console.info(`Nest.js \u6A21\u5757 ${filePath} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u751F\u6210\u4EE3\u7801`);
+    return;
+  }
+  const dto = generateDTO(table);
+  const controller = generateController(table);
+  const service = generateService(table);
+  const moduleContent = generateModule(table);
+  const moduleFilePath = join(moduleDir, `${filePath}.module.ts`);
+  try {
+    await mkdir(moduleDir, { recursive: true });
+    await mkdir(join(moduleDir, "dtos"), { recursive: true });
+    await writeFile(join(moduleDir, "dtos", `${filePath}.dto.ts`), dto);
+    await writeFile(join(moduleDir, `${filePath}.controller.ts`), controller);
+    await writeFile(join(moduleDir, `${filePath}.service.ts`), service);
+    await writeFile(moduleFilePath, moduleContent);
+  } catch (err) {
+    console.error(`\u751F\u6210 Nest.js ${filePath} \u6A21\u5757\u5931\u8D25: ${err.message}`);
+    await rm(moduleDir, { recursive: true });
+  }
+}
+
+// src/commands/db/schema.handler.ts
 async function run(options = {}) {
   let exitCode = 0;
-  const envPath2 = path.resolve(process.cwd(), ".env");
-  if (fs.existsSync(envPath2)) {
+  const envPath2 = path2.resolve(process.cwd(), ".env");
+  if (fs2.existsSync(envPath2)) {
     loadEnv({ path: envPath2 });
     console.log("[gen-db-schema] \u2713 Loaded .env file");
   }
@@ -136,13 +1276,13 @@ async function run(options = {}) {
     process.exit(1);
   }
   const outputPath = options.output || process.env.DB_SCHEMA_OUTPUT || "server/database/schema.ts";
-  const OUT_DIR = path.resolve(process.cwd(), "server/database/.introspect");
-  const SCHEMA_FILE = path.resolve(process.cwd(), outputPath);
+  const OUT_DIR = path2.resolve(process.cwd(), "server/database/.introspect");
+  const SCHEMA_FILE = path2.resolve(process.cwd(), outputPath);
   console.log("[gen-db-schema] Starting...");
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname2 = path.dirname(__filename);
-  const configPath = path.join(__dirname2, "config", "drizzle.config.js");
-  if (!fs.existsSync(configPath)) {
+  const __dirname2 = path2.dirname(__filename);
+  const configPath = path2.join(__dirname2, "config", "drizzle.config.js");
+  if (!fs2.existsSync(configPath)) {
     console.error("[gen-db-schema] Error: drizzle config not found in CLI package");
     process.exit(1);
   }
@@ -162,29 +1302,27 @@ async function run(options = {}) {
     if ((result.status ?? 0) !== 0) {
       throw new Error(`drizzle-kit introspect failed with status ${result.status}`);
     }
-    const generatedSchema = path.join(OUT_DIR, "schema.ts");
-    if (!fs.existsSync(generatedSchema)) {
+    const generatedSchema = path2.join(OUT_DIR, "schema.ts");
+    if (!fs2.existsSync(generatedSchema)) {
       console.error("[gen-db-schema] schema.ts not generated");
       throw new Error("drizzle-kit introspect failed to generate schema.ts");
     }
-    const { postprocessDrizzleSchema } = require2("@lark-apaas/devtool-kits");
     const stats = postprocessDrizzleSchema(generatedSchema);
     if (stats?.unmatchedUnknown?.length) {
       console.warn("[gen-db-schema] Unmatched custom types detected:", stats.unmatchedUnknown);
     }
     console.log("[gen-db-schema] \u2713 Postprocessed schema");
-    fs.mkdirSync(path.dirname(SCHEMA_FILE), { recursive: true });
-    fs.copyFileSync(generatedSchema, SCHEMA_FILE);
+    fs2.mkdirSync(path2.dirname(SCHEMA_FILE), { recursive: true });
+    fs2.copyFileSync(generatedSchema, SCHEMA_FILE);
     console.log(`[gen-db-schema] \u2713 Copied to ${outputPath}`);
     try {
       if (options.enableNestModuleGenerate) {
-        const { parseAndGenerateNestResourceTemplate } = require2("@lark-apaas/devtool-kits");
-        const tsConfigFilePath = path.resolve(process.cwd(), "tsconfig.json");
+        const tsConfigFilePath = path2.resolve(process.cwd(), "tsconfig.json");
         const schemaFilePath = SCHEMA_FILE;
         await parseAndGenerateNestResourceTemplate({
           tsConfigFilePath,
           schemaFilePath,
-          moduleOutputDir: path.resolve(process.cwd(), "server/modules")
+          moduleOutputDir: path2.resolve(process.cwd(), "server/modules")
         });
         console.log("[gen-db-schema] \u2713 Generate NestJS Module Boilerplate Successfully");
       }
@@ -196,8 +1334,8 @@ async function run(options = {}) {
     console.error("[gen-db-schema] Failed:", err instanceof Error ? err.message : String(err));
     exitCode = 1;
   } finally {
-    if (fs.existsSync(OUT_DIR)) {
-      fs.rmSync(OUT_DIR, { recursive: true, force: true });
+    if (fs2.existsSync(OUT_DIR)) {
+      fs2.rmSync(OUT_DIR, { recursive: true, force: true });
     }
     process.exit(exitCode);
   }
@@ -215,8 +1353,8 @@ var genDbSchemaCommand = {
 };
 
 // src/commands/sync/run.handler.ts
-import path3 from "path";
-import fs3 from "fs";
+import path4 from "path";
+import fs4 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/sync.ts
@@ -280,23 +1418,23 @@ function genSyncConfig(perms = {}) {
 }
 
 // src/utils/file-ops.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 function removeLineFromFile(filePath, pattern) {
-  if (!fs2.existsSync(filePath)) {
-    console.log(`[fullstack-cli] \u25CB ${path2.basename(filePath)} (not found)`);
+  if (!fs3.existsSync(filePath)) {
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(filePath)} (not found)`);
     return false;
   }
-  const content = fs2.readFileSync(filePath, "utf-8");
+  const content = fs3.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const trimmedPattern = pattern.trim();
   const filteredLines = lines.filter((line) => line.trim() !== trimmedPattern);
   if (filteredLines.length === lines.length) {
-    console.log(`[fullstack-cli] \u25CB ${path2.basename(filePath)} (pattern not found: ${pattern})`);
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(filePath)} (pattern not found: ${pattern})`);
     return false;
   }
-  fs2.writeFileSync(filePath, filteredLines.join("\n"));
-  console.log(`[fullstack-cli] \u2713 ${path2.basename(filePath)} (removed: ${pattern})`);
+  fs3.writeFileSync(filePath, filteredLines.join("\n"));
+  console.log(`[fullstack-cli] \u2713 ${path3.basename(filePath)} (removed: ${pattern})`);
   return true;
 }
 
@@ -304,14 +1442,14 @@ function removeLineFromFile(filePath, pattern) {
 async function run2(options) {
   const userProjectRoot = process.env.INIT_CWD || process.cwd();
   const __filename = fileURLToPath2(import.meta.url);
-  const __dirname2 = path3.dirname(__filename);
-  const pluginRoot = path3.resolve(__dirname2, "..");
+  const __dirname2 = path4.dirname(__filename);
+  const pluginRoot = path4.resolve(__dirname2, "..");
   if (userProjectRoot === pluginRoot) {
     console.log("[fullstack-cli] Skip syncing (installing plugin itself)");
     process.exit(0);
   }
-  const userPackageJson = path3.join(userProjectRoot, "package.json");
-  if (!fs3.existsSync(userPackageJson)) {
+  const userPackageJson = path4.join(userProjectRoot, "package.json");
+  if (!fs4.existsSync(userPackageJson)) {
     console.log("[fullstack-cli] Skip syncing (not a valid npm project)");
     process.exit(0);
   }
@@ -339,7 +1477,7 @@ async function run2(options) {
 }
 async function syncRule(rule, pluginRoot, userProjectRoot) {
   if (rule.type === "delete-file" || rule.type === "delete-directory") {
-    const destPath2 = path3.join(userProjectRoot, rule.to);
+    const destPath2 = path4.join(userProjectRoot, rule.to);
     if (rule.type === "delete-file") {
       deleteFile(destPath2);
     } else {
@@ -348,16 +1486,16 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
     return;
   }
   if (rule.type === "remove-line") {
-    const destPath2 = path3.join(userProjectRoot, rule.to);
+    const destPath2 = path4.join(userProjectRoot, rule.to);
     removeLineFromFile(destPath2, rule.pattern);
     return;
   }
   if (!("from" in rule)) {
     return;
   }
-  const srcPath = path3.join(pluginRoot, rule.from);
-  const destPath = path3.join(userProjectRoot, rule.to);
-  if (!fs3.existsSync(srcPath)) {
+  const srcPath = path4.join(pluginRoot, rule.from);
+  const destPath = path4.join(userProjectRoot, rule.to);
+  if (!fs4.existsSync(srcPath)) {
     console.warn(`[fullstack-cli] Source not found: ${rule.from}`);
     return;
   }
@@ -374,64 +1512,64 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
   }
 }
 function syncFile(src, dest, overwrite = true) {
-  const destDir = path3.dirname(dest);
-  if (!fs3.existsSync(destDir)) {
-    fs3.mkdirSync(destDir, { recursive: true });
+  const destDir = path4.dirname(dest);
+  if (!fs4.existsSync(destDir)) {
+    fs4.mkdirSync(destDir, { recursive: true });
   }
-  if (fs3.existsSync(dest) && !overwrite) {
-    console.log(`[fullstack-cli] \u25CB ${path3.basename(dest)} (skipped, already exists)`);
+  if (fs4.existsSync(dest) && !overwrite) {
+    console.log(`[fullstack-cli] \u25CB ${path4.basename(dest)} (skipped, already exists)`);
     return;
   }
-  fs3.copyFileSync(src, dest);
-  console.log(`[fullstack-cli] \u2713 ${path3.basename(dest)}`);
+  fs4.copyFileSync(src, dest);
+  console.log(`[fullstack-cli] \u2713 ${path4.basename(dest)}`);
 }
 function syncDirectory(src, dest, overwrite = true) {
-  if (!fs3.existsSync(dest)) {
-    fs3.mkdirSync(dest, { recursive: true });
+  if (!fs4.existsSync(dest)) {
+    fs4.mkdirSync(dest, { recursive: true });
   }
-  const files = fs3.readdirSync(src);
+  const files = fs4.readdirSync(src);
   let count = 0;
   files.forEach((file) => {
-    const srcFile = path3.join(src, file);
-    const destFile = path3.join(dest, file);
-    const stats = fs3.statSync(srcFile);
+    const srcFile = path4.join(src, file);
+    const destFile = path4.join(dest, file);
+    const stats = fs4.statSync(srcFile);
     if (stats.isDirectory()) {
       syncDirectory(srcFile, destFile, overwrite);
     } else {
-      if (overwrite || !fs3.existsSync(destFile)) {
-        fs3.copyFileSync(srcFile, destFile);
-        console.log(`[fullstack-cli] \u2713 ${path3.relative(dest, destFile)}`);
+      if (overwrite || !fs4.existsSync(destFile)) {
+        fs4.copyFileSync(srcFile, destFile);
+        console.log(`[fullstack-cli] \u2713 ${path4.relative(dest, destFile)}`);
         count++;
       }
     }
   });
   if (count > 0) {
-    console.log(`[fullstack-cli] Synced ${count} files to ${path3.basename(dest)}/`);
+    console.log(`[fullstack-cli] Synced ${count} files to ${path4.basename(dest)}/`);
   }
 }
 function appendToFile(src, dest) {
-  const content = fs3.readFileSync(src, "utf-8");
+  const content = fs4.readFileSync(src, "utf-8");
   let existingContent = "";
-  if (fs3.existsSync(dest)) {
-    existingContent = fs3.readFileSync(dest, "utf-8");
+  if (fs4.existsSync(dest)) {
+    existingContent = fs4.readFileSync(dest, "utf-8");
   }
   if (existingContent.includes(content.trim())) {
-    console.log(`[fullstack-cli] \u25CB ${path3.basename(dest)} (already contains content)`);
+    console.log(`[fullstack-cli] \u25CB ${path4.basename(dest)} (already contains content)`);
     return;
   }
-  fs3.appendFileSync(dest, content);
-  console.log(`[fullstack-cli] \u2713 ${path3.basename(dest)} (appended)`);
+  fs4.appendFileSync(dest, content);
+  console.log(`[fullstack-cli] \u2713 ${path4.basename(dest)} (appended)`);
 }
 function setPermissions(permissions, projectRoot) {
   for (const [pattern, mode] of Object.entries(permissions)) {
     if (pattern === "**/*.sh") {
-      const scriptsDir = path3.join(projectRoot, "scripts");
-      if (fs3.existsSync(scriptsDir)) {
-        const files = fs3.readdirSync(scriptsDir);
+      const scriptsDir = path4.join(projectRoot, "scripts");
+      if (fs4.existsSync(scriptsDir)) {
+        const files = fs4.readdirSync(scriptsDir);
         files.forEach((file) => {
           if (file.endsWith(".sh")) {
-            const filePath = path3.join(scriptsDir, file);
-            fs3.chmodSync(filePath, mode);
+            const filePath = path4.join(scriptsDir, file);
+            fs4.chmodSync(filePath, mode);
           }
         });
       }
@@ -439,19 +1577,19 @@ function setPermissions(permissions, projectRoot) {
   }
 }
 function deleteFile(filePath) {
-  if (fs3.existsSync(filePath)) {
-    fs3.unlinkSync(filePath);
-    console.log(`[fullstack-cli] \u2713 ${path3.basename(filePath)} (deleted)`);
+  if (fs4.existsSync(filePath)) {
+    fs4.unlinkSync(filePath);
+    console.log(`[fullstack-cli] \u2713 ${path4.basename(filePath)} (deleted)`);
   } else {
-    console.log(`[fullstack-cli] \u25CB ${path3.basename(filePath)} (not found)`);
+    console.log(`[fullstack-cli] \u25CB ${path4.basename(filePath)} (not found)`);
   }
 }
 function deleteDirectory(dirPath) {
-  if (fs3.existsSync(dirPath)) {
-    fs3.rmSync(dirPath, { recursive: true });
-    console.log(`[fullstack-cli] \u2713 ${path3.basename(dirPath)} (deleted)`);
+  if (fs4.existsSync(dirPath)) {
+    fs4.rmSync(dirPath, { recursive: true });
+    console.log(`[fullstack-cli] \u2713 ${path4.basename(dirPath)} (deleted)`);
   } else {
-    console.log(`[fullstack-cli] \u25CB ${path3.basename(dirPath)} (not found)`);
+    console.log(`[fullstack-cli] \u25CB ${path4.basename(dirPath)} (not found)`);
   }
 }
 
@@ -467,8 +1605,8 @@ var syncCommand = {
 };
 
 // src/commands/action-plugin/utils.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { spawnSync as spawnSync2, execSync } from "child_process";
 function parsePluginName(input) {
   const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
@@ -486,18 +1624,18 @@ function getProjectRoot() {
   return process.cwd();
 }
 function getPackageJsonPath() {
-  return path4.join(getProjectRoot(), "package.json");
+  return path5.join(getProjectRoot(), "package.json");
 }
 function getPluginPath(pluginName) {
-  return path4.join(getProjectRoot(), "node_modules", pluginName);
+  return path5.join(getProjectRoot(), "node_modules", pluginName);
 }
 function readPackageJson() {
   const pkgPath = getPackageJsonPath();
-  if (!fs4.existsSync(pkgPath)) {
+  if (!fs5.existsSync(pkgPath)) {
     throw new Error("package.json not found in current directory");
   }
   try {
-    const content = fs4.readFileSync(pkgPath, "utf-8");
+    const content = fs5.readFileSync(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
     throw new Error("Failed to parse package.json");
@@ -505,7 +1643,7 @@ function readPackageJson() {
 }
 function writePackageJson(pkg2) {
   const pkgPath = getPackageJsonPath();
-  fs4.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs5.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 function readActionPlugins() {
   const pkg2 = readPackageJson();
@@ -538,12 +1676,12 @@ function npmInstall(tgzPath) {
   }
 }
 function getPackageVersion(pluginName) {
-  const pkgJsonPath = path4.join(getPluginPath(pluginName), "package.json");
-  if (!fs4.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path5.join(getPluginPath(pluginName), "package.json");
+  if (!fs5.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs4.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs5.readFileSync(pkgJsonPath, "utf-8");
     const pkg2 = JSON.parse(content);
     return pkg2.version || null;
   } catch {
@@ -551,49 +1689,49 @@ function getPackageVersion(pluginName) {
   }
 }
 function readPluginPackageJson(pluginPath) {
-  const pkgJsonPath = path4.join(pluginPath, "package.json");
-  if (!fs4.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path5.join(pluginPath, "package.json");
+  if (!fs5.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs4.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs5.readFileSync(pkgJsonPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function extractTgzToNodeModules(tgzPath, pluginName) {
-  const nodeModulesPath = path4.join(getProjectRoot(), "node_modules");
-  const targetDir = path4.join(nodeModulesPath, pluginName);
-  const scopeDir = path4.dirname(targetDir);
-  if (!fs4.existsSync(scopeDir)) {
-    fs4.mkdirSync(scopeDir, { recursive: true });
+  const nodeModulesPath = path5.join(getProjectRoot(), "node_modules");
+  const targetDir = path5.join(nodeModulesPath, pluginName);
+  const scopeDir = path5.dirname(targetDir);
+  if (!fs5.existsSync(scopeDir)) {
+    fs5.mkdirSync(scopeDir, { recursive: true });
   }
-  if (fs4.existsSync(targetDir)) {
-    fs4.rmSync(targetDir, { recursive: true });
+  if (fs5.existsSync(targetDir)) {
+    fs5.rmSync(targetDir, { recursive: true });
   }
-  const tempDir = path4.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
-  if (fs4.existsSync(tempDir)) {
-    fs4.rmSync(tempDir, { recursive: true });
+  const tempDir = path5.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs5.existsSync(tempDir)) {
+    fs5.rmSync(tempDir, { recursive: true });
   }
-  fs4.mkdirSync(tempDir, { recursive: true });
+  fs5.mkdirSync(tempDir, { recursive: true });
   try {
     execSync(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
-    const extractedDir = path4.join(tempDir, "package");
-    if (fs4.existsSync(extractedDir)) {
-      fs4.renameSync(extractedDir, targetDir);
+    const extractedDir = path5.join(tempDir, "package");
+    if (fs5.existsSync(extractedDir)) {
+      fs5.renameSync(extractedDir, targetDir);
     } else {
-      const files = fs4.readdirSync(tempDir);
+      const files = fs5.readdirSync(tempDir);
       if (files.length === 1) {
-        fs4.renameSync(path4.join(tempDir, files[0]), targetDir);
+        fs5.renameSync(path5.join(tempDir, files[0]), targetDir);
       } else {
         throw new Error("Unexpected tgz structure");
       }
     }
     return targetDir;
   } finally {
-    if (fs4.existsSync(tempDir)) {
-      fs4.rmSync(tempDir, { recursive: true });
+    if (fs5.existsSync(tempDir)) {
+      fs5.rmSync(tempDir, { recursive: true });
     }
   }
 }
@@ -602,10 +1740,10 @@ function checkMissingPeerDeps(peerDeps) {
     return [];
   }
   const missing = [];
-  const nodeModulesPath = path4.join(getProjectRoot(), "node_modules");
+  const nodeModulesPath = path5.join(getProjectRoot(), "node_modules");
   for (const [depName, _version] of Object.entries(peerDeps)) {
-    const depPath = path4.join(nodeModulesPath, depName);
-    if (!fs4.existsSync(depPath)) {
+    const depPath = path5.join(nodeModulesPath, depName);
+    if (!fs5.existsSync(depPath)) {
       missing.push(depName);
     }
   }
@@ -629,16 +1767,16 @@ function installMissingDeps(deps) {
 }
 function removePluginDirectory(pluginName) {
   const pluginPath = getPluginPath(pluginName);
-  if (fs4.existsSync(pluginPath)) {
-    fs4.rmSync(pluginPath, { recursive: true });
+  if (fs5.existsSync(pluginPath)) {
+    fs5.rmSync(pluginPath, { recursive: true });
     console.log(`[action-plugin] Removed ${pluginName}`);
   }
 }
 
 // src/commands/action-plugin/api-client.ts
 import { HttpClient as HttpClient2 } from "@lark-apaas/http-client";
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 
 // src/utils/http-client.ts
 import { HttpClient } from "@lark-apaas/http-client";
@@ -723,19 +1861,19 @@ async function downloadFromPublic(downloadURL) {
   return Buffer.from(arrayBuffer);
 }
 function getPluginCacheDir() {
-  return path5.join(process.cwd(), PLUGIN_CACHE_DIR);
+  return path6.join(process.cwd(), PLUGIN_CACHE_DIR);
 }
 function ensureCacheDir() {
   const cacheDir = getPluginCacheDir();
-  if (!fs5.existsSync(cacheDir)) {
-    fs5.mkdirSync(cacheDir, { recursive: true });
+  if (!fs6.existsSync(cacheDir)) {
+    fs6.mkdirSync(cacheDir, { recursive: true });
   }
 }
 function getTempFilePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}-${version}.tgz`;
-  return path5.join(getPluginCacheDir(), filename);
+  return path6.join(getPluginCacheDir(), filename);
 }
 async function downloadPlugin(pluginKey, requestedVersion) {
   console.log(`[action-plugin] Fetching plugin info for ${pluginKey}@${requestedVersion}...`);
@@ -751,7 +1889,7 @@ async function downloadPlugin(pluginKey, requestedVersion) {
     tgzBuffer = await downloadFromPublic(pluginInfo.downloadURL);
   }
   const tgzPath = getTempFilePath(pluginKey, pluginInfo.version);
-  fs5.writeFileSync(tgzPath, tgzBuffer);
+  fs6.writeFileSync(tgzPath, tgzBuffer);
   console.log(`[action-plugin] Downloaded to ${tgzPath} (${(tgzBuffer.length / 1024).toFixed(2)} KB)`);
   return {
     tgzPath,
@@ -761,8 +1899,8 @@ async function downloadPlugin(pluginKey, requestedVersion) {
 }
 function cleanupTempFile(tgzPath) {
   try {
-    if (fs5.existsSync(tgzPath)) {
-      fs5.unlinkSync(tgzPath);
+    if (fs6.existsSync(tgzPath)) {
+      fs6.unlinkSync(tgzPath);
     }
   } catch {
   }
@@ -1087,39 +2225,39 @@ var actionPluginCommandGroup = {
 };
 
 // src/commands/capability/utils.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 var CAPABILITIES_DIR = "server/capabilities";
 function getProjectRoot2() {
   return process.cwd();
 }
 function getCapabilitiesDir() {
-  return path6.join(getProjectRoot2(), CAPABILITIES_DIR);
+  return path7.join(getProjectRoot2(), CAPABILITIES_DIR);
 }
 function getCapabilityPath(id) {
-  return path6.join(getCapabilitiesDir(), `${id}.json`);
+  return path7.join(getCapabilitiesDir(), `${id}.json`);
 }
 function getPluginManifestPath(pluginKey) {
-  return path6.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
+  return path7.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
-  return fs6.existsSync(getCapabilitiesDir());
+  return fs7.existsSync(getCapabilitiesDir());
 }
 function listCapabilityIds() {
   const dir = getCapabilitiesDir();
-  if (!fs6.existsSync(dir)) {
+  if (!fs7.existsSync(dir)) {
     return [];
   }
-  const files = fs6.readdirSync(dir);
+  const files = fs7.readdirSync(dir);
   return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
 }
 function readCapability(id) {
   const filePath = getCapabilityPath(id);
-  if (!fs6.existsSync(filePath)) {
+  if (!fs7.existsSync(filePath)) {
     throw new Error(`Capability not found: ${id}`);
   }
   try {
-    const content = fs6.readFileSync(filePath, "utf-8");
+    const content = fs7.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -1134,11 +2272,11 @@ function readAllCapabilities() {
 }
 function readPluginManifest(pluginKey) {
   const manifestPath = getPluginManifestPath(pluginKey);
-  if (!fs6.existsSync(manifestPath)) {
+  if (!fs7.existsSync(manifestPath)) {
     throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
-    const content = fs6.readFileSync(manifestPath, "utf-8");
+    const content = fs7.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -1312,58 +2450,58 @@ var capabilityCommandGroup = {
 };
 
 // src/commands/migration/version-manager.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 var PACKAGE_JSON = "package.json";
 var VERSION_FIELD = "migrationVersion";
 function getPackageJsonPath2() {
-  return path7.join(process.cwd(), PACKAGE_JSON);
+  return path8.join(process.cwd(), PACKAGE_JSON);
 }
 function getCurrentVersion() {
   const pkgPath = getPackageJsonPath2();
-  if (!fs7.existsSync(pkgPath)) {
+  if (!fs8.existsSync(pkgPath)) {
     throw new Error("package.json not found");
   }
-  const pkg2 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
   return pkg2[VERSION_FIELD] ?? 0;
 }
 function setCurrentVersion(version) {
   const pkgPath = getPackageJsonPath2();
-  const pkg2 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
   pkg2[VERSION_FIELD] = version;
-  fs7.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs8.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 
 // src/commands/migration/versions/v001_capability/utils.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 var CAPABILITIES_DIR2 = "server/capabilities";
 function getProjectRoot3() {
   return process.cwd();
 }
 function getCapabilitiesDir2() {
-  return path8.join(getProjectRoot3(), CAPABILITIES_DIR2);
+  return path9.join(getProjectRoot3(), CAPABILITIES_DIR2);
 }
 function getPluginManifestPath2(pluginKey) {
-  return path8.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
+  return path9.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
 function detectJsonMigration() {
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldFilePath = path9.join(capabilitiesDir, "capabilities.json");
-  if (!fs9.existsSync(oldFilePath)) {
+  const oldFilePath = path10.join(capabilitiesDir, "capabilities.json");
+  if (!fs10.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
       reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs9.readFileSync(oldFilePath, "utf-8");
+    const content = fs10.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
     const capabilities = Array.isArray(parsed) ? parsed : [];
     return {
@@ -1403,8 +2541,8 @@ async function check(options) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path11 from "path";
 
 // src/commands/migration/versions/v001_capability/mapping.ts
 var DEFAULT_PLUGIN_VERSION = "1.0.0";
@@ -1634,18 +2772,18 @@ function transformCapabilities(oldCapabilities) {
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
 function loadExistingCapabilities() {
   const capabilitiesDir = getCapabilitiesDir2();
-  if (!fs10.existsSync(capabilitiesDir)) {
+  if (!fs11.existsSync(capabilitiesDir)) {
     return [];
   }
-  const files = fs10.readdirSync(capabilitiesDir);
+  const files = fs11.readdirSync(capabilitiesDir);
   const capabilities = [];
   for (const file of files) {
     if (file === "capabilities.json" || !file.endsWith(".json")) {
       continue;
     }
     try {
-      const filePath = path10.join(capabilitiesDir, file);
-      const content = fs10.readFileSync(filePath, "utf-8");
+      const filePath = path11.join(capabilitiesDir, file);
+      const content = fs11.readFileSync(filePath, "utf-8");
       const capability = JSON.parse(content);
       if (capability.id && capability.pluginKey) {
         capabilities.push(capability);
@@ -1703,9 +2841,9 @@ async function migrateJsonFiles(options) {
   }
   const capabilitiesDir = getCapabilitiesDir2();
   for (const cap of newCapabilities) {
-    const filePath = path10.join(capabilitiesDir, `${cap.id}.json`);
+    const filePath = path11.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs10.writeFileSync(filePath, content, "utf-8");
+    fs11.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
   return {
@@ -1717,10 +2855,10 @@ async function migrateJsonFiles(options) {
 }
 
 // src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
-import fs11 from "fs";
+import fs12 from "fs";
 function isPluginInstalled2(pluginKey) {
   const manifestPath = getPluginManifestPath2(pluginKey);
-  return fs11.existsSync(manifestPath);
+  return fs12.existsSync(manifestPath);
 }
 function detectPluginsToInstall(capabilities) {
   const pluginKeys = /* @__PURE__ */ new Set();
@@ -1796,12 +2934,12 @@ async function installPlugins(capabilities, options) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-import path12 from "path";
-import { Project } from "ts-morph";
+import path13 from "path";
+import { Project as Project2 } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
-import fs12 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
   "dist",
@@ -1816,9 +2954,9 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs12.readdirSync(dir, { withFileTypes: true });
+  const entries = fs13.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path11.join(dir, entry.name);
+    const fullPath = path12.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.includes(entry.name)) {
         continue;
@@ -1834,14 +2972,14 @@ function scanDirectory(dir, files = []) {
   return files;
 }
 function scanServerFiles() {
-  const serverDir = path11.join(getProjectRoot3(), "server");
-  if (!fs12.existsSync(serverDir)) {
+  const serverDir = path12.join(getProjectRoot3(), "server");
+  if (!fs13.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs12.readFileSync(filePath, "utf-8");
+  const content = fs13.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -2216,7 +3354,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
-  const relativePath = path12.relative(getProjectRoot3(), filePath);
+  const relativePath = path13.relative(getProjectRoot3(), filePath);
   return {
     filePath: relativePath,
     imports,
@@ -2227,7 +3365,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   };
 }
 function migrateFile(project, analysis, dryRun) {
-  const absolutePath = path12.join(getProjectRoot3(), analysis.filePath);
+  const absolutePath = path13.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
       filePath: analysis.filePath,
@@ -2287,7 +3425,7 @@ async function migrateCode(options, capabilities) {
     console.log("   No files need code migration.\n");
     return result;
   }
-  const project = new Project({
+  const project = new Project2({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: {
       allowJs: true
@@ -2330,17 +3468,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path14 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldJsonPath = path13.join(capabilitiesDir, "capabilities.json");
-  if (fs13.existsSync(oldJsonPath)) {
+  const oldJsonPath = path14.join(capabilitiesDir, "capabilities.json");
+  if (fs14.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs13.unlinkSync(oldJsonPath);
+        fs14.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -2348,11 +3486,11 @@ function cleanupOldFiles(capabilities, dryRun) {
     }
   }
   for (const cap of capabilities) {
-    const tsFilePath = path13.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs13.existsSync(tsFilePath)) {
+    const tsFilePath = path14.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs14.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs13.unlinkSync(tsFilePath);
+          fs14.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -2368,8 +3506,8 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs15 from "fs";
+import path15 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
   const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
@@ -2532,15 +3670,15 @@ async function generateReport(result) {
   }
   lines.push("");
   const logDir = process.env.LOG_DIR || "logs";
-  if (!fs14.existsSync(logDir)) {
+  if (!fs15.existsSync(logDir)) {
     return;
   }
-  const reportDir = path14.join(logDir, "migration");
-  if (!fs14.existsSync(reportDir)) {
-    fs14.mkdirSync(reportDir, { recursive: true });
+  const reportDir = path15.join(logDir, "migration");
+  if (!fs15.existsSync(reportDir)) {
+    fs15.mkdirSync(reportDir, { recursive: true });
   }
-  const reportPath = path14.join(reportDir, REPORT_FILE);
-  fs14.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  const reportPath = path15.join(reportDir, REPORT_FILE);
+  fs15.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${reportPath}`);
 }
 
@@ -3072,10 +4210,10 @@ var migrationCommand = {
 };
 
 // src/commands/read-logs/index.ts
-import path15 from "path";
+import path16 from "path";
 
 // src/commands/read-logs/std-utils.ts
-import fs15 from "fs";
+import fs16 from "fs";
 function formatStdPrefixTime(localTime) {
   const match = localTime.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
   if (!match) return localTime;
@@ -3105,11 +4243,11 @@ function stripPrefixFromStdLine(line) {
   return `[${time}] ${content}`;
 }
 function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
-  const stat = fs15.statSync(filePath);
+  const stat = fs16.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], markerFound: false, totalLinesCount: 0 };
   }
-  const fd = fs15.openSync(filePath, "r");
+  const fd = fs16.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -3123,7 +4261,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs15.readSync(fd, buffer, 0, length, position);
+      fs16.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -3165,7 +4303,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       }
     }
   } finally {
-    fs15.closeSync(fd);
+    fs16.closeSync(fd);
   }
   return { lines: collected.reverse(), markerFound, totalLinesCount };
 }
@@ -3186,21 +4324,21 @@ function readServerStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/tail.ts
-import fs16 from "fs";
+import fs17 from "fs";
 function fileExists(filePath) {
   try {
-    fs16.accessSync(filePath, fs16.constants.F_OK | fs16.constants.R_OK);
+    fs17.accessSync(filePath, fs17.constants.F_OK | fs17.constants.R_OK);
     return true;
   } catch {
     return false;
   }
 }
 function readFileTailLines(filePath, maxLines) {
-  const stat = fs16.statSync(filePath);
+  const stat = fs17.statSync(filePath);
   if (stat.size === 0) {
     return [];
   }
-  const fd = fs16.openSync(filePath, "r");
+  const fd = fs17.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   const chunks = [];
   let position = stat.size;
@@ -3210,13 +4348,13 @@ function readFileTailLines(filePath, maxLines) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs16.readSync(fd, buffer, 0, length, position);
+      fs17.readSync(fd, buffer, 0, length, position);
       chunks.unshift(buffer.toString("utf8"));
       const chunkLines = buffer.toString("utf8").split("\n").length - 1;
       collectedLines += chunkLines;
     }
   } finally {
-    fs16.closeSync(fd);
+    fs17.closeSync(fd);
   }
   const content = chunks.join("");
   const allLines = content.split("\n");
@@ -3232,11 +4370,11 @@ function readFileTailLines(filePath, maxLines) {
   return allLines.slice(allLines.length - maxLines);
 }
 function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
-  const stat = fs16.statSync(filePath);
+  const stat = fs17.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs16.openSync(filePath, "r");
+  const fd = fs17.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -3248,7 +4386,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs16.readSync(fd, buffer, 0, length, position);
+      fs17.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -3279,7 +4417,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       }
     }
   } finally {
-    fs16.closeSync(fd);
+    fs17.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -3381,7 +4519,7 @@ function extractClientStdSegment(lines, maxLines, offset) {
 }
 
 // src/commands/read-logs/json-lines.ts
-import fs17 from "fs";
+import fs18 from "fs";
 function normalizePid(value) {
   if (typeof value === "number") {
     return String(value);
@@ -3432,11 +4570,11 @@ function buildWantedLevelSet(levels) {
   return set.size > 0 ? set : null;
 }
 function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
-  const stat = fs17.statSync(filePath);
+  const stat = fs18.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs17.openSync(filePath, "r");
+  const fd = fs18.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -3451,7 +4589,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs17.readSync(fd, buffer, 0, length, position);
+      fs18.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -3513,7 +4651,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs17.closeSync(fd);
+    fs18.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -3556,11 +4694,11 @@ function extractTraceId(obj) {
 function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
   const wanted = traceId.trim();
   if (!wanted) return { lines: [], totalLinesCount: 0 };
-  const stat = fs17.statSync(filePath);
+  const stat = fs18.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs17.openSync(filePath, "r");
+  const fd = fs18.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -3573,7 +4711,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs17.readSync(fd, buffer, 0, length, position);
+      fs18.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -3626,7 +4764,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs17.closeSync(fd);
+    fs18.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -3635,11 +4773,11 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
   if (!wantedLevelSet) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const stat = fs17.statSync(filePath);
+  const stat = fs18.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs17.openSync(filePath, "r");
+  const fd = fs18.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -3651,7 +4789,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs17.readSync(fd, buffer, 0, length, position);
+      fs18.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -3698,7 +4836,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs17.closeSync(fd);
+    fs18.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -3829,21 +4967,21 @@ async function readLogsJsonResult(options) {
   };
 }
 function resolveLogFilePath(logDir, type) {
-  const base = path15.isAbsolute(logDir) ? logDir : path15.join(process.cwd(), logDir);
+  const base = path16.isAbsolute(logDir) ? logDir : path16.join(process.cwd(), logDir);
   if (type === "server") {
-    return path15.join(base, "server.log");
+    return path16.join(base, "server.log");
   }
   if (type === "trace") {
-    return path15.join(base, "trace.log");
+    return path16.join(base, "trace.log");
   }
   if (type === "server-std") {
-    return path15.join(base, "server.std.log");
+    return path16.join(base, "server.std.log");
   }
   if (type === "client-std") {
-    return path15.join(base, "client.std.log");
+    return path16.join(base, "client.std.log");
   }
   if (type === "browser") {
-    return path15.join(base, "browser.log");
+    return path16.join(base, "browser.log");
   }
   throw new Error(`Unsupported log type: ${type}`);
 }
@@ -3918,12 +5056,12 @@ var commands = [
 ];
 
 // src/index.ts
-var envPath = path16.join(process.cwd(), ".env");
-if (fs18.existsSync(envPath)) {
+var envPath = path17.join(process.cwd(), ".env");
+if (fs19.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path16.dirname(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(fs18.readFileSync(path16.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path17.dirname(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(fs19.readFileSync(path17.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();