@lark-apaas/fullstack-cli 1.1.16-alpha.2 → 1.1.16-alpha.4

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import fs21 from "fs";
+import fs20 from "fs";
 import path17 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { config as dotenvConfig } from "dotenv";
@@ -117,94 +117,104 @@ Command "${ctx.commandName}" completed in ${elapsed}ms`);
 
 // src/commands/db/schema.handler.ts
 import path2 from "path";
-import fs4 from "fs";
+import fs3 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { spawnSync } from "child_process";
 import { createRequire } from "module";
 import { config as loadEnv } from "dotenv";
 
-// src/commands/db/gen-dbschema/index.ts
-import fs3 from "fs";
-import path from "path";
-
 // src/commands/db/gen-dbschema/postprocess.ts
 import fs2 from "fs";
+import path from "path";
 
-// src/commands/db/gen-dbschema/transforms/core.ts
-import { IndentationText, Project, QuoteKind } from "ts-morph";
-
-// src/commands/db/gen-dbschema/transforms/types.ts
-function createEmptyStats() {
-  return {
-    patchedDefects: 0,
-    removedPgSchemas: 0,
-    convertedSchemaCalls: 0,
-    renamedIdentifiers: [],
-    replacedUnknown: 0,
-    fallbackToText: 0,
-    unmatchedUnknown: [],
-    replacedTimestamp: 0,
-    replacedDefaultNow: 0,
-    removedSystemFields: 0,
-    addedImports: [],
-    removedImports: []
-  };
-}
-
-// src/commands/db/gen-dbschema/transforms/core.ts
-var PROJECT_OPTIONS = {
-  skipAddingFilesFromTsConfig: true,
-  skipFileDependencyResolution: true,
-  manipulationSettings: {
-    indentationText: IndentationText.TwoSpaces,
-    quoteKind: QuoteKind.Single
+// src/commands/db/gen-dbschema/helper/header-format.ts
+var HEADER_COMMENT = "/** auto generated, do not edit */";
+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}
+`;
   }
-};
-function parseSource(source, fileName = "schema.ts") {
-  const project = new Project({
-    ...PROJECT_OPTIONS,
-    useInMemoryFileSystem: true
-  });
-  const sourceFile = project.createSourceFile(fileName, source);
-  return { project, sourceFile };
+  return `${HEADER_COMMENT}
+${trimmed}`;
 }
-function applyTransforms(sourceFile, transforms) {
-  const stats = createEmptyStats();
-  for (const transform of transforms) {
-    try {
-      transform.transform({ sourceFile, stats });
-    } catch (error) {
-      console.error(`[ast] Transform "${transform.name}" failed:`, error);
-      throw error;
-    }
+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 stats;
-}
-function formatSourceFile(sourceFile) {
-  sourceFile.formatText({
-    indentSize: 2,
-    convertTabsToSpaces: true
-  });
+  return current;
 }
-function printSourceFile(sourceFile) {
-  return sourceFile.getFullText();
+function collapseExtraBlankLines(text) {
+  return text.replace(/\n{3,}/g, "\n\n");
 }
 
-// src/commands/db/gen-dbschema/transforms/ast/rename-identifiers.ts
-import { Node } from "ts-morph";
+// src/commands/db/gen-dbschema/helper/schema-conversion.ts
+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 };
+}
 
-// src/commands/db/gen-dbschema/utils/identifier.ts
+// src/commands/db/gen-dbschema/helper/table-rename.ts
 import { pinyin } from "pinyin-pro";
-function toAsciiName(name) {
-  if (!/[^\x00-\x7F]/.test(name)) {
-    return name;
-  }
-  try {
-    const transliterated = pinyin(name, { toneType: "none", type: "array" }).join("_");
-    return transliterated || name;
-  } catch {
-    return name;
+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 escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\//g, "\\/");
 }
 function toCamelCase(str) {
   const words = str.split(/[_\-\s]+/).filter(Boolean);
@@ -232,640 +242,120 @@ function sanitizeIdentifier(name) {
   }
   return sanitized;
 }
-
-// src/commands/db/gen-dbschema/transforms/ast/rename-identifiers.ts
-var PG_FACTORIES = [
-  "pgTable",
-  "pgView",
-  "pgMaterializedView",
-  "pgEnum",
-  "pgSequence",
-  // Also match schema.xxx() format (before conversion)
-  "table",
-  "view",
-  "materializedView",
-  "enum",
-  "sequence"
-];
-function extractFactoryName(initializer) {
-  if (!Node.isCallExpression(initializer)) {
-    return void 0;
-  }
-  const args = initializer.getArguments();
-  if (args.length === 0) {
-    return void 0;
-  }
-  const firstArg = args[0];
-  if (Node.isStringLiteral(firstArg)) {
-    return firstArg.getLiteralText();
-  }
-  return void 0;
-}
-function isPgFactoryCall(initializer) {
-  if (!Node.isCallExpression(initializer)) {
-    return false;
-  }
-  const expression = initializer.getExpression();
-  const exprText = expression.getText();
-  if (PG_FACTORIES.includes(exprText)) {
-    return true;
+function toAsciiName(name) {
+  if (!/[^\x00-\x7F]/.test(name)) {
+    return name;
   }
-  if (Node.isPropertyAccessExpression(expression)) {
-    const propName = expression.getName();
-    if (PG_FACTORIES.includes(propName)) {
-      return true;
-    }
+  try {
+    const transliterated = pinyin(name, { toneType: "none", type: "array" }).join("_");
+    return transliterated || name;
+  } catch (error) {
+    return name;
   }
-  return false;
 }
-function getCurrentName(decl) {
-  const name = decl.getName();
-  return name.replace(/^"|"$/g, "");
-}
-var renameIdentifiersTransform = {
-  name: "rename-identifiers",
-  transform(ctx) {
-    const { sourceFile, stats } = ctx;
-    const renames = [];
-    for (const statement of sourceFile.getStatements()) {
-      if (!Node.isVariableStatement(statement)) {
-        continue;
-      }
-      if (!statement.hasExportKeyword()) {
-        continue;
-      }
-      for (const decl of statement.getDeclarations()) {
-        const initializer = decl.getInitializer();
-        if (!initializer) {
-          continue;
-        }
-        if (!isPgFactoryCall(initializer)) {
-          continue;
-        }
-        const tableName = extractFactoryName(initializer);
-        if (!tableName) {
-          continue;
-        }
-        const currentName = getCurrentName(decl);
-        const sanitized = sanitizeIdentifier(tableName);
-        if (sanitized !== currentName) {
-          renames.push({ decl, from: currentName, to: sanitized });
-        }
-      }
-    }
-    for (const { decl, from, to } of renames.reverse()) {
-      try {
-        decl.rename(to);
-        stats.renamedIdentifiers.push({ from, to });
-      } catch (error) {
-        console.warn(`[rename-identifiers] Failed to rename "${from}" to "${to}":`, error);
-      }
-    }
-    stats.renamedIdentifiers.reverse();
-  }
-};
-
-// src/commands/db/gen-dbschema/transforms/ast/remove-pg-schema.ts
-import { Node as Node2 } from "ts-morph";
-var removePgSchemaTransform = {
-  name: "remove-pg-schema",
-  transform(ctx) {
-    const { sourceFile, stats } = ctx;
-    const statementsToRemove = [];
-    for (const statement of sourceFile.getStatements()) {
-      if (!Node2.isVariableStatement(statement)) {
-        continue;
-      }
-      for (const decl of statement.getDeclarations()) {
-        const initializer = decl.getInitializer();
-        if (!initializer || !Node2.isCallExpression(initializer)) {
-          continue;
-        }
-        const calleeText = initializer.getExpression().getText();
-        if (calleeText === "pgSchema") {
-          statementsToRemove.push(statement);
-          stats.removedPgSchemas++;
-          break;
-        }
-      }
-    }
-    for (const statement of statementsToRemove.reverse()) {
-      statement.remove();
-    }
-  }
-};
 
-// src/commands/db/gen-dbschema/transforms/ast/convert-schema-calls.ts
-import { Node as Node3 } from "ts-morph";
-var SCHEMA_METHOD_TO_PG = {
-  table: "pgTable",
-  view: "pgView",
-  materializedView: "pgMaterializedView",
-  enum: "pgEnum",
-  sequence: "pgSequence"
-};
-var convertSchemaCallsTransform = {
-  name: "convert-schema-calls",
-  transform(ctx) {
-    const { sourceFile, stats } = ctx;
-    sourceFile.forEachDescendant((node) => {
-      if (!Node3.isCallExpression(node)) {
-        return;
-      }
-      const expression = node.getExpression();
-      if (!Node3.isPropertyAccessExpression(expression)) {
-        return;
-      }
-      const objectExpr = expression.getExpression();
-      const methodName = expression.getName();
-      const pgFactoryName = SCHEMA_METHOD_TO_PG[methodName];
-      if (!pgFactoryName) {
-        return;
-      }
-      if (!Node3.isIdentifier(objectExpr)) {
-        return;
-      }
-      expression.replaceWithText(pgFactoryName);
-      stats.convertedSchemaCalls++;
-    });
-  }
-};
-
-// src/commands/db/gen-dbschema/transforms/ast/patch-defects.ts
-import { Node as Node4 } from "ts-morph";
-var patchDefectsTransform = {
-  name: "patch-defects",
-  transform(ctx) {
-    const { sourceFile, stats } = ctx;
-    sourceFile.forEachDescendant((node) => {
-      if (!Node4.isCallExpression(node)) {
-        return;
-      }
-      const expr = node.getExpression();
-      if (!Node4.isPropertyAccessExpression(expr)) {
-        return;
-      }
-      if (expr.getName() !== "default") {
-        return;
-      }
-      const args = node.getArguments();
-      if (args.length !== 1) {
-        return;
-      }
-      const arg = args[0];
-      if (Node4.isStringLiteral(arg)) {
-        const text = arg.getLiteralText();
-        if (text === "") {
-          stats.patchedDefects++;
-        }
-      }
-    });
-  }
-};
-
-// src/commands/db/gen-dbschema/transforms/ast/replace-unknown.ts
-import { Node as Node5 } from "ts-morph";
-var KNOWN_TYPE_FACTORIES = {
-  user_profile: "userProfile",
-  file_attachment: "fileAttachment"
-};
-var replaceUnknownTransform = {
-  name: "replace-unknown",
-  transform(ctx) {
-    const { sourceFile, stats } = ctx;
-    const fullText = sourceFile.getFullText();
-    sourceFile.forEachDescendant((node) => {
-      if (!Node5.isCallExpression(node)) {
-        return;
-      }
-      const expression = node.getExpression();
-      if (!Node5.isIdentifier(expression) || expression.getText() !== "unknown") {
-        return;
-      }
-      const nodeStart = node.getStart();
-      const textBefore = fullText.slice(Math.max(0, nodeStart - 500), nodeStart);
-      const lines = textBefore.split("\n");
-      let factoryName = "text";
-      let foundKnownType = false;
-      for (let i = lines.length - 1; i >= Math.max(0, lines.length - 5); i--) {
-        const line = lines[i];
-        const todoMatch = line.match(/\/\/ TODO: failed to parse database type '(?:\w+\.)?([\w_]+)(\[\])?'/);
-        if (todoMatch) {
-          const typeName = todoMatch[1];
-          if (KNOWN_TYPE_FACTORIES[typeName]) {
-            factoryName = KNOWN_TYPE_FACTORIES[typeName];
-            foundKnownType = true;
-          }
-          break;
-        }
-      }
-      expression.replaceWithText(factoryName);
-      if (foundKnownType) {
-        stats.replacedUnknown++;
+// src/commands/db/gen-dbschema/helper/custom-types.ts
+var CUSTOM_TYPE_PATTERN = /\/\/ TODO: failed to parse database type '(?:\w+\.)?(user_profile|file_attachment)(\[\])?'/;
+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 {
-        stats.fallbackToText++;
+        unmatched.push(line.trim());
+        result.push(line);
       }
-    });
-    const todoCommentRegex = /\/\/ TODO: failed to parse database type '[^']+'\s*\n/g;
-    const currentText = sourceFile.getFullText();
-    const cleanedText = currentText.replace(todoCommentRegex, "");
-    if (cleanedText !== currentText) {
-      sourceFile.replaceWithText(cleanedText);
-    }
-  }
-};
-
-// src/commands/db/gen-dbschema/transforms/ast/replace-timestamp.ts
-import { Node as Node6 } from "ts-morph";
-function checkTimestampOptions(optionsArg) {
-  let hasWithTimezone = false;
-  let hasModeString = false;
-  for (const prop of optionsArg.getProperties()) {
-    if (!Node6.isPropertyAssignment(prop)) {
       continue;
     }
-    const propName = prop.getName();
-    const initializer = prop.getInitializer();
-    if (propName === "withTimezone") {
-      if (Node6.isTrueLiteral(initializer)) {
-        hasWithTimezone = true;
-      }
-    }
-    if (propName === "mode") {
-      if (Node6.isStringLiteral(initializer) && initializer.getLiteralText() === "string") {
-        hasModeString = true;
-      }
+    if (line.includes("unknown(")) {
+      unmatched.push(line.trim());
     }
+    result.push(line);
   }
-  return hasWithTimezone && hasModeString;
+  return {
+    text: result.join("\n"),
+    replaced,
+    unmatched
+  };
 }
-var replaceTimestampTransform = {
-  name: "replace-timestamp",
-  transform(ctx) {
-    const { sourceFile, stats } = ctx;
-    const replacements = [];
-    sourceFile.forEachDescendant((node) => {
-      if (!Node6.isCallExpression(node)) {
-        return;
-      }
-      const expression = node.getExpression();
-      if (!Node6.isIdentifier(expression) || expression.getText() !== "timestamp") {
-        return;
-      }
-      const args = node.getArguments();
-      if (args.length === 2) {
-        const [fieldArg, optionsArg] = args;
-        if (!Node6.isStringLiteral(fieldArg)) {
-          return;
-        }
-        if (!Node6.isObjectLiteralExpression(optionsArg)) {
-          return;
-        }
-        if (checkTimestampOptions(optionsArg)) {
-          const quote = fieldArg.getQuoteKind() === 1 ? '"' : "'";
-          const fieldName = fieldArg.getLiteralText();
-          replacements.push({
-            node,
-            replacement: `customTimestamptz(${quote}${fieldName}${quote})`
-          });
-        }
-        return;
-      }
-      if (args.length === 1) {
-        const [optionsArg] = args;
-        if (!Node6.isObjectLiteralExpression(optionsArg)) {
-          return;
-        }
-        if (checkTimestampOptions(optionsArg)) {
-          replacements.push({
-            node,
-            replacement: "customTimestamptz()"
-          });
-        }
-        return;
-      }
-    });
-    for (const { node, replacement } of replacements.reverse()) {
-      node.replaceWithText(replacement);
-      stats.replacedTimestamp++;
-    }
-  }
-};
-
-// src/commands/db/gen-dbschema/transforms/ast/replace-default-now.ts
-import { Node as Node7 } from "ts-morph";
-var replaceDefaultNowTransform = {
-  name: "replace-default-now",
-  transform(ctx) {
-    const { sourceFile, stats } = ctx;
-    sourceFile.forEachDescendant((node) => {
-      if (!Node7.isCallExpression(node)) {
-        return;
-      }
-      const expression = node.getExpression();
-      if (!Node7.isPropertyAccessExpression(expression)) {
-        return;
-      }
-      if (expression.getName() !== "defaultNow") {
-        return;
-      }
-      if (node.getArguments().length !== 0) {
-        return;
-      }
-      const objectExpr = expression.getExpression();
-      const objectText = objectExpr.getText();
-      node.replaceWithText(`${objectText}.default(sql\`CURRENT_TIMESTAMP\`)`);
-      stats.replacedDefaultNow++;
-    });
+function replaceFollowingUnknown(nextLine, factory) {
+  if (!nextLine || !nextLine.includes("unknown(")) {
+    return void 0;
   }
-};
+  return nextLine.replace("unknown(", `${factory}(`);
+}
 
-// src/commands/db/gen-dbschema/transforms/ast/remove-system-fields.ts
-import { Node as Node8 } from "ts-morph";
-var SYSTEM_TO_BUSINESS = {
-  _created_at: "created_at",
-  _created_by: "created_by",
-  _updated_at: "updated_at",
-  _updated_by: "updated_by"
-};
-var TABLE_FACTORIES = ["pgTable", "pgView", "pgMaterializedView", "table", "view", "materializedView"];
-var removeSystemFieldsTransform = {
-  name: "remove-system-fields",
-  transform(ctx) {
-    const { sourceFile, stats } = ctx;
-    sourceFile.forEachDescendant((node) => {
-      if (!Node8.isCallExpression(node)) {
-        return;
-      }
-      const expression = node.getExpression();
-      let factoryName = "";
-      if (Node8.isIdentifier(expression)) {
-        factoryName = expression.getText();
-      } else if (Node8.isPropertyAccessExpression(expression)) {
-        factoryName = expression.getName();
-      }
-      if (!TABLE_FACTORIES.includes(factoryName)) {
-        return;
-      }
-      const args = node.getArguments();
-      if (args.length < 2) {
-        return;
-      }
-      const columnsArg = args[1];
-      if (!Node8.isObjectLiteralExpression(columnsArg)) {
-        return;
-      }
-      const fieldNames = /* @__PURE__ */ new Set();
-      const properties = columnsArg.getProperties();
-      for (const prop of properties) {
-        if (!Node8.isPropertyAssignment(prop)) {
-          continue;
-        }
-        const nameNode = prop.getNameNode();
-        let fieldName = "";
-        if (Node8.isStringLiteral(nameNode)) {
-          fieldName = nameNode.getLiteralText();
-        } else if (Node8.isIdentifier(nameNode)) {
-          fieldName = nameNode.getText();
-        }
-        if (fieldName) {
-          fieldNames.add(fieldName);
-        }
-      }
-      const propsToRemove = [];
-      for (const prop of properties) {
-        if (!Node8.isPropertyAssignment(prop)) {
-          continue;
-        }
-        const nameNode = prop.getNameNode();
-        let fieldName = "";
-        if (Node8.isStringLiteral(nameNode)) {
-          fieldName = nameNode.getLiteralText();
-        } else if (Node8.isIdentifier(nameNode)) {
-          fieldName = nameNode.getText();
-        }
-        const businessField = SYSTEM_TO_BUSINESS[fieldName];
-        if (businessField && fieldNames.has(businessField)) {
-          propsToRemove.push(prop);
-        }
-      }
-      for (const prop of propsToRemove) {
-        const leadingCommentRanges = prop.getLeadingCommentRanges();
-        for (const comment of leadingCommentRanges) {
-          const commentText = comment.getText();
-          if (commentText.includes("System field:")) {
-          }
-        }
-        prop.remove();
-        stats.removedSystemFields++;
-      }
-    });
+// src/commands/db/gen-dbschema/helper/imports.ts
+import fs from "fs";
+import { fileURLToPath } from "url";
+function tweakImports(source) {
+  const importRegex = /import \{([^}]*)\} from "drizzle-orm\/pg-core";?/;
+  const match = source.match(importRegex);
+  if (!match) {
+    return source;
   }
-};
-
-// src/commands/db/gen-dbschema/transforms/ast/tweak-imports.ts
-var REMOVE_IMPORTS = ["pgSchema", "customType"];
-var PG_FACTORIES2 = ["pgTable", "pgView", "pgMaterializedView", "pgEnum", "pgSequence"];
-var tweakImportsTransform = {
-  name: "tweak-imports",
-  transform(ctx) {
-    const { sourceFile, stats } = ctx;
-    const fullText = sourceFile.getFullText();
-    const imports = sourceFile.getImportDeclarations();
-    const pgCoreImport = imports.find((imp) => {
-      const moduleSpec = imp.getModuleSpecifierValue();
-      return moduleSpec === "drizzle-orm/pg-core";
-    });
-    if (!pgCoreImport) {
-      return;
-    }
-    const namedImports = pgCoreImport.getNamedImports();
-    const currentImports = namedImports.map((ni) => ni.getName());
-    const toRemove = [];
-    const toAdd = [];
-    for (const identifier of REMOVE_IMPORTS) {
-      if (currentImports.includes(identifier)) {
-        toRemove.push(identifier);
-        stats.removedImports.push(identifier);
-      }
-    }
-    if (currentImports.includes("timestamp")) {
-      const timestampUsed = /timestamp\s*\(/.test(fullText);
-      if (!timestampUsed) {
-        toRemove.push("timestamp");
-        stats.removedImports.push("timestamp");
-      }
-    }
-    for (const factory of PG_FACTORIES2) {
-      if (!currentImports.includes(factory)) {
-        const pattern = new RegExp(`${factory}\\s*\\(`);
-        if (pattern.test(fullText)) {
-          toAdd.push(factory);
-          stats.addedImports.push(factory);
-        }
-      }
-    }
-    for (const identifier of toRemove) {
-      const freshNamedImports = pgCoreImport.getNamedImports();
-      const namedImport = freshNamedImports.find((ni) => ni.getName() === identifier);
-      if (namedImport) {
-        namedImport.remove();
-      }
-    }
-    for (const identifier of toAdd) {
-      pgCoreImport.addNamedImport(identifier);
-    }
-    if (fullText.includes("sql`CURRENT_TIMESTAMP`")) {
-      const drizzleOrmImport = imports.find((imp) => {
-        const moduleSpec = imp.getModuleSpecifierValue();
-        return moduleSpec === "drizzle-orm";
-      });
-      if (!drizzleOrmImport) {
-        sourceFile.addImportDeclaration({
-          moduleSpecifier: "drizzle-orm",
-          namedImports: ["sql"]
-        });
-        stats.addedImports.push("sql");
-      } else {
-        const hasSql = drizzleOrmImport.getNamedImports().some((ni) => ni.getName() === "sql");
-        if (!hasSql) {
-          drizzleOrmImport.addNamedImport("sql");
-          stats.addedImports.push("sql");
-        }
-      }
+  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);
     }
-  }
-};
-
-// src/commands/db/gen-dbschema/transforms/ast/index.ts
-var defaultTransforms = [
-  patchDefectsTransform,
-  // #2 Fix syntax errors first
-  removePgSchemaTransform,
-  // #3 Remove pgSchema declarations
-  convertSchemaCallsTransform,
-  // #4 Convert schema.xxx() to pgXxx()
-  renameIdentifiersTransform,
-  // #5+#6 Rename identifiers (auto-updates refs)
-  replaceUnknownTransform,
-  // #7 Replace unknown types
-  replaceTimestampTransform,
-  // #8 Replace timestamp
-  replaceDefaultNowTransform,
-  // #9 Replace .defaultNow()
-  removeSystemFieldsTransform,
-  // #10 Remove conflicting system fields
-  tweakImportsTransform
-  // #12 Adjust imports
-];
-
-// src/commands/db/gen-dbschema/transforms/text/patch-defects.ts
-function patchDefects(source) {
-  let fixed = 0;
-  const renamedQuotedExports = [];
-  let text = source;
-  text = text.replace(/\.default\('\)/g, () => {
-    fixed += 1;
-    return `.default('')`;
-  });
-  const quotedExportPattern = /export const\s+"([^"]+)"\s*=/g;
-  text = text.replace(quotedExportPattern, (match, quotedName) => {
-    const sanitized = sanitizeIdentifier(quotedName);
-    renamedQuotedExports.push({ from: quotedName, to: sanitized });
-    fixed += 1;
-    return `export const ${sanitized} =`;
+    return true;
   });
-  for (const { from, to } of renamedQuotedExports) {
-    const escaped = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const callPattern = new RegExp(`"${escaped}"\\s*\\(`, "g");
-    text = text.replace(callPattern, `${to}(`);
-    const dotPattern = new RegExp(`"${escaped}"\\s*\\.`, "g");
-    text = text.replace(dotPattern, `${to}.`);
+  if (source.includes("pgTable(") && !filteredIdentifiers.includes("pgTable")) {
+    filteredIdentifiers.push("pgTable");
   }
-  return { text, fixed, renamedQuotedExports };
-}
-
-// src/commands/db/gen-dbschema/transforms/text/header.ts
-var ESLINT_DISABLE = "/* eslint-disable */";
-var HEADER_COMMENT = "/** auto generated, do not edit */";
-var FULL_HEADER = `${ESLINT_DISABLE}
-${HEADER_COMMENT}`;
-function ensureHeader(source) {
-  let trimmed = source;
-  const headerPatterns = [
-    /^\/\*\s*eslint-disable\s*\*\/\s*\n?/,
-    /^\/\*\*\s*auto generated[^*]*\*\/\s*\n?/
-  ];
-  for (const pattern of headerPatterns) {
-    while (pattern.test(trimmed)) {
-      trimmed = trimmed.replace(pattern, "");
-    }
+  if (source.includes("pgView(") && !filteredIdentifiers.includes("pgView")) {
+    filteredIdentifiers.push("pgView");
   }
-  trimmed = trimmed.trimStart();
-  return `${FULL_HEADER}
-${trimmed}`;
-}
-
-// src/commands/db/gen-dbschema/transforms/text/system-comments.ts
-var SYSTEM_FIELD_COMMENTS = {
-  _created_at: "Creation time",
-  _created_by: "Creator",
-  _updated_at: "Update time",
-  _updated_by: "Updater"
-};
-function addSystemFieldComments(source) {
-  const lines = source.split("\n");
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i];
-    const entry = Object.entries(SYSTEM_FIELD_COMMENTS).find(
-      ([key]) => line.includes(`"${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;
+  if (source.includes("pgMaterializedView(") && !filteredIdentifiers.includes("pgMaterializedView")) {
+    filteredIdentifiers.push("pgMaterializedView");
   }
-  return lines.join("\n");
+  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);
 }
-
-// src/commands/db/gen-dbschema/transforms/text/inline-types.ts
-import fs from "fs";
-import { fileURLToPath } from "url";
 function inlineCustomTypes(source) {
-  let text = source.replace(/import \{[^}]*\} from ["']\.\/types["'];?\n*/g, "");
+  const text = source.replace(/import \{[^}]*\} from ["']\.\/types["'];?\n*/g, "");
   const templatePath = resolveTemplateTypesPath();
   if (!templatePath) {
-    console.warn("[text/inline-types] Template types file not found.");
+    console.warn("[postprocess-drizzle-schema] Template types file not found.");
     return text;
   }
-  const templateContent = fs.readFileSync(templatePath, "utf8");
-  return inlineFromTemplate(text, templateContent);
+  return inlineFromTemplateContent(text, fs.readFileSync(templatePath, "utf8"));
 }
-function inlineFromTemplate(source, templateContent) {
+function inlineFromTemplateContent(text, templateContent) {
   const typeDefinitions = templateContent.replace(/^import\s+.*;\r?\n*/gm, "").trim();
-  let text = source;
   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) {
+  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 = `${FULL_HEADER}
+  const headerPrefix = `${HEADER_COMMENT}
 `;
   let insertionPoint = 0;
   if (text.startsWith(headerPrefix)) {
@@ -899,8 +389,8 @@ function ensureImportIdentifier(source, packageName, identifier) {
 }
 function resolveTemplateTypesPath() {
   const candidates = [
-    new URL("../../template/types.ts", import.meta.url),
-    new URL("../template/types.ts", import.meta.url)
+    new URL("../template/types.ts", import.meta.url),
+    new URL("./gen-dbschema-template/types.ts", import.meta.url)
   ];
   for (const url of candidates) {
     const p = fileURLToPath(url);
@@ -911,9 +401,131 @@ function resolveTemplateTypesPath() {
   return void 0;
 }
 
-// src/commands/db/gen-dbschema/transforms/text/table-aliases.ts
+// src/commands/db/gen-dbschema/helper/system-fields.ts
+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 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++;
+        if (char === "}") bracketDepth--;
+      }
+      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++) {
+          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");
+}
+
+// src/commands/db/gen-dbschema/helper/patch-helper.ts
+function patchDrizzleKitDefects(source) {
+  let fixed = 0;
+  const text = source.replace(/\.default\('\)/g, () => {
+    fixed += 1;
+    return `.default('')`;
+  });
+  return { text, fixed };
+}
+
+// src/commands/db/gen-dbschema/helper/timestamp-replacement.ts
+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 };
+}
+
+// src/commands/db/gen-dbschema/helper/appendTableAliases.ts
 var TABLE_ALIAS_MARKER = "// table aliases";
-function generateTableAliases(source) {
+function appendTableAliases(source) {
   const markerIndex = source.indexOf(`
 ${TABLE_ALIAS_MARKER}`);
   const base = markerIndex === -1 ? source : source.slice(0, markerIndex);
@@ -935,100 +547,62 @@ ${aliasLines}
 `;
 }
 
-// src/commands/db/gen-dbschema/transforms/text/format.ts
-function formatSource(source) {
-  let text = source;
-  text = text.replace(/\r\n/g, "\n");
-  text = text.replace(/\n{3,}/g, "\n\n");
-  if (!text.endsWith("\n")) {
-    text += "\n";
-  }
-  return text;
-}
-
 // src/commands/db/gen-dbschema/postprocess.ts
-function postprocessSchema(rawSource) {
-  const patchResult = patchDefects(rawSource);
-  let source = patchResult.text;
-  const { sourceFile } = parseSource(source);
-  const astStats = applyTransforms(sourceFile, defaultTransforms);
-  formatSourceFile(sourceFile);
-  source = printSourceFile(sourceFile);
-  source = ensureHeader(source);
-  source = addSystemFieldComments(source);
-  source = inlineCustomTypes(source);
-  source = generateTableAliases(source);
-  source = formatSource(source);
-  return {
-    source,
-    astStats,
-    patchedDefects: patchResult.fixed
-  };
-}
-function logStats(result, prefix = "[postprocess]") {
-  const { astStats, patchedDefects } = result;
-  if (patchedDefects > 0) {
-    console.info(`${prefix} Patched ${patchedDefects} syntax defects`);
-  }
-  if (astStats.removedPgSchemas > 0) {
-    console.info(`${prefix} Removed ${astStats.removedPgSchemas} pgSchema declarations`);
-  }
-  if (astStats.convertedSchemaCalls > 0) {
-    console.info(`${prefix} Converted ${astStats.convertedSchemaCalls} schema.xxx() calls`);
-  }
-  if (astStats.renamedIdentifiers.length > 0) {
-    console.info(`${prefix} Renamed ${astStats.renamedIdentifiers.length} identifiers:`);
-    for (const { from, to } of astStats.renamedIdentifiers) {
-      console.info(`${prefix}   ${from} -> ${to}`);
-    }
-  }
-  if (astStats.replacedUnknown > 0) {
-    console.info(`${prefix} Replaced ${astStats.replacedUnknown} unknown types with custom types`);
-  }
-  if (astStats.fallbackToText > 0) {
-    console.info(`${prefix} Replaced ${astStats.fallbackToText} unknown types with text (fallback)`);
-  }
-  if (astStats.unmatchedUnknown.length > 0) {
-    console.warn(`${prefix} Unmatched unknown types:`);
-    for (const line of astStats.unmatchedUnknown) {
-      console.warn(`${prefix}   ${line}`);
-    }
-  }
-  if (astStats.replacedTimestamp > 0) {
-    console.info(`${prefix} Replaced ${astStats.replacedTimestamp} timestamp with customTimestamptz`);
-  }
-  if (astStats.replacedDefaultNow > 0) {
-    console.info(`${prefix} Replaced ${astStats.replacedDefaultNow} .defaultNow() calls`);
-  }
-  if (astStats.removedSystemFields > 0) {
-    console.info(`${prefix} Removed ${astStats.removedSystemFields} conflicting system fields`);
-  }
-  if (astStats.addedImports.length > 0) {
-    console.info(`${prefix} Added imports: ${astStats.addedImports.join(", ")}`);
-  }
-  if (astStats.removedImports.length > 0) {
-    console.info(`${prefix} Removed imports: ${astStats.removedImports.join(", ")}`);
-  }
-}
-
-// src/commands/db/gen-dbschema/index.ts
 function postprocessDrizzleSchema(targetPath) {
   const resolvedPath = path.resolve(targetPath);
-  if (!fs3.existsSync(resolvedPath)) {
+  if (!fs2.existsSync(resolvedPath)) {
     console.warn(`[postprocess-drizzle-schema] File not found: ${resolvedPath}`);
     return void 0;
   }
-  const rawSource = fs3.readFileSync(resolvedPath, "utf8");
-  const result = postprocessSchema(rawSource);
-  fs3.writeFileSync(resolvedPath, result.source, "utf8");
-  logStats(result, "[postprocess-drizzle-schema]");
+  let text = fs2.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);
+  fs2.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: result.astStats.replacedUnknown,
-    fallbackToText: result.astStats.fallbackToText,
-    unmatchedUnknown: result.astStats.unmatchedUnknown,
-    patchedDefects: result.patchedDefects,
-    replacedTimestamps: result.astStats.replacedTimestamp,
-    replacedDefaultNow: result.astStats.replacedDefaultNow
+    replacedUnknown: replacement.replaced,
+    unmatchedUnknown: replacement.unmatched,
+    patchedDefects: patchResult.fixed,
+    replacedTimestamps: timestampReplacement.replaced,
+    replacedDefaultNow: defaultNowReplacement.replaced
   };
 }
 
@@ -1450,10 +1024,10 @@ export class ${className}Module {}
 }
 
 // src/commands/db/gen-nest-resource/schema-parser.ts
-import { Project as Project2, Node as Node9 } from "ts-morph";
+import { Project, Node } from "ts-morph";
 var DrizzleSchemaParser = class {
   constructor(projectOptions) {
-    this.project = new Project2(projectOptions);
+    this.project = new Project(projectOptions);
   }
   parseSchemaFile(filePath) {
     const sourceFile = this.project.addSourceFileAtPath(filePath);
@@ -1463,7 +1037,7 @@ var DrizzleSchemaParser = class {
       const declarations = statement.getDeclarations();
       for (const declaration of declarations) {
         const initializer = declaration.getInitializer();
-        if (initializer && Node9.isCallExpression(initializer)) {
+        if (initializer && Node.isCallExpression(initializer)) {
           const expression = initializer.getExpression();
           if (expression.getText() === "pgTable") {
             const tableInfo = this.parsePgTable(
@@ -1486,13 +1060,13 @@ var DrizzleSchemaParser = class {
     }
     const tableName = args[0].getText().replace(/['"]/g, "");
     const fieldsArg = args[1];
-    if (!Node9.isObjectLiteralExpression(fieldsArg)) {
+    if (!Node.isObjectLiteralExpression(fieldsArg)) {
       return null;
     }
     const fields = [];
     const properties = fieldsArg.getProperties();
     for (const prop of properties) {
-      if (Node9.isPropertyAssignment(prop)) {
+      if (Node.isPropertyAssignment(prop)) {
         const fieldName = prop.getName();
         const initializer = prop.getInitializer();
         const leadingComments = prop.getLeadingCommentRanges();
@@ -1500,7 +1074,7 @@ var DrizzleSchemaParser = class {
         if (leadingComments.length > 0) {
           comment = leadingComments.map((c) => c.getText()).join("\n").replace(/\/\//g, "").trim();
         }
-        if (initializer && Node9.isCallExpression(initializer)) {
+        if (initializer && Node.isCallExpression(initializer)) {
           const fieldInfo = this.parseField(fieldName, initializer, comment);
           fields.push(fieldInfo);
         }
@@ -1532,10 +1106,10 @@ var DrizzleSchemaParser = class {
   parseBaseType(callExpr, fieldInfo) {
     let current = callExpr;
     let baseCall = null;
-    while (Node9.isCallExpression(current)) {
+    while (Node.isCallExpression(current)) {
       baseCall = current;
       const expression2 = current.getExpression();
-      if (Node9.isPropertyAccessExpression(expression2)) {
+      if (Node.isPropertyAccessExpression(expression2)) {
         current = expression2.getExpression();
       } else {
         break;
@@ -1546,7 +1120,7 @@ var DrizzleSchemaParser = class {
     }
     const expression = baseCall.getExpression();
     let typeName = "";
-    if (Node9.isPropertyAccessExpression(expression)) {
+    if (Node.isPropertyAccessExpression(expression)) {
       typeName = expression.getName();
     } else {
       typeName = expression.getText();
@@ -1555,25 +1129,25 @@ var DrizzleSchemaParser = class {
     const args = baseCall.getArguments();
     if (args.length > 0) {
       const firstArg = args[0];
-      if (Node9.isStringLiteral(firstArg)) {
+      if (Node.isStringLiteral(firstArg)) {
         fieldInfo.columnName = firstArg.getLiteralText();
-      } else if (Node9.isObjectLiteralExpression(firstArg)) {
+      } else if (Node.isObjectLiteralExpression(firstArg)) {
         this.parseTypeConfig(firstArg, fieldInfo);
-      } else if (Node9.isArrayLiteralExpression(firstArg)) {
+      } else if (Node.isArrayLiteralExpression(firstArg)) {
         fieldInfo.enumValues = firstArg.getElements().map((el) => el.getText().replace(/['"]/g, ""));
       }
     }
-    if (args.length > 1 && Node9.isObjectLiteralExpression(args[1])) {
+    if (args.length > 1 && Node.isObjectLiteralExpression(args[1])) {
       this.parseTypeConfig(args[1], fieldInfo);
     }
   }
   parseTypeConfig(objLiteral, fieldInfo) {
-    if (!Node9.isObjectLiteralExpression(objLiteral)) {
+    if (!Node.isObjectLiteralExpression(objLiteral)) {
       return;
     }
     const properties = objLiteral.getProperties();
     for (const prop of properties) {
-      if (Node9.isPropertyAssignment(prop)) {
+      if (Node.isPropertyAssignment(prop)) {
         const propName = prop.getName();
         const value = prop.getInitializer()?.getText();
         switch (propName) {
@@ -1605,9 +1179,9 @@ var DrizzleSchemaParser = class {
   }
   parseCallChain(callExpr, fieldInfo) {
     let current = callExpr;
-    while (Node9.isCallExpression(current)) {
+    while (Node.isCallExpression(current)) {
       const expression = current.getExpression();
-      if (Node9.isPropertyAccessExpression(expression)) {
+      if (Node.isPropertyAccessExpression(expression)) {
         const methodName = expression.getName();
         const args = current.getArguments();
         switch (methodName) {
@@ -1704,7 +1278,7 @@ var require2 = createRequire(import.meta.url);
 async function run(options = {}) {
   let exitCode = 0;
   const envPath2 = path2.resolve(process.cwd(), ".env");
-  if (fs4.existsSync(envPath2)) {
+  if (fs3.existsSync(envPath2)) {
     loadEnv({ path: envPath2 });
     console.log("[gen-db-schema] \u2713 Loaded .env file");
   }
@@ -1724,7 +1298,7 @@ async function run(options = {}) {
     path2.resolve(__dirname2, "../../config/drizzle.config.js"),
     path2.resolve(__dirname2, "../../../dist/config/drizzle.config.js")
   ];
-  const configPath = configPathCandidates.find((p) => fs4.existsSync(p));
+  const configPath = configPathCandidates.find((p) => fs3.existsSync(p));
   console.log("[gen-db-schema] Using drizzle config from:", configPath ?? "(not found)");
   if (!configPath) {
     console.error("[gen-db-schema] Error: drizzle config not found in CLI package");
@@ -1736,8 +1310,8 @@ async function run(options = {}) {
     let lastDir = null;
     while (currentDir !== lastDir) {
       const pkgJsonPath = path2.join(currentDir, "package.json");
-      if (fs4.existsSync(pkgJsonPath)) {
-        const pkgJsonRaw = fs4.readFileSync(pkgJsonPath, "utf8");
+      if (fs3.existsSync(pkgJsonPath)) {
+        const pkgJsonRaw = fs3.readFileSync(pkgJsonPath, "utf8");
         const pkgJson = JSON.parse(pkgJsonRaw);
         if (pkgJson.name === "drizzle-kit") {
           const binField = pkgJson.bin;
@@ -1772,7 +1346,7 @@ async function run(options = {}) {
       throw new Error(`drizzle-kit introspect failed with status ${result.status}`);
     }
     const generatedSchema = path2.join(OUT_DIR, "schema.ts");
-    if (!fs4.existsSync(generatedSchema)) {
+    if (!fs3.existsSync(generatedSchema)) {
       console.error("[gen-db-schema] schema.ts not generated");
       throw new Error("drizzle-kit introspect failed to generate schema.ts");
     }
@@ -1781,8 +1355,8 @@ async function run(options = {}) {
       console.warn("[gen-db-schema] Unmatched custom types detected:", stats.unmatchedUnknown);
     }
     console.log("[gen-db-schema] \u2713 Postprocessed schema");
-    fs4.mkdirSync(path2.dirname(SCHEMA_FILE), { recursive: true });
-    fs4.copyFileSync(generatedSchema, SCHEMA_FILE);
+    fs3.mkdirSync(path2.dirname(SCHEMA_FILE), { recursive: true });
+    fs3.copyFileSync(generatedSchema, SCHEMA_FILE);
     console.log(`[gen-db-schema] \u2713 Copied to ${outputPath}`);
     try {
       if (options.enableNestModuleGenerate) {
@@ -1803,8 +1377,8 @@ async function run(options = {}) {
     console.error("[gen-db-schema] Failed:", err instanceof Error ? err.message : String(err));
     exitCode = 1;
   } finally {
-    if (fs4.existsSync(OUT_DIR)) {
-      fs4.rmSync(OUT_DIR, { recursive: true, force: true });
+    if (fs3.existsSync(OUT_DIR)) {
+      fs3.rmSync(OUT_DIR, { recursive: true, force: true });
     }
     process.exit(exitCode);
   }
@@ -1823,7 +1397,7 @@ var genDbSchemaCommand = {
 
 // src/commands/sync/run.handler.ts
 import path4 from "path";
-import fs6 from "fs";
+import fs5 from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/config/sync.ts
@@ -1887,14 +1461,14 @@ function genSyncConfig(perms = {}) {
 }
 
 // src/utils/file-ops.ts
-import fs5 from "fs";
+import fs4 from "fs";
 import path3 from "path";
 function removeLineFromFile(filePath, pattern) {
-  if (!fs5.existsSync(filePath)) {
+  if (!fs4.existsSync(filePath)) {
     console.log(`[fullstack-cli] \u25CB ${path3.basename(filePath)} (not found)`);
     return false;
   }
-  const content = fs5.readFileSync(filePath, "utf-8");
+  const content = fs4.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const trimmedPattern = pattern.trim();
   const filteredLines = lines.filter((line) => line.trim() !== trimmedPattern);
@@ -1902,7 +1476,7 @@ function removeLineFromFile(filePath, pattern) {
     console.log(`[fullstack-cli] \u25CB ${path3.basename(filePath)} (pattern not found: ${pattern})`);
     return false;
   }
-  fs5.writeFileSync(filePath, filteredLines.join("\n"));
+  fs4.writeFileSync(filePath, filteredLines.join("\n"));
   console.log(`[fullstack-cli] \u2713 ${path3.basename(filePath)} (removed: ${pattern})`);
   return true;
 }
@@ -1918,7 +1492,7 @@ async function run2(options) {
     process.exit(0);
   }
   const userPackageJson = path4.join(userProjectRoot, "package.json");
-  if (!fs6.existsSync(userPackageJson)) {
+  if (!fs5.existsSync(userPackageJson)) {
     console.log("[fullstack-cli] Skip syncing (not a valid npm project)");
     process.exit(0);
   }
@@ -1964,7 +1538,7 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
   }
   const srcPath = path4.join(pluginRoot, rule.from);
   const destPath = path4.join(userProjectRoot, rule.to);
-  if (!fs6.existsSync(srcPath)) {
+  if (!fs5.existsSync(srcPath)) {
     console.warn(`[fullstack-cli] Source not found: ${rule.from}`);
     return;
   }
@@ -1982,31 +1556,31 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
 }
 function syncFile(src, dest, overwrite = true) {
   const destDir = path4.dirname(dest);
-  if (!fs6.existsSync(destDir)) {
-    fs6.mkdirSync(destDir, { recursive: true });
+  if (!fs5.existsSync(destDir)) {
+    fs5.mkdirSync(destDir, { recursive: true });
   }
-  if (fs6.existsSync(dest) && !overwrite) {
+  if (fs5.existsSync(dest) && !overwrite) {
     console.log(`[fullstack-cli] \u25CB ${path4.basename(dest)} (skipped, already exists)`);
     return;
   }
-  fs6.copyFileSync(src, dest);
+  fs5.copyFileSync(src, dest);
   console.log(`[fullstack-cli] \u2713 ${path4.basename(dest)}`);
 }
 function syncDirectory(src, dest, overwrite = true) {
-  if (!fs6.existsSync(dest)) {
-    fs6.mkdirSync(dest, { recursive: true });
+  if (!fs5.existsSync(dest)) {
+    fs5.mkdirSync(dest, { recursive: true });
   }
-  const files = fs6.readdirSync(src);
+  const files = fs5.readdirSync(src);
   let count = 0;
   files.forEach((file) => {
     const srcFile = path4.join(src, file);
     const destFile = path4.join(dest, file);
-    const stats = fs6.statSync(srcFile);
+    const stats = fs5.statSync(srcFile);
     if (stats.isDirectory()) {
       syncDirectory(srcFile, destFile, overwrite);
     } else {
-      if (overwrite || !fs6.existsSync(destFile)) {
-        fs6.copyFileSync(srcFile, destFile);
+      if (overwrite || !fs5.existsSync(destFile)) {
+        fs5.copyFileSync(srcFile, destFile);
         console.log(`[fullstack-cli] \u2713 ${path4.relative(dest, destFile)}`);
         count++;
       }
@@ -2017,28 +1591,28 @@ function syncDirectory(src, dest, overwrite = true) {
   }
 }
 function appendToFile(src, dest) {
-  const content = fs6.readFileSync(src, "utf-8");
+  const content = fs5.readFileSync(src, "utf-8");
   let existingContent = "";
-  if (fs6.existsSync(dest)) {
-    existingContent = fs6.readFileSync(dest, "utf-8");
+  if (fs5.existsSync(dest)) {
+    existingContent = fs5.readFileSync(dest, "utf-8");
   }
   if (existingContent.includes(content.trim())) {
     console.log(`[fullstack-cli] \u25CB ${path4.basename(dest)} (already contains content)`);
     return;
   }
-  fs6.appendFileSync(dest, content);
+  fs5.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 = path4.join(projectRoot, "scripts");
-      if (fs6.existsSync(scriptsDir)) {
-        const files = fs6.readdirSync(scriptsDir);
+      if (fs5.existsSync(scriptsDir)) {
+        const files = fs5.readdirSync(scriptsDir);
         files.forEach((file) => {
           if (file.endsWith(".sh")) {
             const filePath = path4.join(scriptsDir, file);
-            fs6.chmodSync(filePath, mode);
+            fs5.chmodSync(filePath, mode);
           }
         });
       }
@@ -2046,16 +1620,16 @@ function setPermissions(permissions, projectRoot) {
   }
 }
 function deleteFile(filePath) {
-  if (fs6.existsSync(filePath)) {
-    fs6.unlinkSync(filePath);
+  if (fs5.existsSync(filePath)) {
+    fs5.unlinkSync(filePath);
     console.log(`[fullstack-cli] \u2713 ${path4.basename(filePath)} (deleted)`);
   } else {
     console.log(`[fullstack-cli] \u25CB ${path4.basename(filePath)} (not found)`);
   }
 }
 function deleteDirectory(dirPath) {
-  if (fs6.existsSync(dirPath)) {
-    fs6.rmSync(dirPath, { recursive: true });
+  if (fs5.existsSync(dirPath)) {
+    fs5.rmSync(dirPath, { recursive: true });
     console.log(`[fullstack-cli] \u2713 ${path4.basename(dirPath)} (deleted)`);
   } else {
     console.log(`[fullstack-cli] \u25CB ${path4.basename(dirPath)} (not found)`);
@@ -2074,7 +1648,7 @@ var syncCommand = {
 };
 
 // src/commands/action-plugin/utils.ts
-import fs7 from "fs";
+import fs6 from "fs";
 import path5 from "path";
 import { spawnSync as spawnSync2, execSync } from "child_process";
 function parsePluginName(input) {
@@ -2100,11 +1674,11 @@ function getPluginPath(pluginName) {
 }
 function readPackageJson() {
   const pkgPath = getPackageJsonPath();
-  if (!fs7.existsSync(pkgPath)) {
+  if (!fs6.existsSync(pkgPath)) {
     throw new Error("package.json not found in current directory");
   }
   try {
-    const content = fs7.readFileSync(pkgPath, "utf-8");
+    const content = fs6.readFileSync(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
     throw new Error("Failed to parse package.json");
@@ -2112,7 +1686,7 @@ function readPackageJson() {
 }
 function writePackageJson(pkg2) {
   const pkgPath = getPackageJsonPath();
-  fs7.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs6.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 function readActionPlugins() {
   const pkg2 = readPackageJson();
@@ -2146,11 +1720,11 @@ function npmInstall(tgzPath) {
 }
 function getPackageVersion(pluginName) {
   const pkgJsonPath = path5.join(getPluginPath(pluginName), "package.json");
-  if (!fs7.existsSync(pkgJsonPath)) {
+  if (!fs6.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs7.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs6.readFileSync(pkgJsonPath, "utf-8");
     const pkg2 = JSON.parse(content);
     return pkg2.version || null;
   } catch {
@@ -2159,11 +1733,11 @@ function getPackageVersion(pluginName) {
 }
 function readPluginPackageJson(pluginPath) {
   const pkgJsonPath = path5.join(pluginPath, "package.json");
-  if (!fs7.existsSync(pkgJsonPath)) {
+  if (!fs6.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs7.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs6.readFileSync(pkgJsonPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -2173,34 +1747,34 @@ function extractTgzToNodeModules(tgzPath, pluginName) {
   const nodeModulesPath = path5.join(getProjectRoot(), "node_modules");
   const targetDir = path5.join(nodeModulesPath, pluginName);
   const scopeDir = path5.dirname(targetDir);
-  if (!fs7.existsSync(scopeDir)) {
-    fs7.mkdirSync(scopeDir, { recursive: true });
+  if (!fs6.existsSync(scopeDir)) {
+    fs6.mkdirSync(scopeDir, { recursive: true });
   }
-  if (fs7.existsSync(targetDir)) {
-    fs7.rmSync(targetDir, { recursive: true });
+  if (fs6.existsSync(targetDir)) {
+    fs6.rmSync(targetDir, { recursive: true });
   }
   const tempDir = path5.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
-  if (fs7.existsSync(tempDir)) {
-    fs7.rmSync(tempDir, { recursive: true });
+  if (fs6.existsSync(tempDir)) {
+    fs6.rmSync(tempDir, { recursive: true });
   }
-  fs7.mkdirSync(tempDir, { recursive: true });
+  fs6.mkdirSync(tempDir, { recursive: true });
   try {
     execSync(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
     const extractedDir = path5.join(tempDir, "package");
-    if (fs7.existsSync(extractedDir)) {
-      fs7.renameSync(extractedDir, targetDir);
+    if (fs6.existsSync(extractedDir)) {
+      fs6.renameSync(extractedDir, targetDir);
     } else {
-      const files = fs7.readdirSync(tempDir);
+      const files = fs6.readdirSync(tempDir);
       if (files.length === 1) {
-        fs7.renameSync(path5.join(tempDir, files[0]), targetDir);
+        fs6.renameSync(path5.join(tempDir, files[0]), targetDir);
       } else {
         throw new Error("Unexpected tgz structure");
       }
     }
     return targetDir;
   } finally {
-    if (fs7.existsSync(tempDir)) {
-      fs7.rmSync(tempDir, { recursive: true });
+    if (fs6.existsSync(tempDir)) {
+      fs6.rmSync(tempDir, { recursive: true });
     }
   }
 }
@@ -2212,7 +1786,7 @@ function checkMissingPeerDeps(peerDeps) {
   const nodeModulesPath = path5.join(getProjectRoot(), "node_modules");
   for (const [depName, _version] of Object.entries(peerDeps)) {
     const depPath = path5.join(nodeModulesPath, depName);
-    if (!fs7.existsSync(depPath)) {
+    if (!fs6.existsSync(depPath)) {
       missing.push(depName);
     }
   }
@@ -2236,15 +1810,15 @@ function installMissingDeps(deps) {
 }
 function removePluginDirectory(pluginName) {
   const pluginPath = getPluginPath(pluginName);
-  if (fs7.existsSync(pluginPath)) {
-    fs7.rmSync(pluginPath, { recursive: true });
+  if (fs6.existsSync(pluginPath)) {
+    fs6.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 fs8 from "fs";
+import fs7 from "fs";
 import path6 from "path";
 
 // src/utils/http-client.ts
@@ -2258,13 +1832,10 @@ function getHttpClient() {
         enabled: true
       }
     });
-    const canaryEnv = process.env.FORCE_FRAMEWORK_CLI_CANARY_ENV;
-    if (canaryEnv) {
-      clientInstance.interceptors.request.use((req) => {
-        req.headers["x-tt-env"] = canaryEnv;
-        return req;
-      });
-    }
+    clientInstance.interceptors.request.use((req) => {
+      req.headers["x-tt-env"] = "boe_miaoda_plugin";
+      return req;
+    });
   }
   return clientInstance;
 }
@@ -2337,8 +1908,8 @@ function getPluginCacheDir() {
 }
 function ensureCacheDir() {
   const cacheDir = getPluginCacheDir();
-  if (!fs8.existsSync(cacheDir)) {
-    fs8.mkdirSync(cacheDir, { recursive: true });
+  if (!fs7.existsSync(cacheDir)) {
+    fs7.mkdirSync(cacheDir, { recursive: true });
   }
 }
 function getTempFilePath(pluginKey, version) {
@@ -2361,7 +1932,7 @@ async function downloadPlugin(pluginKey, requestedVersion) {
     tgzBuffer = await downloadFromPublic(pluginInfo.downloadURL);
   }
   const tgzPath = getTempFilePath(pluginKey, pluginInfo.version);
-  fs8.writeFileSync(tgzPath, tgzBuffer);
+  fs7.writeFileSync(tgzPath, tgzBuffer);
   console.log(`[action-plugin] Downloaded to ${tgzPath} (${(tgzBuffer.length / 1024).toFixed(2)} KB)`);
   return {
     tgzPath,
@@ -2371,8 +1942,8 @@ async function downloadPlugin(pluginKey, requestedVersion) {
 }
 function cleanupTempFile(tgzPath) {
   try {
-    if (fs8.existsSync(tgzPath)) {
-      fs8.unlinkSync(tgzPath);
+    if (fs7.existsSync(tgzPath)) {
+      fs7.unlinkSync(tgzPath);
     }
   } catch {
   }
@@ -2708,7 +2279,7 @@ var actionPluginCommandGroup = {
 };
 
 // src/commands/capability/utils.ts
-import fs9 from "fs";
+import fs8 from "fs";
 import path7 from "path";
 var CAPABILITIES_DIR = "server/capabilities";
 function getProjectRoot2() {
@@ -2724,23 +2295,23 @@ function getPluginManifestPath(pluginKey) {
   return path7.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
-  return fs9.existsSync(getCapabilitiesDir());
+  return fs8.existsSync(getCapabilitiesDir());
 }
 function listCapabilityIds() {
   const dir = getCapabilitiesDir();
-  if (!fs9.existsSync(dir)) {
+  if (!fs8.existsSync(dir)) {
     return [];
   }
-  const files = fs9.readdirSync(dir);
-  return files.filter((f) => f.endsWith(".json") && f !== "capabilities.json").map((f) => f.replace(/\.json$/, ""));
+  const files = fs8.readdirSync(dir);
+  return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
 }
 function readCapability(id) {
   const filePath = getCapabilityPath(id);
-  if (!fs9.existsSync(filePath)) {
+  if (!fs8.existsSync(filePath)) {
     throw new Error(`Capability not found: ${id}`);
   }
   try {
-    const content = fs9.readFileSync(filePath, "utf-8");
+    const content = fs8.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -2751,27 +2322,15 @@ function readCapability(id) {
 }
 function readAllCapabilities() {
   const ids = listCapabilityIds();
-  const capabilities = [];
-  for (const id of ids) {
-    try {
-      const capability = readCapability(id);
-      if (!capability.pluginKey) {
-        continue;
-      }
-      capabilities.push(capability);
-    } catch {
-      continue;
-    }
-  }
-  return capabilities;
+  return ids.map((id) => readCapability(id));
 }
 function readPluginManifest(pluginKey) {
   const manifestPath = getPluginManifestPath(pluginKey);
-  if (!fs9.existsSync(manifestPath)) {
+  if (!fs8.existsSync(manifestPath)) {
     throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
-    const content = fs9.readFileSync(manifestPath, "utf-8");
+    const content = fs8.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -2945,7 +2504,7 @@ var capabilityCommandGroup = {
 };
 
 // src/commands/migration/version-manager.ts
-import fs10 from "fs";
+import fs9 from "fs";
 import path8 from "path";
 var PACKAGE_JSON = "package.json";
 var VERSION_FIELD = "migrationVersion";
@@ -2954,25 +2513,25 @@ function getPackageJsonPath2() {
 }
 function getCurrentVersion() {
   const pkgPath = getPackageJsonPath2();
-  if (!fs10.existsSync(pkgPath)) {
+  if (!fs9.existsSync(pkgPath)) {
     throw new Error("package.json not found");
   }
-  const pkg2 = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
   return pkg2[VERSION_FIELD] ?? 0;
 }
 function setCurrentVersion(version) {
   const pkgPath = getPackageJsonPath2();
-  const pkg2 = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
   pkg2[VERSION_FIELD] = version;
-  fs10.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs9.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
-import fs12 from "fs";
+import fs11 from "fs";
 import path10 from "path";
 
 // src/commands/migration/versions/v001_capability/utils.ts
-import fs11 from "fs";
+import fs10 from "fs";
 import path9 from "path";
 var CAPABILITIES_DIR2 = "server/capabilities";
 function getProjectRoot3() {
@@ -2989,30 +2548,19 @@ function getPluginManifestPath2(pluginKey) {
 function detectJsonMigration() {
   const capabilitiesDir = getCapabilitiesDir2();
   const oldFilePath = path10.join(capabilitiesDir, "capabilities.json");
-  if (!fs12.existsSync(oldFilePath)) {
+  if (!fs11.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
       reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs12.readFileSync(oldFilePath, "utf-8");
+    const content = fs11.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
-    if (!Array.isArray(parsed)) {
-      return {
-        needsMigration: false,
-        reason: "capabilities.json is not a valid array"
-      };
-    }
-    if (parsed.length === 0) {
-      return {
-        needsMigration: false,
-        reason: "capabilities.json is an empty array"
-      };
-    }
+    const capabilities = Array.isArray(parsed) ? parsed : [];
     return {
       needsMigration: true,
-      oldCapabilities: parsed,
+      oldCapabilities: capabilities,
       oldFilePath
     };
   } catch (error) {
@@ -3047,7 +2595,7 @@ async function check(options) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
-import fs13 from "fs";
+import fs12 from "fs";
 import path11 from "path";
 
 // src/commands/migration/versions/v001_capability/mapping.ts
@@ -3278,10 +2826,10 @@ function transformCapabilities(oldCapabilities) {
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
 function loadExistingCapabilities() {
   const capabilitiesDir = getCapabilitiesDir2();
-  if (!fs13.existsSync(capabilitiesDir)) {
+  if (!fs12.existsSync(capabilitiesDir)) {
     return [];
   }
-  const files = fs13.readdirSync(capabilitiesDir);
+  const files = fs12.readdirSync(capabilitiesDir);
   const capabilities = [];
   for (const file of files) {
     if (file === "capabilities.json" || !file.endsWith(".json")) {
@@ -3289,7 +2837,7 @@ function loadExistingCapabilities() {
     }
     try {
       const filePath = path11.join(capabilitiesDir, file);
-      const content = fs13.readFileSync(filePath, "utf-8");
+      const content = fs12.readFileSync(filePath, "utf-8");
       const capability = JSON.parse(content);
       if (capability.id && capability.pluginKey) {
         capabilities.push(capability);
@@ -3349,7 +2897,7 @@ async function migrateJsonFiles(options) {
   for (const cap of newCapabilities) {
     const filePath = path11.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs13.writeFileSync(filePath, content, "utf-8");
+    fs12.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
   return {
@@ -3361,11 +2909,11 @@ async function migrateJsonFiles(options) {
 }
 
 // src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
-import fs14 from "fs";
+import fs13 from "fs";
 function isPluginInstalled2(pluginKey) {
   const actionPlugins = readActionPlugins();
   const manifestPath = getPluginManifestPath2(pluginKey);
-  return fs14.existsSync(manifestPath) && !!actionPlugins[pluginKey];
+  return fs13.existsSync(manifestPath) && !!actionPlugins[pluginKey];
 }
 function detectPluginsToInstall(capabilities) {
   const pluginKeys = /* @__PURE__ */ new Set();
@@ -3442,10 +2990,10 @@ async function installPlugins(capabilities, options) {
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
 import path13 from "path";
-import { Project as Project3 } from "ts-morph";
+import { Project as Project2 } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
-import fs15 from "fs";
+import fs14 from "fs";
 import path12 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
@@ -3461,7 +3009,7 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs15.readdirSync(dir, { withFileTypes: true });
+  const entries = fs14.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path12.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -3480,13 +3028,13 @@ function scanDirectory(dir, files = []) {
 }
 function scanServerFiles() {
   const serverDir = path12.join(getProjectRoot3(), "server");
-  if (!fs15.existsSync(serverDir)) {
+  if (!fs14.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs15.readFileSync(filePath, "utf-8");
+  const content = fs14.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -3550,17 +3098,17 @@ function analyzeImports(sourceFile) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/analyzers/call-site-analyzer.ts
-import { SyntaxKind as SyntaxKind6 } from "ts-morph";
+import { SyntaxKind } from "ts-morph";
 function analyzeCallSites(sourceFile, imports) {
   const callSites = [];
   const importMap = /* @__PURE__ */ new Map();
   for (const imp of imports) {
     importMap.set(imp.importName, imp.capabilityId);
   }
-  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind6.CallExpression);
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
   for (const callExpr of callExpressions) {
     const expression = callExpr.getExpression();
-    if (expression.getKind() === SyntaxKind6.Identifier) {
+    if (expression.getKind() === SyntaxKind.Identifier) {
       const functionName = expression.getText();
       const capabilityId = importMap.get(functionName);
       if (capabilityId) {
@@ -3573,11 +3121,11 @@ function analyzeCallSites(sourceFile, imports) {
           text: callExpr.getText()
         });
       }
-    } else if (expression.getKind() === SyntaxKind6.PropertyAccessExpression) {
-      const propAccess = expression.asKind(SyntaxKind6.PropertyAccessExpression);
+    } else if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+      const propAccess = expression.asKind(SyntaxKind.PropertyAccessExpression);
       if (propAccess) {
         const objectExpr = propAccess.getExpression();
-        if (objectExpr.getKind() === SyntaxKind6.Identifier) {
+        if (objectExpr.getKind() === SyntaxKind.Identifier) {
           const objectName = objectExpr.getText();
           const capabilityId = importMap.get(objectName);
           if (capabilityId) {
@@ -3613,15 +3161,13 @@ function analyzeClass(sourceFile) {
     if (!name) continue;
     const isInjectable = hasDecorator(classDecl, "Injectable");
     const isController = hasDecorator(classDecl, "Controller");
-    const isAutomation = hasDecorator(classDecl, "Automation");
-    if (classInfo && classInfo.isInjectable && !isInjectable && !isController && !isAutomation) {
+    if (classInfo && classInfo.isInjectable && !isInjectable && !isController) {
       continue;
     }
     const info = {
       name,
       isInjectable,
       isController,
-      isAutomation,
       constructorParamCount: 0
     };
     const classBody = classDecl.getChildSyntaxListOrThrow();
@@ -3640,7 +3186,7 @@ function analyzeClass(sourceFile) {
         info.constructorParamsEnd = ctor.getStart();
       }
     }
-    if (isInjectable || isController || isAutomation || !classInfo) {
+    if (isInjectable || isController || !classInfo) {
       classInfo = info;
     }
   }
@@ -3653,10 +3199,10 @@ function canAutoMigrate(classInfo) {
       reason: "No class found in file"
     };
   }
-  if (!classInfo.isInjectable && !classInfo.isController && !classInfo.isAutomation) {
+  if (!classInfo.isInjectable && !classInfo.isController) {
     return {
       canMigrate: false,
-      reason: `Class "${classInfo.name}" is not @Injectable, @Controller or @Automation`
+      reason: `Class "${classInfo.name}" is not @Injectable or @Controller`
     };
   }
   return { canMigrate: true };
@@ -3806,7 +3352,7 @@ function addInjection(sourceFile) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/transformers/call-site-transformer.ts
-import { SyntaxKind as SyntaxKind7 } from "ts-morph";
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
 var DEFAULT_ACTION_NAME = "run";
 function generateNewCallText(capabilityId, actionName, args) {
   const argsText = args.trim() || "{}";
@@ -3821,19 +3367,19 @@ function transformCallSites(sourceFile, imports) {
     });
   }
   let replacedCount = 0;
-  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind7.CallExpression);
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression);
   const sortedCalls = [...callExpressions].sort((a, b) => b.getStart() - a.getStart());
   for (const callExpr of sortedCalls) {
     const expression = callExpr.getExpression();
     let importInfo;
-    if (expression.getKind() === SyntaxKind7.Identifier) {
+    if (expression.getKind() === SyntaxKind2.Identifier) {
       const functionName = expression.getText();
       importInfo = importMap.get(functionName);
-    } else if (expression.getKind() === SyntaxKind7.PropertyAccessExpression) {
-      const propAccess = expression.asKind(SyntaxKind7.PropertyAccessExpression);
+    } else if (expression.getKind() === SyntaxKind2.PropertyAccessExpression) {
+      const propAccess = expression.asKind(SyntaxKind2.PropertyAccessExpression);
       if (propAccess) {
         const objectExpr = propAccess.getExpression();
-        if (objectExpr.getKind() === SyntaxKind7.Identifier) {
+        if (objectExpr.getKind() === SyntaxKind2.Identifier) {
           const objectName = objectExpr.getText();
           importInfo = importMap.get(objectName);
         }
@@ -3934,7 +3480,7 @@ async function migrateCode(options, capabilities) {
     console.log("   No files need code migration.\n");
     return result;
   }
-  const project = new Project3({
+  const project = new Project2({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: {
       allowJs: true
@@ -3977,17 +3523,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs16 from "fs";
+import fs15 from "fs";
 import path14 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
   const oldJsonPath = path14.join(capabilitiesDir, "capabilities.json");
-  if (fs16.existsSync(oldJsonPath)) {
+  if (fs15.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs16.unlinkSync(oldJsonPath);
+        fs15.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -3996,10 +3542,10 @@ function cleanupOldFiles(capabilities, dryRun) {
   }
   for (const cap of capabilities) {
     const tsFilePath = path14.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs16.existsSync(tsFilePath)) {
+    if (fs15.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs16.unlinkSync(tsFilePath);
+          fs15.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -4015,7 +3561,7 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs17 from "fs";
+import fs16 from "fs";
 import path15 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
@@ -4179,15 +3725,15 @@ async function generateReport(result) {
   }
   lines.push("");
   const logDir = process.env.LOG_DIR || "logs";
-  if (!fs17.existsSync(logDir)) {
+  if (!fs16.existsSync(logDir)) {
     return;
   }
   const reportDir = path15.join(logDir, "migration");
-  if (!fs17.existsSync(reportDir)) {
-    fs17.mkdirSync(reportDir, { recursive: true });
+  if (!fs16.existsSync(reportDir)) {
+    fs16.mkdirSync(reportDir, { recursive: true });
   }
   const reportPath = path15.join(reportDir, REPORT_FILE);
-  fs17.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  fs16.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${reportPath}`);
 }
 
@@ -4722,7 +4268,7 @@ var migrationCommand = {
 import path16 from "path";
 
 // src/commands/read-logs/std-utils.ts
-import fs18 from "fs";
+import fs17 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;
@@ -4752,11 +4298,11 @@ function stripPrefixFromStdLine(line) {
   return `[${time}] ${content}`;
 }
 function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
-  const stat = fs18.statSync(filePath);
+  const stat = fs17.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], markerFound: false, totalLinesCount: 0 };
   }
-  const fd = fs18.openSync(filePath, "r");
+  const fd = fs17.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -4770,7 +4316,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs18.readSync(fd, buffer, 0, length, position);
+      fs17.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -4812,7 +4358,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       }
     }
   } finally {
-    fs18.closeSync(fd);
+    fs17.closeSync(fd);
   }
   return { lines: collected.reverse(), markerFound, totalLinesCount };
 }
@@ -4833,21 +4379,21 @@ function readServerStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/tail.ts
-import fs19 from "fs";
+import fs18 from "fs";
 function fileExists(filePath) {
   try {
-    fs19.accessSync(filePath, fs19.constants.F_OK | fs19.constants.R_OK);
+    fs18.accessSync(filePath, fs18.constants.F_OK | fs18.constants.R_OK);
     return true;
   } catch {
     return false;
   }
 }
 function readFileTailLines(filePath, maxLines) {
-  const stat = fs19.statSync(filePath);
+  const stat = fs18.statSync(filePath);
   if (stat.size === 0) {
     return [];
   }
-  const fd = fs19.openSync(filePath, "r");
+  const fd = fs18.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   const chunks = [];
   let position = stat.size;
@@ -4857,13 +4403,13 @@ function readFileTailLines(filePath, maxLines) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs19.readSync(fd, buffer, 0, length, position);
+      fs18.readSync(fd, buffer, 0, length, position);
       chunks.unshift(buffer.toString("utf8"));
       const chunkLines = buffer.toString("utf8").split("\n").length - 1;
       collectedLines += chunkLines;
     }
   } finally {
-    fs19.closeSync(fd);
+    fs18.closeSync(fd);
   }
   const content = chunks.join("");
   const allLines = content.split("\n");
@@ -4879,11 +4425,11 @@ function readFileTailLines(filePath, maxLines) {
   return allLines.slice(allLines.length - maxLines);
 }
 function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
-  const stat = fs19.statSync(filePath);
+  const stat = fs18.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs19.openSync(filePath, "r");
+  const fd = fs18.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -4895,7 +4441,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs19.readSync(fd, buffer, 0, length, position);
+      fs18.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -4926,7 +4472,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       }
     }
   } finally {
-    fs19.closeSync(fd);
+    fs18.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5028,7 +4574,7 @@ function extractClientStdSegment(lines, maxLines, offset) {
 }
 
 // src/commands/read-logs/json-lines.ts
-import fs20 from "fs";
+import fs19 from "fs";
 function normalizePid(value) {
   if (typeof value === "number") {
     return String(value);
@@ -5079,11 +4625,11 @@ function buildWantedLevelSet(levels) {
   return set.size > 0 ? set : null;
 }
 function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
-  const stat = fs20.statSync(filePath);
+  const stat = fs19.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs20.openSync(filePath, "r");
+  const fd = fs19.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5098,7 +4644,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs20.readSync(fd, buffer, 0, length, position);
+      fs19.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5160,7 +4706,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs20.closeSync(fd);
+    fs19.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5203,11 +4749,11 @@ function extractTraceId(obj) {
 function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
   const wanted = traceId.trim();
   if (!wanted) return { lines: [], totalLinesCount: 0 };
-  const stat = fs20.statSync(filePath);
+  const stat = fs19.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs20.openSync(filePath, "r");
+  const fd = fs19.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5220,7 +4766,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs20.readSync(fd, buffer, 0, length, position);
+      fs19.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5273,7 +4819,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs20.closeSync(fd);
+    fs19.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5282,11 +4828,11 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
   if (!wantedLevelSet) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const stat = fs20.statSync(filePath);
+  const stat = fs19.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs20.openSync(filePath, "r");
+  const fd = fs19.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5298,7 +4844,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs20.readSync(fd, buffer, 0, length, position);
+      fs19.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5345,13 +4891,97 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs20.closeSync(fd);
+    fs19.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
 
 // src/commands/read-logs/index.ts
 var LOG_TYPES = ["server", "trace", "server-std", "client-std", "browser"];
+function normalizeObjectKey(key) {
+  return key.toLowerCase().replace(/_/g, "");
+}
+function formatIsoWithLocalOffset(date, includeMilliseconds) {
+  const pad2 = (n) => String(n).padStart(2, "0");
+  const pad3 = (n) => String(n).padStart(3, "0");
+  const year = date.getFullYear();
+  const month = pad2(date.getMonth() + 1);
+  const day = pad2(date.getDate());
+  const hour = pad2(date.getHours());
+  const minute = pad2(date.getMinutes());
+  const second = pad2(date.getSeconds());
+  const ms = pad3(date.getMilliseconds());
+  const tzOffsetMinutes = -date.getTimezoneOffset();
+  const sign = tzOffsetMinutes >= 0 ? "+" : "-";
+  const abs = Math.abs(tzOffsetMinutes);
+  const offsetHH = pad2(Math.floor(abs / 60));
+  const offsetMM = pad2(abs % 60);
+  const msPart = includeMilliseconds ? `.${ms}` : "";
+  return `${year}-${month}-${day}T${hour}:${minute}:${second}${msPart}${sign}${offsetHH}:${offsetMM}`;
+}
+function formatLocalDateTimeStringWithOffset(input) {
+  const match = input.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
+  if (!match) return input;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const hour = Number(match[4]);
+  const minute = Number(match[5]);
+  const second = Number(match[6]);
+  const date = new Date(year, month - 1, day, hour, minute, second, 0);
+  if (Number.isNaN(date.getTime())) return input;
+  return formatIsoWithLocalOffset(date, false);
+}
+function formatIsoNoTzStringWithOffset(input) {
+  const match = input.match(
+    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?$/
+  );
+  if (!match) return input;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const hour = Number(match[4]);
+  const minute = Number(match[5]);
+  const second = Number(match[6]);
+  const msRaw = match[7];
+  const ms = typeof msRaw === "string" ? Number(msRaw.padEnd(3, "0")) : 0;
+  const date = new Date(year, month - 1, day, hour, minute, second, ms);
+  if (Number.isNaN(date.getTime())) return input;
+  return formatIsoWithLocalOffset(date, typeof msRaw === "string");
+}
+function normalizeTimeString(input) {
+  const localDateTime = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/;
+  if (localDateTime.test(input)) {
+    return formatLocalDateTimeStringWithOffset(input);
+  }
+  const isoWithTz = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/i;
+  if (isoWithTz.test(input)) {
+    const date = new Date(input);
+    if (Number.isNaN(date.getTime())) return input;
+    const includeMs = /\.\d{1,3}/.test(input);
+    return formatIsoWithLocalOffset(date, includeMs);
+  }
+  const isoNoTz = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?$/;
+  if (isoNoTz.test(input)) {
+    return formatIsoNoTzStringWithOffset(input);
+  }
+  return input;
+}
+function normalizeTimezonesInValue(value, keyNormalized) {
+  if (typeof value === "string" && (keyNormalized === "time" || keyNormalized === "servertime")) {
+    return normalizeTimeString(value);
+  }
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeTimezonesInValue(item));
+  }
+  const obj = value;
+  const result = {};
+  for (const [key, child] of Object.entries(obj)) {
+    result[key] = normalizeTimezonesInValue(child, normalizeObjectKey(key));
+  }
+  return result;
+}
 function sanitizeStructuredLog(value) {
   if (!value || typeof value !== "object") return value;
   if (Array.isArray(value)) return value;
@@ -5456,16 +5086,17 @@ async function readLogsJsonResult(options) {
   const logs = [];
   let hasError = false;
   for (const line of lines) {
-    if (!hasError && hasErrorInStdLines([line])) {
-      hasError = true;
-    }
     try {
       const parsed = JSON.parse(line);
-      logs.push(sanitizeStructuredLog(parsed));
+      const normalized = normalizeTimezonesInValue(parsed);
+      logs.push(sanitizeStructuredLog(normalized));
       if (!hasError && hasErrorInLogObject(parsed)) {
         hasError = true;
       }
     } catch {
+      if (!hasError && hasErrorInStdLines([line])) {
+        hasError = true;
+      }
       continue;
     }
   }
@@ -5495,15 +5126,8 @@ function resolveLogFilePath(logDir, type) {
   throw new Error(`Unsupported log type: ${type}`);
 }
 async function run4(options) {
-  try {
-    const result = await readLogsJsonResult(options);
-    process.stdout.write(JSON.stringify(result) + "\n");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const result = { hasError: true, totalLinesCount: 0, logs: [message] };
-    process.stdout.write(JSON.stringify(result) + "\n");
-    process.exitCode = 1;
-  }
+  const result = await readLogsJsonResult(options);
+  process.stdout.write(JSON.stringify(result) + "\n");
 }
 function parseLogType(input) {
   const value = typeof input === "string" ? input.trim() : "";
@@ -5535,9 +5159,9 @@ var readLogsCommand = {
   name: "read-logs",
   description: "Read latest logs from log files",
   register(program) {
-    program.command(this.name).description(this.description).option("--dir <path>", "Logs directory", "logs").option("--type <type>", `Log type: ${LOG_TYPES.join("|")}`, "server-std").option("--max-lines <lines>", "Max lines to return", "30").option("--offset <lines>", "Skip latest N lines for pagination", "0").option("--trace-id <id>", "Filter structured logs by trace id").option("--level <levels>", "Filter structured logs by level (comma-separated)").action(async (rawOptions) => {
+    program.command(this.name).description(this.description).option("--dir <path>", "Logs directory", "/tmp").option("--type <type>", `Log type: ${LOG_TYPES.join("|")}`, "server-std").option("--max-lines <lines>", "Max lines to return", "30").option("--offset <lines>", "Skip latest N lines for pagination", "0").option("--trace-id <id>", "Filter structured logs by trace id").option("--level <levels>", "Filter structured logs by level (comma-separated)").action(async (rawOptions) => {
       try {
-        const logDir = typeof rawOptions.dir === "string" ? rawOptions.dir : "logs";
+        const logDir = typeof rawOptions.dir === "string" ? rawOptions.dir : "/tmp";
         const type = parseLogType(rawOptions.type);
         const maxLines = parsePositiveInt(rawOptions.maxLines, "--max-lines");
         const offset = parseNonNegativeInt(rawOptions.offset, "--offset");
@@ -5546,8 +5170,7 @@ var readLogsCommand = {
         await run4({ logDir, type, maxLines, offset, traceId, levels });
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        const result = { hasError: true, totalLinesCount: 0, logs: [message] };
-        process.stdout.write(JSON.stringify(result) + "\n");
+        process.stderr.write(message + "\n");
         process.exitCode = 1;
       }
     });
@@ -5566,11 +5189,11 @@ var commands = [
 
 // src/index.ts
 var envPath = path17.join(process.cwd(), ".env");
-if (fs21.existsSync(envPath)) {
+if (fs20.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
 var __dirname = path17.dirname(fileURLToPath4(import.meta.url));
-var pkg = JSON.parse(fs21.readFileSync(path17.join(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(fs20.readFileSync(path17.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();