@lark-apaas/fullstack-cli 1.1.9 → 1.1.10

package/dist/index.js

@@ -1,54 +1,3881 @@
-import { fileURLToPath } from 'node:url';
-import path from 'node:path';
-import fs from 'node:fs';
-import cac from 'cac';
-import { run as runGenDbSchema } from './commands/gen-db-schema.js';
-import { run as runSync } from './commands/sync.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// 读取 package.json
-const pkgPath = path.join(__dirname, '../package.json');
-const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-const cli = cac('fullstack-cli');
-// 设置全局描述和版本
-cli
-    .version(pkg.version)
-    .help();
-// gen-db-schema 命令
-cli
-    .command('gen-db-schema', 'Generate database schema from existing database')
-    .option('--output <path>', 'Output path for schema', {
-    default: 'server/database/schema.ts',
-})
-    .option('--schema-filter <schemas>', 'Schema filter, comma-separated')
-    .option('--tables-filter <tables>', 'Tables filter, comma-separated')
-    .option('--enable-nest-module-generate', 'Enable generate NestJS module boilerplate')
-    .example('fullstack-cli gen-db-schema')
-    .example('fullstack-cli gen-db-schema --output custom/schema.ts')
-    .action(async (options) => {
-    try {
-        await runGenDbSchema(options);
-    }
-    catch (error) {
-        console.error(`Failed to execute command:`, error.message);
-        console.error(error.stack);
-        process.exit(1);
+// src/index.ts
+import fs18 from "fs";
+import path16 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { config as dotenvConfig } from "dotenv";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/hooks.ts
+var HooksManager = class {
+  constructor() {
+    this.beforeHooks = [];
+    this.afterHooks = [];
+  }
+  /** 注册 beforeRun hook */
+  beforeRun(hook) {
+    this.beforeHooks.push(hook);
+    return this;
+  }
+  /** 注册 afterRun hook */
+  afterRun(hook) {
+    this.afterHooks.push(hook);
+    return this;
+  }
+  /** 执行 beforeRun hooks */
+  async runBeforeHooks(ctx) {
+    for (const hook of this.beforeHooks) {
+      await hook(ctx);
+    }
+  }
+  /** 执行 afterRun hooks */
+  async runAfterHooks(ctx, error) {
+    for (const hook of this.afterHooks) {
+      await hook(ctx, error);
+    }
+  }
+  /** 包装命令 action，自动执行 hooks */
+  wrapAction(commandName, action) {
+    return async (...args) => {
+      const ctx = {
+        commandName,
+        args: args.filter((a) => typeof a === "string"),
+        options: args.find((a) => typeof a === "object" && a !== null) || {},
+        startTime: Date.now()
+      };
+      let error;
+      try {
+        await this.runBeforeHooks(ctx);
+        await action(...args);
+      } catch (e) {
+        error = e instanceof Error ? e : new Error(String(e));
+        throw error;
+      } finally {
+        await this.runAfterHooks(ctx, error);
+      }
+    };
+  }
+};
+
+// src/cli.ts
+var FullstackCLI = class {
+  constructor(version) {
+    this.program = new Command();
+    this.hooks = new HooksManager();
+    this.program.name("fullstack-cli").description("CLI tool for fullstack template management").version(version);
+    this.setupDefaultHooks();
+  }
+  setupDefaultHooks() {
+    this.hooks.afterRun((ctx, error) => {
+      if (error) {
+        console.error(`
+Command "${ctx.commandName}" failed:`, error.message);
+        if (process.env.DEBUG) {
+          console.error(error.stack);
+        }
+        process.exitCode = 1;
+      }
+    });
+    this.hooks.afterRun((ctx, error) => {
+      if (process.env.DEBUG && !error) {
+        const elapsed = Date.now() - ctx.startTime;
+        console.log(`
+Command "${ctx.commandName}" completed in ${elapsed}ms`);
+      }
+    });
+  }
+  /** 注册单个命令 */
+  use(command) {
+    command.register(this.program);
+    return this;
+  }
+  /** 注册命令组 */
+  useGroup(group) {
+    const groupCmd = this.program.command(group.name).description(group.description);
+    for (const cmd of group.commands) {
+      cmd.register(groupCmd);
+    }
+    return this;
+  }
+  /** 批量注册 */
+  useAll(items) {
+    for (const item of items) {
+      if ("commands" in item) {
+        this.useGroup(item);
+      } else {
+        this.use(item);
+      }
+    }
+    return this;
+  }
+  /** 运行 CLI */
+  run(argv = process.argv) {
+    this.program.parse(argv);
+  }
+};
+
+// src/commands/db/schema.handler.ts
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { spawnSync } from "child_process";
+import { createRequire } from "module";
+import { config as loadEnv } from "dotenv";
+var require2 = createRequire(import.meta.url);
+async function run(options = {}) {
+  let exitCode = 0;
+  const envPath2 = path.resolve(process.cwd(), ".env");
+  if (fs.existsSync(envPath2)) {
+    loadEnv({ path: envPath2 });
+    console.log("[gen-db-schema] \u2713 Loaded .env file");
+  }
+  const databaseUrl = process.env.SUDA_DATABASE_URL;
+  if (!databaseUrl) {
+    console.error("[gen-db-schema] Error: SUDA_DATABASE_URL environment variable is required");
+    process.exit(1);
+  }
+  const outputPath = options.output || process.env.DB_SCHEMA_OUTPUT || "server/database/schema.ts";
+  const OUT_DIR = path.resolve(process.cwd(), "server/database/.introspect");
+  const SCHEMA_FILE = path.resolve(process.cwd(), outputPath);
+  console.log("[gen-db-schema] Starting...");
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname2 = path.dirname(__filename);
+  const configPath = path.join(__dirname2, "config", "drizzle.config.js");
+  if (!fs.existsSync(configPath)) {
+    console.error("[gen-db-schema] Error: drizzle config not found in CLI package");
+    process.exit(1);
+  }
+  try {
+    const env = {
+      ...process.env,
+      __DRIZZLE_OUT_DIR__: OUT_DIR,
+      __DRIZZLE_SCHEMA_PATH__: SCHEMA_FILE
+    };
+    const args = process.argv.slice(3).filter((arg) => !arg.startsWith("--enable-nest-module-generate"));
+    const spawnArgs = ["--yes", "drizzle-kit", "introspect", "--config", configPath, ...args];
+    const result = spawnSync("npx", spawnArgs, { stdio: "inherit", env });
+    if (result.error) {
+      console.error("[gen-db-schema] Execution failed:", result.error);
+      throw result.error;
+    }
+    if ((result.status ?? 0) !== 0) {
+      throw new Error(`drizzle-kit introspect failed with status ${result.status}`);
+    }
+    const generatedSchema = path.join(OUT_DIR, "schema.ts");
+    if (!fs.existsSync(generatedSchema)) {
+      console.error("[gen-db-schema] schema.ts not generated");
+      throw new Error("drizzle-kit introspect failed to generate schema.ts");
+    }
+    const { postprocessDrizzleSchema } = require2("@lark-apaas/devtool-kits");
+    const stats = postprocessDrizzleSchema(generatedSchema);
+    if (stats?.unmatchedUnknown?.length) {
+      console.warn("[gen-db-schema] Unmatched custom types detected:", stats.unmatchedUnknown);
+    }
+    console.log("[gen-db-schema] \u2713 Postprocessed schema");
+    fs.mkdirSync(path.dirname(SCHEMA_FILE), { recursive: true });
+    fs.copyFileSync(generatedSchema, SCHEMA_FILE);
+    console.log(`[gen-db-schema] \u2713 Copied to ${outputPath}`);
+    try {
+      if (options.enableNestModuleGenerate) {
+        const { parseAndGenerateNestResourceTemplate } = require2("@lark-apaas/devtool-kits");
+        const tsConfigFilePath = path.resolve(process.cwd(), "tsconfig.json");
+        const schemaFilePath = SCHEMA_FILE;
+        await parseAndGenerateNestResourceTemplate({
+          tsConfigFilePath,
+          schemaFilePath,
+          moduleOutputDir: path.resolve(process.cwd(), "server/modules")
+        });
+        console.log("[gen-db-schema] \u2713 Generate NestJS Module Boilerplate Successfully");
+      }
+    } catch (error) {
+      console.warn("[gen-db-schema] Generate NestJS Module Boilerplate failed:", error instanceof Error ? error.message : String(error));
+    }
+    console.log("[gen-db-schema] \u2713 Complete");
+  } catch (err) {
+    console.error("[gen-db-schema] Failed:", err instanceof Error ? err.message : String(err));
+    exitCode = 1;
+  } finally {
+    if (fs.existsSync(OUT_DIR)) {
+      fs.rmSync(OUT_DIR, { recursive: true, force: true });
+    }
+    process.exit(exitCode);
+  }
+}
+
+// src/commands/db/index.ts
+var genDbSchemaCommand = {
+  name: "gen-db-schema",
+  description: "Generate database schema from existing database",
+  register(program) {
+    program.command(this.name).description(this.description).option("--output <path>", "Output path for schema", "server/database/schema.ts").option("--schema-filter <schemas>", "Schema filter, comma-separated").option("--tables-filter <tables>", "Tables filter, comma-separated").option("--enable-nest-module-generate", "Enable generate NestJS module boilerplate").action(async (options) => {
+      await run(options);
+    });
+  }
+};
+
+// src/commands/sync/run.handler.ts
+import path3 from "path";
+import fs3 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/config/sync.ts
+var syncConfig = {
+  // 派生规则
+  sync: [
+    // 1. 派生 scripts 目录（总是覆盖）
+    {
+      from: "templates/scripts",
+      to: "scripts",
+      type: "directory",
+      overwrite: true
+    },
+    // 2. 覆写 nest-cli.json 配置，禁止用户修改
+    {
+      from: "templates/nest-cli.json",
+      to: "nest-cli.json",
+      type: "file",
+      overwrite: true
+    },
+    // // 2. 追加内容到 .gitignore
+    // {
+    //   from: 'templates/.gitignore.append',
+    //   to: '.gitignore',
+    //   type: 'append',
+    // },
+    // 3. 派生 server/type.ts 文件（总是覆盖）
+    // {
+    //   from: 'templates/server/global.d.ts',
+    //   to: 'server/types/global.d.ts',
+    //   type: 'file',
+    // },
+    {
+      type: "delete-directory",
+      to: ".swc"
+      // 删除 .swc 目录（如果存在）
+    },
+    // 4. 从 .gitignore 中移除 package-lock.json
+    {
+      type: "remove-line",
+      to: ".gitignore",
+      pattern: "package-lock.json"
+    }
+  ],
+  // 文件权限设置
+  permissions: {
+    // 所有 .sh 文件设置为可执行
+    // '**/*.sh': 0o755,
+  }
+};
+function genSyncConfig(perms = {}) {
+  if (!perms.disableGenOpenapi) {
+    syncConfig.sync.push({
+      from: "templates/helper/gen-openapi.ts",
+      to: "scripts/gen-openapi.ts",
+      type: "file",
+      overwrite: true
+    });
+  }
+  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 = 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 = path3.join(userProjectRoot, "package.json");
+  if (!fs3.existsSync(userPackageJson)) {
+    console.log("[fullstack-cli] Skip syncing (not a valid npm project)");
+    process.exit(0);
+  }
+  try {
+    console.log("[fullstack-cli] Starting sync...");
+    const config = genSyncConfig({
+      disableGenOpenapi: options.disableGenOpenapi ?? false
+    });
+    if (!config || !config.sync) {
+      console.warn("[fullstack-cli] No sync configuration found");
+      process.exit(0);
+    }
+    for (const rule of config.sync) {
+      await syncRule(rule, pluginRoot, userProjectRoot);
+    }
+    if (config.permissions) {
+      setPermissions(config.permissions, userProjectRoot);
+    }
+    console.log("[fullstack-cli] Sync completed successfully \u2705");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[fullstack-cli] Failed to sync:", message);
+    process.exit(1);
+  }
+}
+async function syncRule(rule, pluginRoot, userProjectRoot) {
+  if (rule.type === "delete-file" || rule.type === "delete-directory") {
+    const destPath2 = path3.join(userProjectRoot, rule.to);
+    if (rule.type === "delete-file") {
+      deleteFile(destPath2);
+    } else {
+      deleteDirectory(destPath2);
+    }
+    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 = 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;
+  }
+  switch (rule.type) {
+    case "directory":
+      syncDirectory(srcPath, destPath, rule.overwrite ?? true);
+      break;
+    case "file":
+      syncFile(srcPath, destPath, rule.overwrite ?? true);
+      break;
+    case "append":
+      appendToFile(srcPath, destPath);
+      break;
+  }
+}
+function syncFile(src, dest, overwrite = true) {
+  const destDir = path3.dirname(dest);
+  if (!fs3.existsSync(destDir)) {
+    fs3.mkdirSync(destDir, { recursive: true });
+  }
+  if (fs3.existsSync(dest) && !overwrite) {
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(dest)} (skipped, already exists)`);
+    return;
+  }
+  fs3.copyFileSync(src, dest);
+  console.log(`[fullstack-cli] \u2713 ${path3.basename(dest)}`);
+}
+function syncDirectory(src, dest, overwrite = true) {
+  if (!fs3.existsSync(dest)) {
+    fs3.mkdirSync(dest, { recursive: true });
+  }
+  const files = fs3.readdirSync(src);
+  let count = 0;
+  files.forEach((file) => {
+    const srcFile = path3.join(src, file);
+    const destFile = path3.join(dest, file);
+    const stats = fs3.statSync(srcFile);
+    if (stats.isDirectory()) {
+      syncDirectory(srcFile, destFile, overwrite);
+    } else {
+      if (overwrite || !fs3.existsSync(destFile)) {
+        fs3.copyFileSync(srcFile, destFile);
+        console.log(`[fullstack-cli] \u2713 ${path3.relative(dest, destFile)}`);
+        count++;
+      }
+    }
+  });
+  if (count > 0) {
+    console.log(`[fullstack-cli] Synced ${count} files to ${path3.basename(dest)}/`);
+  }
+}
+function appendToFile(src, dest) {
+  const content = fs3.readFileSync(src, "utf-8");
+  let existingContent = "";
+  if (fs3.existsSync(dest)) {
+    existingContent = fs3.readFileSync(dest, "utf-8");
+  }
+  if (existingContent.includes(content.trim())) {
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(dest)} (already contains content)`);
+    return;
+  }
+  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 = path3.join(projectRoot, "scripts");
+      if (fs3.existsSync(scriptsDir)) {
+        const files = fs3.readdirSync(scriptsDir);
+        files.forEach((file) => {
+          if (file.endsWith(".sh")) {
+            const filePath = path3.join(scriptsDir, file);
+            fs3.chmodSync(filePath, mode);
+          }
+        });
+      }
+    }
+  }
+}
+function deleteFile(filePath) {
+  if (fs3.existsSync(filePath)) {
+    fs3.unlinkSync(filePath);
+    console.log(`[fullstack-cli] \u2713 ${path3.basename(filePath)} (deleted)`);
+  } else {
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(filePath)} (not found)`);
+  }
+}
+function deleteDirectory(dirPath) {
+  if (fs3.existsSync(dirPath)) {
+    fs3.rmSync(dirPath, { recursive: true });
+    console.log(`[fullstack-cli] \u2713 ${path3.basename(dirPath)} (deleted)`);
+  } else {
+    console.log(`[fullstack-cli] \u25CB ${path3.basename(dirPath)} (not found)`);
+  }
+}
+
+// src/commands/sync/index.ts
+var syncCommand = {
+  name: "sync",
+  description: "Sync template files (scripts, configs) to user project",
+  register(program) {
+    program.command(this.name).description(this.description).option("--disable-gen-openapi", "Disable generating openapi.ts").action(async (options) => {
+      await run2(options);
+    });
+  }
+};
+
+// src/commands/action-plugin/utils.ts
+import fs4 from "fs";
+import path4 from "path";
+import { spawnSync as spawnSync2, execSync } from "child_process";
+function parsePluginName(input) {
+  const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
+  if (!match) {
+    throw new Error(
+      `Invalid plugin name format: ${input}. Expected format: @scope/name or @scope/name@version`
+    );
+  }
+  return {
+    name: match[1],
+    version: match[2] || "latest"
+  };
+}
+function getProjectRoot() {
+  return process.cwd();
+}
+function getPackageJsonPath() {
+  return path4.join(getProjectRoot(), "package.json");
+}
+function getPluginPath(pluginName) {
+  return path4.join(getProjectRoot(), "node_modules", pluginName);
+}
+function readPackageJson() {
+  const pkgPath = getPackageJsonPath();
+  if (!fs4.existsSync(pkgPath)) {
+    throw new Error("package.json not found in current directory");
+  }
+  try {
+    const content = fs4.readFileSync(pkgPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    throw new Error("Failed to parse package.json");
+  }
+}
+function writePackageJson(pkg2) {
+  const pkgPath = getPackageJsonPath();
+  fs4.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+}
+function readActionPlugins() {
+  const pkg2 = readPackageJson();
+  return pkg2.actionPlugins || {};
+}
+function writeActionPlugins(plugins) {
+  const pkg2 = readPackageJson();
+  pkg2.actionPlugins = plugins;
+  writePackageJson(pkg2);
+}
+function isPluginInstalled(pluginName) {
+  const plugins = readActionPlugins();
+  return pluginName in plugins;
+}
+function getInstalledPluginVersion(pluginName) {
+  const plugins = readActionPlugins();
+  return plugins[pluginName] || null;
+}
+function npmInstall(tgzPath) {
+  console.log(`[action-plugin] Running npm install ${tgzPath}...`);
+  const result = spawnSync2("npm", ["install", tgzPath, "--no-save", "--no-package-lock", "--ignore-scripts"], {
+    cwd: getProjectRoot(),
+    stdio: "inherit"
+  });
+  if (result.error) {
+    throw new Error(`npm install failed: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`npm install failed with exit code ${result.status}`);
+  }
+}
+function getPackageVersion(pluginName) {
+  const pkgJsonPath = path4.join(getPluginPath(pluginName), "package.json");
+  if (!fs4.existsSync(pkgJsonPath)) {
+    return null;
+  }
+  try {
+    const content = fs4.readFileSync(pkgJsonPath, "utf-8");
+    const pkg2 = JSON.parse(content);
+    return pkg2.version || null;
+  } catch {
+    return null;
+  }
+}
+function readPluginPackageJson(pluginPath) {
+  const pkgJsonPath = path4.join(pluginPath, "package.json");
+  if (!fs4.existsSync(pkgJsonPath)) {
+    return null;
+  }
+  try {
+    const content = fs4.readFileSync(pkgJsonPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function extractTgzToNodeModules(tgzPath, pluginName) {
+  const nodeModulesPath = path4.join(getProjectRoot(), "node_modules");
+  const targetDir = path4.join(nodeModulesPath, pluginName);
+  const scopeDir = path4.dirname(targetDir);
+  if (!fs4.existsSync(scopeDir)) {
+    fs4.mkdirSync(scopeDir, { recursive: true });
+  }
+  if (fs4.existsSync(targetDir)) {
+    fs4.rmSync(targetDir, { recursive: true });
+  }
+  const tempDir = path4.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs4.existsSync(tempDir)) {
+    fs4.rmSync(tempDir, { recursive: true });
+  }
+  fs4.mkdirSync(tempDir, { recursive: true });
+  try {
+    execSync(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
+    const extractedDir = path4.join(tempDir, "package");
+    if (fs4.existsSync(extractedDir)) {
+      fs4.renameSync(extractedDir, targetDir);
+    } else {
+      const files = fs4.readdirSync(tempDir);
+      if (files.length === 1) {
+        fs4.renameSync(path4.join(tempDir, files[0]), targetDir);
+      } else {
+        throw new Error("Unexpected tgz structure");
+      }
+    }
+    return targetDir;
+  } finally {
+    if (fs4.existsSync(tempDir)) {
+      fs4.rmSync(tempDir, { recursive: true });
+    }
+  }
+}
+function checkMissingPeerDeps(peerDeps) {
+  if (!peerDeps || Object.keys(peerDeps).length === 0) {
+    return [];
+  }
+  const missing = [];
+  const nodeModulesPath = path4.join(getProjectRoot(), "node_modules");
+  for (const [depName, _version] of Object.entries(peerDeps)) {
+    const depPath = path4.join(nodeModulesPath, depName);
+    if (!fs4.existsSync(depPath)) {
+      missing.push(depName);
+    }
+  }
+  return missing;
+}
+function installMissingDeps(deps) {
+  if (deps.length === 0) {
+    return;
+  }
+  console.log(`[action-plugin] Installing missing dependencies: ${deps.join(", ")}`);
+  const result = spawnSync2("npm", ["install", ...deps, "--no-save", "--no-package-lock"], {
+    cwd: getProjectRoot(),
+    stdio: "inherit"
+  });
+  if (result.error) {
+    throw new Error(`npm install failed: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`npm install failed with exit code ${result.status}`);
+  }
+}
+function removePluginDirectory(pluginName) {
+  const pluginPath = getPluginPath(pluginName);
+  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 fs5 from "fs";
+import path5 from "path";
+
+// src/utils/http-client.ts
+import { HttpClient } from "@lark-apaas/http-client";
+var clientInstance = null;
+function getHttpClient() {
+  if (!clientInstance) {
+    clientInstance = new HttpClient({
+      timeout: 3e4,
+      platform: {
+        enabled: true
+      }
+    });
+    clientInstance.interceptors.request.use((req) => {
+      req.headers["x-tt-env"] = "boe_miaoda_plugin";
+      return req;
+    });
+  }
+  return clientInstance;
+}
+
+// src/commands/action-plugin/api-client.ts
+var PLUGIN_CACHE_DIR = "node_modules/.cache/fullstack-cli/plugins";
+async function getPluginVersions(keys, latestOnly = true) {
+  const client = getHttpClient();
+  const response = await client.post(`/api/v1/studio/innerapi/plugins/-/versions/batch_get?keys=${keys.join(",")}&latest_only=${latestOnly}`);
+  if (!response.ok || response.status !== 200) {
+    throw new Error(`Failed to get plugin versions: ${response.status} ${response.statusText}`);
+  }
+  const result = await response.json();
+  console.log("getPluginVersions response:", result);
+  if (result.status_code !== "0") {
+    throw new Error(`API error: ${result.message}`);
+  }
+  return result.data.pluginVersions;
+}
+async function getPluginVersion(pluginKey, requestedVersion) {
+  const isLatest = requestedVersion === "latest";
+  const versions = await getPluginVersions([pluginKey], isLatest);
+  const pluginVersions = versions[pluginKey];
+  if (!pluginVersions || pluginVersions.length === 0) {
+    throw new Error(`Plugin not found: ${pluginKey}`);
+  }
+  if (isLatest) {
+    return pluginVersions[0];
+  }
+  const targetVersion = pluginVersions.find((v) => v.version === requestedVersion);
+  if (!targetVersion) {
+    throw new Error(
+      `Version ${requestedVersion} not found for plugin ${pluginKey}. Available versions: ${pluginVersions.map((v) => v.version).join(", ")}`
+    );
+  }
+  return targetVersion;
+}
+function parsePluginKey(key) {
+  const match = key.match(/^(@[^/]+)\/(.+)$/);
+  if (!match) {
+    throw new Error(`Invalid plugin key format: ${key}`);
+  }
+  return { scope: match[1], name: match[2] };
+}
+async function downloadFromInner(pluginKey, version) {
+  const client = getHttpClient();
+  const { scope, name } = parsePluginKey(pluginKey);
+  const url = `/api/v1/studio/innerapi/plugins/${scope}/${name}/versions/${version}/package`;
+  console.log(`[action-plugin] Downloading plugin from inner API: ${url}`);
+  const response = await client.get(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download plugin: ${response.status} ${response.statusText}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+async function downloadFromPublic(downloadURL) {
+  const client = new HttpClient2({
+    timeout: 6e4
+  });
+  const response = await client.get(downloadURL);
+  if (!response.ok) {
+    throw new Error(`Failed to download plugin from public URL: ${response.status} ${response.statusText}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+function getPluginCacheDir() {
+  return path5.join(process.cwd(), PLUGIN_CACHE_DIR);
+}
+function ensureCacheDir() {
+  const cacheDir = getPluginCacheDir();
+  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 path5.join(getPluginCacheDir(), filename);
+}
+async function downloadPlugin(pluginKey, requestedVersion) {
+  console.log(`[action-plugin] Fetching plugin info for ${pluginKey}@${requestedVersion}...`);
+  const pluginInfo = await getPluginVersion(pluginKey, requestedVersion);
+  console.log(`[action-plugin] Found: ${pluginInfo.name} v${pluginInfo.version}`);
+  console.log(`[action-plugin] Download approach: ${pluginInfo.downloadApproach}`);
+  let tgzBuffer;
+  if (pluginInfo.downloadApproach === "inner") {
+    console.log(`[action-plugin] Downloading from inner API...`);
+    tgzBuffer = await downloadFromInner(pluginKey, pluginInfo.version);
+  } else {
+    console.log(`[action-plugin] Downloading from public URL...`);
+    tgzBuffer = await downloadFromPublic(pluginInfo.downloadURL);
+  }
+  const tgzPath = getTempFilePath(pluginKey, pluginInfo.version);
+  fs5.writeFileSync(tgzPath, tgzBuffer);
+  console.log(`[action-plugin] Downloaded to ${tgzPath} (${(tgzBuffer.length / 1024).toFixed(2)} KB)`);
+  return {
+    tgzPath,
+    version: pluginInfo.version,
+    pluginInfo
+  };
+}
+function cleanupTempFile(tgzPath) {
+  try {
+    if (fs5.existsSync(tgzPath)) {
+      fs5.unlinkSync(tgzPath);
+    }
+  } catch {
+  }
+}
+
+// src/commands/action-plugin/init.handler.ts
+async function installOneForInit(name, version) {
+  let tgzPath;
+  try {
+    const installedVersion = getPackageVersion(name);
+    if (installedVersion === version) {
+      return { name, version, success: true, skipped: true };
+    }
+    console.log(`[action-plugin] Installing ${name}@${version}...`);
+    const downloadResult = await downloadPlugin(name, version);
+    tgzPath = downloadResult.tgzPath;
+    const pluginDir = extractTgzToNodeModules(tgzPath, name);
+    const pluginPkg = readPluginPackageJson(pluginDir);
+    if (pluginPkg?.peerDependencies) {
+      const missingDeps = checkMissingPeerDeps(pluginPkg.peerDependencies);
+      if (missingDeps.length > 0) {
+        installMissingDeps(missingDeps);
+      }
+    }
+    console.log(`[action-plugin] \u2713 Installed ${name}@${version}`);
+    return { name, version, success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[action-plugin] \u2717 Failed to install ${name}: ${message}`);
+    return { name, version, success: false, error: message };
+  } finally {
+    if (tgzPath) {
+      cleanupTempFile(tgzPath);
+    }
+  }
+}
+async function init() {
+  console.log("[action-plugin] Reading plugins from package.json...");
+  const plugins = readActionPlugins();
+  const entries = Object.entries(plugins);
+  if (entries.length === 0) {
+    console.log("[action-plugin] No plugins found in package.json");
+    return;
+  }
+  console.log(`[action-plugin] Found ${entries.length} plugin(s) to install
+`);
+  const results = [];
+  for (const [name, version] of entries) {
+    const result = await installOneForInit(name, version);
+    results.push(result);
+  }
+  console.log("");
+  const successful = results.filter((r) => r.success && !r.skipped);
+  const skipped = results.filter((r) => r.skipped);
+  const failed = results.filter((r) => !r.success);
+  if (successful.length > 0 || skipped.length > 0) {
+    console.log(
+      `[action-plugin] \u2713 All plugins installed successfully (${successful.length + skipped.length}/${entries.length})`
+    );
+    if (skipped.length > 0) {
+      console.log(`  Skipped (already installed): ${skipped.map((r) => r.name).join(", ")}`);
+    }
+  }
+  if (failed.length > 0) {
+    console.log(`[action-plugin] \u2717 Failed to install ${failed.length} plugin(s): ${failed.map((r) => r.name).join(", ")}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/action-plugin/install.handler.ts
+async function installOne(nameWithVersion) {
+  let tgzPath;
+  const { name, version: requestedVersion } = parsePluginName(nameWithVersion);
+  try {
+    console.log(`[action-plugin] Installing ${name}@${requestedVersion}...`);
+    const actualVersion = getPackageVersion(name);
+    if (actualVersion && requestedVersion !== "latest") {
+      if (actualVersion === requestedVersion) {
+        console.log(`[action-plugin] Plugin ${name}@${requestedVersion} is already installed`);
+        return { name, version: actualVersion, success: true, skipped: true };
+      }
+    }
+    if (actualVersion && requestedVersion === "latest") {
+      const latestInfo = await getPluginVersion(name, "latest");
+      if (actualVersion === latestInfo.version) {
+        console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${actualVersion})`);
+        return { name, version: actualVersion, success: true, skipped: true };
+      }
+      console.log(`[action-plugin] Found newer version: ${latestInfo.version} (installed: ${actualVersion})`);
+    }
+    const downloadResult = await downloadPlugin(name, requestedVersion);
+    tgzPath = downloadResult.tgzPath;
+    console.log(`[action-plugin] Extracting to node_modules...`);
+    const pluginDir = extractTgzToNodeModules(tgzPath, name);
+    const pluginPkg = readPluginPackageJson(pluginDir);
+    if (pluginPkg?.peerDependencies) {
+      const missingDeps = checkMissingPeerDeps(pluginPkg.peerDependencies);
+      if (missingDeps.length > 0) {
+        installMissingDeps(missingDeps);
+      }
+    }
+    const installedVersion = getPackageVersion(name) || downloadResult.version;
+    const plugins = readActionPlugins();
+    plugins[name] = installedVersion;
+    writeActionPlugins(plugins);
+    console.log(`[action-plugin] Successfully installed ${name}@${installedVersion}`);
+    return { name, version: installedVersion, success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[action-plugin] Failed to install ${name}: ${message}`);
+    return { name, version: requestedVersion, success: false, error: message };
+  } finally {
+    if (tgzPath) {
+      cleanupTempFile(tgzPath);
+    }
+  }
+}
+async function install(namesWithVersion) {
+  if (namesWithVersion.length === 0) {
+    console.error("[action-plugin] No plugin names provided");
+    process.exit(1);
+  }
+  const results = [];
+  for (const nameWithVersion of namesWithVersion) {
+    const result = await installOne(nameWithVersion);
+    results.push(result);
+  }
+  if (namesWithVersion.length > 1) {
+    console.log("\n[action-plugin] Installation summary:");
+    const successful = results.filter((r) => r.success && !r.skipped);
+    const skipped = results.filter((r) => r.skipped);
+    const failed = results.filter((r) => !r.success);
+    if (successful.length > 0) {
+      console.log(`  \u2713 Installed: ${successful.map((r) => `${r.name}@${r.version}`).join(", ")}`);
+    }
+    if (skipped.length > 0) {
+      console.log(`  \u25CB Skipped (up to date): ${skipped.map((r) => r.name).join(", ")}`);
+    }
+    if (failed.length > 0) {
+      console.log(`  \u2717 Failed: ${failed.map((r) => r.name).join(", ")}`);
+    }
+  }
+  if (results.some((r) => !r.success)) {
+    process.exit(1);
+  }
+}
+
+// src/commands/action-plugin/update.handler.ts
+async function updateOne(nameWithVersion) {
+  let tgzPath;
+  const { name } = parsePluginName(nameWithVersion);
+  try {
+    console.log(`[action-plugin] Updating ${name}...`);
+    if (!isPluginInstalled(name)) {
+      console.error(`[action-plugin] Plugin ${name} is not installed`);
+      return { name, success: false, notInstalled: true };
+    }
+    const oldVersion = getInstalledPluginVersion(name) || "unknown";
+    console.log(`[action-plugin] Current version: ${oldVersion}`);
+    const downloadResult = await downloadPlugin(name, "latest");
+    tgzPath = downloadResult.tgzPath;
+    if (oldVersion === downloadResult.version) {
+      console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${downloadResult.version})`);
+      return { name, oldVersion, newVersion: downloadResult.version, success: true, skipped: true };
+    }
+    npmInstall(tgzPath);
+    const installedVersion = getPackageVersion(name) || downloadResult.version;
+    const plugins = readActionPlugins();
+    plugins[name] = installedVersion;
+    writeActionPlugins(plugins);
+    console.log(`[action-plugin] Successfully updated ${name} to ${installedVersion}`);
+    return { name, oldVersion, newVersion: installedVersion, success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[action-plugin] Failed to update ${name}: ${message}`);
+    return { name, success: false, error: message };
+  } finally {
+    if (tgzPath) {
+      cleanupTempFile(tgzPath);
+    }
+  }
+}
+async function update(names) {
+  if (names.length === 0) {
+    console.error("[action-plugin] No plugin names provided");
+    process.exit(1);
+  }
+  const results = [];
+  for (const name of names) {
+    const result = await updateOne(name);
+    results.push(result);
+  }
+  if (names.length > 1) {
+    console.log("\n[action-plugin] Update summary:");
+    const updated = results.filter((r) => r.success && !r.skipped);
+    const skipped = results.filter((r) => r.skipped);
+    const notInstalled = results.filter((r) => r.notInstalled);
+    const failed = results.filter((r) => !r.success && !r.notInstalled);
+    if (updated.length > 0) {
+      console.log(`  \u2713 Updated: ${updated.map((r) => `${r.name} (${r.oldVersion} \u2192 ${r.newVersion})`).join(", ")}`);
+    }
+    if (skipped.length > 0) {
+      console.log(`  \u25CB Skipped (up to date): ${skipped.map((r) => r.name).join(", ")}`);
+    }
+    if (notInstalled.length > 0) {
+      console.log(`  \u26A0 Not installed: ${notInstalled.map((r) => r.name).join(", ")}`);
+    }
+    if (failed.length > 0) {
+      console.log(`  \u2717 Failed: ${failed.map((r) => r.name).join(", ")}`);
+    }
+  }
+  if (results.some((r) => !r.success && !r.notInstalled)) {
+    process.exit(1);
+  }
+}
+
+// src/commands/action-plugin/remove.handler.ts
+async function remove(nameWithVersion) {
+  try {
+    const { name } = parsePluginName(nameWithVersion);
+    console.log(`[action-plugin] Removing ${name}...`);
+    if (!isPluginInstalled(name)) {
+      console.error(`[action-plugin] Plugin ${name} is not installed`);
+      process.exit(1);
+    }
+    removePluginDirectory(name);
+    const plugins = readActionPlugins();
+    delete plugins[name];
+    writeActionPlugins(plugins);
+    console.log(`[action-plugin] Successfully removed ${name}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[action-plugin] Failed to remove: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/action-plugin/list.handler.ts
+async function list() {
+  try {
+    const plugins = Object.entries(readActionPlugins());
+    if (plugins.length === 0) {
+      console.log("[action-plugin] No plugins installed");
+      console.log('[action-plugin] Use "action-plugin install <name>" to install a plugin');
+      return;
+    }
+    console.log("[action-plugin] Installed plugins:\n");
+    const nameWidth = Math.max(40, ...plugins.map(([name]) => name.length + 2));
+    const versionWidth = 15;
+    console.log(
+      "  " + "Plugin".padEnd(nameWidth) + "Version"
+    );
+    console.log("  " + "-".repeat(nameWidth + versionWidth));
+    for (const [name, version] of plugins) {
+      console.log(
+        "  " + name.padEnd(nameWidth) + version
+      );
+    }
+    console.log(`
+  Total: ${plugins.length} plugin(s)`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[action-plugin] Failed to list plugins: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/action-plugin/index.ts
+var initCommand = {
+  name: "init",
+  description: "Install all plugins from package.json",
+  register(program) {
+    program.command(this.name).description(this.description).action(async () => {
+      await init();
+    });
+  }
+};
+var installCommand = {
+  name: "install",
+  description: "Install action plugin(s) (default: latest version)",
+  aliases: ["i"],
+  register(program) {
+    program.command(this.name).alias("i").description(this.description).argument("<names...>", "Plugin name(s) (e.g., @office/feishu-create-group or @office/feishu-create-group@1.0.0)").action(async (names) => {
+      await install(names);
+    });
+  }
+};
+var updateCommand = {
+  name: "update",
+  description: "Update action plugin(s) to the latest version",
+  aliases: ["up"],
+  register(program) {
+    program.command(this.name).alias("up").description(this.description).argument("<names...>", "Plugin name(s) (e.g., @office/feishu-create-group)").action(async (names) => {
+      await update(names);
+    });
+  }
+};
+var removeCommand = {
+  name: "remove",
+  description: "Remove an installed action plugin",
+  aliases: ["rm"],
+  register(program) {
+    program.command(this.name).alias("rm").description(this.description).argument("<name>", "Plugin name (e.g., @office/feishu-create-group)").action(async (name) => {
+      await remove(name);
+    });
+  }
+};
+var listCommand = {
+  name: "list",
+  description: "List all installed action plugins",
+  aliases: ["ls"],
+  register(program) {
+    program.command(this.name).alias("ls").description(this.description).action(async () => {
+      await list();
+    });
+  }
+};
+var actionPluginCommandGroup = {
+  name: "action-plugin",
+  description: "Manage action plugins",
+  commands: [initCommand, installCommand, updateCommand, removeCommand, listCommand]
+};
+
+// src/commands/capability/utils.ts
+import fs6 from "fs";
+import path6 from "path";
+var CAPABILITIES_DIR = "server/capabilities";
+function getProjectRoot2() {
+  return process.cwd();
+}
+function getCapabilitiesDir() {
+  return path6.join(getProjectRoot2(), CAPABILITIES_DIR);
+}
+function getCapabilityPath(id) {
+  return path6.join(getCapabilitiesDir(), `${id}.json`);
+}
+function getPluginManifestPath(pluginKey) {
+  return path6.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
+}
+function capabilitiesDirExists() {
+  return fs6.existsSync(getCapabilitiesDir());
+}
+function listCapabilityIds() {
+  const dir = getCapabilitiesDir();
+  if (!fs6.existsSync(dir)) {
+    return [];
+  }
+  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 (!fs6.existsSync(filePath)) {
+    throw new Error(`Capability not found: ${id}`);
+  }
+  try {
+    const content = fs6.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in capability file: ${id}.json`);
+    }
+    throw error;
+  }
+}
+function readAllCapabilities() {
+  const ids = listCapabilityIds();
+  return ids.map((id) => readCapability(id));
+}
+function readPluginManifest(pluginKey) {
+  const manifestPath = getPluginManifestPath(pluginKey);
+  if (!fs6.existsSync(manifestPath)) {
+    throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
+  }
+  try {
+    const content = fs6.readFileSync(manifestPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in plugin manifest: ${pluginKey}/manifest.json`);
+    }
+    throw error;
+  }
+}
+function isDynamicSchema(schema) {
+  return schema !== void 0 && typeof schema === "object" && "dynamic" in schema && schema.dynamic === true;
+}
+function hasValidParamsSchema(paramsSchema) {
+  return paramsSchema !== void 0 && Object.keys(paramsSchema).length > 0;
+}
+async function loadPlugin(pluginKey) {
+  try {
+    const pluginPackage = (await import(pluginKey)).default;
+    if (!pluginPackage || typeof pluginPackage.create !== "function") {
+      throw new Error(`Plugin ${pluginKey} does not export a valid create function`);
+    }
+    return pluginPackage;
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      throw new Error(`Plugin not installed: ${pluginKey}`);
+    }
+    throw new Error(
+      `Failed to load plugin ${pluginKey}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function hydrateCapability(capability) {
+  try {
+    const manifest = readPluginManifest(capability.pluginKey);
+    if (!manifest.actions || manifest.actions.length === 0) {
+      throw new Error(`Plugin ${capability.pluginKey} has no actions defined`);
+    }
+    const hasDynamicSchema = manifest.actions.some(
+      (action) => isDynamicSchema(action.inputSchema) || isDynamicSchema(action.outputSchema)
+    );
+    let pluginInstance = null;
+    if (hasDynamicSchema) {
+      const plugin = await loadPlugin(capability.pluginKey);
+      pluginInstance = plugin.create(capability.formValue || {});
+    }
+    const actions = [];
+    for (let index = 0; index < manifest.actions.length; index++) {
+      const manifestAction = manifest.actions[index];
+      let inputSchema;
+      if (index === 0 && hasValidParamsSchema(capability.paramsSchema)) {
+        inputSchema = capability.paramsSchema;
+      } else if (isDynamicSchema(manifestAction.inputSchema)) {
+        if (!pluginInstance) {
+          throw new Error(`Plugin instance not available for dynamic schema`);
+        }
+        const jsonSchema = pluginInstance.getInputJsonSchema(manifestAction.key);
+        if (!jsonSchema) {
+          throw new Error(`Failed to get input schema for action: ${manifestAction.key}`);
+        }
+        inputSchema = jsonSchema;
+      } else {
+        inputSchema = manifestAction.inputSchema;
+      }
+      let outputSchema;
+      if (isDynamicSchema(manifestAction.outputSchema)) {
+        if (!pluginInstance) {
+          throw new Error(`Plugin instance not available for dynamic schema`);
+        }
+        const jsonSchema = pluginInstance.getOutputJsonSchema(manifestAction.key, capability.formValue || {});
+        if (!jsonSchema) {
+          throw new Error(`Failed to get output schema for action: ${manifestAction.key}`);
+        }
+        outputSchema = jsonSchema;
+      } else {
+        outputSchema = manifestAction.outputSchema;
+      }
+      actions.push({
+        key: manifestAction.key,
+        inputSchema,
+        outputSchema,
+        outputMode: manifestAction.outputMode || ""
+      });
+    }
+    return {
+      id: capability.id,
+      pluginKey: capability.pluginKey,
+      pluginVersion: capability.pluginVersion,
+      name: capability.name,
+      description: capability.description,
+      actions,
+      createdAt: capability.createdAt,
+      updatedAt: capability.updatedAt
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ...capability,
+      _hydrateError: message
+    };
+  }
+}
+function formatJsonOutput(data, compact = false) {
+  return compact ? JSON.stringify(data) : JSON.stringify(data, null, 2);
+}
+function printJson(data, compact = false) {
+  console.log(formatJsonOutput(data, compact));
+}
+function logError(message) {
+  console.error(`[capability] Error: ${message}`);
+}
+
+// src/commands/capability/list.handler.ts
+async function list2(options) {
+  try {
+    if (!capabilitiesDirExists()) {
+      logError("server/capabilities directory not found");
+      process.exit(1);
+    }
+    if (options.id) {
+      await listSingle(options.id, options.summary);
+    } else {
+      await listAll(options.summary);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logError(message);
+    process.exit(1);
+  }
+}
+async function listSingle(id, summary) {
+  const capability = readCapability(id);
+  if (summary) {
+    printJson(capability);
+  } else {
+    const hydrated = await hydrateCapability(capability);
+    printJson(hydrated);
+  }
+}
+async function listAll(summary) {
+  const capabilities = readAllCapabilities();
+  if (capabilities.length === 0) {
+    printJson([]);
+    return;
+  }
+  if (summary) {
+    printJson(capabilities);
+  } else {
+    const hydrated = [];
+    for (const capability of capabilities) {
+      const result = await hydrateCapability(capability);
+      hydrated.push(result);
+    }
+    printJson(hydrated);
+  }
+}
+
+// src/commands/capability/index.ts
+var listCommand2 = {
+  name: "list",
+  description: "List capability configurations",
+  aliases: ["ls"],
+  register(program) {
+    program.command(this.name).alias("ls").description(this.description).option("--summary", "Return raw capability config (without hydration)").option("--id <id>", "Specify capability ID").action(async (options) => {
+      await list2(options);
+    });
+  }
+};
+var capabilityCommandGroup = {
+  name: "capability",
+  description: "Manage capability configurations",
+  commands: [listCommand2]
+};
+
+// src/commands/migration/version-manager.ts
+import fs7 from "fs";
+import path7 from "path";
+var PACKAGE_JSON = "package.json";
+var VERSION_FIELD = "migrationVersion";
+function getPackageJsonPath2() {
+  return path7.join(process.cwd(), PACKAGE_JSON);
+}
+function getCurrentVersion() {
+  const pkgPath = getPackageJsonPath2();
+  if (!fs7.existsSync(pkgPath)) {
+    throw new Error("package.json not found");
+  }
+  const pkg2 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+  return pkg2[VERSION_FIELD] ?? 0;
+}
+function setCurrentVersion(version) {
+  const pkgPath = getPackageJsonPath2();
+  const pkg2 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+  pkg2[VERSION_FIELD] = version;
+  fs7.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/detector.ts
+import fs9 from "fs";
+import path9 from "path";
+
+// src/commands/migration/versions/v001_capability/utils.ts
+import fs8 from "fs";
+import path8 from "path";
+var CAPABILITIES_DIR2 = "server/capabilities";
+function getProjectRoot3() {
+  return process.cwd();
+}
+function getCapabilitiesDir2() {
+  return path8.join(getProjectRoot3(), CAPABILITIES_DIR2);
+}
+function getPluginManifestPath2(pluginKey) {
+  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 = path9.join(capabilitiesDir, "capabilities.json");
+  if (!fs9.existsSync(oldFilePath)) {
+    return {
+      needsMigration: false,
+      reason: "capabilities.json not found"
+    };
+  }
+  try {
+    const content = fs9.readFileSync(oldFilePath, "utf-8");
+    const parsed = JSON.parse(content);
+    const capabilities = Array.isArray(parsed) ? parsed : [];
+    return {
+      needsMigration: true,
+      oldCapabilities: capabilities,
+      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: false,
+      reason: `capabilities.json is not valid JSON: ${errorMessage}`
+    };
+  }
+}
+
+// src/commands/migration/versions/v001_capability/check.ts
+async function check(options) {
+  const detection = detectJsonMigration();
+  if (!detection.needsMigration) {
+    return {
+      needsMigration: false,
+      message: detection.reason || "No migration needed"
+    };
+  }
+  const capabilityCount = detection.oldCapabilities?.length || 0;
+  return {
+    needsMigration: true,
+    message: `found ${capabilityCount} capabilities to migrate`,
+    items: [
+      `server/capabilities/capabilities.json \u2192 server/capabilities/*.json`,
+      `${capabilityCount} capabilities will be converted to new format`
+    ]
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/index.ts
+import fs10 from "fs";
+import path10 from "path";
+
+// src/commands/migration/versions/v001_capability/mapping.ts
+var DEFAULT_PLUGIN_VERSION = "1.0.0";
+var PLUGIN_MAPPING = {
+  // 飞书相关
+  "@official-plugins/send-feishu-message": {
+    sourceActionID: "official_feishu/send_message",
+    pluginVersion: "1.0.0",
+    actionName: "send_feishu_message"
+  },
+  "@official-plugins/feishu-group-create": {
+    sourceActionID: "official_feishu/create_group",
+    pluginVersion: "1.0.0",
+    actionName: "createGroup"
+  },
+  // AI 相关
+  "@official-plugins/ai-text-generate": {
+    sourceActionID: "official_ai/text_generate",
+    pluginVersion: "1.0.0",
+    actionName: "textGenerate"
+  },
+  "@official-plugins/ai-image-understanding": {
+    sourceActionID: "official_ai/image_understanding",
+    pluginVersion: "1.0.0",
+    actionName: "imageUnderstanding"
+  },
+  "@official-plugins/ai-text-to-image": {
+    sourceActionID: "official_ai/image_generate",
+    pluginVersion: "1.0.0",
+    actionName: "textToImage"
+  }
+};
+function getPluginInfoBySourceActionID(sourceActionID) {
+  for (const [pluginKey, item] of Object.entries(PLUGIN_MAPPING)) {
+    if (item.sourceActionID === sourceActionID) {
+      return {
+        pluginKey,
+        pluginVersion: item.pluginVersion ?? DEFAULT_PLUGIN_VERSION,
+        actionName: item.actionName
+      };
+    }
+  }
+  throw new Error(
+    `Unknown sourceActionID: "${sourceActionID}". This sourceActionID is not in the built-in mapping. Please contact the developer to add it.`
+  );
+}
+function getActionNameByPluginKey(pluginKey) {
+  const item = PLUGIN_MAPPING[pluginKey];
+  if (!item) {
+    throw new Error(
+      `Unknown pluginKey: "${pluginKey}". This pluginKey is not in the built-in mapping. Please contact the developer to add it.`
+    );
+  }
+  return item.actionName;
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/send-feishu-message.ts
+function transformSendFeishuMessage(input) {
+  const actionInput = input;
+  const cardContent = actionInput.card_content;
+  const header = cardContent?.header;
+  const bodyElements = cardContent?.body?.elements;
+  const title = {
+    title: header?.title?.content ?? "",
+    titleColor: header?.template
+  };
+  const markdownElement = bodyElements?.find((el) => el.tag === "markdown");
+  const content = markdownElement?.content ?? "";
+  const columnSet = bodyElements?.find((el) => el.tag === "column_set");
+  const buttons = columnSet?.columns?.flatMap(
+    (column) => column.elements?.filter((el) => el.tag === "button").map((btn) => ({
+      style: btn.type,
+      text: btn.text?.content,
+      url: btn.behaviors?.[0]?.default_url
+    })) ?? []
+  ) ?? [];
+  return {
+    sender: "bot",
+    receiverUserList: actionInput.receiver_user_list ?? [],
+    receiverGroupList: actionInput.receiver_group_list ?? [],
+    title,
+    content,
+    buttons
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/feishu-group-create.ts
+function transformFeishuGroupCreate(input) {
+  const actionInput = input;
+  return {
+    owner: actionInput.owner,
+    members: actionInput.members ?? [],
+    groupName: actionInput.group_name ?? "",
+    groupDescription: actionInput.group_description ?? "",
+    welcomeMessage: actionInput.welcome_message ?? ""
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/utils.ts
+function convertToNumber(value, defaultValue) {
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  const num = Number(value);
+  return isNaN(num) ? defaultValue : num;
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/ai-text-generate.ts
+var DEFAULT_MODEL_ID = "87";
+var DEFAULT_MAX_TOKENS = 8192;
+var DEFAULT_TEMPERATURE = 0.7;
+function transformAITextGenerate(input) {
+  const actionInput = input;
+  return {
+    modelID: DEFAULT_MODEL_ID,
+    prompt: actionInput.prompt ?? "",
+    modelParams: {
+      maxTokens: convertToNumber(actionInput.max_tokens, DEFAULT_MAX_TOKENS),
+      temperature: convertToNumber(actionInput.temperature, DEFAULT_TEMPERATURE)
+    }
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/ai-image-understanding.ts
+var DEFAULT_MODEL_ID2 = "87";
+var DEFAULT_MAX_TOKENS2 = 8192;
+var DEFAULT_TEMPERATURE2 = 0.7;
+function transformAIImageUnderstanding(input) {
+  const actionInput = input;
+  return {
+    prompt: actionInput.prompt ?? "",
+    images: actionInput.image_list ?? [],
+    modelID: DEFAULT_MODEL_ID2,
+    modelParams: {
+      maxTokens: convertToNumber(actionInput.max_tokens, DEFAULT_MAX_TOKENS2),
+      temperature: convertToNumber(actionInput.temperature, DEFAULT_TEMPERATURE2)
+    }
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/ai-text-to-image.ts
+var DEFAULT_RATIO = "1:1";
+var DEFAULT_WATERMARK = true;
+function transformAITextToImage(input) {
+  const actionInput = input;
+  return {
+    prompt: actionInput.prompt ?? "",
+    ratio: actionInput.image_ratio ?? DEFAULT_RATIO,
+    watermark: actionInput.watermark ?? DEFAULT_WATERMARK
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/index.ts
+var TRANSFORMER_MAP = {
+  "official_feishu/send_message": transformSendFeishuMessage,
+  "official_feishu/create_group": transformFeishuGroupCreate,
+  "official_ai/text_generate": transformAITextGenerate,
+  "official_ai/image_understanding": transformAIImageUnderstanding,
+  "official_ai/image_generate": transformAITextToImage
+};
+function transformFormValue(sourceActionID, actionInput) {
+  const transformer = TRANSFORMER_MAP[sourceActionID];
+  if (!transformer) {
+    throw new Error(
+      `No formValue transformer found for sourceActionID: "${sourceActionID}". Please implement the transformer and add it to TRANSFORMER_MAP.`
+    );
+  }
+  return transformer(actionInput);
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/transformer.ts
+function transformCapability(old) {
+  const { pluginKey, pluginVersion } = getPluginInfoBySourceActionID(old.sourceActionID);
+  const formValue = transformFormValue(old.sourceActionID, old.actionInput);
+  return {
+    id: old.id,
+    pluginKey,
+    pluginVersion,
+    name: old.name,
+    description: old.desc,
+    paramsSchema: old.inputSchema,
+    formValue,
+    createdAt: old.createdAt,
+    updatedAt: old.updatedAt
+  };
+}
+function transformCapabilities(oldCapabilities) {
+  return oldCapabilities.map((old) => transformCapability(old));
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/index.ts
+function loadExistingCapabilities() {
+  const capabilitiesDir = getCapabilitiesDir2();
+  if (!fs10.existsSync(capabilitiesDir)) {
+    return [];
+  }
+  const files = fs10.readdirSync(capabilitiesDir);
+  const capabilities = [];
+  for (const file of files) {
+    if (file === "capabilities.json" || !file.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const filePath = path10.join(capabilitiesDir, file);
+      const content = fs10.readFileSync(filePath, "utf-8");
+      const capability = JSON.parse(content);
+      if (capability.id && capability.pluginKey) {
+        capabilities.push(capability);
+      }
+    } catch {
+    }
+  }
+  return capabilities;
+}
+async function migrateJsonFiles(options) {
+  const detection = detectJsonMigration();
+  if (!detection.needsMigration) {
+    const existingCapabilities = loadExistingCapabilities();
+    return {
+      success: true,
+      skipped: true,
+      reason: detection.reason,
+      count: existingCapabilities.length,
+      capabilities: existingCapabilities
+    };
+  }
+  const { oldCapabilities, oldFilePath } = detection;
+  if (!oldCapabilities || !oldFilePath) {
+    return {
+      success: false,
+      skipped: false,
+      reason: "Detection error: missing data",
+      count: 0,
+      capabilities: []
+    };
+  }
+  let newCapabilities;
+  try {
+    newCapabilities = transformCapabilities(oldCapabilities);
+  } catch (error) {
+    return {
+      success: false,
+      skipped: false,
+      reason: error instanceof Error ? error.message : String(error),
+      count: 0,
+      capabilities: []
+    };
+  }
+  if (options.dryRun) {
+    console.log(`   Would create ${newCapabilities.length} capability files:`);
+    for (const cap of newCapabilities) {
+      console.log(`   - ${cap.id}.json (pluginKey: ${cap.pluginKey})`);
+    }
+    return {
+      success: true,
+      skipped: false,
+      count: newCapabilities.length,
+      capabilities: newCapabilities
+    };
+  }
+  const capabilitiesDir = getCapabilitiesDir2();
+  for (const cap of newCapabilities) {
+    const filePath = path10.join(capabilitiesDir, `${cap.id}.json`);
+    const content = JSON.stringify(cap, null, 2);
+    fs10.writeFileSync(filePath, content, "utf-8");
+    console.log(`   \u2713 Created: ${cap.id}.json`);
+  }
+  return {
+    success: true,
+    skipped: false,
+    count: newCapabilities.length,
+    capabilities: newCapabilities
+  };
+}
+
+// src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
+import fs11 from "fs";
+function isPluginInstalled2(pluginKey) {
+  const manifestPath = getPluginManifestPath2(pluginKey);
+  return fs11.existsSync(manifestPath);
+}
+function detectPluginsToInstall(capabilities) {
+  const pluginKeys = /* @__PURE__ */ new Set();
+  for (const cap of capabilities) {
+    pluginKeys.add(cap.pluginKey);
+  }
+  const toInstall = [];
+  const alreadyInstalled = [];
+  for (const pluginKey of pluginKeys) {
+    if (isPluginInstalled2(pluginKey)) {
+      alreadyInstalled.push(pluginKey);
+    } else {
+      toInstall.push(pluginKey);
+    }
+  }
+  return { toInstall, alreadyInstalled };
+}
+
+// src/commands/migration/versions/v001_capability/plugin-installer/index.ts
+async function installPlugins(capabilities, options) {
+  const detection = detectPluginsToInstall(capabilities);
+  const result = {
+    installed: [],
+    alreadyInstalled: detection.alreadyInstalled,
+    failed: []
+  };
+  if (detection.toInstall.length === 0) {
+    return result;
+  }
+  if (options.dryRun) {
+    console.log(`   Would install ${detection.toInstall.length} plugins:`);
+    for (const pluginKey of detection.toInstall) {
+      console.log(`   - ${pluginKey}`);
+    }
+    result.installed = detection.toInstall;
+    return result;
+  }
+  console.log(`   \u2B07 Installing ${detection.toInstall.length} plugins...`);
+  for (const pluginKey of detection.toInstall) {
+    console.log(`     - ${pluginKey}`);
+  }
+  try {
+    const originalExit = process.exit;
+    let exitCalled = false;
+    process.exit = ((code) => {
+      exitCalled = true;
+      if (code !== 0) {
+        throw new Error(`Plugin installation failed with exit code ${code}`);
+      }
+    });
+    try {
+      await install(detection.toInstall);
+      result.installed = detection.toInstall;
+    } catch (error) {
+      for (const pluginKey of detection.toInstall) {
+        result.failed.push({
+          pluginKey,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    } finally {
+      process.exit = originalExit;
+    }
+  } catch (error) {
+    for (const pluginKey of detection.toInstall) {
+      result.failed.push({
+        pluginKey,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+
+// src/commands/migration/versions/v001_capability/code-migrator/index.ts
+import path12 from "path";
+import { Project } from "ts-morph";
+
+// src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
+import fs12 from "fs";
+import path11 from "path";
+var EXCLUDED_DIRS = [
+  "node_modules",
+  "dist",
+  "build",
+  ".git",
+  "__test__",
+  "__tests__"
+];
+var EXCLUDED_PATTERNS = [
+  /\.spec\.ts$/,
+  /\.test\.ts$/,
+  /\.d\.ts$/
+];
+function scanDirectory(dir, files = []) {
+  const entries = fs12.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path11.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (EXCLUDED_DIRS.includes(entry.name)) {
+        continue;
+      }
+      scanDirectory(fullPath, files);
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      const shouldExclude = EXCLUDED_PATTERNS.some((pattern) => pattern.test(entry.name));
+      if (!shouldExclude) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function scanServerFiles() {
+  const serverDir = path11.join(getProjectRoot3(), "server");
+  if (!fs12.existsSync(serverDir)) {
+    return [];
+  }
+  return scanDirectory(serverDir);
+}
+function hasCapabilityImport(filePath) {
+  const content = fs12.readFileSync(filePath, "utf-8");
+  return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
+}
+function scanFilesToMigrate() {
+  const allFiles = scanServerFiles();
+  return allFiles.filter(hasCapabilityImport);
+}
+
+// src/commands/migration/versions/v001_capability/code-migrator/analyzers/import-analyzer.ts
+function extractCapabilityId(importPath) {
+  const match = importPath.match(/capabilities\/([^/]+)$/);
+  return match ? match[1] : null;
+}
+function isCapabilityImport(importPath) {
+  return importPath.includes("capabilities/") || importPath.includes("capabilities\\");
+}
+function analyzeImports(sourceFile) {
+  const imports = [];
+  const importDeclarations = sourceFile.getImportDeclarations();
+  for (const importDecl of importDeclarations) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (!isCapabilityImport(moduleSpecifier)) {
+      continue;
+    }
+    const capabilityId = extractCapabilityId(moduleSpecifier);
+    if (!capabilityId) {
+      continue;
+    }
+    const namedImports = importDecl.getNamedImports();
+    for (const namedImport of namedImports) {
+      const importName = namedImport.getAliasNode()?.getText() || namedImport.getName();
+      imports.push({
+        importName,
+        capabilityId,
+        start: importDecl.getStart(),
+        end: importDecl.getEnd(),
+        text: importDecl.getText()
+      });
+    }
+    const namespaceImport = importDecl.getNamespaceImport();
+    if (namespaceImport) {
+      imports.push({
+        importName: namespaceImport.getText(),
+        capabilityId,
+        start: importDecl.getStart(),
+        end: importDecl.getEnd(),
+        text: importDecl.getText()
+      });
+    }
+    const defaultImport = importDecl.getDefaultImport();
+    if (defaultImport) {
+      imports.push({
+        importName: defaultImport.getText(),
+        capabilityId,
+        start: importDecl.getStart(),
+        end: importDecl.getEnd(),
+        text: importDecl.getText()
+      });
+    }
+  }
+  return imports;
+}
+
+// src/commands/migration/versions/v001_capability/code-migrator/analyzers/call-site-analyzer.ts
+import { SyntaxKind } from "ts-morph";
+function analyzeCallSites(sourceFile, imports) {
+  const callSites = [];
+  const importMap = /* @__PURE__ */ new Map();
+  for (const imp of imports) {
+    importMap.set(imp.importName, imp.capabilityId);
+  }
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+  for (const callExpr of callExpressions) {
+    const expression = callExpr.getExpression();
+    if (expression.getKind() === SyntaxKind.Identifier) {
+      const functionName = expression.getText();
+      const capabilityId = importMap.get(functionName);
+      if (capabilityId) {
+        callSites.push({
+          functionName,
+          capabilityId,
+          start: callExpr.getStart(),
+          end: callExpr.getEnd(),
+          line: callExpr.getStartLineNumber(),
+          text: callExpr.getText()
+        });
+      }
+    } else if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+      const propAccess = expression.asKind(SyntaxKind.PropertyAccessExpression);
+      if (propAccess) {
+        const objectExpr = propAccess.getExpression();
+        if (objectExpr.getKind() === SyntaxKind.Identifier) {
+          const objectName = objectExpr.getText();
+          const capabilityId = importMap.get(objectName);
+          if (capabilityId) {
+            callSites.push({
+              functionName: `${objectName}.${propAccess.getName()}`,
+              capabilityId,
+              start: callExpr.getStart(),
+              end: callExpr.getEnd(),
+              line: callExpr.getStartLineNumber(),
+              text: callExpr.getText()
+            });
+          }
+        }
+      }
+    }
+  }
+  return callSites;
+}
+
+// src/commands/migration/versions/v001_capability/code-migrator/analyzers/class-analyzer.ts
+function hasDecorator(classDecl, decoratorName) {
+  const decorators = classDecl.getDecorators();
+  return decorators.some((decorator) => {
+    const name = decorator.getName();
+    return name === decoratorName;
+  });
+}
+function analyzeClass(sourceFile) {
+  const classes = sourceFile.getClasses();
+  let classInfo;
+  for (const classDecl of classes) {
+    const name = classDecl.getName();
+    if (!name) continue;
+    const isInjectable = hasDecorator(classDecl, "Injectable");
+    const isController = hasDecorator(classDecl, "Controller");
+    if (classInfo && classInfo.isInjectable && !isInjectable && !isController) {
+      continue;
+    }
+    const info = {
+      name,
+      isInjectable,
+      isController,
+      constructorParamCount: 0
+    };
+    const classBody = classDecl.getChildSyntaxListOrThrow();
+    info.classBodyStart = classBody.getStart();
+    const constructors = classDecl.getConstructors();
+    if (constructors.length > 0) {
+      const ctor = constructors[0];
+      info.constructorParamCount = ctor.getParameters().length;
+      info.constructorStart = ctor.getStart();
+      info.constructorEnd = ctor.getEnd();
+      const params = ctor.getParameters();
+      if (params.length > 0) {
+        const lastParam = params[params.length - 1];
+        info.constructorParamsEnd = lastParam.getEnd();
+      } else {
+        info.constructorParamsEnd = ctor.getStart();
+      }
     }
-});
-// sync 命令
-cli
-    .command('sync', 'Sync template files (scripts, configs) to user project')
-    .option('--disable-gen-openapi', 'Disable generating openapi.ts')
-    .example('fullstack-cli sync')
-    .action(async (options) => {
+    if (isInjectable || isController || !classInfo) {
+      classInfo = info;
+    }
+  }
+  return classInfo;
+}
+function canAutoMigrate(classInfo) {
+  if (!classInfo) {
+    return {
+      canMigrate: false,
+      reason: "No class found in file"
+    };
+  }
+  if (!classInfo.isInjectable && !classInfo.isController) {
+    return {
+      canMigrate: false,
+      reason: `Class "${classInfo.name}" is not @Injectable or @Controller`
+    };
+  }
+  return { canMigrate: true };
+}
+
+// src/commands/migration/versions/v001_capability/code-migrator/transformers/import-transformer.ts
+var CORE_MODULE = "@lark-apaas/fullstack-nestjs-core";
+var NESTJS_COMMON_MODULE = "@nestjs/common";
+function hasCapabilityServiceImport(sourceFile) {
+  const imports = sourceFile.getImportDeclarations();
+  for (const importDecl of imports) {
+    if (importDecl.getModuleSpecifierValue() === CORE_MODULE) {
+      const namedImports = importDecl.getNamedImports();
+      if (namedImports.some((ni) => ni.getName() === "CapabilityService")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasInjectImport(sourceFile) {
+  const imports = sourceFile.getImportDeclarations();
+  for (const importDecl of imports) {
+    if (importDecl.getModuleSpecifierValue() === NESTJS_COMMON_MODULE) {
+      const namedImports = importDecl.getNamedImports();
+      if (namedImports.some((ni) => ni.getName() === "Inject")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function transformImports(sourceFile, capabilityImports) {
+  let importAdded = false;
+  let importsRemoved = 0;
+  const importPaths = new Set(capabilityImports.map((imp) => {
+    const match = imp.text.match(/from\s+['"]([^'"]+)['"]/);
+    return match ? match[1] : "";
+  }));
+  const importDeclarations = sourceFile.getImportDeclarations();
+  for (const importDecl of importDeclarations) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (importPaths.has(moduleSpecifier)) {
+      importDecl.remove();
+      importsRemoved++;
+    }
+  }
+  if (!hasCapabilityServiceImport(sourceFile)) {
+    const existingCoreImport = sourceFile.getImportDeclaration(CORE_MODULE);
+    if (existingCoreImport) {
+      const namedImports = existingCoreImport.getNamedImports();
+      const existingNames = namedImports.map((ni) => ni.getName());
+      if (!existingNames.includes("CapabilityService")) {
+        existingCoreImport.addNamedImport("CapabilityService");
+      }
+      if (!existingNames.includes("migrationAdaptor")) {
+        existingCoreImport.addNamedImport("migrationAdaptor");
+      }
+    } else {
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: CORE_MODULE,
+        namedImports: ["CapabilityService", "migrationAdaptor"]
+      });
+    }
+    importAdded = true;
+  }
+  if (!hasInjectImport(sourceFile)) {
+    const existingNestImport = sourceFile.getImportDeclaration(NESTJS_COMMON_MODULE);
+    if (existingNestImport) {
+      const namedImports = existingNestImport.getNamedImports();
+      const existingNames = namedImports.map((ni) => ni.getName());
+      if (!existingNames.includes("Inject")) {
+        existingNestImport.addNamedImport("Inject");
+      }
+    } else {
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: NESTJS_COMMON_MODULE,
+        namedImports: ["Inject"]
+      });
+    }
+    importAdded = true;
+  }
+  return { importAdded, importsRemoved };
+}
+
+// src/commands/migration/versions/v001_capability/code-migrator/transformers/injection-transformer.ts
+import { Scope } from "ts-morph";
+var PARAM_NAME = "capabilityService";
+var PARAM_TYPE = "CapabilityService";
+function hasCapabilityServiceInjection(sourceFile) {
+  const classes = sourceFile.getClasses();
+  for (const classDecl of classes) {
+    const constructors = classDecl.getConstructors();
+    for (const ctor of constructors) {
+      const params = ctor.getParameters();
+      for (const param of params) {
+        if (param.getName() === PARAM_NAME) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function findInjectableClass(sourceFile) {
+  const classes = sourceFile.getClasses();
+  for (const classDecl of classes) {
+    const decorators = classDecl.getDecorators();
+    const isInjectable = decorators.some((d) => d.getName() === "Injectable");
+    const isController = decorators.some((d) => d.getName() === "Controller");
+    if (isInjectable || isController) {
+      return classDecl;
+    }
+  }
+  return void 0;
+}
+function addInjection(sourceFile) {
+  if (hasCapabilityServiceInjection(sourceFile)) {
+    return { injectionAdded: false };
+  }
+  const classDecl = findInjectableClass(sourceFile);
+  if (!classDecl) {
+    return { injectionAdded: false };
+  }
+  const constructors = classDecl.getConstructors();
+  if (constructors.length > 0) {
+    const ctor = constructors[0];
+    ctor.addParameter({
+      name: PARAM_NAME,
+      type: PARAM_TYPE,
+      scope: Scope.Private,
+      isReadonly: true,
+      decorators: [{ name: "Inject", arguments: [] }]
+    });
+  } else {
+    classDecl.addConstructor({
+      parameters: [{
+        name: PARAM_NAME,
+        type: PARAM_TYPE,
+        scope: Scope.Private,
+        isReadonly: true,
+        decorators: [{ name: "Inject", arguments: [] }]
+      }]
+    });
+  }
+  return { injectionAdded: true };
+}
+
+// src/commands/migration/versions/v001_capability/code-migrator/transformers/call-site-transformer.ts
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+var DEFAULT_ACTION_NAME = "run";
+function generateNewCallText(capabilityId, actionName, args) {
+  const argsText = args.trim() || "{}";
+  return `migrationAdaptor(this.capabilityService.load('${capabilityId}').call('${actionName}', ${argsText}))`;
+}
+function transformCallSites(sourceFile, imports) {
+  const importMap = /* @__PURE__ */ new Map();
+  for (const imp of imports) {
+    importMap.set(imp.importName, {
+      capabilityId: imp.capabilityId,
+      actionName: imp.actionName ?? DEFAULT_ACTION_NAME
+    });
+  }
+  let replacedCount = 0;
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression);
+  const sortedCalls = [...callExpressions].sort((a, b) => b.getStart() - a.getStart());
+  for (const callExpr of sortedCalls) {
+    const expression = callExpr.getExpression();
+    let importInfo;
+    if (expression.getKind() === SyntaxKind2.Identifier) {
+      const functionName = expression.getText();
+      importInfo = importMap.get(functionName);
+    } else if (expression.getKind() === SyntaxKind2.PropertyAccessExpression) {
+      const propAccess = expression.asKind(SyntaxKind2.PropertyAccessExpression);
+      if (propAccess) {
+        const objectExpr = propAccess.getExpression();
+        if (objectExpr.getKind() === SyntaxKind2.Identifier) {
+          const objectName = objectExpr.getText();
+          importInfo = importMap.get(objectName);
+        }
+      }
+    }
+    if (importInfo) {
+      const args = callExpr.getArguments();
+      const argsText = args.map((arg) => arg.getText()).join(", ");
+      const newCallText = generateNewCallText(importInfo.capabilityId, importInfo.actionName, argsText);
+      callExpr.replaceWithText(newCallText);
+      replacedCount++;
+    }
+  }
+  return { replacedCount };
+}
+
+// src/commands/migration/versions/v001_capability/code-migrator/index.ts
+function analyzeFile(project, filePath, actionNameMap) {
+  const sourceFile = project.addSourceFileAtPath(filePath);
+  const imports = analyzeImports(sourceFile);
+  for (const imp of imports) {
+    const actionName = actionNameMap.get(imp.capabilityId);
+    if (actionName) {
+      imp.actionName = actionName;
+    }
+  }
+  const callSites = analyzeCallSites(sourceFile, imports);
+  const classInfo = analyzeClass(sourceFile);
+  const { canMigrate, reason } = canAutoMigrate(classInfo);
+  const relativePath = path12.relative(getProjectRoot3(), filePath);
+  return {
+    filePath: relativePath,
+    imports,
+    callSites,
+    classInfo,
+    canAutoMigrate: canMigrate,
+    manualMigrationReason: reason
+  };
+}
+function migrateFile(project, analysis, dryRun) {
+  const absolutePath = path12.join(getProjectRoot3(), analysis.filePath);
+  if (!analysis.canAutoMigrate) {
+    return {
+      filePath: analysis.filePath,
+      success: false,
+      importsRemoved: 0,
+      callSitesReplaced: 0,
+      injectionAdded: false,
+      error: analysis.manualMigrationReason
+    };
+  }
+  try {
+    const sourceFile = project.getSourceFileOrThrow(absolutePath);
+    const callResult = transformCallSites(sourceFile, analysis.imports);
+    const importResult = transformImports(sourceFile, analysis.imports);
+    const injectionResult = addInjection(sourceFile);
+    if (!dryRun) {
+      sourceFile.saveSync();
+    }
+    return {
+      filePath: analysis.filePath,
+      success: true,
+      importsRemoved: importResult.importsRemoved,
+      callSitesReplaced: callResult.replacedCount,
+      injectionAdded: injectionResult.injectionAdded
+    };
+  } catch (error) {
+    return {
+      filePath: analysis.filePath,
+      success: false,
+      importsRemoved: 0,
+      callSitesReplaced: 0,
+      injectionAdded: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function buildActionNameMap(capabilities) {
+  const map = /* @__PURE__ */ new Map();
+  for (const cap of capabilities) {
+    try {
+      const actionName = getActionNameByPluginKey(cap.pluginKey);
+      map.set(cap.id, actionName);
+    } catch {
+      map.set(cap.id, "run");
+    }
+  }
+  return map;
+}
+async function migrateCode(options, capabilities) {
+  const result = {
+    autoMigrated: [],
+    manualRequired: []
+  };
+  const actionNameMap = buildActionNameMap(capabilities);
+  const filesToMigrate = scanFilesToMigrate();
+  if (filesToMigrate.length === 0) {
+    console.log("   No files need code migration.\n");
+    return result;
+  }
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: {
+      allowJs: true
+    }
+  });
+  const analyses = [];
+  for (const filePath of filesToMigrate) {
+    try {
+      const analysis = analyzeFile(project, filePath, actionNameMap);
+      analyses.push(analysis);
+    } catch (error) {
+      console.error(`   \u2717 Failed to analyze ${filePath}: ${error}`);
+    }
+  }
+  const autoMigratable = analyses.filter((a) => a.canAutoMigrate);
+  const manualRequired = analyses.filter((a) => !a.canAutoMigrate);
+  for (const analysis of manualRequired) {
+    const capabilityIds = [...new Set(analysis.imports.map((i) => i.capabilityId))];
+    result.manualRequired.push({
+      filePath: analysis.filePath,
+      reason: analysis.manualMigrationReason || "Unknown reason",
+      capabilities: capabilityIds,
+      suggestion: getSuggestion(analysis)
+    });
+  }
+  for (const analysis of autoMigratable) {
+    const migrationResult = migrateFile(project, analysis, options.dryRun);
+    result.autoMigrated.push(migrationResult);
+  }
+  return result;
+}
+function getSuggestion(analysis) {
+  if (!analysis.classInfo) {
+    return "Consider moving capability usage to an @Injectable service";
+  }
+  if (!analysis.classInfo.isInjectable && !analysis.classInfo.isController) {
+    return `Add @Injectable() decorator to class "${analysis.classInfo.name}" or move capability usage to an injectable service`;
+  }
+  return "Manual review required";
+}
+
+// src/commands/migration/versions/v001_capability/cleanup.ts
+import fs13 from "fs";
+import path13 from "path";
+function cleanupOldFiles(capabilities, dryRun) {
+  const deletedFiles = [];
+  const errors = [];
+  const capabilitiesDir = getCapabilitiesDir2();
+  const oldJsonPath = path13.join(capabilitiesDir, "capabilities.json");
+  if (fs13.existsSync(oldJsonPath)) {
+    try {
+      if (!dryRun) {
+        fs13.unlinkSync(oldJsonPath);
+      }
+      deletedFiles.push("capabilities.json");
+    } catch (error) {
+      errors.push(`Failed to delete capabilities.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  for (const cap of capabilities) {
+    const tsFilePath = path13.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs13.existsSync(tsFilePath)) {
+      try {
+        if (!dryRun) {
+          fs13.unlinkSync(tsFilePath);
+        }
+        deletedFiles.push(`${cap.id}.ts`);
+      } catch (error) {
+        errors.push(`Failed to delete ${cap.id}.ts: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  return {
+    success: errors.length === 0,
+    deletedFiles,
+    errors
+  };
+}
+
+// src/commands/migration/versions/v001_capability/report-generator.ts
+import fs14 from "fs";
+import path14 from "path";
+var REPORT_FILE = "capability-migration-report.md";
+function printSummary(result) {
+  const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
+  console.log("\u{1F4CA} Migration Summary");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  if (!jsonMigration.skipped) {
+    console.log(`   JSON files migrated:     ${jsonMigration.count}`);
+  }
+  const totalPlugins = pluginInstallation.installed.length + pluginInstallation.alreadyInstalled.length;
+  if (totalPlugins > 0) {
+    console.log(`   Plugins installed:       ${pluginInstallation.installed.length}`);
+    console.log(`   Plugins already present: ${pluginInstallation.alreadyInstalled.length}`);
+    if (pluginInstallation.failed.length > 0) {
+      console.log(`   Plugins failed:          ${pluginInstallation.failed.length}`);
+    }
+  }
+  const successfulMigrations = codeMigration.autoMigrated.filter((f) => f.success);
+  const failedMigrations = codeMigration.autoMigrated.filter((f) => !f.success);
+  const totalCallSites = successfulMigrations.reduce((sum, f) => sum + f.callSitesReplaced, 0);
+  console.log(`   Files auto-migrated:     ${successfulMigrations.length}`);
+  if (failedMigrations.length > 0) {
+    console.log(`   Files failed:            ${failedMigrations.length}`);
+  }
+  if (codeMigration.manualRequired.length > 0) {
+    console.log(`   Files need manual work:  ${codeMigration.manualRequired.length}`);
+  }
+  console.log(`   Total call sites fixed:  ${totalCallSites}`);
+  if (cleanup.deletedFiles.length > 0) {
+    console.log(`   Old files cleaned up:    ${cleanup.deletedFiles.length}`);
+  }
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  const hasErrors = pluginInstallation.failed.length > 0 || failedMigrations.length > 0;
+  const hasManual = codeMigration.manualRequired.length > 0;
+  if (hasErrors) {
+    console.log("\u26A0\uFE0F  Migration completed with errors!\n");
+  } else if (hasManual) {
+    console.log("\u2705 Migration completed! (some files need manual work)\n");
+  } else {
+    console.log("\u2705 Migration completed!\n");
+  }
+  console.log("\u{1F4DD} Next steps:");
+  console.log("   1. Review changes: git diff");
+  console.log("   2. Run TypeScript check: npm run typecheck");
+  console.log("   3. Run tests: npm test");
+  if (hasManual) {
+    console.log("   4. Handle manual migrations (see report)");
+  }
+  console.log("");
+}
+async function generateReport(result) {
+  const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
+  const lines = [];
+  lines.push("# Capability \u8FC1\u79FB\u62A5\u544A");
+  lines.push("");
+  lines.push(`\u751F\u6210\u65F6\u95F4: ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+  lines.push("");
+  lines.push("## 1. \u914D\u7F6E\u8FC1\u79FB");
+  lines.push("");
+  if (jsonMigration.skipped) {
+    lines.push(`\u8DF3\u8FC7: ${jsonMigration.reason}`);
+  } else {
+    lines.push("### 1.1 \u5DF2\u8FC1\u79FB\u7684 Capabilities");
+    lines.push("");
+    lines.push("| ID | pluginKey |");
+    lines.push("|----|-----------|");
+    for (const cap of jsonMigration.capabilities) {
+      lines.push(`| ${cap.id} | ${cap.pluginKey} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## 2. \u63D2\u4EF6\u5B89\u88C5");
+  lines.push("");
+  if (pluginInstallation.installed.length === 0 && pluginInstallation.alreadyInstalled.length === 0) {
+    lines.push("\u65E0\u63D2\u4EF6\u9700\u8981\u5B89\u88C5\u3002");
+  } else {
+    lines.push("| pluginKey | \u72B6\u6001 |");
+    lines.push("|-----------|------|");
+    for (const pluginKey of pluginInstallation.alreadyInstalled) {
+      lines.push(`| ${pluginKey} | \u5DF2\u5B89\u88C5 |`);
+    }
+    for (const pluginKey of pluginInstallation.installed) {
+      lines.push(`| ${pluginKey} | \u65B0\u5B89\u88C5 |`);
+    }
+    for (const failed of pluginInstallation.failed) {
+      lines.push(`| ${failed.pluginKey} | \u274C \u5931\u8D25: ${failed.error} |`);
+    }
+  }
+  lines.push("");
+  lines.push("## 3. \u4EE3\u7801\u8FC1\u79FB");
+  lines.push("");
+  const successfulMigrations = codeMigration.autoMigrated.filter((f) => f.success);
+  const failedMigrations = codeMigration.autoMigrated.filter((f) => !f.success);
+  if (successfulMigrations.length > 0) {
+    lines.push(`### 3.1 \u81EA\u52A8\u8FC1\u79FB\u7684\u6587\u4EF6 (${successfulMigrations.length} \u4E2A)`);
+    lines.push("");
+    for (const file of successfulMigrations) {
+      lines.push(`#### ${file.filePath}`);
+      lines.push("");
+      lines.push("**\u53D8\u66F4\uFF1A**");
+      lines.push(`- \u5220\u9664 ${file.importsRemoved} \u4E2A capability import`);
+      if (file.injectionAdded) {
+        lines.push("- \u6DFB\u52A0 CapabilityService \u4F9D\u8D56\u6CE8\u5165");
+      }
+      lines.push(`- \u66FF\u6362 ${file.callSitesReplaced} \u4E2A\u8C03\u7528\u70B9`);
+      lines.push("");
+    }
+  }
+  if (failedMigrations.length > 0) {
+    lines.push(`### 3.2 \u8FC1\u79FB\u5931\u8D25\u7684\u6587\u4EF6 (${failedMigrations.length} \u4E2A)`);
+    lines.push("");
+    for (const file of failedMigrations) {
+      lines.push(`#### ${file.filePath}`);
+      lines.push("");
+      lines.push(`**\u9519\u8BEF\uFF1A** ${file.error}`);
+      lines.push("");
+    }
+  }
+  if (codeMigration.manualRequired.length > 0) {
+    lines.push(`### 3.3 \u9700\u8981\u624B\u52A8\u8FC1\u79FB\u7684\u6587\u4EF6 (${codeMigration.manualRequired.length} \u4E2A)`);
+    lines.push("");
+    for (const item of codeMigration.manualRequired) {
+      lines.push(`#### ${item.filePath}`);
+      lines.push("");
+      lines.push(`- **\u539F\u56E0\uFF1A** ${item.reason}`);
+      lines.push(`- **\u6D89\u53CA\u7684 Capabilities\uFF1A** ${item.capabilities.join(", ")}`);
+      lines.push(`- **\u5EFA\u8BAE\uFF1A** ${item.suggestion}`);
+      lines.push("");
+    }
+  }
+  lines.push("## 4. \u6E05\u7406\u8001\u6587\u4EF6");
+  lines.push("");
+  if (cleanup.deletedFiles.length === 0 && cleanup.errors.length === 0) {
+    lines.push("\u65E0\u6587\u4EF6\u9700\u8981\u6E05\u7406\u3002");
+  } else {
+    if (cleanup.deletedFiles.length > 0) {
+      lines.push("### 4.1 \u5DF2\u5220\u9664\u7684\u6587\u4EF6");
+      lines.push("");
+      for (const file of cleanup.deletedFiles) {
+        lines.push(`- \`${file}\``);
+      }
+      lines.push("");
+    }
+    if (cleanup.errors.length > 0) {
+      lines.push("### 4.2 \u6E05\u7406\u5931\u8D25");
+      lines.push("");
+      for (const err of cleanup.errors) {
+        lines.push(`- \u274C ${err}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("");
+  lines.push("## 5. \u9A8C\u8BC1\u6E05\u5355");
+  lines.push("");
+  lines.push("- [ ] \u8FD0\u884C `git diff` \u68C0\u67E5\u4EE3\u7801\u53D8\u66F4");
+  lines.push("- [ ] \u8FD0\u884C `npm run typecheck` \u68C0\u67E5\u7C7B\u578B");
+  lines.push("- [ ] \u8FD0\u884C `npm test` \u9A8C\u8BC1\u529F\u80FD");
+  if (codeMigration.manualRequired.length > 0) {
+    lines.push("- [ ] \u5904\u7406\u624B\u52A8\u8FC1\u79FB\u9879");
+  }
+  lines.push("");
+  const reportPath = path14.join(getProjectRoot3(), REPORT_FILE);
+  fs14.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  console.log(`\u{1F4C4} Report generated: ${REPORT_FILE}`);
+}
+
+// src/commands/migration/versions/v001_capability/migration-runner.ts
+async function runCapabilityMigration(options = {}) {
+  const fullOptions = {
+    dryRun: options.dryRun ?? false
+  };
+  console.log("\u{1F50D} Analyzing project...\n");
+  if (fullOptions.dryRun) {
+    console.log("\u{1F4CB} Running in dry-run mode (no files will be modified)\n");
+  }
+  let jsonResult = {
+    success: false,
+    skipped: true,
+    reason: "Not executed",
+    count: 0,
+    capabilities: []
+  };
+  let pluginResult = {
+    installed: [],
+    alreadyInstalled: [],
+    failed: []
+  };
+  let codeResult = {
+    autoMigrated: [],
+    manualRequired: []
+  };
+  let cleanupResult = {
+    success: true,
+    deletedFiles: [],
+    errors: []
+  };
+  console.log("\u{1F4C1} Step 1: JSON File Migration");
+  try {
+    jsonResult = await migrateJsonFiles(fullOptions);
+    if (jsonResult.skipped) {
+      console.log(`   \u25CB Skipped: ${jsonResult.reason}
+`);
+    } else if (jsonResult.success) {
+      console.log(`   \u2713 Created ${jsonResult.count} capability files
+`);
+    } else {
+      console.log(`   \u2717 Failed: ${jsonResult.reason}
+`);
+      return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.log(`   \u2717 Error: ${errorMsg}
+`);
+    jsonResult = {
+      success: false,
+      skipped: false,
+      reason: errorMsg,
+      count: 0,
+      capabilities: []
+    };
+    return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
+  }
+  if (jsonResult.skipped) {
+    return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
+  }
+  console.log("\u{1F4E6} Step 2: Plugin Installation");
+  try {
+    pluginResult = await installPlugins(jsonResult.capabilities, fullOptions);
+    if (pluginResult.alreadyInstalled.length > 0) {
+      console.log(`   \u2713 Already installed: ${pluginResult.alreadyInstalled.join(", ")}`);
+    }
+    if (pluginResult.installed.length > 0) {
+      console.log(`   \u2713 Installed: ${pluginResult.installed.join(", ")}`);
+    }
+    if (pluginResult.failed.length > 0) {
+      console.log(`   \u26A0 Failed (will continue): ${pluginResult.failed.map((f) => f.pluginKey).join(", ")}`);
+      for (const f of pluginResult.failed) {
+        console.log(`     - ${f.pluginKey}: ${f.error}`);
+      }
+    }
+    console.log("");
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.log(`   \u26A0 Error (will continue): ${errorMsg}
+`);
+    pluginResult = {
+      installed: [],
+      alreadyInstalled: [],
+      failed: [{ pluginKey: "unknown", error: errorMsg }]
+    };
+  }
+  console.log("\u{1F527} Step 3: Code Migration");
+  console.log("   Scanning server/ directory...\n");
+  try {
+    codeResult = await migrateCode(fullOptions, jsonResult.capabilities);
+    let hasCodeError = false;
+    for (const file of codeResult.autoMigrated) {
+      if (file.success) {
+        console.log(`   \u2713 ${file.filePath}`);
+        console.log(`     - Removed ${file.importsRemoved} capability imports`);
+        if (file.injectionAdded) {
+          console.log(`     - Added CapabilityService injection`);
+        }
+        console.log(`     - Replaced ${file.callSitesReplaced} call sites`);
+      } else {
+        console.log(`   \u2717 ${file.filePath}: ${file.error}`);
+        hasCodeError = true;
+      }
+    }
+    if (codeResult.manualRequired.length > 0) {
+      console.log("");
+      for (const item of codeResult.manualRequired) {
+        console.log(`   \u26A0 ${item.filePath} (manual migration required)`);
+        console.log(`     - Reason: ${item.reason}`);
+      }
+    }
+    console.log("");
+    if (hasCodeError) {
+      console.log("   \u2717 Code migration failed, aborting...\n");
+      return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.log(`   \u2717 Error: ${errorMsg}
+`);
+    codeResult = {
+      autoMigrated: [],
+      manualRequired: []
+    };
+    return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
+  }
+  console.log("\u{1F9F9} Step 4: Cleanup Old Files");
+  try {
+    cleanupResult = cleanupOldFiles(jsonResult.capabilities, fullOptions.dryRun);
+    if (cleanupResult.deletedFiles.length > 0) {
+      for (const file of cleanupResult.deletedFiles) {
+        console.log(`   \u2713 Deleted: ${file}`);
+      }
+    } else {
+      console.log("   \u25CB No files to clean up");
+    }
+    if (cleanupResult.errors.length > 0) {
+      for (const err of cleanupResult.errors) {
+        console.log(`   \u26A0 ${err}`);
+      }
+    }
+    console.log("");
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.log(`   \u26A0 Error: ${errorMsg}
+`);
+    cleanupResult = {
+      success: false,
+      deletedFiles: [],
+      errors: [errorMsg]
+    };
+  }
+  const result = buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
+  printSummary(result);
+  if (!fullOptions.dryRun) {
+    await generateReport(result);
+  }
+  return result;
+}
+function buildResult(jsonMigration, pluginInstallation, codeMigration, cleanup) {
+  return {
+    jsonMigration,
+    pluginInstallation,
+    codeMigration,
+    cleanup
+  };
+}
+
+// src/commands/migration/versions/v001_capability/run.ts
+async function run3(options) {
+  try {
+    const migrationOptions = {
+      dryRun: options.dryRun ?? false
+    };
+    const result = await runCapabilityMigration(migrationOptions);
+    const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
+    const jsonFailed = !jsonMigration.success && !jsonMigration.skipped;
+    const codeFailed = codeMigration.autoMigrated.some((f) => !f.success);
+    if (jsonFailed) {
+      return {
+        success: false,
+        message: jsonMigration.reason || "JSON migration failed",
+        error: new Error(jsonMigration.reason || "Unknown error")
+      };
+    }
+    if (codeFailed) {
+      return {
+        success: false,
+        message: "Code migration failed",
+        error: new Error("Some files failed to migrate")
+      };
+    }
+    const messages = [];
+    if (jsonMigration.success) {
+      messages.push(`${jsonMigration.count} capabilities migrated`);
+    }
+    if (pluginInstallation.installed.length > 0) {
+      messages.push(`${pluginInstallation.installed.length} plugins installed`);
+    }
+    if (codeMigration.autoMigrated.length > 0) {
+      const successCount = codeMigration.autoMigrated.filter((f) => f.success).length;
+      if (successCount > 0) {
+        messages.push(`${successCount} files auto-migrated`);
+      }
+    }
+    if (cleanup.deletedFiles.length > 0) {
+      messages.push(`${cleanup.deletedFiles.length} old files cleaned up`);
+    }
+    if (codeMigration.manualRequired.length > 0) {
+      messages.push(`${codeMigration.manualRequired.length} files need manual migration`);
+    }
+    if (pluginInstallation.failed.length > 0) {
+      messages.push(`${pluginInstallation.failed.length} plugins failed to install`);
+    }
+    return {
+      success: true,
+      message: messages.join(", ") || "No migration needed"
+    };
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    return {
+      success: false,
+      message: err.message,
+      error: err
+    };
+  }
+}
+
+// src/commands/migration/versions/v001_capability/index.ts
+var v001CapabilityMigration = {
+  version: 1,
+  name: "capability",
+  description: "Migrate capability configurations from old format (capabilities.json array) to new format (individual JSON files)",
+  check,
+  run: run3
+};
+
+// src/commands/migration/versions/index.ts
+var versionedMigrations = [
+  v001CapabilityMigration
+  // 未来新增的迁移脚本在此添加，如:
+  // v002ConfigMigration,
+  // v003RoutesMigration,
+];
+function getPendingMigrations(currentVersion) {
+  return versionedMigrations.filter((m) => m.version > currentVersion).sort((a, b) => a.version - b.version);
+}
+function getLatestVersion() {
+  if (versionedMigrations.length === 0) return 0;
+  return Math.max(...versionedMigrations.map((m) => m.version));
+}
+
+// src/commands/migration/runner.ts
+function log(message) {
+  console.log(`[migration] ${message}`);
+}
+async function executeSingle(migration, options) {
+  const { version, name } = migration;
+  const versionTag = `v${version}`;
+  try {
+    log(`Checking [${versionTag}] ${name}...`);
+    const checkResult = await migration.check(options);
+    if (!checkResult.needsMigration) {
+      log(`[${versionTag}] ${name}: no migration needed`);
+      return {
+        name,
+        status: "skipped",
+        message: checkResult.message || "No migration needed"
+      };
+    }
+    log(`[${versionTag}] ${name}: needs migration (${checkResult.message})`);
+    if (checkResult.items && checkResult.items.length > 0) {
+      for (const item of checkResult.items) {
+        console.log(`    - ${item}`);
+      }
+    }
+    if (options.dryRun) {
+      return {
+        name,
+        status: "skipped",
+        message: `Dry-run: ${checkResult.message}`
+      };
+    }
+    log(`Running [${versionTag}] ${name} migration...`);
+    const runResult = await migration.run(options);
+    if (runResult.success) {
+      log(`\u2713 [${versionTag}] ${name}: completed (${runResult.message})`);
+      return {
+        name,
+        status: "completed",
+        message: runResult.message
+      };
+    } else {
+      log(`\u2717 [${versionTag}] ${name}: failed`);
+      if (runResult.error) {
+        console.log(`    Error: ${runResult.error.message}`);
+      }
+      return {
+        name,
+        status: "failed",
+        message: runResult.message,
+        error: runResult.error
+      };
+    }
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    log(`\u2717 [${versionTag}] ${name}: failed`);
+    console.log(`    Error: ${err.message}`);
+    return {
+      name,
+      status: "failed",
+      message: err.message,
+      error: err
+    };
+  }
+}
+function printSummary2(summary, dryRun) {
+  console.log("");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(dryRun ? "Dry-run Summary:" : "Migration Summary:");
+  if (dryRun) {
+    const needsMigration = summary.skipped.filter((s) => s.message.startsWith("Dry-run:")).length;
+    const noAction = summary.skipped.filter((s) => !s.message.startsWith("Dry-run:")).length;
+    console.log(`  Needs migration: ${needsMigration}`);
+    console.log(`  No action needed: ${noAction}`);
+  } else {
+    console.log(`  \u2713 Completed: ${summary.completed.length}`);
+    console.log(`  \u25CB Skipped:   ${summary.skipped.length} (no migration needed)`);
+    console.log(`  \u2717 Failed:    ${summary.failed.length}`);
+  }
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+}
+async function runMigrations(options) {
+  const currentVersion = getCurrentVersion();
+  const latestVersion = getLatestVersion();
+  console.log("");
+  log(`Current version: ${currentVersion || "0 (not set)"}`);
+  if (currentVersion >= latestVersion) {
+    log("All migrations are up to date.");
+    return {
+      needsMigration: false,
+      completed: [],
+      skipped: [],
+      failed: []
+    };
+  }
+  const pendingMigrations = getPendingMigrations(currentVersion);
+  if (options.dryRun) {
+    log("Dry-run mode enabled, no changes will be made.");
+  } else {
+    log("Applying migrations...");
+  }
+  console.log("");
+  const summary = {
+    needsMigration: false,
+    completed: [],
+    skipped: [],
+    failed: []
+  };
+  let hasAnyMigration = false;
+  for (const migration of pendingMigrations) {
+    const result = await executeSingle(migration, options);
+    switch (result.status) {
+      case "completed":
+        summary.completed.push(result);
+        hasAnyMigration = true;
+        if (!options.dryRun) {
+          setCurrentVersion(migration.version);
+        }
+        break;
+      case "skipped":
+        summary.skipped.push(result);
+        if (result.message.startsWith("Dry-run:")) {
+          hasAnyMigration = true;
+        }
+        break;
+      case "failed":
+        summary.failed.push(result);
+        hasAnyMigration = true;
+        log("Migration aborted due to failure.");
+        printSummary2(summary, !!options.dryRun);
+        return summary;
+    }
+    console.log("");
+  }
+  summary.needsMigration = hasAnyMigration;
+  if (currentVersion === 0 && !hasAnyMigration && !options.dryRun) {
+    log(`All migrations skipped. Project is up to date.`);
+    log(`Updated migrationVersion to ${latestVersion}.`);
+    setCurrentVersion(latestVersion);
+  } else if (!options.dryRun && summary.completed.length > 0) {
+    log(`Migration complete. Updated to version ${getCurrentVersion()}.`);
+  }
+  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();
+  console.log("");
+  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: [],
+      skipped: [],
+      failed: []
+    };
+  }
+  log("Checking pending migrations...");
+  console.log("");
+  const pendingMigrations = getPendingMigrations(currentVersion);
+  const summary = {
+    needsMigration: false,
+    completed: [],
+    skipped: [],
+    failed: []
+  };
+  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 {
-        await runSync(options);
+      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) {
+            console.log(`    - ${item}`);
+          }
+        }
+        summary.skipped.push({
+          name,
+          status: "skipped",
+          message: `Needs migration: ${checkResult.message}`
+        });
+      } else {
+        noActionCount++;
+        console.log(`  ${versionTag} (${name}): no migration needed`);
+        summary.skipped.push({
+          name,
+          status: "skipped",
+          message: checkResult.message || "No migration needed"
+        });
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.log(`  ${versionTag} (${name}): check failed`);
+      console.log(`    Error: ${err.message}`);
+      summary.failed.push({
+        name,
+        status: "failed",
+        message: err.message,
+        error: err
+      });
     }
-    catch (error) {
-        console.error(`Failed to execute command:`, error.message);
-        console.error(error.stack);
+  }
+  console.log("");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("Check Summary:");
+  console.log(`  Needs migration: ${needsCount}`);
+  console.log(`  No action needed: ${noActionCount}`);
+  if (summary.failed.length > 0) {
+    console.log(`  Check failed: ${summary.failed.length}`);
+  }
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  if (needsCount > 0) {
+    console.log("");
+    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;
+}
+
+// src/commands/migration/index.ts
+var migrationCommand = {
+  name: "migration",
+  description: "Run versioned migration scripts",
+  register(program) {
+    const migrationCmd = program.command(this.name).description("Run all pending migrations based on current migrationVersion").option("--dry-run", "Preview mode, only run check() without executing run()").action(async (options) => {
+      const summary = await runMigrations(options);
+      if (summary.failed.length > 0) {
         process.exit(1);
+      }
+    });
+    migrationCmd.command("check").description("Check pending migrations without applying them").action(async () => {
+      const summary = await checkMigrations({});
+      if (summary.failed.length > 0) {
+        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;
     }
-});
-// 解析命令行参数
-cli.parse();
+  }
+  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,
+  readLogsCommand
+];
+
+// src/index.ts
+var envPath = path16.join(process.cwd(), ".env");
+if (fs18.existsSync(envPath)) {
+  dotenvConfig({ path: envPath });
+}
+var __dirname = path16.dirname(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(fs18.readFileSync(path16.join(__dirname, "../package.json"), "utf-8"));
+var cli = new FullstackCLI(pkg.version);
+cli.useAll(commands);
+cli.run();