@lark-apaas/fullstack-cli 1.1.39 → 1.1.40-alpha.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs26 from "fs";
-import path22 from "path";
+import fs28 from "fs";
+import path24 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -3105,6 +3105,309 @@ async function run3(options = {}) {
 
 // src/commands/upgrade/deps/run.handler.ts
 import { spawnSync as spawnSync3 } from "child_process";
+
+// src/utils/grayscale/cache.ts
+import fs10 from "fs";
+import path8 from "path";
+import os from "os";
+var CACHE_PATH = path8.join(os.homedir(), ".fullstack", "grayscale-cache.json");
+var NORMAL_TTL_MS = 30 * 60 * 1e3;
+var FALLBACK_TTL_MS = 24 * 60 * 60 * 1e3;
+function readLocalCache(fallback = false) {
+  try {
+    if (!fs10.existsSync(CACHE_PATH)) {
+      return null;
+    }
+    const content = fs10.readFileSync(CACHE_PATH, "utf-8");
+    const entry = JSON.parse(content);
+    if (!entry.config || !entry.timestamp) {
+      return null;
+    }
+    const ttl = fallback ? FALLBACK_TTL_MS : NORMAL_TTL_MS;
+    const age = Date.now() - entry.timestamp;
+    if (age > ttl) {
+      return null;
+    }
+    return entry.config;
+  } catch {
+    return null;
+  }
+}
+function writeLocalCache(config) {
+  try {
+    const dir = path8.dirname(CACHE_PATH);
+    if (!fs10.existsSync(dir)) {
+      fs10.mkdirSync(dir, { recursive: true });
+    }
+    const entry = {
+      config,
+      timestamp: Date.now()
+    };
+    fs10.writeFileSync(CACHE_PATH, JSON.stringify(entry, null, 2), "utf-8");
+  } catch {
+  }
+}
+
+// src/utils/grayscale/config.ts
+var memoryCache = null;
+var MEMORY_TTL_MS = 60 * 1e3;
+var API_TIMEOUT_MS = 3e3;
+async function fetchFromApi() {
+  try {
+    const client = getHttpClient();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+    try {
+      const response = await client.post(
+        "/api/v1/studio/innerapi/get_grayscale_config",
+        {},
+        { signal: controller.signal }
+      );
+      if (!response.ok) {
+        console.warn(`[grayscale] API request failed: ${response.status} ${response.statusText}`);
+        return null;
+      }
+      const result = await response.json();
+      if (result.status_code !== "0") {
+        console.warn(`[grayscale] API error: ${result.message}`);
+        return null;
+      }
+      return result.data?.config ?? null;
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[grayscale] Failed to fetch config from API: ${message}`);
+    return null;
+  }
+}
+async function getGrayscaleConfig() {
+  if (memoryCache) {
+    const age = Date.now() - memoryCache.timestamp;
+    if (age <= MEMORY_TTL_MS) {
+      return memoryCache.config;
+    }
+    memoryCache = null;
+  }
+  const localNormal = readLocalCache(false);
+  if (localNormal) {
+    memoryCache = { config: localNormal, timestamp: Date.now() };
+    return localNormal;
+  }
+  const apiConfig = await fetchFromApi();
+  if (apiConfig) {
+    memoryCache = { config: apiConfig, timestamp: Date.now() };
+    writeLocalCache(apiConfig);
+    return apiConfig;
+  }
+  const localFallback = readLocalCache(true);
+  if (localFallback) {
+    memoryCache = { config: localFallback, timestamp: Date.now() };
+    return localFallback;
+  }
+  return null;
+}
+
+// src/utils/grayscale/identity.ts
+import fs11 from "fs";
+import path9 from "path";
+function readFromEnvVars() {
+  const appId = process.env.app_id || process.env.APP_ID;
+  const tenantId = process.env.tenant_id || process.env.TENANT_ID;
+  return { appId, tenantId };
+}
+function parseEnvFile(filePath) {
+  const result = {};
+  if (!fs11.existsSync(filePath)) {
+    return result;
+  }
+  try {
+    const content = fs11.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+      const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=["']?(.+?)["']?$/);
+      if (match) {
+        result[match[1]] = match[2];
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function readFromForceEnvFile(cwd) {
+  const envPath2 = path9.join(cwd, ".force", "environment", "env");
+  const vars = parseEnvFile(envPath2);
+  return {
+    appId: vars.app_id || vars.APP_ID,
+    tenantId: vars.tenant_id || vars.TENANT_ID
+  };
+}
+function readFromClientBasePath() {
+  const basePath = process.env.CLIENT_BASE_PATH;
+  if (!basePath) {
+    return {};
+  }
+  const afMatch = basePath.match(/\/af\/p\/([^/]+)/);
+  if (afMatch) {
+    return { appId: afMatch[1] };
+  }
+  const appMatch = basePath.match(/\/app\/([^/]+)/);
+  if (appMatch) {
+    return { appId: appMatch[1] };
+  }
+  return {};
+}
+function readFromDotEnv(cwd) {
+  const envPath2 = path9.join(cwd, ".env");
+  const vars = parseEnvFile(envPath2);
+  return {
+    appId: vars.app_id || vars.APP_ID,
+    tenantId: vars.tenant_id || vars.TENANT_ID
+  };
+}
+function readFromPackageJson(cwd) {
+  const pkgPath = path9.join(cwd, "package.json");
+  if (!fs11.existsSync(pkgPath)) {
+    return {};
+  }
+  try {
+    const content = fs11.readFileSync(pkgPath, "utf-8");
+    const pkg2 = JSON.parse(content);
+    const appId = pkg2?.fullstack?.appId;
+    return appId ? { appId } : {};
+  } catch {
+    return {};
+  }
+}
+function readProjectIdentity(cwd) {
+  const sources = [
+    () => readFromEnvVars(),
+    () => readFromForceEnvFile(cwd),
+    () => readFromClientBasePath(),
+    () => readFromDotEnv(cwd),
+    () => readFromPackageJson(cwd)
+  ];
+  const merged = {};
+  for (const source of sources) {
+    const identity = source();
+    if (!merged.appId && identity.appId) {
+      merged.appId = identity.appId;
+    }
+    if (!merged.tenantId && identity.tenantId) {
+      merged.tenantId = identity.tenantId;
+    }
+    if (merged.appId && merged.tenantId) {
+      break;
+    }
+  }
+  return merged;
+}
+
+// src/utils/grayscale/rules.ts
+import { createHash } from "crypto";
+function isInPercentage(key, percentage) {
+  if (percentage <= 0) return false;
+  if (percentage >= 100) return true;
+  const hash = createHash("md5").update(`grayscale:${key}`).digest("hex");
+  const value = parseInt(hash.substring(0, 8), 16) % 1e4;
+  const threshold = Math.floor(percentage * 100);
+  return value < threshold;
+}
+function matchConditions(rule, identity) {
+  const { conditions } = rule;
+  if (conditions.tenant_ids && conditions.tenant_ids.length > 0) {
+    if (identity.tenantId && conditions.tenant_ids.includes(identity.tenantId)) {
+      return true;
+    }
+  }
+  if (conditions.app_ids && conditions.app_ids.length > 0) {
+    if (identity.appId && conditions.app_ids.includes(identity.appId)) {
+      return true;
+    }
+  }
+  if (conditions.percentage != null && conditions.percentage > 0) {
+    const hashKey = conditions.hash_key || "app_id";
+    const hashValue = hashKey === "tenant_id" ? identity.tenantId : identity.appId;
+    if (hashValue && isInPercentage(hashValue, conditions.percentage)) {
+      return true;
+    }
+  }
+  const hasConditions = conditions.tenant_ids && conditions.tenant_ids.length > 0 || conditions.app_ids && conditions.app_ids.length > 0 || conditions.percentage != null && conditions.percentage > 0;
+  return !hasConditions;
+}
+function evaluateRules(config, identity) {
+  const enabledRules = config.rules.filter((rule) => rule.enabled).sort((a, b) => b.priority - a.priority);
+  for (const rule of enabledRules) {
+    if (matchConditions(rule, identity)) {
+      return rule;
+    }
+  }
+  return null;
+}
+function resolveTargetVersions(config, identity) {
+  const matchedRule = evaluateRules(config, identity);
+  const channelName = matchedRule?.channel || config.default_channel;
+  const channel = config.channels[channelName];
+  if (!channel) {
+    console.warn(`[grayscale] Channel "${channelName}" not found in config`);
+    return null;
+  }
+  const versions = /* @__PURE__ */ new Map();
+  for (const [pkgName, version] of Object.entries(channel.versions)) {
+    if (config.blocked_versions?.includes(version)) {
+      console.warn(`[grayscale] Version ${version} of ${pkgName} is blocked, skipping`);
+      continue;
+    }
+    versions.set(pkgName, version);
+  }
+  if (config.force_versions) {
+    for (const [pkgName, version] of Object.entries(config.force_versions)) {
+      versions.set(pkgName, version);
+    }
+  }
+  if (matchedRule) {
+    console.log(`[grayscale] Matched rule: "${matchedRule.name}" (id: ${matchedRule.id}), channel: ${channelName}`);
+  } else {
+    console.log(`[grayscale] No rule matched, using default channel: ${channelName}`);
+  }
+  return versions;
+}
+
+// src/utils/grayscale/index.ts
+async function resolveGrayscaleVersions(cwd) {
+  const config = await getGrayscaleConfig();
+  if (!config) {
+    console.log("[grayscale] Config not available, skipping grayscale");
+    return null;
+  }
+  if (!config.enabled) {
+    console.log("[grayscale] Grayscale is disabled");
+    return null;
+  }
+  const identity = readProjectIdentity(cwd);
+  if (!identity.appId && !identity.tenantId) {
+    console.log("[grayscale] No app_id or tenant_id found, skipping grayscale");
+    return null;
+  }
+  console.log(`[grayscale] Project identity: appId=${identity.appId || "N/A"}, tenantId=${identity.tenantId || "N/A"}`);
+  const versions = resolveTargetVersions(config, identity);
+  if (!versions || versions.size === 0) {
+    console.log("[grayscale] No target versions resolved");
+    return null;
+  }
+  console.log(`[grayscale] Resolved ${versions.size} package version(s):`);
+  for (const [pkg2, ver] of versions) {
+    console.log(`[grayscale]   ${pkg2} -> ${ver}`);
+  }
+  return versions;
+}
+
+// src/commands/upgrade/deps/run.handler.ts
 function findLarkAapaasPackages(cwd, filterPackages) {
   const pkg2 = readPackageJson(cwd);
   const allPackages = /* @__PURE__ */ new Set();
@@ -3157,11 +3460,43 @@ function upgradePackages(packages, version, cwd) {
     });
   }
 }
+function installGrayscaleVersions(packages, grayscaleVersions, cwd, dryRun) {
+  const upgradePlan = [];
+  for (const pkg2 of packages) {
+    const version = grayscaleVersions.get(pkg2);
+    if (version) {
+      upgradePlan.push({ pkg: pkg2, version });
+    }
+  }
+  if (upgradePlan.length === 0) {
+    console.log("[fullstack-cli] No grayscale versions matched current packages");
+    return;
+  }
+  console.log(`[fullstack-cli] Grayscale upgrade plan (${upgradePlan.length} package(s)):`);
+  upgradePlan.forEach(({ pkg: pkg2, version }) => {
+    console.log(`  - ${pkg2} -> ${version}`);
+  });
+  if (dryRun) {
+    console.log("[fullstack-cli] Dry run mode, skipping actual installation");
+    return;
+  }
+  for (const { pkg: pkg2, version } of upgradePlan) {
+    const target = `${pkg2}@${version}`;
+    console.log(`[fullstack-cli]   Installing ${target}...`);
+    const result = spawnSync3("npm", ["install", target], {
+      cwd,
+      stdio: "inherit"
+    });
+    if (result.error || result.status !== 0) {
+      throw new Error(`Failed to install ${target}`);
+    }
+  }
+}
 async function run4(options = {}) {
   const cwd = process.env.INIT_CWD || process.cwd();
   console.log("[fullstack-cli] Starting dependencies upgrade...");
   try {
-    console.log("[fullstack-cli] Step 1/2: Scanning @lark-apaas dependencies...");
+    console.log("[fullstack-cli] Step 1/3: Scanning @lark-apaas dependencies...");
     const packages = findLarkAapaasPackages(cwd, options.packages);
     if (packages.length === 0) {
       console.log("[fullstack-cli] No @lark-apaas packages found");
@@ -3169,7 +3504,35 @@ async function run4(options = {}) {
     }
     console.log(`[fullstack-cli] Found ${packages.length} @lark-apaas package(s):`);
     packages.forEach((p) => console.log(`  - ${p}`));
-    console.log("[fullstack-cli] Step 2/2: Upgrading packages...");
+    if (!options.skipGrayscale && !options.version) {
+      console.log("[fullstack-cli] Step 2/3: Checking grayscale config...");
+      try {
+        const grayscaleVersions = await resolveGrayscaleVersions(cwd);
+        if (grayscaleVersions) {
+          console.log("[fullstack-cli] Step 3/3: Applying grayscale versions...");
+          installGrayscaleVersions(packages, grayscaleVersions, cwd, !!options.dryRun);
+          if (!options.dryRun) {
+            console.log(`[fullstack-cli] \u2713 Successfully upgraded ${packages.length} package(s) via grayscale`);
+            console.log("[fullstack-cli] Dependencies upgrade completed successfully \u2705");
+          }
+          return;
+        }
+        console.log("[fullstack-cli] Grayscale not available, falling back to default upgrade");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.warn(`[fullstack-cli] Grayscale check failed: ${msg}, falling back to default upgrade`);
+      }
+    } else if (options.skipGrayscale) {
+      console.log("[fullstack-cli] Step 2/3: Skipping grayscale check (--skip-grayscale)");
+    } else {
+      console.log("[fullstack-cli] Step 2/3: Skipping grayscale check (explicit --version provided)");
+    }
+    if (options.dryRun) {
+      console.log("[fullstack-cli] Dry run mode: would upgrade via npm update (no grayscale)");
+      packages.forEach((p) => console.log(`  - ${p} -> ${options.version || "latest compatible"}`));
+      return;
+    }
+    console.log("[fullstack-cli] Step 3/3: Upgrading packages...");
     upgradePackages(packages, options.version, cwd);
     console.log(`[fullstack-cli] \u2713 Successfully upgraded ${packages.length} package(s)`);
     console.log("[fullstack-cli] Dependencies upgrade completed successfully \u2705");
@@ -3185,7 +3548,7 @@ var depsCommand = {
   name: "deps",
   description: "Upgrade @lark-apaas dependencies",
   register(parentCommand) {
-    parentCommand.command(this.name).description(this.description).option("--version <version>", "Upgrade to specific version").option("--packages <packages>", "Only upgrade specific packages (comma-separated)").action(async (options) => {
+    parentCommand.command(this.name).description(this.description).option("--version <version>", "Upgrade to specific version").option("--packages <packages>", "Only upgrade specific packages (comma-separated)").option("--skip-grayscale", "Skip grayscale version check").option("--dry-run", "Show upgrade plan without executing").action(async (options) => {
       await run4(options);
     });
   }
@@ -3204,8 +3567,8 @@ var upgradeCommand = {
 };
 
 // src/commands/action-plugin/utils.ts
-import fs10 from "fs";
-import path8 from "path";
+import fs12 from "fs";
+import path10 from "path";
 import { spawnSync as spawnSync4, execSync as execSync2 } from "child_process";
 function parsePluginName(input) {
   const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
@@ -3223,18 +3586,18 @@ function getProjectRoot() {
   return process.cwd();
 }
 function getPackageJsonPath() {
-  return path8.join(getProjectRoot(), "package.json");
+  return path10.join(getProjectRoot(), "package.json");
 }
 function getPluginPath(pluginName) {
-  return path8.join(getProjectRoot(), "node_modules", pluginName);
+  return path10.join(getProjectRoot(), "node_modules", pluginName);
 }
 function readPackageJson2() {
   const pkgPath = getPackageJsonPath();
-  if (!fs10.existsSync(pkgPath)) {
+  if (!fs12.existsSync(pkgPath)) {
     throw new Error("package.json not found in current directory");
   }
   try {
-    const content = fs10.readFileSync(pkgPath, "utf-8");
+    const content = fs12.readFileSync(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
     throw new Error("Failed to parse package.json");
@@ -3242,7 +3605,7 @@ function readPackageJson2() {
 }
 function writePackageJson2(pkg2) {
   const pkgPath = getPackageJsonPath();
-  fs10.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs12.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 function readActionPlugins() {
   const pkg2 = readPackageJson2();
@@ -3275,12 +3638,12 @@ function npmInstall(tgzPath) {
   }
 }
 function getPackageVersion(pluginName) {
-  const pkgJsonPath = path8.join(getPluginPath(pluginName), "package.json");
-  if (!fs10.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path10.join(getPluginPath(pluginName), "package.json");
+  if (!fs12.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs10.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs12.readFileSync(pkgJsonPath, "utf-8");
     const pkg2 = JSON.parse(content);
     return pkg2.version || null;
   } catch {
@@ -3288,49 +3651,49 @@ function getPackageVersion(pluginName) {
   }
 }
 function readPluginPackageJson(pluginPath) {
-  const pkgJsonPath = path8.join(pluginPath, "package.json");
-  if (!fs10.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path10.join(pluginPath, "package.json");
+  if (!fs12.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs10.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs12.readFileSync(pkgJsonPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function extractTgzToNodeModules(tgzPath, pluginName) {
-  const nodeModulesPath = path8.join(getProjectRoot(), "node_modules");
-  const targetDir = path8.join(nodeModulesPath, pluginName);
-  const scopeDir = path8.dirname(targetDir);
-  if (!fs10.existsSync(scopeDir)) {
-    fs10.mkdirSync(scopeDir, { recursive: true });
+  const nodeModulesPath = path10.join(getProjectRoot(), "node_modules");
+  const targetDir = path10.join(nodeModulesPath, pluginName);
+  const scopeDir = path10.dirname(targetDir);
+  if (!fs12.existsSync(scopeDir)) {
+    fs12.mkdirSync(scopeDir, { recursive: true });
   }
-  if (fs10.existsSync(targetDir)) {
-    fs10.rmSync(targetDir, { recursive: true });
+  if (fs12.existsSync(targetDir)) {
+    fs12.rmSync(targetDir, { recursive: true });
   }
-  const tempDir = path8.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
-  if (fs10.existsSync(tempDir)) {
-    fs10.rmSync(tempDir, { recursive: true });
+  const tempDir = path10.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs12.existsSync(tempDir)) {
+    fs12.rmSync(tempDir, { recursive: true });
   }
-  fs10.mkdirSync(tempDir, { recursive: true });
+  fs12.mkdirSync(tempDir, { recursive: true });
   try {
     execSync2(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
-    const extractedDir = path8.join(tempDir, "package");
-    if (fs10.existsSync(extractedDir)) {
-      fs10.renameSync(extractedDir, targetDir);
+    const extractedDir = path10.join(tempDir, "package");
+    if (fs12.existsSync(extractedDir)) {
+      fs12.renameSync(extractedDir, targetDir);
     } else {
-      const files = fs10.readdirSync(tempDir);
+      const files = fs12.readdirSync(tempDir);
       if (files.length === 1) {
-        fs10.renameSync(path8.join(tempDir, files[0]), targetDir);
+        fs12.renameSync(path10.join(tempDir, files[0]), targetDir);
       } else {
         throw new Error("Unexpected tgz structure");
       }
     }
     return targetDir;
   } finally {
-    if (fs10.existsSync(tempDir)) {
-      fs10.rmSync(tempDir, { recursive: true });
+    if (fs12.existsSync(tempDir)) {
+      fs12.rmSync(tempDir, { recursive: true });
     }
   }
 }
@@ -3339,10 +3702,10 @@ function checkMissingPeerDeps(peerDeps) {
     return [];
   }
   const missing = [];
-  const nodeModulesPath = path8.join(getProjectRoot(), "node_modules");
+  const nodeModulesPath = path10.join(getProjectRoot(), "node_modules");
   for (const [depName, _version] of Object.entries(peerDeps)) {
-    const depPath = path8.join(nodeModulesPath, depName);
-    if (!fs10.existsSync(depPath)) {
+    const depPath = path10.join(nodeModulesPath, depName);
+    if (!fs12.existsSync(depPath)) {
       missing.push(depName);
     }
   }
@@ -3366,16 +3729,16 @@ function installMissingDeps(deps) {
 }
 function removePluginDirectory(pluginName) {
   const pluginPath = getPluginPath(pluginName);
-  if (fs10.existsSync(pluginPath)) {
-    fs10.rmSync(pluginPath, { recursive: true });
+  if (fs12.existsSync(pluginPath)) {
+    fs12.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 fs11 from "fs";
-import path9 from "path";
+import fs13 from "fs";
+import path11 from "path";
 var PLUGIN_CACHE_DIR = "node_modules/.cache/fullstack-cli/plugins";
 async function getPluginVersions(keys, latestOnly = true) {
   const client = getHttpClient();
@@ -3439,19 +3802,19 @@ async function downloadFromPublic(downloadURL) {
   return Buffer.from(arrayBuffer);
 }
 function getPluginCacheDir() {
-  return path9.join(process.cwd(), PLUGIN_CACHE_DIR);
+  return path11.join(process.cwd(), PLUGIN_CACHE_DIR);
 }
 function ensureCacheDir() {
   const cacheDir = getPluginCacheDir();
-  if (!fs11.existsSync(cacheDir)) {
-    fs11.mkdirSync(cacheDir, { recursive: true });
+  if (!fs13.existsSync(cacheDir)) {
+    fs13.mkdirSync(cacheDir, { recursive: true });
   }
 }
 function getTempFilePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}@${version}.tgz`;
-  return path9.join(getPluginCacheDir(), filename);
+  return path11.join(getPluginCacheDir(), filename);
 }
 var MAX_RETRIES = 2;
 async function withRetry(operation, description, maxRetries = MAX_RETRIES) {
@@ -3488,7 +3851,7 @@ async function downloadPlugin(pluginKey, requestedVersion) {
     );
   }
   const tgzPath = getTempFilePath(pluginKey, pluginInfo.version);
-  fs11.writeFileSync(tgzPath, tgzBuffer);
+  fs13.writeFileSync(tgzPath, tgzBuffer);
   console.log(`[action-plugin] Downloaded to ${tgzPath} (${(tgzBuffer.length / 1024).toFixed(2)} KB)`);
   return {
     tgzPath,
@@ -3502,18 +3865,18 @@ function getCachePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}@${version}.tgz`;
-  return path9.join(getPluginCacheDir(), filename);
+  return path11.join(getPluginCacheDir(), filename);
 }
 function hasCachedPlugin(pluginKey, version) {
   const cachePath = getCachePath(pluginKey, version);
-  return fs11.existsSync(cachePath);
+  return fs13.existsSync(cachePath);
 }
 function listCachedPlugins() {
   const cacheDir = getPluginCacheDir();
-  if (!fs11.existsSync(cacheDir)) {
+  if (!fs13.existsSync(cacheDir)) {
     return [];
   }
-  const files = fs11.readdirSync(cacheDir);
+  const files = fs13.readdirSync(cacheDir);
   const result = [];
   for (const file of files) {
     if (!file.endsWith(".tgz")) continue;
@@ -3521,8 +3884,8 @@ function listCachedPlugins() {
     if (!match) continue;
     const [, rawName, version] = match;
     const name = rawName.replace(/^_/, "@").replace(/_/, "/");
-    const filePath = path9.join(cacheDir, file);
-    const stat = fs11.statSync(filePath);
+    const filePath = path11.join(cacheDir, file);
+    const stat = fs13.statSync(filePath);
     result.push({
       name,
       version,
@@ -3535,14 +3898,14 @@ function listCachedPlugins() {
 }
 function cleanAllCache() {
   const cacheDir = getPluginCacheDir();
-  if (!fs11.existsSync(cacheDir)) {
+  if (!fs13.existsSync(cacheDir)) {
     return 0;
   }
-  const files = fs11.readdirSync(cacheDir);
+  const files = fs13.readdirSync(cacheDir);
   let count = 0;
   for (const file of files) {
     if (file.endsWith(".tgz")) {
-      fs11.unlinkSync(path9.join(cacheDir, file));
+      fs13.unlinkSync(path11.join(cacheDir, file));
       count++;
     }
   }
@@ -3550,21 +3913,21 @@ function cleanAllCache() {
 }
 function cleanPluginCache(pluginKey, version) {
   const cacheDir = getPluginCacheDir();
-  if (!fs11.existsSync(cacheDir)) {
+  if (!fs13.existsSync(cacheDir)) {
     return 0;
   }
   const safeKey = pluginKey.replace(/[/@]/g, "_");
-  const files = fs11.readdirSync(cacheDir);
+  const files = fs13.readdirSync(cacheDir);
   let count = 0;
   for (const file of files) {
     if (version) {
       if (file === `${safeKey}@${version}.tgz`) {
-        fs11.unlinkSync(path9.join(cacheDir, file));
+        fs13.unlinkSync(path11.join(cacheDir, file));
         count++;
       }
     } else {
       if (file.startsWith(`${safeKey}@`) && file.endsWith(".tgz")) {
-        fs11.unlinkSync(path9.join(cacheDir, file));
+        fs13.unlinkSync(path11.join(cacheDir, file));
         count++;
       }
     }
@@ -3991,40 +4354,40 @@ var actionPluginCommandGroup = {
 };
 
 // src/commands/capability/utils.ts
-import fs12 from "fs";
+import fs14 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path10 from "path";
+import path12 from "path";
 var CAPABILITIES_DIR = "server/capabilities";
 function getProjectRoot2() {
   return process.cwd();
 }
 function getCapabilitiesDir() {
-  return path10.join(getProjectRoot2(), CAPABILITIES_DIR);
+  return path12.join(getProjectRoot2(), CAPABILITIES_DIR);
 }
 function getCapabilityPath(id) {
-  return path10.join(getCapabilitiesDir(), `${id}.json`);
+  return path12.join(getCapabilitiesDir(), `${id}.json`);
 }
 function getPluginManifestPath(pluginKey) {
-  return path10.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
+  return path12.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
-  return fs12.existsSync(getCapabilitiesDir());
+  return fs14.existsSync(getCapabilitiesDir());
 }
 function listCapabilityIds() {
   const dir = getCapabilitiesDir();
-  if (!fs12.existsSync(dir)) {
+  if (!fs14.existsSync(dir)) {
     return [];
   }
-  const files = fs12.readdirSync(dir);
+  const files = fs14.readdirSync(dir);
   return files.filter((f) => f.endsWith(".json") && f !== "capabilities.json").map((f) => f.replace(/\.json$/, ""));
 }
 function readCapability(id) {
   const filePath = getCapabilityPath(id);
-  if (!fs12.existsSync(filePath)) {
+  if (!fs14.existsSync(filePath)) {
     throw new Error(`Capability not found: ${id}`);
   }
   try {
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs14.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -4051,11 +4414,11 @@ function readAllCapabilities() {
 }
 function readPluginManifest(pluginKey) {
   const manifestPath = getPluginManifestPath(pluginKey);
-  if (!fs12.existsSync(manifestPath)) {
+  if (!fs14.existsSync(manifestPath)) {
     throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
-    const content = fs12.readFileSync(manifestPath, "utf-8");
+    const content = fs14.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -4072,7 +4435,7 @@ function hasValidParamsSchema(paramsSchema) {
 }
 async function loadPlugin(pluginKey) {
   try {
-    const userRequire = createRequire2(path10.join(getProjectRoot2(), "package.json"));
+    const userRequire = createRequire2(path12.join(getProjectRoot2(), "package.json"));
     const resolvedPath = userRequire.resolve(pluginKey);
     const pluginModule = await import(resolvedPath);
     const pluginPackage = pluginModule.default ?? pluginModule;
@@ -4235,9 +4598,9 @@ var capabilityCommandGroup = {
 import { execFile } from "child_process";
 
 // src/commands/component/registry-preparer.ts
-import fs13 from "fs";
-import path11 from "path";
-import os from "os";
+import fs15 from "fs";
+import path13 from "path";
+import os2 from "os";
 
 // src/commands/component/service.ts
 import { mapValues } from "es-toolkit";
@@ -4292,7 +4655,7 @@ async function sendInstallEvent(key) {
 }
 
 // src/commands/component/registry-preparer.ts
-var REGISTRY_TEMP_DIR = path11.join(os.tmpdir(), "miaoda-registry");
+var REGISTRY_TEMP_DIR = path13.join(os2.tmpdir(), "miaoda-registry");
 function parseComponentKey(key) {
   const match = key.match(/^@([^/]+)\/(.+)$/);
   if (!match) {
@@ -4304,11 +4667,11 @@ function parseComponentKey(key) {
 }
 function getLocalRegistryPath(key) {
   const { scope, name } = parseComponentKey(key);
-  return path11.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
+  return path13.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
 }
 function ensureDir(dirPath) {
-  if (!fs13.existsSync(dirPath)) {
-    fs13.mkdirSync(dirPath, { recursive: true });
+  if (!fs15.existsSync(dirPath)) {
+    fs15.mkdirSync(dirPath, { recursive: true });
   }
 }
 async function prepareRecursive(key, visited) {
@@ -4341,8 +4704,8 @@ async function prepareRecursive(key, visited) {
     registryDependencies: deps.map((dep) => getLocalRegistryPath(dep))
   };
   const localPath = getLocalRegistryPath(key);
-  ensureDir(path11.dirname(localPath));
-  fs13.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
+  ensureDir(path13.dirname(localPath));
+  fs15.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
   debug("\u4FDD\u5B58\u5230: %s", localPath);
 }
 async function prepareComponentRegistryItems(id) {
@@ -4352,18 +4715,18 @@ async function prepareComponentRegistryItems(id) {
 }
 function cleanupTempDir() {
   try {
-    if (fs13.existsSync(REGISTRY_TEMP_DIR)) {
-      fs13.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
+    if (fs15.existsSync(REGISTRY_TEMP_DIR)) {
+      fs15.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
     }
   } catch {
   }
 }
 function getDownloadedRegistryItem(itemId) {
   const localPath = getLocalRegistryPath(itemId);
-  if (!fs13.existsSync(localPath)) {
+  if (!fs15.existsSync(localPath)) {
     return null;
   }
-  const content = fs13.readFileSync(localPath, "utf-8");
+  const content = fs15.readFileSync(localPath, "utf-8");
   return JSON.parse(content);
 }
 
@@ -4531,58 +4894,58 @@ var componentCommandGroup = {
 };
 
 // src/commands/migration/version-manager.ts
-import fs14 from "fs";
-import path12 from "path";
+import fs16 from "fs";
+import path14 from "path";
 var PACKAGE_JSON = "package.json";
 var VERSION_FIELD = "migrationVersion";
 function getPackageJsonPath2() {
-  return path12.join(process.cwd(), PACKAGE_JSON);
+  return path14.join(process.cwd(), PACKAGE_JSON);
 }
 function getCurrentVersion() {
   const pkgPath = getPackageJsonPath2();
-  if (!fs14.existsSync(pkgPath)) {
+  if (!fs16.existsSync(pkgPath)) {
     throw new Error("package.json not found");
   }
-  const pkg2 = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
   return pkg2[VERSION_FIELD] ?? 0;
 }
 function setCurrentVersion(version) {
   const pkgPath = getPackageJsonPath2();
-  const pkg2 = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
   pkg2[VERSION_FIELD] = version;
-  fs14.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs16.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
-import fs16 from "fs";
-import path14 from "path";
+import fs18 from "fs";
+import path16 from "path";
 
 // src/commands/migration/versions/v001_capability/utils.ts
-import fs15 from "fs";
-import path13 from "path";
+import fs17 from "fs";
+import path15 from "path";
 var CAPABILITIES_DIR2 = "server/capabilities";
 function getProjectRoot3() {
   return process.cwd();
 }
 function getCapabilitiesDir2() {
-  return path13.join(getProjectRoot3(), CAPABILITIES_DIR2);
+  return path15.join(getProjectRoot3(), CAPABILITIES_DIR2);
 }
 function getPluginManifestPath2(pluginKey) {
-  return path13.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
+  return path15.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
 function detectJsonMigration() {
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldFilePath = path14.join(capabilitiesDir, "capabilities.json");
-  if (!fs16.existsSync(oldFilePath)) {
+  const oldFilePath = path16.join(capabilitiesDir, "capabilities.json");
+  if (!fs18.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
       reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs16.readFileSync(oldFilePath, "utf-8");
+    const content = fs18.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) {
       return {
@@ -4633,8 +4996,8 @@ async function check(options) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
-import fs17 from "fs";
-import path15 from "path";
+import fs19 from "fs";
+import path17 from "path";
 
 // src/commands/migration/versions/v001_capability/mapping.ts
 var DEFAULT_PLUGIN_VERSION = "1.0.0";
@@ -4864,18 +5227,18 @@ function transformCapabilities(oldCapabilities) {
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
 function loadExistingCapabilities() {
   const capabilitiesDir = getCapabilitiesDir2();
-  if (!fs17.existsSync(capabilitiesDir)) {
+  if (!fs19.existsSync(capabilitiesDir)) {
     return [];
   }
-  const files = fs17.readdirSync(capabilitiesDir);
+  const files = fs19.readdirSync(capabilitiesDir);
   const capabilities = [];
   for (const file of files) {
     if (file === "capabilities.json" || !file.endsWith(".json")) {
       continue;
     }
     try {
-      const filePath = path15.join(capabilitiesDir, file);
-      const content = fs17.readFileSync(filePath, "utf-8");
+      const filePath = path17.join(capabilitiesDir, file);
+      const content = fs19.readFileSync(filePath, "utf-8");
       const capability = JSON.parse(content);
       if (capability.id && capability.pluginKey) {
         capabilities.push(capability);
@@ -4933,9 +5296,9 @@ async function migrateJsonFiles(options) {
   }
   const capabilitiesDir = getCapabilitiesDir2();
   for (const cap of newCapabilities) {
-    const filePath = path15.join(capabilitiesDir, `${cap.id}.json`);
+    const filePath = path17.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs17.writeFileSync(filePath, content, "utf-8");
+    fs19.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
   return {
@@ -4947,11 +5310,11 @@ async function migrateJsonFiles(options) {
 }
 
 // src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
-import fs18 from "fs";
+import fs20 from "fs";
 function isPluginInstalled2(pluginKey) {
   const actionPlugins = readActionPlugins();
   const manifestPath = getPluginManifestPath2(pluginKey);
-  return fs18.existsSync(manifestPath) && !!actionPlugins[pluginKey];
+  return fs20.existsSync(manifestPath) && !!actionPlugins[pluginKey];
 }
 function detectPluginsToInstall(capabilities) {
   const pluginKeys = /* @__PURE__ */ new Set();
@@ -5027,12 +5390,12 @@ async function installPlugins(capabilities, options) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-import path17 from "path";
+import path19 from "path";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
-import fs19 from "fs";
-import path16 from "path";
+import fs21 from "fs";
+import path18 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
   "dist",
@@ -5047,9 +5410,9 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs19.readdirSync(dir, { withFileTypes: true });
+  const entries = fs21.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path16.join(dir, entry.name);
+    const fullPath = path18.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.includes(entry.name)) {
         continue;
@@ -5065,14 +5428,14 @@ function scanDirectory(dir, files = []) {
   return files;
 }
 function scanServerFiles() {
-  const serverDir = path16.join(getProjectRoot3(), "server");
-  if (!fs19.existsSync(serverDir)) {
+  const serverDir = path18.join(getProjectRoot3(), "server");
+  if (!fs21.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs19.readFileSync(filePath, "utf-8");
+  const content = fs21.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -5449,7 +5812,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
-  const relativePath = path17.relative(getProjectRoot3(), filePath);
+  const relativePath = path19.relative(getProjectRoot3(), filePath);
   return {
     filePath: relativePath,
     imports,
@@ -5460,7 +5823,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   };
 }
 function migrateFile(project, analysis, dryRun) {
-  const absolutePath = path17.join(getProjectRoot3(), analysis.filePath);
+  const absolutePath = path19.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
       filePath: analysis.filePath,
@@ -5563,17 +5926,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs20 from "fs";
-import path18 from "path";
+import fs22 from "fs";
+import path20 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldJsonPath = path18.join(capabilitiesDir, "capabilities.json");
-  if (fs20.existsSync(oldJsonPath)) {
+  const oldJsonPath = path20.join(capabilitiesDir, "capabilities.json");
+  if (fs22.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs20.unlinkSync(oldJsonPath);
+        fs22.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -5581,11 +5944,11 @@ function cleanupOldFiles(capabilities, dryRun) {
     }
   }
   for (const cap of capabilities) {
-    const tsFilePath = path18.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs20.existsSync(tsFilePath)) {
+    const tsFilePath = path20.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs22.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs20.unlinkSync(tsFilePath);
+          fs22.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -5601,8 +5964,8 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs21 from "fs";
-import path19 from "path";
+import fs23 from "fs";
+import path21 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
   const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
@@ -5765,15 +6128,15 @@ async function generateReport(result) {
   }
   lines.push("");
   const logDir = process.env.LOG_DIR || "logs";
-  if (!fs21.existsSync(logDir)) {
+  if (!fs23.existsSync(logDir)) {
     return;
   }
-  const reportDir = path19.join(logDir, "migration");
-  if (!fs21.existsSync(reportDir)) {
-    fs21.mkdirSync(reportDir, { recursive: true });
+  const reportDir = path21.join(logDir, "migration");
+  if (!fs23.existsSync(reportDir)) {
+    fs23.mkdirSync(reportDir, { recursive: true });
   }
-  const reportPath = path19.join(reportDir, REPORT_FILE);
-  fs21.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  const reportPath = path21.join(reportDir, REPORT_FILE);
+  fs23.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${reportPath}`);
 }
 
@@ -6305,10 +6668,10 @@ var migrationCommand = {
 };
 
 // src/commands/read-logs/index.ts
-import path20 from "path";
+import path22 from "path";
 
 // src/commands/read-logs/std-utils.ts
-import fs22 from "fs";
+import fs24 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;
@@ -6338,11 +6701,11 @@ function stripPrefixFromStdLine(line) {
   return `[${time}] ${content}`;
 }
 function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
-  const stat = fs22.statSync(filePath);
+  const stat = fs24.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], markerFound: false, totalLinesCount: 0 };
   }
-  const fd = fs22.openSync(filePath, "r");
+  const fd = fs24.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6356,7 +6719,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs22.readSync(fd, buffer, 0, length, position);
+      fs24.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -6398,7 +6761,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       }
     }
   } finally {
-    fs22.closeSync(fd);
+    fs24.closeSync(fd);
   }
   return { lines: collected.reverse(), markerFound, totalLinesCount };
 }
@@ -6419,21 +6782,21 @@ function readServerStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/tail.ts
-import fs23 from "fs";
+import fs25 from "fs";
 function fileExists(filePath) {
   try {
-    fs23.accessSync(filePath, fs23.constants.F_OK | fs23.constants.R_OK);
+    fs25.accessSync(filePath, fs25.constants.F_OK | fs25.constants.R_OK);
     return true;
   } catch {
     return false;
   }
 }
 function readFileTailLines(filePath, maxLines) {
-  const stat = fs23.statSync(filePath);
+  const stat = fs25.statSync(filePath);
   if (stat.size === 0) {
     return [];
   }
-  const fd = fs23.openSync(filePath, "r");
+  const fd = fs25.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   const chunks = [];
   let position = stat.size;
@@ -6443,13 +6806,13 @@ function readFileTailLines(filePath, maxLines) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs23.readSync(fd, buffer, 0, length, position);
+      fs25.readSync(fd, buffer, 0, length, position);
       chunks.unshift(buffer.toString("utf8"));
       const chunkLines = buffer.toString("utf8").split("\n").length - 1;
       collectedLines += chunkLines;
     }
   } finally {
-    fs23.closeSync(fd);
+    fs25.closeSync(fd);
   }
   const content = chunks.join("");
   const allLines = content.split("\n");
@@ -6465,11 +6828,11 @@ function readFileTailLines(filePath, maxLines) {
   return allLines.slice(allLines.length - maxLines);
 }
 function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
-  const stat = fs23.statSync(filePath);
+  const stat = fs25.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs23.openSync(filePath, "r");
+  const fd = fs25.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6481,7 +6844,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs23.readSync(fd, buffer, 0, length, position);
+      fs25.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -6512,7 +6875,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       }
     }
   } finally {
-    fs23.closeSync(fd);
+    fs25.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -6654,7 +7017,7 @@ function readDevStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/json-lines.ts
-import fs24 from "fs";
+import fs26 from "fs";
 function normalizePid(value) {
   if (typeof value === "number") {
     return String(value);
@@ -6705,11 +7068,11 @@ function buildWantedLevelSet(levels) {
   return set.size > 0 ? set : null;
 }
 function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
-  const stat = fs24.statSync(filePath);
+  const stat = fs26.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs24.openSync(filePath, "r");
+  const fd = fs26.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6724,7 +7087,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs24.readSync(fd, buffer, 0, length, position);
+      fs26.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -6786,7 +7149,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs24.closeSync(fd);
+    fs26.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -6829,11 +7192,11 @@ function extractTraceId(obj) {
 function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
   const wanted = traceId.trim();
   if (!wanted) return { lines: [], totalLinesCount: 0 };
-  const stat = fs24.statSync(filePath);
+  const stat = fs26.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs24.openSync(filePath, "r");
+  const fd = fs26.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6846,7 +7209,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs24.readSync(fd, buffer, 0, length, position);
+      fs26.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -6899,7 +7262,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs24.closeSync(fd);
+    fs26.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -6908,11 +7271,11 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
   if (!wantedLevelSet) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const stat = fs24.statSync(filePath);
+  const stat = fs26.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs24.openSync(filePath, "r");
+  const fd = fs26.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6924,7 +7287,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs24.readSync(fd, buffer, 0, length, position);
+      fs26.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -6971,7 +7334,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs24.closeSync(fd);
+    fs26.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -7205,30 +7568,30 @@ async function readLogsJsonResult(options) {
   };
 }
 function resolveLogFilePath(logDir, type) {
-  const base = path20.isAbsolute(logDir) ? logDir : path20.join(process.cwd(), logDir);
+  const base = path22.isAbsolute(logDir) ? logDir : path22.join(process.cwd(), logDir);
   if (type === "server") {
-    return path20.join(base, "server.log");
+    return path22.join(base, "server.log");
   }
   if (type === "trace") {
-    return path20.join(base, "trace.log");
+    return path22.join(base, "trace.log");
   }
   if (type === "server-std") {
-    return path20.join(base, "server.std.log");
+    return path22.join(base, "server.std.log");
   }
   if (type === "client-std") {
-    return path20.join(base, "client.std.log");
+    return path22.join(base, "client.std.log");
   }
   if (type === "dev") {
-    return path20.join(base, "dev.log");
+    return path22.join(base, "dev.log");
   }
   if (type === "dev-std") {
-    return path20.join(base, "dev.std.log");
+    return path22.join(base, "dev.std.log");
   }
   if (type === "install-dep-std") {
-    return path20.join(base, "install-dep.std.log");
+    return path22.join(base, "install-dep.std.log");
   }
   if (type === "browser") {
-    return path20.join(base, "browser.log");
+    return path22.join(base, "browser.log");
   }
   throw new Error(`Unsupported log type: ${type}`);
 }
@@ -7405,9 +7768,9 @@ function camelToKebab(str) {
 }
 
 // src/commands/build/upload-static.handler.ts
-import * as fs25 from "fs";
-import * as os2 from "os";
-import * as path21 from "path";
+import * as fs27 from "fs";
+import * as os3 from "os";
+import * as path23 from "path";
 import { execFileSync } from "child_process";
 function readCredentialsFromEnv() {
   const uploadPrefix = process.env.STATIC_UPLOAD_PREFIX;
@@ -7431,8 +7794,8 @@ async function uploadStatic(options) {
       endpoint = UPLOAD_STATIC_DEFAULTS.endpoint,
       region = UPLOAD_STATIC_DEFAULTS.region
     } = options;
-    const resolvedStaticDir = path21.resolve(staticDir);
-    if (!fs25.existsSync(resolvedStaticDir)) {
+    const resolvedStaticDir = path23.resolve(staticDir);
+    if (!fs27.existsSync(resolvedStaticDir)) {
       console.error(`${LOG_PREFIX} \u76EE\u5F55\u4E0D\u5B58\u5728: ${resolvedStaticDir}\uFF0C\u8DF3\u8FC7\u4E0A\u4F20`);
       return;
     }
@@ -7465,8 +7828,8 @@ async function uploadStatic(options) {
       ({ AccessKeyID: accessKeyID, SecretAccessKey: secretAccessKey, SessionToken: sessionToken } = uploadCredential);
     }
     console.error(`${LOG_PREFIX} \u4E0A\u4F20\u76EE\u6807: ${uploadPrefix}`);
-    const confPath = path21.join(os2.tmpdir(), `.tosutilconfig-static-${process.pid}`);
-    fs25.writeFileSync(confPath, "");
+    const confPath = path23.join(os3.tmpdir(), `.tosutilconfig-static-${process.pid}`);
+    fs27.writeFileSync(confPath, "");
     try {
       console.error(`${LOG_PREFIX} \u914D\u7F6E tosutil...`);
       configureTosutil(resolvedTosutil, confPath, {
@@ -7480,7 +7843,7 @@ async function uploadStatic(options) {
       uploadToTos(resolvedTosutil, confPath, resolvedStaticDir, uploadPrefix);
     } finally {
       try {
-        fs25.unlinkSync(confPath);
+        fs27.unlinkSync(confPath);
       } catch {
       }
     }
@@ -7500,8 +7863,8 @@ async function uploadStatic(options) {
   }
 }
 function resolveTosutilPath(tosutilPath) {
-  if (path21.isAbsolute(tosutilPath)) {
-    return fs25.existsSync(tosutilPath) ? tosutilPath : null;
+  if (path23.isAbsolute(tosutilPath)) {
+    return fs27.existsSync(tosutilPath) ? tosutilPath : null;
   }
   try {
     const resolved = execFileSync("which", [tosutilPath], { encoding: "utf-8" }).trim();
@@ -7546,7 +7909,7 @@ async function resolveBucketId(appId) {
   return bucketId;
 }
 function isDirEmpty(dirPath) {
-  const entries = fs25.readdirSync(dirPath);
+  const entries = fs27.readdirSync(dirPath);
   return entries.length === 0;
 }
 
@@ -7641,12 +8004,12 @@ var commands = [
 ];
 
 // src/index.ts
-var envPath = path22.join(process.cwd(), ".env");
-if (fs26.existsSync(envPath)) {
+var envPath = path24.join(process.cwd(), ".env");
+if (fs28.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path22.dirname(fileURLToPath5(import.meta.url));
-var pkg = JSON.parse(fs26.readFileSync(path22.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path24.dirname(fileURLToPath5(import.meta.url));
+var pkg = JSON.parse(fs28.readFileSync(path24.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();