@lark-apaas/fullstack-cli 1.1.19 → 1.1.20-alpha.1

package/dist/gen-dbschema-template/types.ts

@@ -38,6 +38,60 @@ export const fileAttachment = customType<{
   },
 });
 
+/** Escape single quotes in SQL string literals */
+function escapeLiteral(str: string): string {
+  return `'${str.replace(/'/g, "''")}'`;
+}
+
+export const userProfileArray = customType<{
+  data: string[];
+  driverData: string;
+}>({
+  dataType() {
+    return 'user_profile[]';
+  },
+  toDriver(value: string[]) {
+    if (!value || value.length === 0) {
+      return sql`'{}'::user_profile[]`;
+    }
+    const elements = value.map(id => `ROW(${escapeLiteral(id)})::user_profile`).join(',');
+    return sql.raw(`ARRAY[${elements}]::user_profile[]`);
+  },
+  fromDriver(value: string): string[] {
+    if (!value || value === '{}') return [];
+    const inner = value.slice(1, -1);
+    const matches = inner.match(/\([^)]*\)/g) || [];
+    return matches.map(m => m.slice(1, -1).split(',')[0].trim());
+  },
+});
+
+export const fileAttachmentArray = customType<{
+  data: FileAttachment[];
+  driverData: string;
+}>({
+  dataType() {
+    return 'file_attachment[]';
+  },
+  toDriver(value: FileAttachment[]) {
+    if (!value || value.length === 0) {
+      return sql`'{}'::file_attachment[]`;
+    }
+    const elements = value.map(f =>
+      `ROW(${escapeLiteral(f.bucket_id)},${escapeLiteral(f.file_path)})::file_attachment`
+    ).join(',');
+    return sql.raw(`ARRAY[${elements}]::file_attachment[]`);
+  },
+  fromDriver(value: string): FileAttachment[] {
+    if (!value || value === '{}') return [];
+    const inner = value.slice(1, -1);
+    const matches = inner.match(/\([^)]*\)/g) || [];
+    return matches.map(m => {
+      const [bucketId, filePath] = m.slice(1, -1).split(',');
+      return { bucket_id: bucketId.trim(), file_path: filePath.trim() };
+    });
+  },
+});
+
 export const customTimestamptz = customType<{
   data: Date;
   driverData: string;

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs21 from "fs";
-import path17 from "path";
+import fs22 from "fs";
+import path18 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -472,6 +472,10 @@ var KNOWN_TYPE_FACTORIES = {
   user_profile: "userProfile",
   file_attachment: "fileAttachment"
 };
+var KNOWN_ARRAY_TYPE_FACTORIES = {
+  user_profile: "userProfileArray",
+  file_attachment: "fileAttachmentArray"
+};
 var replaceUnknownTransform = {
   name: "replace-unknown",
   transform(ctx) {
@@ -490,12 +494,17 @@ var replaceUnknownTransform = {
       const lines = textBefore.split("\n");
       let factoryName = "text";
       let foundKnownType = false;
+      let isArrayType = 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]) {
+          isArrayType = todoMatch[2] === "[]";
+          if (isArrayType && KNOWN_ARRAY_TYPE_FACTORIES[typeName]) {
+            factoryName = KNOWN_ARRAY_TYPE_FACTORIES[typeName];
+            foundKnownType = true;
+          } else if (KNOWN_TYPE_FACTORIES[typeName]) {
             factoryName = KNOWN_TYPE_FACTORIES[typeName];
             foundKnownType = true;
           }
@@ -503,6 +512,15 @@ var replaceUnknownTransform = {
         }
       }
       expression.replaceWithText(factoryName);
+      if (isArrayType && foundKnownType) {
+        const parent = node.getParent();
+        if (Node5.isPropertyAccessExpression(parent) && parent.getName() === "array") {
+          const grandParent = parent.getParent();
+          if (Node5.isCallExpression(grandParent)) {
+            grandParent.replaceWithText(node.getText());
+          }
+        }
+      }
       if (foundKnownType) {
         stats.replacedUnknown++;
       } else {
@@ -1005,6 +1023,139 @@ function resolveTemplateTypesPath() {
   return void 0;
 }
 
+// src/commands/db/gen-dbschema/utils/fetch-column-comments.ts
+import postgres from "postgres";
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function fetchColumnComments(connectionString, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const url = new URL(connectionString);
+  const schemaName = url.searchParams.get("schema") ?? "public";
+  const sql = postgres(connectionString, {
+    connect_timeout: Math.ceil(timeoutMs / 1e3),
+    idle_timeout: Math.ceil(timeoutMs / 1e3)
+  });
+  try {
+    const queryPromise = sql`
+      SELECT
+        c.table_name AS "tableName",
+        c.column_name AS "columnName",
+        pgd.description AS "comment"
+      FROM information_schema.columns c
+      JOIN pg_catalog.pg_statio_all_tables st
+        ON c.table_name = st.relname AND c.table_schema = st.schemaname
+      JOIN pg_catalog.pg_description pgd
+        ON pgd.objoid = st.relid AND pgd.objsubid = c.ordinal_position
+      WHERE c.table_schema = ${schemaName}
+        AND pgd.description IS NOT NULL
+        AND pgd.description != ''
+    `;
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs);
+    });
+    const result = await Promise.race([queryPromise, timeoutPromise]);
+    const commentMap = /* @__PURE__ */ new Map();
+    for (const row of result) {
+      const key = `${row.tableName}.${row.columnName}`;
+      commentMap.set(key, row.comment);
+    }
+    return commentMap;
+  } finally {
+    await sql.end().catch(() => {
+    });
+  }
+}
+function extractTypeAnnotation(comment) {
+  const typeStart = comment.indexOf("@type");
+  if (typeStart === -1) return null;
+  const afterType = comment.slice(typeStart + 5).trimStart();
+  if (!afterType.startsWith("{")) return null;
+  let depth = 0;
+  let endIndex = 0;
+  for (let i = 0; i < afterType.length; i++) {
+    if (afterType[i] === "{") depth++;
+    if (afterType[i] === "}") depth--;
+    if (depth === 0) {
+      endIndex = i + 1;
+      break;
+    }
+  }
+  if (endIndex === 0) return null;
+  return afterType.slice(0, endIndex);
+}
+function parseColumnComment(comment) {
+  const typeValue = extractTypeAnnotation(comment);
+  if (typeValue) {
+    const descMatch = comment.match(/@description\s+([^@]+)/);
+    return {
+      type: typeValue,
+      description: descMatch?.[1]?.trim()
+    };
+  }
+  return { description: comment.trim() };
+}
+
+// src/commands/db/gen-dbschema/transforms/text/jsonb-comments.ts
+function addJsonbTypeComments(source, columnComments) {
+  if (!columnComments || columnComments.size === 0) {
+    return { text: source, added: 0 };
+  }
+  const lines = source.split("\n");
+  const result = [];
+  let added = 0;
+  let currentTableName = null;
+  const tableDefRegex = /export const\s+\w+\s*=\s*pgTable\(\s*["'`]([^"'`]+)["'`]/;
+  const jsonFieldWithNameRegex = /^\s*(\w+):\s*(?:json|jsonb)\(\s*["'`]([^"'`]+)["'`]\)/;
+  const jsonFieldNoNameRegex = /^\s*(\w+):\s*(?:json|jsonb)\(\s*\)/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const tableMatch = line.match(tableDefRegex);
+    if (tableMatch) {
+      currentTableName = tableMatch[1];
+    }
+    let columnName = null;
+    const jsonMatchWithName = line.match(jsonFieldWithNameRegex);
+    const jsonMatchNoName = line.match(jsonFieldNoNameRegex);
+    if (jsonMatchWithName) {
+      columnName = jsonMatchWithName[2];
+    } else if (jsonMatchNoName) {
+      columnName = jsonMatchNoName[1];
+    }
+    if (columnName && currentTableName) {
+      const commentKey = `${currentTableName}.${columnName}`;
+      const comment = columnComments.get(commentKey);
+      if (comment) {
+        const parsed = parseColumnComment(comment);
+        const indentMatch = line.match(/^\s*/);
+        const indent = indentMatch ? indentMatch[0] : "";
+        const prevLine = result[result.length - 1]?.trim() ?? "";
+        if (!prevLine.startsWith("/**") && !prevLine.startsWith("*") && !prevLine.startsWith("//")) {
+          const commentLines = [];
+          commentLines.push(`${indent}/**`);
+          if (parsed.description) {
+            const safeDesc = parsed.description.replace(/[\r\n]+/g, " ").trim();
+            commentLines.push(`${indent} * ${safeDesc}`);
+          }
+          if (parsed.type) {
+            if (parsed.description) {
+              commentLines.push(`${indent} *`);
+            }
+            const safeType = parsed.type.replace(/[\r\n]+/g, " ").trim();
+            commentLines.push(`${indent} * @type ${safeType}`);
+          }
+          commentLines.push(`${indent} */`);
+          result.push(...commentLines);
+          added++;
+        }
+      }
+    }
+    if (line.match(/^\}\);?\s*$/) || line.match(/^}\s*,\s*\{/)) {
+      currentTableName = null;
+    }
+    result.push(line);
+  }
+  return { text: result.join("\n"), added };
+}
+
 // src/commands/db/gen-dbschema/transforms/text/table-aliases.ts
 var TABLE_ALIAS_MARKER = "// table aliases";
 function generateTableAliases(source) {
@@ -1041,7 +1192,7 @@ function formatSource(source) {
 }
 
 // src/commands/db/gen-dbschema/postprocess.ts
-function postprocessSchema(rawSource) {
+function postprocessSchema(rawSource, options = {}) {
   const patchResult = patchDefects(rawSource);
   let source = patchResult.text;
   const { sourceFile } = parseSource(source);
@@ -1051,12 +1202,15 @@ function postprocessSchema(rawSource) {
   source = ensureHeader(source);
   source = addSystemFieldComments(source);
   source = inlineCustomTypes(source);
+  const jsonbCommentsResult = addJsonbTypeComments(source, options.columnComments);
+  source = jsonbCommentsResult.text;
   source = generateTableAliases(source);
   source = formatSource(source);
   return {
     source,
     astStats,
-    patchedDefects: patchResult.fixed
+    patchedDefects: patchResult.fixed,
+    addedJsonbComments: jsonbCommentsResult.added
   };
 }
 function logStats(result, prefix = "[postprocess]") {
@@ -1103,17 +1257,20 @@ function logStats(result, prefix = "[postprocess]") {
   if (astStats.removedImports.length > 0) {
     console.info(`${prefix} Removed imports: ${astStats.removedImports.join(", ")}`);
   }
+  if (result.addedJsonbComments > 0) {
+    console.info(`${prefix} Added ${result.addedJsonbComments} JSDoc comments for jsonb fields`);
+  }
 }
 
 // src/commands/db/gen-dbschema/index.ts
-function postprocessDrizzleSchema(targetPath) {
+async function postprocessDrizzleSchema(targetPath, options = {}) {
   const resolvedPath = path.resolve(targetPath);
   if (!fs3.existsSync(resolvedPath)) {
     console.warn(`[postprocess-drizzle-schema] File not found: ${resolvedPath}`);
     return void 0;
   }
   const rawSource = fs3.readFileSync(resolvedPath, "utf8");
-  const result = postprocessSchema(rawSource);
+  const result = postprocessSchema(rawSource, { columnComments: options.columnComments });
   fs3.writeFileSync(resolvedPath, result.source, "utf8");
   logStats(result, "[postprocess-drizzle-schema]");
   return {
@@ -1122,7 +1279,8 @@ function postprocessDrizzleSchema(targetPath) {
     unmatchedUnknown: result.astStats.unmatchedUnknown,
     patchedDefects: result.patchedDefects,
     replacedTimestamps: result.astStats.replacedTimestamp,
-    replacedDefaultNow: result.astStats.replacedDefaultNow
+    replacedDefaultNow: result.astStats.replacedDefaultNow,
+    addedJsonbComments: result.addedJsonbComments
   };
 }
 
@@ -1847,6 +2005,16 @@ async function run(options = {}) {
     }
     throw new Error("Unable to locate drizzle-kit package root");
   };
+  let columnComments;
+  try {
+    columnComments = await fetchColumnComments(databaseUrl, { timeoutMs: 1e4 });
+    console.log(`[gen-db-schema] \u2713 Fetched ${columnComments.size} column comments`);
+  } catch (err) {
+    console.warn(
+      "[gen-db-schema] \u26A0 Failed to fetch column comments (skipping):",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
   try {
     const env = {
       ...process.env,
@@ -1870,7 +2038,9 @@ async function run(options = {}) {
       console.error("[gen-db-schema] schema.ts not generated");
       throw new Error("drizzle-kit introspect failed to generate schema.ts");
     }
-    const stats = postprocessDrizzleSchema(generatedSchema);
+    const stats = await postprocessDrizzleSchema(generatedSchema, {
+      columnComments
+    });
     if (stats?.unmatchedUnknown?.length) {
       console.warn("[gen-db-schema] Unmatched custom types detected:", stats.unmatchedUnknown);
     }
@@ -3282,59 +3452,344 @@ var capabilityCommandGroup = {
   commands: [listCommand2]
 };
 
-// src/commands/migration/version-manager.ts
+// src/commands/component/registry-preparer.ts
 import fs10 from "fs";
 import path8 from "path";
+import os from "os";
+
+// src/commands/component/service.ts
+import { mapValues } from "es-toolkit";
+
+// src/commands/component/utils.ts
+import createDebug from "debug";
+var debug = createDebug("component");
+
+// src/commands/component/service.ts
+async function getComponents(keys) {
+  const client = getHttpClient();
+  debug("\u8C03\u7528 /components/batch_get %o", keys);
+  const response = await client.post(
+    `/api/v1/studio/innerapi/components/batch_get?keys=${keys.join(",")}`
+  );
+  if (response.status !== 200) {
+    throw new Error(
+      `\u83B7\u53D6\u7EC4\u4EF6\u4FE1\u606F\u5931\u8D25\uFF1A${response.status} ${response.statusText}`
+    );
+  }
+  const result = await response.json();
+  if (result.status_code !== "0") {
+    debug("\u63A5\u53E3\u8FD4\u56DE\u9519\u8BEF\uFF1A%o", result);
+    throw new Error(`\u83B7\u53D6\u7EC4\u4EF6\u4FE1\u606F\u5931\u8D25\uFF1A${result.error_msg}`);
+  }
+  return mapValues(result.data.components, ([component]) => component);
+}
+async function getRegistryItem(url) {
+  const client = getHttpClient();
+  debug("\u4E0B\u8F7D registry-item.json\uFF1A%s", url);
+  const response = await client.get(url);
+  if (!response.ok) {
+    throw new Error(
+      `\u4E0B\u8F7D registry-item.json \u5931\u8D25\uFF1A${response.status} ${response.statusText}`
+    );
+  }
+  const item = await response.json();
+  return item;
+}
+async function sendInstallEvent(key) {
+  const client = getHttpClient();
+  await client.post("/api/v1/studio/innerapi/resource_events", {
+    events: [
+      {
+        resourceType: "component",
+        resourceKey: key,
+        eventType: "install",
+        details: {}
+      }
+    ]
+  });
+}
+
+// src/commands/component/registry-preparer.ts
+var REGISTRY_TEMP_DIR = path8.join(os.tmpdir(), "miaoda-registry");
+function parseComponentKey(key) {
+  const match = key.match(/^@([^/]+)\/(.+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid component key format: ${key}. Expected format: @scope/name`
+    );
+  }
+  return { scope: match[1], name: match[2] };
+}
+function getLocalRegistryPath(key) {
+  const { scope, name } = parseComponentKey(key);
+  return path8.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
+}
+function ensureDir(dirPath) {
+  if (!fs10.existsSync(dirPath)) {
+    fs10.mkdirSync(dirPath, { recursive: true });
+  }
+}
+async function prepareRecursive(key, visited) {
+  if (visited.has(key)) {
+    debug("\u8DF3\u8FC7\u5DF2\u5904\u7406\u7684\u7EC4\u4EF6: %s", key);
+    return;
+  }
+  visited.add(key);
+  debug("\u5904\u7406\u7EC4\u4EF6: %s", key);
+  debug("\u83B7\u53D6\u7EC4\u4EF6\u4E0B\u8F7D\u4FE1\u606F...");
+  const infoMap = await getComponents([key]);
+  const info = infoMap[key];
+  debug("\u7EC4\u4EF6\u4FE1\u606F: %o", info);
+  if (!info) {
+    throw new Error(`Component not found: ${key}`);
+  }
+  if (info.status !== "active") {
+    throw new Error(`Component is not active: ${key}`);
+  }
+  debug("\u4E0B\u8F7D registry item: %s", info.downloadURL);
+  const registryItem = await getRegistryItem(info.downloadURL);
+  debug("registry item \u5185\u5BB9: %o", registryItem);
+  const deps = registryItem.registryDependencies || [];
+  debug("\u4F9D\u8D56\u5217\u8868: %o", deps);
+  for (const dep of deps) {
+    await prepareRecursive(dep, visited);
+  }
+  const rewrittenItem = {
+    ...registryItem,
+    registryDependencies: deps.map((dep) => getLocalRegistryPath(dep))
+  };
+  const localPath = getLocalRegistryPath(key);
+  ensureDir(path8.dirname(localPath));
+  fs10.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
+  debug("\u4FDD\u5B58\u5230: %s", localPath);
+}
+async function prepareComponentRegistryItems(id) {
+  const visited = /* @__PURE__ */ new Set();
+  await prepareRecursive(id, visited);
+  return getLocalRegistryPath(id);
+}
+function cleanupTempDir() {
+  try {
+    if (fs10.existsSync(REGISTRY_TEMP_DIR)) {
+      fs10.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+function getDownloadedRegistryItem(itemId) {
+  const localPath = getLocalRegistryPath(itemId);
+  if (!fs10.existsSync(localPath)) {
+    return null;
+  }
+  const content = fs10.readFileSync(localPath, "utf-8");
+  return JSON.parse(content);
+}
+
+// src/commands/component/shadcn-executor.ts
+import * as pty from "@lydell/node-pty";
+function parseOutput(output) {
+  const state = {
+    currentSection: null,
+    files: /* @__PURE__ */ new Set()
+  };
+  const lines = output.split("\n");
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (/Created \d+ files?:/.test(trimmedLine)) {
+      state.currentSection = "created";
+      continue;
+    }
+    if (/Updated \d+ files?:/.test(trimmedLine)) {
+      state.currentSection = "updated";
+      continue;
+    }
+    if (/Skipped \d+ files?:/.test(trimmedLine)) {
+      state.currentSection = "skipped";
+      continue;
+    }
+    if (state.currentSection && trimmedLine.startsWith("- ")) {
+      const filePath = trimmedLine.slice(2).trim();
+      if (filePath && filePath.includes("/")) {
+        state.files.add(filePath);
+      }
+    }
+    if (state.currentSection && trimmedLine.length > 1 && !trimmedLine.startsWith("- ")) {
+      state.currentSection = null;
+    }
+  }
+  return Array.from(state.files);
+}
+function toFileInfo(filePath) {
+  const name = filePath.split("/").pop() || filePath;
+  return { name, path: filePath };
+}
+var PROMPT_PATTERNS = [
+  // 文件覆盖确认 - 回答 n（不覆盖）
+  { pattern: /overwrite/i, answer: "n\n" },
+  // 主题/样式选择 - 回答 n（不安装额外主题）
+  { pattern: /theme/i, answer: "n\n" },
+  { pattern: /style/i, answer: "n\n" },
+  // 继续确认 - 回答 y
+  { pattern: /continue\?/i, answer: "y\n" },
+  { pattern: /proceed\?/i, answer: "y\n" }
+];
+async function executeShadcnAdd(registryItemPath) {
+  return new Promise((resolve) => {
+    let output = "";
+    const args = ["--yes", "shadcn@3.8.2", "add", registryItemPath];
+    const ptyProcess = pty.spawn("npx", args, {
+      name: "xterm-color",
+      cols: 120,
+      rows: 30,
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        // 禁用颜色输出以便解析
+        NO_COLOR: "1",
+        FORCE_COLOR: "0"
+      }
+    });
+    ptyProcess.onData((data) => {
+      output += data;
+      for (const { pattern, answer } of PROMPT_PATTERNS) {
+        if (pattern.test(data)) {
+          ptyProcess.write(answer);
+          return;
+        }
+      }
+    });
+    const timeoutId = setTimeout(() => {
+      ptyProcess.kill();
+      resolve({
+        success: false,
+        files: [],
+        error: "\u6267\u884C\u8D85\u65F6"
+      });
+    }, 3 * 60 * 1e3);
+    ptyProcess.onExit(({ exitCode }) => {
+      clearTimeout(timeoutId);
+      const success = exitCode === 0;
+      const filePaths = parseOutput(output);
+      const files = filePaths.map(toFileInfo);
+      resolve({
+        success,
+        files,
+        error: success ? void 0 : output || `Process exited with code ${exitCode}`
+      });
+    });
+  });
+}
+
+// src/commands/component/add.handler.ts
+function printResult(result) {
+  console.log(JSON.stringify(result, null, 2));
+}
+async function addComponent(key) {
+  debug("\u5F00\u59CB\u5B89\u88C5\u7EC4\u4EF6: %s", key);
+  debug("\u51C6\u5907 registry items...");
+  const registryItemPath = await prepareComponentRegistryItems(key);
+  debug("registry item \u8DEF\u5F84: %s", registryItemPath);
+  const registryItem = getDownloadedRegistryItem(key);
+  debug("\u83B7\u53D6\u5230 registry item: %o", registryItem);
+  debug("\u6267\u884C shadcn add...");
+  const executeResult = await executeShadcnAdd(registryItemPath);
+  debug("shadcn \u6267\u884C\u7ED3\u679C: %o", executeResult);
+  if (!executeResult.success) {
+    throw new Error(executeResult.error || "\u5B89\u88C5\u5931\u8D25\uFF0C\u672A\u77E5\u539F\u56E0");
+  }
+  return {
+    success: true,
+    name: key,
+    description: registryItem?.description || "",
+    files: executeResult.files,
+    docs: registryItem?.docs || ""
+  };
+}
+async function add(key) {
+  try {
+    const result = await addComponent(key);
+    printResult(result);
+    void sendInstallEvent(key);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "\u5B89\u88C5\u5931\u8D25\uFF0C\u539F\u56E0\u672A\u77E5";
+    printResult({
+      success: false,
+      errors: [{ message: errorMessage }]
+    });
+  } finally {
+    cleanupTempDir();
+  }
+}
+
+// src/commands/component/index.ts
+var addCommand = {
+  name: "add",
+  description: "\u5B89\u88C5\u5999\u642D\u7EC4\u4EF6\u5E02\u573A\u4E2D\u7684\u7EC4\u4EF6",
+  register(program) {
+    program.command(this.name).description(this.description).argument("<component>", "\u7EC4\u4EF6 ID (\u4F8B\u5982 @miaoda/button)").action(async (component) => {
+      await add(component);
+    });
+  }
+};
+var componentCommandGroup = {
+  name: "component",
+  description: "\u7EC4\u4EF6\u76F8\u5173\u547D\u4EE4",
+  commands: [addCommand]
+};
+
+// src/commands/migration/version-manager.ts
+import fs11 from "fs";
+import path9 from "path";
 var PACKAGE_JSON = "package.json";
 var VERSION_FIELD = "migrationVersion";
 function getPackageJsonPath2() {
-  return path8.join(process.cwd(), PACKAGE_JSON);
+  return path9.join(process.cwd(), PACKAGE_JSON);
 }
 function getCurrentVersion() {
   const pkgPath = getPackageJsonPath2();
-  if (!fs10.existsSync(pkgPath)) {
+  if (!fs11.existsSync(pkgPath)) {
     throw new Error("package.json not found");
   }
-  const pkg2 = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs11.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(fs11.readFileSync(pkgPath, "utf-8"));
   pkg2[VERSION_FIELD] = version;
-  fs10.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs11.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 path10 from "path";
+import fs13 from "fs";
+import path11 from "path";
 
 // src/commands/migration/versions/v001_capability/utils.ts
-import fs11 from "fs";
-import path9 from "path";
+import fs12 from "fs";
+import path10 from "path";
 var CAPABILITIES_DIR2 = "server/capabilities";
 function getProjectRoot3() {
   return process.cwd();
 }
 function getCapabilitiesDir2() {
-  return path9.join(getProjectRoot3(), CAPABILITIES_DIR2);
+  return path10.join(getProjectRoot3(), CAPABILITIES_DIR2);
 }
 function getPluginManifestPath2(pluginKey) {
-  return path9.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
+  return path10.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
 function detectJsonMigration() {
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldFilePath = path10.join(capabilitiesDir, "capabilities.json");
-  if (!fs12.existsSync(oldFilePath)) {
+  const oldFilePath = path11.join(capabilitiesDir, "capabilities.json");
+  if (!fs13.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
       reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs12.readFileSync(oldFilePath, "utf-8");
+    const content = fs13.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) {
       return {
@@ -3385,8 +3840,8 @@ async function check(options) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
-import fs13 from "fs";
-import path11 from "path";
+import fs14 from "fs";
+import path12 from "path";
 
 // src/commands/migration/versions/v001_capability/mapping.ts
 var DEFAULT_PLUGIN_VERSION = "1.0.0";
@@ -3616,18 +4071,18 @@ function transformCapabilities(oldCapabilities) {
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
 function loadExistingCapabilities() {
   const capabilitiesDir = getCapabilitiesDir2();
-  if (!fs13.existsSync(capabilitiesDir)) {
+  if (!fs14.existsSync(capabilitiesDir)) {
     return [];
   }
-  const files = fs13.readdirSync(capabilitiesDir);
+  const files = fs14.readdirSync(capabilitiesDir);
   const capabilities = [];
   for (const file of files) {
     if (file === "capabilities.json" || !file.endsWith(".json")) {
       continue;
     }
     try {
-      const filePath = path11.join(capabilitiesDir, file);
-      const content = fs13.readFileSync(filePath, "utf-8");
+      const filePath = path12.join(capabilitiesDir, file);
+      const content = fs14.readFileSync(filePath, "utf-8");
       const capability = JSON.parse(content);
       if (capability.id && capability.pluginKey) {
         capabilities.push(capability);
@@ -3685,9 +4140,9 @@ async function migrateJsonFiles(options) {
   }
   const capabilitiesDir = getCapabilitiesDir2();
   for (const cap of newCapabilities) {
-    const filePath = path11.join(capabilitiesDir, `${cap.id}.json`);
+    const filePath = path12.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs13.writeFileSync(filePath, content, "utf-8");
+    fs14.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
   return {
@@ -3699,11 +4154,11 @@ async function migrateJsonFiles(options) {
 }
 
 // src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
-import fs14 from "fs";
+import fs15 from "fs";
 function isPluginInstalled2(pluginKey) {
   const actionPlugins = readActionPlugins();
   const manifestPath = getPluginManifestPath2(pluginKey);
-  return fs14.existsSync(manifestPath) && !!actionPlugins[pluginKey];
+  return fs15.existsSync(manifestPath) && !!actionPlugins[pluginKey];
 }
 function detectPluginsToInstall(capabilities) {
   const pluginKeys = /* @__PURE__ */ new Set();
@@ -3779,12 +4234,12 @@ async function installPlugins(capabilities, options) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-import path13 from "path";
+import path14 from "path";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
-import fs15 from "fs";
-import path12 from "path";
+import fs16 from "fs";
+import path13 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
   "dist",
@@ -3799,9 +4254,9 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs15.readdirSync(dir, { withFileTypes: true });
+  const entries = fs16.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path12.join(dir, entry.name);
+    const fullPath = path13.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.includes(entry.name)) {
         continue;
@@ -3817,14 +4272,14 @@ function scanDirectory(dir, files = []) {
   return files;
 }
 function scanServerFiles() {
-  const serverDir = path12.join(getProjectRoot3(), "server");
-  if (!fs15.existsSync(serverDir)) {
+  const serverDir = path13.join(getProjectRoot3(), "server");
+  if (!fs16.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs15.readFileSync(filePath, "utf-8");
+  const content = fs16.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -4201,7 +4656,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
-  const relativePath = path13.relative(getProjectRoot3(), filePath);
+  const relativePath = path14.relative(getProjectRoot3(), filePath);
   return {
     filePath: relativePath,
     imports,
@@ -4212,7 +4667,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   };
 }
 function migrateFile(project, analysis, dryRun) {
-  const absolutePath = path13.join(getProjectRoot3(), analysis.filePath);
+  const absolutePath = path14.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
       filePath: analysis.filePath,
@@ -4315,17 +4770,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs16 from "fs";
-import path14 from "path";
+import fs17 from "fs";
+import path15 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldJsonPath = path14.join(capabilitiesDir, "capabilities.json");
-  if (fs16.existsSync(oldJsonPath)) {
+  const oldJsonPath = path15.join(capabilitiesDir, "capabilities.json");
+  if (fs17.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs16.unlinkSync(oldJsonPath);
+        fs17.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -4333,11 +4788,11 @@ function cleanupOldFiles(capabilities, dryRun) {
     }
   }
   for (const cap of capabilities) {
-    const tsFilePath = path14.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs16.existsSync(tsFilePath)) {
+    const tsFilePath = path15.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs17.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs16.unlinkSync(tsFilePath);
+          fs17.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -4353,8 +4808,8 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs17 from "fs";
-import path15 from "path";
+import fs18 from "fs";
+import path16 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
   const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
@@ -4517,15 +4972,15 @@ async function generateReport(result) {
   }
   lines.push("");
   const logDir = process.env.LOG_DIR || "logs";
-  if (!fs17.existsSync(logDir)) {
+  if (!fs18.existsSync(logDir)) {
     return;
   }
-  const reportDir = path15.join(logDir, "migration");
-  if (!fs17.existsSync(reportDir)) {
-    fs17.mkdirSync(reportDir, { recursive: true });
+  const reportDir = path16.join(logDir, "migration");
+  if (!fs18.existsSync(reportDir)) {
+    fs18.mkdirSync(reportDir, { recursive: true });
   }
-  const reportPath = path15.join(reportDir, REPORT_FILE);
-  fs17.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  const reportPath = path16.join(reportDir, REPORT_FILE);
+  fs18.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${reportPath}`);
 }
 
@@ -5057,10 +5512,10 @@ var migrationCommand = {
 };
 
 // src/commands/read-logs/index.ts
-import path16 from "path";
+import path17 from "path";
 
 // src/commands/read-logs/std-utils.ts
-import fs18 from "fs";
+import fs19 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;
@@ -5090,11 +5545,11 @@ function stripPrefixFromStdLine(line) {
   return `[${time}] ${content}`;
 }
 function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
-  const stat = fs18.statSync(filePath);
+  const stat = fs19.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], markerFound: false, totalLinesCount: 0 };
   }
-  const fd = fs18.openSync(filePath, "r");
+  const fd = fs19.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5108,7 +5563,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);
+      fs19.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5150,7 +5605,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       }
     }
   } finally {
-    fs18.closeSync(fd);
+    fs19.closeSync(fd);
   }
   return { lines: collected.reverse(), markerFound, totalLinesCount };
 }
@@ -5171,21 +5626,21 @@ function readServerStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/tail.ts
-import fs19 from "fs";
+import fs20 from "fs";
 function fileExists(filePath) {
   try {
-    fs19.accessSync(filePath, fs19.constants.F_OK | fs19.constants.R_OK);
+    fs20.accessSync(filePath, fs20.constants.F_OK | fs20.constants.R_OK);
     return true;
   } catch {
     return false;
   }
 }
 function readFileTailLines(filePath, maxLines) {
-  const stat = fs19.statSync(filePath);
+  const stat = fs20.statSync(filePath);
   if (stat.size === 0) {
     return [];
   }
-  const fd = fs19.openSync(filePath, "r");
+  const fd = fs20.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   const chunks = [];
   let position = stat.size;
@@ -5195,13 +5650,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);
+      fs20.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);
+    fs20.closeSync(fd);
   }
   const content = chunks.join("");
   const allLines = content.split("\n");
@@ -5217,11 +5672,11 @@ function readFileTailLines(filePath, maxLines) {
   return allLines.slice(allLines.length - maxLines);
 }
 function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
-  const stat = fs19.statSync(filePath);
+  const stat = fs20.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs19.openSync(filePath, "r");
+  const fd = fs20.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5233,7 +5688,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);
+      fs20.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5264,7 +5719,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       }
     }
   } finally {
-    fs19.closeSync(fd);
+    fs20.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5277,13 +5732,19 @@ function readClientStdSegment(filePath, maxLines, offset) {
 function extractClientStdSegment(lines, maxLines, offset) {
   const bodyLines = lines.map(stripPrefixFromStdLine);
   const hotStartMarkers = [
+    // Webpack markers
     /file change detected\..*incremental compilation/i,
     /starting incremental compilation/i,
     /starting compilation/i,
     /\bcompiling\b/i,
-    /\brecompil/i
+    /\brecompil/i,
+    // Vite markers - format: "3:11:46 PM [vite] (client) hmr update ..."
+    /VITE v[\d.]+.*ready/i,
+    /\[vite\].*page reload/i,
+    /\[vite\].*hmr update/i
   ];
   const hotEndMarkers = [
+    // Webpack markers
     /file change detected\..*incremental compilation/i,
     /\bwebpack compiled\b/i,
     /compiled successfully/i,
@@ -5294,14 +5755,25 @@ function extractClientStdSegment(lines, maxLines, offset) {
     /\bhmr\b/i,
     /hot update/i,
     /\bhot reload\b/i,
-    /\bhmr update\b/i
+    /\bhmr update\b/i,
+    // Vite markers
+    /VITE v[\d.]+.*ready/i,
+    /\[vite\].*page reload/i,
+    /\[vite\].*hmr update/i,
+    /\[vite\].*hmr invalidate/i,
+    /\[vite\].*internal server error/i,
+    /\[vite\].*pre-transform error/i
   ];
   const compiledMarkers = [
+    // Webpack markers
     /\bwebpack compiled\b/i,
     /compiled successfully/i,
     /compiled with warnings/i,
     /compiled with errors/i,
-    /failed to compile/i
+    /failed to compile/i,
+    // Vite markers
+    /VITE v[\d.]+.*ready/i,
+    /\[vite\].*hmr update/i
   ];
   let startIndex = -1;
   for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
@@ -5354,14 +5826,15 @@ function extractClientStdSegment(lines, maxLines, offset) {
   }
   const segment = startIndex === -1 ? bodyLines : bodyLines.slice(startIndex);
   if (segment.length === 0) {
-    return { lines: [], totalLinesCount: 0 };
+    return { lines: [], totalLinesCount: 0, allLines: [] };
   }
   const totalLinesCount = segment.length;
   const endExclusive = Math.max(0, segment.length - offset);
   const start = Math.max(0, endExclusive - maxLines);
   return {
     lines: segment.slice(start, endExclusive),
-    totalLinesCount
+    totalLinesCount,
+    allLines: segment
   };
 }
 
@@ -5388,7 +5861,7 @@ function readDevStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/json-lines.ts
-import fs20 from "fs";
+import fs21 from "fs";
 function normalizePid(value) {
   if (typeof value === "number") {
     return String(value);
@@ -5439,11 +5912,11 @@ function buildWantedLevelSet(levels) {
   return set.size > 0 ? set : null;
 }
 function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
-  const stat = fs20.statSync(filePath);
+  const stat = fs21.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs20.openSync(filePath, "r");
+  const fd = fs21.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5458,7 +5931,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);
+      fs21.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5520,7 +5993,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs20.closeSync(fd);
+    fs21.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5563,11 +6036,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 = fs21.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs20.openSync(filePath, "r");
+  const fd = fs21.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5580,7 +6053,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);
+      fs21.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5633,7 +6106,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs20.closeSync(fd);
+    fs21.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5642,11 +6115,11 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
   if (!wantedLevelSet) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const stat = fs20.statSync(filePath);
+  const stat = fs21.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs20.openSync(filePath, "r");
+  const fd = fs21.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5658,7 +6131,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);
+      fs21.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5705,7 +6178,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs20.closeSync(fd);
+    fs21.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5898,12 +6371,21 @@ async function readLatestLogLinesMeta(options) {
   return { lines: [], totalLinesCount: 0 };
 }
 async function readLogsJsonResult(options) {
-  const { lines, totalLinesCount } = await readLatestLogLinesMeta(options);
+  const { lines, totalLinesCount, allLines } = await readLatestLogLinesMeta(options);
   if (options.type === "server-std" || options.type === "client-std" || options.type === "dev" || options.type === "dev-std" || options.type === "install-dep-std") {
+    const linesForErrorCheck = allLines ?? lines;
+    const stackTracePattern = /\bat\s+\S+\s+\([^)]+:\d+:\d+\)/;
+    const linesToFilter = allLines ?? lines;
+    const filteredLines = linesToFilter.filter((line) => !stackTracePattern.test(line));
+    const maxLines = options.maxLines ?? 30;
+    const offset = options.offset ?? 0;
+    const endExclusive = Math.max(0, filteredLines.length - offset);
+    const start = Math.max(0, endExclusive - maxLines);
+    const paginatedLogs = filteredLines.slice(start, endExclusive);
     return {
-      hasError: hasErrorInStdLines(lines),
-      totalLinesCount,
-      logs: lines
+      hasError: hasErrorInStdLines(linesForErrorCheck),
+      totalLinesCount: filteredLines.length,
+      logs: paginatedLogs
     };
   }
   const logs = [];
@@ -5930,30 +6412,30 @@ async function readLogsJsonResult(options) {
   };
 }
 function resolveLogFilePath(logDir, type) {
-  const base = path16.isAbsolute(logDir) ? logDir : path16.join(process.cwd(), logDir);
+  const base = path17.isAbsolute(logDir) ? logDir : path17.join(process.cwd(), logDir);
   if (type === "server") {
-    return path16.join(base, "server.log");
+    return path17.join(base, "server.log");
   }
   if (type === "trace") {
-    return path16.join(base, "trace.log");
+    return path17.join(base, "trace.log");
   }
   if (type === "server-std") {
-    return path16.join(base, "server.std.log");
+    return path17.join(base, "server.std.log");
   }
   if (type === "client-std") {
-    return path16.join(base, "client.std.log");
+    return path17.join(base, "client.std.log");
   }
   if (type === "dev") {
-    return path16.join(base, "dev.log");
+    return path17.join(base, "dev.log");
   }
   if (type === "dev-std") {
-    return path16.join(base, "dev.std.log");
+    return path17.join(base, "dev.std.log");
   }
   if (type === "install-dep-std") {
-    return path16.join(base, "install-dep.std.log");
+    return path17.join(base, "install-dep.std.log");
   }
   if (type === "browser") {
-    return path16.join(base, "browser.log");
+    return path17.join(base, "browser.log");
   }
   throw new Error(`Unsupported log type: ${type}`);
 }
@@ -6015,17 +6497,18 @@ var commands = [
   syncCommand,
   actionPluginCommandGroup,
   capabilityCommandGroup,
+  componentCommandGroup,
   migrationCommand,
   readLogsCommand
 ];
 
 // src/index.ts
-var envPath = path17.join(process.cwd(), ".env");
-if (fs21.existsSync(envPath)) {
+var envPath = path18.join(process.cwd(), ".env");
+if (fs22.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 __dirname = path18.dirname(fileURLToPath4(import.meta.url));
+var pkg = JSON.parse(fs22.readFileSync(path18.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.19",
+  "version": "1.1.20-alpha.1",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",
@@ -32,18 +32,23 @@
   },
   "dependencies": {
     "@lark-apaas/http-client": "^0.1.2",
+    "@lydell/node-pty": "1.1.0",
     "@vercel/nft": "^0.30.3",
     "commander": "^13.0.0",
+    "debug": "^4.4.3",
     "dotenv": "^16.0.0",
     "drizzle-kit": "0.31.5",
     "drizzle-orm": "0.44.6",
+    "es-toolkit": "^1.44.0",
     "inflection": "^3.0.2",
     "pinyin-pro": "^3.27.0",
     "postgres": "^3.4.3",
+    "shadcn": "3.8.2",
     "ts-morph": "^27.0.0",
     "zod-to-json-schema": "^3.24.1"
   },
   "devDependencies": {
+    "@types/debug": "^4",
     "@types/node": "^22.0.0",
     "tsup": "^8.3.5",
     "typescript": "^5.9.2",