@lark-apaas/fullstack-cli 1.1.6-alpha.12 → 1.1.6-alpha.14

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs18 from "fs";
+import path16 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -168,15 +168,15 @@ async function run(options = {}) {
       console.error("[gen-db-schema] schema.ts not generated");
       throw new Error("drizzle-kit introspect failed to generate schema.ts");
     }
-    fs.mkdirSync(path.dirname(SCHEMA_FILE), { recursive: true });
-    fs.copyFileSync(generatedSchema, SCHEMA_FILE);
-    console.log(`[gen-db-schema] \u2713 Copied to ${outputPath}`);
     const { postprocessDrizzleSchema } = require2("@lark-apaas/devtool-kits");
-    const stats = postprocessDrizzleSchema(SCHEMA_FILE);
+    const stats = postprocessDrizzleSchema(generatedSchema);
     if (stats?.unmatchedUnknown?.length) {
       console.warn("[gen-db-schema] Unmatched custom types detected:", stats.unmatchedUnknown);
     }
     console.log("[gen-db-schema] \u2713 Postprocessed schema");
+    fs.mkdirSync(path.dirname(SCHEMA_FILE), { recursive: true });
+    fs.copyFileSync(generatedSchema, SCHEMA_FILE);
+    console.log(`[gen-db-schema] \u2713 Copied to ${outputPath}`);
     try {
       if (options.enableNestModuleGenerate) {
         const { parseAndGenerateNestResourceTemplate } = require2("@lark-apaas/devtool-kits");
@@ -216,8 +216,8 @@ var genDbSchemaCommand = {
 };
 
 // src/commands/sync/run.handler.ts
-import path2 from "path";
-import fs2 from "fs";
+import path3 from "path";
+import fs3 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/sync.ts
@@ -254,6 +254,12 @@ var syncConfig = {
       type: "delete-directory",
       to: ".swc"
       // 删除 .swc 目录（如果存在）
+    },
+    // 4. 从 .gitignore 中移除 package-lock.json
+    {
+      type: "remove-line",
+      to: ".gitignore",
+      pattern: "package-lock.json"
     }
   ],
   // 文件权限设置
@@ -274,18 +280,39 @@ function genSyncConfig(perms = {}) {
   return syncConfig;
 }
 
+// src/utils/file-ops.ts
+import fs2 from "fs";
+import path2 from "path";
+function removeLineFromFile(filePath, pattern) {
+  if (!fs2.existsSync(filePath)) {
+    console.log(`[fullstack-cli] \u25CB ${path2.basename(filePath)} (not found)`);
+    return false;
+  }
+  const content = fs2.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const trimmedPattern = pattern.trim();
+  const filteredLines = lines.filter((line) => line.trim() !== trimmedPattern);
+  if (filteredLines.length === lines.length) {
+    console.log(`[fullstack-cli] \u25CB ${path2.basename(filePath)} (pattern not found: ${pattern})`);
+    return false;
+  }
+  fs2.writeFileSync(filePath, filteredLines.join("\n"));
+  console.log(`[fullstack-cli] \u2713 ${path2.basename(filePath)} (removed: ${pattern})`);
+  return true;
+}
+
 // src/commands/sync/run.handler.ts
 async function run2(options) {
   const userProjectRoot = process.env.INIT_CWD || process.cwd();
   const __filename = fileURLToPath2(import.meta.url);
-  const __dirname2 = path2.dirname(__filename);
-  const pluginRoot = path2.resolve(__dirname2, "..");
+  const __dirname2 = path3.dirname(__filename);
+  const pluginRoot = path3.resolve(__dirname2, "..");
   if (userProjectRoot === pluginRoot) {
     console.log("[fullstack-cli] Skip syncing (installing plugin itself)");
     process.exit(0);
   }
-  const userPackageJson = path2.join(userProjectRoot, "package.json");
-  if (!fs2.existsSync(userPackageJson)) {
+  const userPackageJson = path3.join(userProjectRoot, "package.json");
+  if (!fs3.existsSync(userPackageJson)) {
     console.log("[fullstack-cli] Skip syncing (not a valid npm project)");
     process.exit(0);
   }
@@ -313,7 +340,7 @@ async function run2(options) {
 }
 async function syncRule(rule, pluginRoot, userProjectRoot) {
   if (rule.type === "delete-file" || rule.type === "delete-directory") {
-    const destPath2 = path2.join(userProjectRoot, rule.to);
+    const destPath2 = path3.join(userProjectRoot, rule.to);
     if (rule.type === "delete-file") {
       deleteFile(destPath2);
     } else {
@@ -321,12 +348,17 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
     }
     return;
   }
+  if (rule.type === "remove-line") {
+    const destPath2 = path3.join(userProjectRoot, rule.to);
+    removeLineFromFile(destPath2, rule.pattern);
+    return;
+  }
   if (!("from" in rule)) {
     return;
   }
-  const srcPath = path2.join(pluginRoot, rule.from);
-  const destPath = path2.join(userProjectRoot, rule.to);
-  if (!fs2.existsSync(srcPath)) {
+  const srcPath = path3.join(pluginRoot, rule.from);
+  const destPath = path3.join(userProjectRoot, rule.to);
+  if (!fs3.existsSync(srcPath)) {
     console.warn(`[fullstack-cli] Source not found: ${rule.from}`);
     return;
   }
@@ -343,64 +375,64 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
   }
 }
 function syncFile(src, dest, overwrite = true) {
-  const destDir = path2.dirname(dest);
-  if (!fs2.existsSync(destDir)) {
-    fs2.mkdirSync(destDir, { recursive: true });
+  const destDir = path3.dirname(dest);
+  if (!fs3.existsSync(destDir)) {
+    fs3.mkdirSync(destDir, { recursive: true });
   }
-  if (fs2.existsSync(dest) && !overwrite) {
-    console.log(`[fullstack-cli] \u25CB ${path2.basename(dest)} (skipped, already exists)`);
+  if (fs3.existsSync(dest) && !overwrite) {
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(dest)} (skipped, already exists)`);
     return;
   }
-  fs2.copyFileSync(src, dest);
-  console.log(`[fullstack-cli] \u2713 ${path2.basename(dest)}`);
+  fs3.copyFileSync(src, dest);
+  console.log(`[fullstack-cli] \u2713 ${path3.basename(dest)}`);
 }
 function syncDirectory(src, dest, overwrite = true) {
-  if (!fs2.existsSync(dest)) {
-    fs2.mkdirSync(dest, { recursive: true });
+  if (!fs3.existsSync(dest)) {
+    fs3.mkdirSync(dest, { recursive: true });
   }
-  const files = fs2.readdirSync(src);
+  const files = fs3.readdirSync(src);
   let count = 0;
   files.forEach((file) => {
-    const srcFile = path2.join(src, file);
-    const destFile = path2.join(dest, file);
-    const stats = fs2.statSync(srcFile);
+    const srcFile = path3.join(src, file);
+    const destFile = path3.join(dest, file);
+    const stats = fs3.statSync(srcFile);
     if (stats.isDirectory()) {
       syncDirectory(srcFile, destFile, overwrite);
     } else {
-      if (overwrite || !fs2.existsSync(destFile)) {
-        fs2.copyFileSync(srcFile, destFile);
-        console.log(`[fullstack-cli] \u2713 ${path2.relative(dest, destFile)}`);
+      if (overwrite || !fs3.existsSync(destFile)) {
+        fs3.copyFileSync(srcFile, destFile);
+        console.log(`[fullstack-cli] \u2713 ${path3.relative(dest, destFile)}`);
         count++;
       }
     }
   });
   if (count > 0) {
-    console.log(`[fullstack-cli] Synced ${count} files to ${path2.basename(dest)}/`);
+    console.log(`[fullstack-cli] Synced ${count} files to ${path3.basename(dest)}/`);
   }
 }
 function appendToFile(src, dest) {
-  const content = fs2.readFileSync(src, "utf-8");
+  const content = fs3.readFileSync(src, "utf-8");
   let existingContent = "";
-  if (fs2.existsSync(dest)) {
-    existingContent = fs2.readFileSync(dest, "utf-8");
+  if (fs3.existsSync(dest)) {
+    existingContent = fs3.readFileSync(dest, "utf-8");
   }
   if (existingContent.includes(content.trim())) {
-    console.log(`[fullstack-cli] \u25CB ${path2.basename(dest)} (already contains content)`);
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(dest)} (already contains content)`);
     return;
   }
-  fs2.appendFileSync(dest, content);
-  console.log(`[fullstack-cli] \u2713 ${path2.basename(dest)} (appended)`);
+  fs3.appendFileSync(dest, content);
+  console.log(`[fullstack-cli] \u2713 ${path3.basename(dest)} (appended)`);
 }
 function setPermissions(permissions, projectRoot) {
   for (const [pattern, mode] of Object.entries(permissions)) {
     if (pattern === "**/*.sh") {
-      const scriptsDir = path2.join(projectRoot, "scripts");
-      if (fs2.existsSync(scriptsDir)) {
-        const files = fs2.readdirSync(scriptsDir);
+      const scriptsDir = path3.join(projectRoot, "scripts");
+      if (fs3.existsSync(scriptsDir)) {
+        const files = fs3.readdirSync(scriptsDir);
         files.forEach((file) => {
           if (file.endsWith(".sh")) {
-            const filePath = path2.join(scriptsDir, file);
-            fs2.chmodSync(filePath, mode);
+            const filePath = path3.join(scriptsDir, file);
+            fs3.chmodSync(filePath, mode);
           }
         });
       }
@@ -408,19 +440,19 @@ function setPermissions(permissions, projectRoot) {
   }
 }
 function deleteFile(filePath) {
-  if (fs2.existsSync(filePath)) {
-    fs2.unlinkSync(filePath);
-    console.log(`[fullstack-cli] \u2713 ${path2.basename(filePath)} (deleted)`);
+  if (fs3.existsSync(filePath)) {
+    fs3.unlinkSync(filePath);
+    console.log(`[fullstack-cli] \u2713 ${path3.basename(filePath)} (deleted)`);
   } else {
-    console.log(`[fullstack-cli] \u25CB ${path2.basename(filePath)} (not found)`);
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(filePath)} (not found)`);
   }
 }
 function deleteDirectory(dirPath) {
-  if (fs2.existsSync(dirPath)) {
-    fs2.rmSync(dirPath, { recursive: true });
-    console.log(`[fullstack-cli] \u2713 ${path2.basename(dirPath)} (deleted)`);
+  if (fs3.existsSync(dirPath)) {
+    fs3.rmSync(dirPath, { recursive: true });
+    console.log(`[fullstack-cli] \u2713 ${path3.basename(dirPath)} (deleted)`);
   } else {
-    console.log(`[fullstack-cli] \u25CB ${path2.basename(dirPath)} (not found)`);
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(dirPath)} (not found)`);
   }
 }
 
@@ -436,8 +468,8 @@ var syncCommand = {
 };
 
 // src/commands/action-plugin/utils.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { spawnSync as spawnSync2, execSync } from "child_process";
 function parsePluginName(input) {
   const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
@@ -455,18 +487,18 @@ function getProjectRoot() {
   return process.cwd();
 }
 function getPackageJsonPath() {
-  return path3.join(getProjectRoot(), "package.json");
+  return path4.join(getProjectRoot(), "package.json");
 }
 function getPluginPath(pluginName) {
-  return path3.join(getProjectRoot(), "node_modules", pluginName);
+  return path4.join(getProjectRoot(), "node_modules", pluginName);
 }
 function readPackageJson() {
   const pkgPath = getPackageJsonPath();
-  if (!fs3.existsSync(pkgPath)) {
+  if (!fs4.existsSync(pkgPath)) {
     throw new Error("package.json not found in current directory");
   }
   try {
-    const content = fs3.readFileSync(pkgPath, "utf-8");
+    const content = fs4.readFileSync(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
     throw new Error("Failed to parse package.json");
@@ -474,7 +506,7 @@ function readPackageJson() {
 }
 function writePackageJson(pkg2) {
   const pkgPath = getPackageJsonPath();
-  fs3.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs4.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 function readActionPlugins() {
   const pkg2 = readPackageJson();
@@ -507,12 +539,12 @@ function npmInstall(tgzPath) {
   }
 }
 function getPackageVersion(pluginName) {
-  const pkgJsonPath = path3.join(getPluginPath(pluginName), "package.json");
-  if (!fs3.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path4.join(getPluginPath(pluginName), "package.json");
+  if (!fs4.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs3.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs4.readFileSync(pkgJsonPath, "utf-8");
     const pkg2 = JSON.parse(content);
     return pkg2.version || null;
   } catch {
@@ -520,49 +552,49 @@ function getPackageVersion(pluginName) {
   }
 }
 function readPluginPackageJson(pluginPath) {
-  const pkgJsonPath = path3.join(pluginPath, "package.json");
-  if (!fs3.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path4.join(pluginPath, "package.json");
+  if (!fs4.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs3.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs4.readFileSync(pkgJsonPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function extractTgzToNodeModules(tgzPath, pluginName) {
-  const nodeModulesPath = path3.join(getProjectRoot(), "node_modules");
-  const targetDir = path3.join(nodeModulesPath, pluginName);
-  const scopeDir = path3.dirname(targetDir);
-  if (!fs3.existsSync(scopeDir)) {
-    fs3.mkdirSync(scopeDir, { recursive: true });
+  const nodeModulesPath = path4.join(getProjectRoot(), "node_modules");
+  const targetDir = path4.join(nodeModulesPath, pluginName);
+  const scopeDir = path4.dirname(targetDir);
+  if (!fs4.existsSync(scopeDir)) {
+    fs4.mkdirSync(scopeDir, { recursive: true });
   }
-  if (fs3.existsSync(targetDir)) {
-    fs3.rmSync(targetDir, { recursive: true });
+  if (fs4.existsSync(targetDir)) {
+    fs4.rmSync(targetDir, { recursive: true });
   }
-  const tempDir = path3.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
-  if (fs3.existsSync(tempDir)) {
-    fs3.rmSync(tempDir, { recursive: true });
+  const tempDir = path4.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs4.existsSync(tempDir)) {
+    fs4.rmSync(tempDir, { recursive: true });
   }
-  fs3.mkdirSync(tempDir, { recursive: true });
+  fs4.mkdirSync(tempDir, { recursive: true });
   try {
     execSync(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
-    const extractedDir = path3.join(tempDir, "package");
-    if (fs3.existsSync(extractedDir)) {
-      fs3.renameSync(extractedDir, targetDir);
+    const extractedDir = path4.join(tempDir, "package");
+    if (fs4.existsSync(extractedDir)) {
+      fs4.renameSync(extractedDir, targetDir);
     } else {
-      const files = fs3.readdirSync(tempDir);
+      const files = fs4.readdirSync(tempDir);
       if (files.length === 1) {
-        fs3.renameSync(path3.join(tempDir, files[0]), targetDir);
+        fs4.renameSync(path4.join(tempDir, files[0]), targetDir);
       } else {
         throw new Error("Unexpected tgz structure");
       }
     }
     return targetDir;
   } finally {
-    if (fs3.existsSync(tempDir)) {
-      fs3.rmSync(tempDir, { recursive: true });
+    if (fs4.existsSync(tempDir)) {
+      fs4.rmSync(tempDir, { recursive: true });
     }
   }
 }
@@ -571,10 +603,10 @@ function checkMissingPeerDeps(peerDeps) {
     return [];
   }
   const missing = [];
-  const nodeModulesPath = path3.join(getProjectRoot(), "node_modules");
+  const nodeModulesPath = path4.join(getProjectRoot(), "node_modules");
   for (const [depName, _version] of Object.entries(peerDeps)) {
-    const depPath = path3.join(nodeModulesPath, depName);
-    if (!fs3.existsSync(depPath)) {
+    const depPath = path4.join(nodeModulesPath, depName);
+    if (!fs4.existsSync(depPath)) {
       missing.push(depName);
     }
   }
@@ -598,16 +630,16 @@ function installMissingDeps(deps) {
 }
 function removePluginDirectory(pluginName) {
   const pluginPath = getPluginPath(pluginName);
-  if (fs3.existsSync(pluginPath)) {
-    fs3.rmSync(pluginPath, { recursive: true });
+  if (fs4.existsSync(pluginPath)) {
+    fs4.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 fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // src/utils/http-client.ts
 import { HttpClient } from "@lark-apaas/http-client";
@@ -692,19 +724,19 @@ async function downloadFromPublic(downloadURL) {
   return Buffer.from(arrayBuffer);
 }
 function getPluginCacheDir() {
-  return path4.join(process.cwd(), PLUGIN_CACHE_DIR);
+  return path5.join(process.cwd(), PLUGIN_CACHE_DIR);
 }
 function ensureCacheDir() {
   const cacheDir = getPluginCacheDir();
-  if (!fs4.existsSync(cacheDir)) {
-    fs4.mkdirSync(cacheDir, { recursive: true });
+  if (!fs5.existsSync(cacheDir)) {
+    fs5.mkdirSync(cacheDir, { recursive: true });
   }
 }
 function getTempFilePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}-${version}.tgz`;
-  return path4.join(getPluginCacheDir(), filename);
+  return path5.join(getPluginCacheDir(), filename);
 }
 async function downloadPlugin(pluginKey, requestedVersion) {
   console.log(`[action-plugin] Fetching plugin info for ${pluginKey}@${requestedVersion}...`);
@@ -720,7 +752,7 @@ async function downloadPlugin(pluginKey, requestedVersion) {
     tgzBuffer = await downloadFromPublic(pluginInfo.downloadURL);
   }
   const tgzPath = getTempFilePath(pluginKey, pluginInfo.version);
-  fs4.writeFileSync(tgzPath, tgzBuffer);
+  fs5.writeFileSync(tgzPath, tgzBuffer);
   console.log(`[action-plugin] Downloaded to ${tgzPath} (${(tgzBuffer.length / 1024).toFixed(2)} KB)`);
   return {
     tgzPath,
@@ -730,8 +762,8 @@ async function downloadPlugin(pluginKey, requestedVersion) {
 }
 function cleanupTempFile(tgzPath) {
   try {
-    if (fs4.existsSync(tgzPath)) {
-      fs4.unlinkSync(tgzPath);
+    if (fs5.existsSync(tgzPath)) {
+      fs5.unlinkSync(tgzPath);
     }
   } catch {
   }
@@ -1056,39 +1088,39 @@ var actionPluginCommandGroup = {
 };
 
 // src/commands/capability/utils.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 var CAPABILITIES_DIR = "server/capabilities";
 function getProjectRoot2() {
   return process.cwd();
 }
 function getCapabilitiesDir() {
-  return path5.join(getProjectRoot2(), CAPABILITIES_DIR);
+  return path6.join(getProjectRoot2(), CAPABILITIES_DIR);
 }
 function getCapabilityPath(id) {
-  return path5.join(getCapabilitiesDir(), `${id}.json`);
+  return path6.join(getCapabilitiesDir(), `${id}.json`);
 }
 function getPluginManifestPath(pluginKey) {
-  return path5.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
+  return path6.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
-  return fs5.existsSync(getCapabilitiesDir());
+  return fs6.existsSync(getCapabilitiesDir());
 }
 function listCapabilityIds() {
   const dir = getCapabilitiesDir();
-  if (!fs5.existsSync(dir)) {
+  if (!fs6.existsSync(dir)) {
     return [];
   }
-  const files = fs5.readdirSync(dir);
+  const files = fs6.readdirSync(dir);
   return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
 }
 function readCapability(id) {
   const filePath = getCapabilityPath(id);
-  if (!fs5.existsSync(filePath)) {
+  if (!fs6.existsSync(filePath)) {
     throw new Error(`Capability not found: ${id}`);
   }
   try {
-    const content = fs5.readFileSync(filePath, "utf-8");
+    const content = fs6.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -1103,11 +1135,11 @@ function readAllCapabilities() {
 }
 function readPluginManifest(pluginKey) {
   const manifestPath = getPluginManifestPath(pluginKey);
-  if (!fs5.existsSync(manifestPath)) {
+  if (!fs6.existsSync(manifestPath)) {
     throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
-    const content = fs5.readFileSync(manifestPath, "utf-8");
+    const content = fs6.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -1138,14 +1170,6 @@ async function loadPlugin(pluginKey) {
     );
   }
 }
-async function zodToJsonSchema(zodSchema) {
-  try {
-    const { zodToJsonSchema: convert } = await import("zod-to-json-schema");
-    return convert(zodSchema);
-  } catch {
-    throw new Error("Failed to convert Zod schema to JSON Schema. Make sure zod-to-json-schema is installed.");
-  }
-}
 async function hydrateCapability(capability) {
   try {
     const manifest = readPluginManifest(capability.pluginKey);
@@ -1170,11 +1194,11 @@ async function hydrateCapability(capability) {
         if (!pluginInstance) {
           throw new Error(`Plugin instance not available for dynamic schema`);
         }
-        const zodSchema = pluginInstance.getInputSchema(manifestAction.key);
-        if (!zodSchema) {
+        const jsonSchema = pluginInstance.getInputJsonSchema(manifestAction.key);
+        if (!jsonSchema) {
           throw new Error(`Failed to get input schema for action: ${manifestAction.key}`);
         }
-        inputSchema = await zodToJsonSchema(zodSchema);
+        inputSchema = jsonSchema;
       } else {
         inputSchema = manifestAction.inputSchema;
       }
@@ -1183,11 +1207,11 @@ async function hydrateCapability(capability) {
         if (!pluginInstance) {
           throw new Error(`Plugin instance not available for dynamic schema`);
         }
-        const zodSchema = pluginInstance.getOutputSchema(manifestAction.key, {});
-        if (!zodSchema) {
+        const jsonSchema = pluginInstance.getOutputJsonSchema(manifestAction.key, capability.formValue || {});
+        if (!jsonSchema) {
           throw new Error(`Failed to get output schema for action: ${manifestAction.key}`);
         }
-        outputSchema = await zodToJsonSchema(zodSchema);
+        outputSchema = jsonSchema;
       } else {
         outputSchema = manifestAction.outputSchema;
       }
@@ -1289,58 +1313,58 @@ var capabilityCommandGroup = {
 };
 
 // src/commands/migration/version-manager.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 var PACKAGE_JSON = "package.json";
 var VERSION_FIELD = "migrationVersion";
 function getPackageJsonPath2() {
-  return path6.join(process.cwd(), PACKAGE_JSON);
+  return path7.join(process.cwd(), PACKAGE_JSON);
 }
 function getCurrentVersion() {
   const pkgPath = getPackageJsonPath2();
-  if (!fs6.existsSync(pkgPath)) {
+  if (!fs7.existsSync(pkgPath)) {
     throw new Error("package.json not found");
   }
-  const pkg2 = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
   return pkg2[VERSION_FIELD] ?? 0;
 }
 function setCurrentVersion(version) {
   const pkgPath = getPackageJsonPath2();
-  const pkg2 = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
   pkg2[VERSION_FIELD] = version;
-  fs6.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs7.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 
 // src/commands/migration/versions/v001_capability/utils.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 var CAPABILITIES_DIR2 = "server/capabilities";
 function getProjectRoot3() {
   return process.cwd();
 }
 function getCapabilitiesDir2() {
-  return path7.join(getProjectRoot3(), CAPABILITIES_DIR2);
+  return path8.join(getProjectRoot3(), CAPABILITIES_DIR2);
 }
 function getPluginManifestPath2(pluginKey) {
-  return path7.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
+  return path8.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
 function detectJsonMigration() {
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldFilePath = path8.join(capabilitiesDir, "capabilities.json");
-  if (!fs8.existsSync(oldFilePath)) {
+  const oldFilePath = path9.join(capabilitiesDir, "capabilities.json");
+  if (!fs9.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
       reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs8.readFileSync(oldFilePath, "utf-8");
+    const content = fs9.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
     const capabilities = Array.isArray(parsed) ? parsed : [];
     return {
@@ -1349,10 +1373,12 @@ function detectJsonMigration() {
       oldFilePath
     };
   } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(`[migration] Warning: capabilities.json is not valid JSON, skipping migration`);
+    console.warn(`[migration]   Error: ${errorMessage}`);
     return {
-      needsMigration: true,
-      oldCapabilities: [],
-      oldFilePath
+      needsMigration: false,
+      reason: `capabilities.json is not valid JSON: ${errorMessage}`
     };
   }
 }
@@ -1378,8 +1404,8 @@ async function check(options) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 
 // src/commands/migration/versions/v001_capability/mapping.ts
 var DEFAULT_PLUGIN_VERSION = "1.0.0";
@@ -1494,7 +1520,7 @@ var DEFAULT_TEMPERATURE = 0.7;
 function transformAITextGenerate(input) {
   const actionInput = input;
   return {
-    modelID: actionInput.model_id ?? DEFAULT_MODEL_ID,
+    modelID: DEFAULT_MODEL_ID,
     prompt: actionInput.prompt ?? "",
     modelParams: {
       maxTokens: convertToNumber(actionInput.max_tokens, DEFAULT_MAX_TOKENS),
@@ -1512,7 +1538,7 @@ function transformAIImageUnderstanding(input) {
   return {
     prompt: actionInput.prompt ?? "",
     images: actionInput.image_list ?? [],
-    modelID: actionInput.model_id ?? DEFAULT_MODEL_ID2,
+    modelID: DEFAULT_MODEL_ID2,
     modelParams: {
       maxTokens: convertToNumber(actionInput.max_tokens, DEFAULT_MAX_TOKENS2),
       temperature: convertToNumber(actionInput.temperature, DEFAULT_TEMPERATURE2)
@@ -1573,18 +1599,18 @@ function transformCapabilities(oldCapabilities) {
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
 function loadExistingCapabilities() {
   const capabilitiesDir = getCapabilitiesDir2();
-  if (!fs9.existsSync(capabilitiesDir)) {
+  if (!fs10.existsSync(capabilitiesDir)) {
     return [];
   }
-  const files = fs9.readdirSync(capabilitiesDir);
+  const files = fs10.readdirSync(capabilitiesDir);
   const capabilities = [];
   for (const file of files) {
     if (file === "capabilities.json" || !file.endsWith(".json")) {
       continue;
     }
     try {
-      const filePath = path9.join(capabilitiesDir, file);
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const filePath = path10.join(capabilitiesDir, file);
+      const content = fs10.readFileSync(filePath, "utf-8");
       const capability = JSON.parse(content);
       if (capability.id && capability.pluginKey) {
         capabilities.push(capability);
@@ -1642,9 +1668,9 @@ async function migrateJsonFiles(options) {
   }
   const capabilitiesDir = getCapabilitiesDir2();
   for (const cap of newCapabilities) {
-    const filePath = path9.join(capabilitiesDir, `${cap.id}.json`);
+    const filePath = path10.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs9.writeFileSync(filePath, content, "utf-8");
+    fs10.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
   return {
@@ -1656,10 +1682,10 @@ async function migrateJsonFiles(options) {
 }
 
 // src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
-import fs10 from "fs";
+import fs11 from "fs";
 function isPluginInstalled2(pluginKey) {
   const manifestPath = getPluginManifestPath2(pluginKey);
-  return fs10.existsSync(manifestPath);
+  return fs11.existsSync(manifestPath);
 }
 function detectPluginsToInstall(capabilities) {
   const pluginKeys = /* @__PURE__ */ new Set();
@@ -1735,12 +1761,12 @@ async function installPlugins(capabilities, options) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-import path11 from "path";
+import path12 from "path";
 import { Project } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
   "dist",
@@ -1755,9 +1781,9 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs11.readdirSync(dir, { withFileTypes: true });
+  const entries = fs12.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path10.join(dir, entry.name);
+    const fullPath = path11.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.includes(entry.name)) {
         continue;
@@ -1773,14 +1799,14 @@ function scanDirectory(dir, files = []) {
   return files;
 }
 function scanServerFiles() {
-  const serverDir = path10.join(getProjectRoot3(), "server");
-  if (!fs11.existsSync(serverDir)) {
+  const serverDir = path11.join(getProjectRoot3(), "server");
+  if (!fs12.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs11.readFileSync(filePath, "utf-8");
+  const content = fs12.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -2155,7 +2181,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
-  const relativePath = path11.relative(getProjectRoot3(), filePath);
+  const relativePath = path12.relative(getProjectRoot3(), filePath);
   return {
     filePath: relativePath,
     imports,
@@ -2166,7 +2192,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   };
 }
 function migrateFile(project, analysis, dryRun) {
-  const absolutePath = path11.join(getProjectRoot3(), analysis.filePath);
+  const absolutePath = path12.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
       filePath: analysis.filePath,
@@ -2269,17 +2295,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path13 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldJsonPath = path12.join(capabilitiesDir, "capabilities.json");
-  if (fs12.existsSync(oldJsonPath)) {
+  const oldJsonPath = path13.join(capabilitiesDir, "capabilities.json");
+  if (fs13.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs12.unlinkSync(oldJsonPath);
+        fs13.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -2287,11 +2313,11 @@ function cleanupOldFiles(capabilities, dryRun) {
     }
   }
   for (const cap of capabilities) {
-    const tsFilePath = path12.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs12.existsSync(tsFilePath)) {
+    const tsFilePath = path13.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs13.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs12.unlinkSync(tsFilePath);
+          fs13.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -2307,8 +2333,8 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path14 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
   const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
@@ -2470,8 +2496,8 @@ async function generateReport(result) {
     lines.push("- [ ] \u5904\u7406\u624B\u52A8\u8FC1\u79FB\u9879");
   }
   lines.push("");
-  const reportPath = path13.join(getProjectRoot3(), REPORT_FILE);
-  fs13.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  const reportPath = path14.join(getProjectRoot3(), REPORT_FILE);
+  fs14.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${REPORT_FILE}`);
 }
 
@@ -2871,6 +2897,10 @@ async function runMigrations(options) {
   printSummary2(summary, !!options.dryRun);
   return summary;
 }
+function printMigrationResult(result) {
+  console.log("");
+  console.log(`MigrationResult=${JSON.stringify(result)}`);
+}
 async function checkMigrations(options) {
   const currentVersion = getCurrentVersion();
   const latestVersion = getLatestVersion();
@@ -2878,6 +2908,12 @@ async function checkMigrations(options) {
   log(`Current version: ${currentVersion || "0 (not set)"}`);
   if (currentVersion >= latestVersion) {
     log("All migrations are up to date.");
+    printMigrationResult({
+      needMigration: false,
+      migrationVersion: currentVersion,
+      targetVersion: latestVersion,
+      pendingMigrations: []
+    });
     return {
       needsMigration: false,
       completed: [],
@@ -2896,13 +2932,16 @@ async function checkMigrations(options) {
   };
   let needsCount = 0;
   let noActionCount = 0;
+  const pendingMigrationNames = [];
   for (const migration of pendingMigrations) {
     const { version, name } = migration;
     const versionTag = `v${version}`;
+    const versionName = `v${String(version).padStart(3, "0")}_${name}`;
     try {
       const checkResult = await migration.check(options);
       if (checkResult.needsMigration) {
         needsCount++;
+        pendingMigrationNames.push(versionName);
         console.log(`  ${versionTag} (${name}): needs migration`);
         if (checkResult.items && checkResult.items.length > 0) {
           for (const item of checkResult.items) {
@@ -2949,11 +2988,19 @@ async function checkMigrations(options) {
     log("Run 'fullstack-cli migration' to apply.");
   }
   summary.needsMigration = needsCount > 0;
+  let finalVersion = currentVersion;
   if (needsCount === 0 && summary.failed.length === 0) {
     setCurrentVersion(latestVersion);
+    finalVersion = latestVersion;
     console.log("");
     log(`Updated migrationVersion to ${latestVersion}.`);
   }
+  printMigrationResult({
+    needMigration: needsCount > 0,
+    migrationVersion: finalVersion,
+    targetVersion: latestVersion,
+    pendingMigrations: pendingMigrationNames
+  });
   return summary;
 }
 
@@ -2971,30 +3018,865 @@ var migrationCommand = {
     migrationCmd.command("check").description("Check pending migrations without applying them").action(async () => {
       const summary = await checkMigrations({});
       if (summary.failed.length > 0) {
-        process.exit(2);
-      } else if (summary.needsMigration) {
         process.exit(1);
       }
     });
   }
 };
 
+// src/commands/read-logs/index.ts
+import path15 from "path";
+
+// src/commands/read-logs/std-utils.ts
+import fs15 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;
+  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 localTime;
+  const pad2 = (n) => String(n).padStart(2, "0");
+  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);
+  return `${localTime.replace(" ", "T")}${sign}${offsetHH}:${offsetMM}`;
+}
+function stripPrefixFromStdLine(line) {
+  const match = line.match(/^(\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] \[(server|client)\] )(.*)$/);
+  if (!match) {
+    return line;
+  }
+  const time = formatStdPrefixTime(match[2] || "");
+  const content = match[4] || "";
+  return `[${time}] ${content}`;
+}
+function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
+  const stat = fs15.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], markerFound: false, totalLinesCount: 0 };
+  }
+  const fd = fs15.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let markerFound = false;
+  let finished = false;
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  try {
+    while (position > 0 && !finished) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs15.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const rawLine = parts[i];
+        const line = stripPrefixFromStdLine(rawLine);
+        if (totalLinesCount === 0 && line === "") {
+          continue;
+        }
+        totalLinesCount += 1;
+        if (skipped < offset) {
+          skipped += 1;
+        } else if (collected.length < maxLines) {
+          collected.push(line);
+        }
+        if (isMarker(line)) {
+          markerFound = true;
+          finished = true;
+          break;
+        }
+      }
+    }
+    if (!finished && remainder) {
+      const line = stripPrefixFromStdLine(remainder);
+      if (!(totalLinesCount === 0 && line === "")) {
+        totalLinesCount += 1;
+        if (skipped < offset) {
+          skipped += 1;
+        } else if (collected.length < maxLines) {
+          collected.push(line);
+        }
+      }
+      if (isMarker(line)) {
+        markerFound = true;
+      }
+    }
+  } finally {
+    fs15.closeSync(fd);
+  }
+  return { lines: collected.reverse(), markerFound, totalLinesCount };
+}
+
+// src/commands/read-logs/server-std.ts
+function readServerStdSegment(filePath, maxLines, offset) {
+  const marker = (line) => {
+    if (!line) return false;
+    if (/\bdev:server\b/.test(line)) return true;
+    if (line.includes("Starting compilation in watch mode")) return true;
+    if (line.includes("File change detected. Starting incremental compilation")) return true;
+    if (line.includes("Starting Nest application")) return true;
+    if (line.includes("Nest application successfully started")) return true;
+    return false;
+  };
+  const segment = readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, marker);
+  return { lines: segment.lines, totalLinesCount: segment.totalLinesCount };
+}
+
+// src/commands/read-logs/tail.ts
+import fs16 from "fs";
+function fileExists(filePath) {
+  try {
+    fs16.accessSync(filePath, fs16.constants.F_OK | fs16.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readFileTailLines(filePath, maxLines) {
+  const stat = fs16.statSync(filePath);
+  if (stat.size === 0) {
+    return [];
+  }
+  const fd = fs16.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  const chunks = [];
+  let position = stat.size;
+  let collectedLines = 0;
+  try {
+    while (position > 0 && collectedLines <= maxLines) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs16.readSync(fd, buffer, 0, length, position);
+      chunks.unshift(buffer.toString("utf8"));
+      const chunkLines = buffer.toString("utf8").split("\n").length - 1;
+      collectedLines += chunkLines;
+    }
+  } finally {
+    fs16.closeSync(fd);
+  }
+  const content = chunks.join("");
+  const allLines = content.split("\n");
+  if (allLines.length === 0) {
+    return [];
+  }
+  if (allLines[allLines.length - 1] === "") {
+    allLines.pop();
+  }
+  if (allLines.length <= maxLines) {
+    return allLines;
+  }
+  return allLines.slice(allLines.length - maxLines);
+}
+function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
+  const stat = fs16.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const fd = fs16.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  try {
+    while (position > 0) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs16.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const line = parts[i].trim();
+        if (!line) continue;
+        totalLinesCount += 1;
+        if (skipped < offset) {
+          skipped += 1;
+        } else if (collected.length < maxLines) {
+          collected.push(line);
+        }
+      }
+    }
+    if (remainder) {
+      const line = remainder.trim();
+      if (line) {
+        totalLinesCount += 1;
+        if (skipped < offset) {
+          skipped += 1;
+        } else if (collected.length < maxLines) {
+          collected.push(line);
+        }
+      }
+    }
+  } finally {
+    fs16.closeSync(fd);
+  }
+  return { lines: collected.reverse(), totalLinesCount };
+}
+
+// src/commands/read-logs/client-std.ts
+function readClientStdSegment(filePath, maxLines, offset) {
+  const lines = readFileTailLines(filePath, Math.max((maxLines + offset) * 5, 2e3));
+  return extractClientStdSegment(lines, maxLines, offset);
+}
+function extractClientStdSegment(lines, maxLines, offset) {
+  const bodyLines = lines.map(stripPrefixFromStdLine);
+  const hotStartMarkers = [
+    /file change detected\..*incremental compilation/i,
+    /starting incremental compilation/i,
+    /starting compilation/i,
+    /\bcompiling\b/i,
+    /\brecompil/i
+  ];
+  const hotEndMarkers = [
+    /file change detected\..*incremental compilation/i,
+    /\bwebpack compiled\b/i,
+    /compiled successfully/i,
+    /compiled with warnings/i,
+    /compiled with errors/i,
+    /failed to compile/i,
+    /fast refresh/i,
+    /\bhmr\b/i,
+    /hot update/i,
+    /\bhot reload\b/i,
+    /\bhmr update\b/i
+  ];
+  const compiledMarkers = [
+    /\bwebpack compiled\b/i,
+    /compiled successfully/i,
+    /compiled with warnings/i,
+    /compiled with errors/i,
+    /failed to compile/i
+  ];
+  let startIndex = -1;
+  for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
+    const line = bodyLines[i];
+    if (!line) continue;
+    if (hotStartMarkers.some((re) => re.test(line))) {
+      startIndex = i;
+      break;
+    }
+  }
+  if (startIndex === -1) {
+    let pivotIndex = -1;
+    for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
+      const line = bodyLines[i];
+      if (!line) continue;
+      if (hotEndMarkers.some((re) => re.test(line))) {
+        pivotIndex = i;
+        break;
+      }
+    }
+    if (pivotIndex !== -1) {
+      if (compiledMarkers.some((re) => re.test(bodyLines[pivotIndex] ?? ""))) {
+        startIndex = pivotIndex;
+      } else {
+        const searchLimit = 80;
+        const from = Math.max(0, pivotIndex - searchLimit);
+        for (let i = pivotIndex; i >= from; i -= 1) {
+          const line = bodyLines[i];
+          if (!line) continue;
+          if (compiledMarkers.some((re) => re.test(line))) {
+            startIndex = i;
+            break;
+          }
+        }
+        if (startIndex === -1) {
+          startIndex = pivotIndex;
+        }
+      }
+    }
+  }
+  if (startIndex === -1) {
+    for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
+      const line = bodyLines[i];
+      if (!line) continue;
+      if (/\bdev:client\b/.test(line)) {
+        startIndex = i;
+        break;
+      }
+    }
+  }
+  const segment = startIndex === -1 ? bodyLines : bodyLines.slice(startIndex);
+  if (segment.length === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  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
+  };
+}
+
+// src/commands/read-logs/json-lines.ts
+import fs17 from "fs";
+function normalizePid(value) {
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  return "unknown";
+}
+function normalizeLevelName(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed) return null;
+    if (trimmed === "warning") return "warn";
+    if (trimmed === "err") return "error";
+    const allowed = ["trace", "debug", "info", "warn", "error", "fatal"];
+    return allowed.includes(trimmed) ? trimmed : null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const num = Math.floor(value);
+    if (num <= 10) return "trace";
+    if (num <= 20) return "debug";
+    if (num <= 30) return "info";
+    if (num <= 40) return "warn";
+    if (num <= 50) return "error";
+    return "fatal";
+  }
+  return null;
+}
+function extractLevelName(obj) {
+  if (!obj || typeof obj !== "object") return null;
+  const record = obj;
+  const direct = normalizeLevelName(record["level"]);
+  if (direct) return direct;
+  const meta = record["meta"];
+  if (meta && typeof meta === "object") {
+    return normalizeLevelName(meta["level"]);
+  }
+  return null;
+}
+function buildWantedLevelSet(levels) {
+  if (!levels || levels.length === 0) return null;
+  const set = /* @__PURE__ */ new Set();
+  for (const raw of levels) {
+    const norm = normalizeLevelName(raw);
+    if (norm) set.add(norm);
+  }
+  return set.size > 0 ? set : null;
+}
+function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
+  const stat = fs17.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const fd = fs17.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let targetPid = null;
+  let finished = false;
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  const wantedLevelSet = buildWantedLevelSet(levels);
+  try {
+    while (position > 0 && !finished) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs17.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const line = parts[i].trim();
+        if (!line) continue;
+        let parsed = null;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const pid = normalizePid(parsed?.pid);
+        if (targetPid === null) {
+          targetPid = pid;
+        }
+        if (pid !== targetPid) {
+          finished = true;
+          break;
+        }
+        const levelName = extractLevelName(parsed);
+        if (!wantedLevelSet || levelName && wantedLevelSet.has(levelName)) {
+          totalLinesCount += 1;
+          if (skipped < offset) {
+            skipped += 1;
+          } else if (collected.length < maxLines) {
+            collected.push(line);
+          }
+        }
+      }
+    }
+    if (!finished && remainder) {
+      const line = remainder.trim();
+      if (line) {
+        try {
+          const parsed = JSON.parse(line);
+          const pid = normalizePid(parsed?.pid);
+          if (targetPid === null) {
+            targetPid = pid;
+          }
+          if (pid === targetPid) {
+            const levelName = extractLevelName(parsed);
+            if (!wantedLevelSet || levelName && wantedLevelSet.has(levelName)) {
+              totalLinesCount += 1;
+              if (skipped < offset) {
+                skipped += 1;
+              } else if (collected.length < maxLines) {
+                collected.push(line);
+              }
+            }
+          }
+        } catch {
+          return { lines: [], totalLinesCount: 0 };
+        }
+      }
+    }
+  } finally {
+    fs17.closeSync(fd);
+  }
+  return { lines: collected.reverse(), totalLinesCount };
+}
+function normalizeTraceId(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return null;
+}
+function extractTraceId(obj) {
+  if (!obj || typeof obj !== "object") return null;
+  const record = obj;
+  const directKeys = ["trace_id", "traceId", "traceID", "traceid"];
+  for (const key of directKeys) {
+    const value = normalizeTraceId(record[key]);
+    if (value) return value;
+  }
+  const meta = record["meta"];
+  if (meta && typeof meta === "object") {
+    const metaRecord = meta;
+    for (const key of directKeys) {
+      const value = normalizeTraceId(metaRecord[key]);
+      if (value) return value;
+    }
+  }
+  const attributes = record["attributes"];
+  if (attributes && typeof attributes === "object") {
+    const attrRecord = attributes;
+    for (const key of ["traceID", "trace_id", "traceId", "traceid"]) {
+      const value = normalizeTraceId(attrRecord[key]);
+      if (value) return value;
+    }
+  }
+  return null;
+}
+function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
+  const wanted = traceId.trim();
+  if (!wanted) return { lines: [], totalLinesCount: 0 };
+  const stat = fs17.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const fd = fs17.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  const wantedLevelSet = buildWantedLevelSet(levels);
+  try {
+    while (position > 0) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs17.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const line = parts[i].trim();
+        if (!line) continue;
+        try {
+          const parsed = JSON.parse(line);
+          const lineTraceId = extractTraceId(parsed);
+          if (lineTraceId === wanted) {
+            const levelName = extractLevelName(parsed);
+            if (!wantedLevelSet || levelName && wantedLevelSet.has(levelName)) {
+              totalLinesCount += 1;
+              if (skipped < offset) {
+                skipped += 1;
+              } else if (collected.length < maxLines) {
+                collected.push(line);
+              }
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    if (remainder) {
+      const line = remainder.trim();
+      if (line) {
+        try {
+          const parsed = JSON.parse(line);
+          const lineTraceId = extractTraceId(parsed);
+          if (lineTraceId === wanted) {
+            const levelName = extractLevelName(parsed);
+            if (!wantedLevelSet || levelName && wantedLevelSet.has(levelName)) {
+              totalLinesCount += 1;
+              if (skipped < offset) {
+                skipped += 1;
+              } else if (collected.length < maxLines) {
+                collected.push(line);
+              }
+            }
+          }
+        } catch {
+          return { lines: [], totalLinesCount: 0 };
+        }
+      }
+    }
+  } finally {
+    fs17.closeSync(fd);
+  }
+  return { lines: collected.reverse(), totalLinesCount };
+}
+function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
+  const wantedLevelSet = buildWantedLevelSet(levels);
+  if (!wantedLevelSet) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const stat = fs17.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const fd = fs17.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  try {
+    while (position > 0) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs17.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const line = parts[i].trim();
+        if (!line) continue;
+        try {
+          const parsed = JSON.parse(line);
+          const levelName = extractLevelName(parsed);
+          if (levelName && wantedLevelSet.has(levelName)) {
+            totalLinesCount += 1;
+            if (skipped < offset) {
+              skipped += 1;
+            } else if (collected.length < maxLines) {
+              collected.push(line);
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    if (remainder) {
+      const line = remainder.trim();
+      if (line) {
+        try {
+          const parsed = JSON.parse(line);
+          const levelName = extractLevelName(parsed);
+          if (levelName && wantedLevelSet.has(levelName)) {
+            totalLinesCount += 1;
+            if (skipped < offset) {
+              skipped += 1;
+            } else if (collected.length < maxLines) {
+              collected.push(line);
+            }
+          }
+        } catch {
+          return { lines: [], totalLinesCount: 0 };
+        }
+      }
+    }
+  } finally {
+    fs17.closeSync(fd);
+  }
+  return { lines: collected.reverse(), totalLinesCount };
+}
+
+// src/commands/read-logs/index.ts
+var LOG_TYPES = ["server", "trace", "server-std", "client-std", "browser"];
+function sanitizeStructuredLog(value) {
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value;
+  const obj = value;
+  const sanitized = { ...obj };
+  delete sanitized.tenant_id;
+  delete sanitized.app_id;
+  delete sanitized.pid;
+  return sanitized;
+}
+function hasErrorInStdLines(lines) {
+  const combined = lines.join("\n");
+  if (!combined) return false;
+  const strong = [
+    /compiled with errors/i,
+    /failed to compile/i,
+    /error: \w+/i,
+    /uncaught/i,
+    /unhandled/i,
+    /eaddrinuse/i,
+    /cannot find module/i,
+    /module not found/i,
+    /ts\d{3,5}:/i
+  ];
+  if (strong.some((re) => re.test(combined))) return true;
+  const weakLine = /\b(error|fatal|exception)\b/i;
+  const ignorePatterns = [
+    /\b0\s+errors?\b/i,
+    /Server Error \d{3}/i
+  ];
+  return lines.some((line) => {
+    const text = line.trim();
+    if (!text) return false;
+    if (ignorePatterns.some((re) => re.test(text))) return false;
+    return weakLine.test(text);
+  });
+}
+function hasErrorInLogObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  const rawLevel = obj.level;
+  const level = typeof rawLevel === "string" ? rawLevel.toLowerCase() : "";
+  if (level === "error" || level === "fatal") return true;
+  if (level === "err") return true;
+  if (typeof rawLevel === "number" && Number.isFinite(rawLevel) && rawLevel >= 50) return true;
+  if (level === "warn" && typeof obj.stack === "string" && obj.stack.length > 0) return true;
+  if (typeof obj.stack === "string" && obj.stack.length > 0) return true;
+  const statusCode = obj.statusCode;
+  const status_code = obj.status_code;
+  const meta = obj.meta;
+  const metaObj = meta && typeof meta === "object" ? meta : null;
+  const metaStatusCode = metaObj?.statusCode;
+  const metaStatus_code = metaObj?.status_code;
+  const candidates = [statusCode, status_code, metaStatusCode, metaStatus_code];
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 400) {
+      return true;
+    }
+  }
+  const message = typeof obj.message === "string" ? obj.message : "";
+  if (message && hasErrorInStdLines([message])) return true;
+  return false;
+}
+async function readLatestLogLinesMeta(options) {
+  const maxLines = options.maxLines ?? 30;
+  const offset = options.offset ?? 0;
+  const filePath = resolveLogFilePath(options.logDir, options.type);
+  const levels = Array.isArray(options.levels) ? options.levels : void 0;
+  if (!fileExists(filePath)) {
+    throw new Error(`Log file not found: ${filePath}`);
+  }
+  if (options.type === "server-std") {
+    return readServerStdSegment(filePath, maxLines, offset);
+  }
+  if (options.type === "client-std") {
+    return readClientStdSegment(filePath, maxLines, offset);
+  }
+  const traceId = typeof options.traceId === "string" ? options.traceId.trim() : "";
+  if (traceId) {
+    return readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels);
+  }
+  if (options.type === "server" || options.type === "trace") {
+    return readJsonLinesLastPid(filePath, maxLines, offset, levels);
+  }
+  if (options.type === "browser") {
+    if (levels && levels.length > 0) {
+      return readJsonLinesTailByLevel(filePath, maxLines, offset, levels);
+    }
+    return readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset);
+  }
+  return { lines: [], totalLinesCount: 0 };
+}
+async function readLogsJsonResult(options) {
+  const { lines, totalLinesCount } = await readLatestLogLinesMeta(options);
+  if (options.type === "server-std" || options.type === "client-std") {
+    return {
+      hasError: hasErrorInStdLines(lines),
+      totalLinesCount,
+      logs: lines
+    };
+  }
+  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));
+      if (!hasError && hasErrorInLogObject(parsed)) {
+        hasError = true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return {
+    hasError,
+    totalLinesCount,
+    logs
+  };
+}
+function resolveLogFilePath(logDir, type) {
+  const base = path15.isAbsolute(logDir) ? logDir : path15.join(process.cwd(), logDir);
+  if (type === "server") {
+    return path15.join(base, "server.log");
+  }
+  if (type === "trace") {
+    return path15.join(base, "trace.log");
+  }
+  if (type === "server-std") {
+    return path15.join(base, "server.std.log");
+  }
+  if (type === "client-std") {
+    return path15.join(base, "client.std.log");
+  }
+  if (type === "browser") {
+    return path15.join(base, "browser.log");
+  }
+  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;
+  }
+}
+function parseLogType(input) {
+  const value = typeof input === "string" ? input.trim() : "";
+  if (LOG_TYPES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid --type: ${String(input)}. Expected one of: ${LOG_TYPES.join(", ")}`);
+}
+function parsePositiveInt(input, flagName) {
+  const value = typeof input === "number" ? input : Number.parseInt(String(input), 10);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`Invalid ${flagName}: ${String(input)}. Expected a positive integer.`);
+  }
+  return value;
+}
+function parseNonNegativeInt(input, flagName) {
+  const value = typeof input === "number" ? input : Number.parseInt(String(input), 10);
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`Invalid ${flagName}: ${String(input)}. Expected a non-negative integer.`);
+  }
+  return value;
+}
+function parseCommaSeparatedList(input) {
+  const value = typeof input === "string" ? input : "";
+  const items = value.split(",").map((s) => s.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+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) => {
+      try {
+        const logDir = typeof rawOptions.dir === "string" ? rawOptions.dir : "logs";
+        const type = parseLogType(rawOptions.type);
+        const maxLines = parsePositiveInt(rawOptions.maxLines, "--max-lines");
+        const offset = parseNonNegativeInt(rawOptions.offset, "--offset");
+        const traceId = typeof rawOptions.traceId === "string" ? rawOptions.traceId : void 0;
+        const levels = parseCommaSeparatedList(rawOptions.level);
+        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.exitCode = 1;
+      }
+    });
+  }
+};
+
 // src/commands/index.ts
 var commands = [
   genDbSchemaCommand,
   syncCommand,
   actionPluginCommandGroup,
   capabilityCommandGroup,
-  migrationCommand
+  migrationCommand,
+  readLogsCommand
 ];
 
 // src/index.ts
-var envPath = path14.join(process.cwd(), ".env");
-if (fs14.existsSync(envPath)) {
+var envPath = path16.join(process.cwd(), ".env");
+if (fs18.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path14.dirname(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(fs14.readFileSync(path14.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path16.dirname(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(fs18.readFileSync(path16.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();