@cannbot-ai/install-helper 0.0.2-beta.38 → 0.0.2-beta.39

package/dist/index.js

@@ -1516,9 +1516,9 @@ function createRepositoryManager(customPath) {
 }
 
 // src/core/installer.ts
-import { existsSync as existsSync11 } from "fs";
-import { join as join11 } from "path";
-import { execa as execa3 } from "execa";
+import { existsSync as existsSync12 } from "fs";
+import { join as join12 } from "path";
+import { execa as execa4 } from "execa";
 
 // src/core/record.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, unlinkSync as unlinkSync2 } from "fs";
@@ -1850,39 +1850,211 @@ async function showRestorePrompt(backups) {
   return choice;
 }
 
-// src/core/installer.ts
-async function installPlugin(opts) {
-  const plugin = getPluginById(opts.pluginId);
-  if (!plugin) {
+// src/core/plugin-installer.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, symlinkSync, unlinkSync as unlinkSync4, realpathSync, copyFileSync as copyFileSync2, cpSync, writeFileSync as writeFileSync3, readFileSync as readFileSync8 } from "fs";
+import { join as join11 } from "path";
+import { execa as execa3 } from "execa";
+function readPluginManifest(pluginDir) {
+  const manifestPath = join11(pluginDir, "plugin-manifest.json");
+  if (!existsSync11(manifestPath)) return null;
+  try {
+    const content = JSON.parse(readFileSync8(manifestPath, "utf-8"));
+    if (!content || !content.id) return null;
+    return content;
+  } catch {
+    return null;
+  }
+}
+function installLink(source, target) {
+  try {
+    const resolved = realpathSync(source);
+    if (existsSync11(target) || isSymlink(target)) {
+      unlinkSync4(target);
+    }
+    try {
+      symlinkSync(resolved, target);
+      return "symlink";
+    } catch (e) {
+      if (e.code === "EPERM") {
+        cpSync(resolved, target, { recursive: true });
+        return "copy";
+      }
+      throw e;
+    }
+  } catch {
+    return "failed";
+  }
+}
+function installConfigFile(pluginDir, configFile, tool, level, configRoot, installPath) {
+  const sourcePath = join11(pluginDir, configFile);
+  if (!existsSync11(sourcePath)) return;
+  const agentsFileName = getAgentsFileName(tool);
+  const isProjectLevel = level === "project";
+  let primaryTarget;
+  if (isProjectLevel) {
+    primaryTarget = join11(installPath, agentsFileName);
+  } else {
+    primaryTarget = join11(configRoot, agentsFileName);
+  }
+  if (existsSync11(primaryTarget) || isSymlink(primaryTarget)) {
+    unlinkSync4(primaryTarget);
+  }
+  try {
+    symlinkSync(realpathSync(sourcePath), primaryTarget);
+  } catch (e) {
+    if (e.code === "EPERM") {
+      copyFileSync2(sourcePath, primaryTarget);
+    } else {
+      throw e;
+    }
+  }
+  if (isProjectLevel && primaryTarget !== join11(configRoot, agentsFileName)) {
+    const configRootTarget = join11(configRoot, agentsFileName);
+    if (existsSync11(configRootTarget) || isSymlink(configRootTarget)) {
+      unlinkSync4(configRootTarget);
+    }
+    try {
+      symlinkSync(realpathSync(sourcePath), configRootTarget);
+    } catch (e) {
+      if (e.code === "EPERM") {
+        copyFileSync2(sourcePath, configRootTarget);
+      }
+    }
+  }
+}
+async function installExternalRepos(repos, repoPath) {
+  if (!repos || repos.length === 0) return;
+  for (const repo of repos) {
+    const targetDir = join11(repoPath, repo.dir);
+    if (existsSync11(targetDir)) {
+      logger.info(`  ${repo.dir} already exists, skipping clone`);
+      continue;
+    }
+    const args = ["clone"];
+    if (repo.depth) {
+      args.push("--depth", String(repo.depth));
+    }
+    if (repo.recursive) {
+      args.push("--recursive");
+    }
+    args.push(repo.url, targetDir);
+    try {
+      await execa3("git", args, { timeout: 12e4 });
+    } catch {
+      logger.warn(`  git clone failed: ${repo.url}, clone manually: git clone ${repo.url} ${repo.dir}`);
+    }
+  }
+}
+function writeCannbotManifest(configRoot, pluginId, version, level, tool, skills, agents) {
+  const manifest = {
+    brand: "CANNBot",
+    version,
+    team: pluginId,
+    level,
+    tool,
+    installed_skills: skills,
+    installed_agents: agents,
+    brand_dir: configRoot,
+    install_time: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const manifestPath = join11(configRoot, "cannbot-manifest.json");
+  writeFileSync3(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  return manifest;
+}
+async function installViaManifest(manifest, pluginDir, repoPath, tool, level, installPath) {
+  const cwd = installPath || process.cwd();
+  const configRoot = getConfigRoot(tool, level, installPath);
+  try {
+    const skillsDir = join11(configRoot, "skills");
+    const agentsDir = join11(configRoot, "agents");
+    mkdirSync5(skillsDir, { recursive: true });
+    mkdirSync5(agentsDir, { recursive: true });
+    const installedSkills = [];
+    const installedAgents = [];
+    for (const source of manifest.skills) {
+      const sourceDir = join11(repoPath, source.dir);
+      if (!existsSync11(sourceDir)) {
+        logger.warn(`  Skill source not found: ${source.dir}`);
+        continue;
+      }
+      for (const skillName of source.skills) {
+        const skillPath = join11(sourceDir, skillName);
+        if (!existsSync11(skillPath)) {
+          logger.warn(`  Skill not found: ${skillName} in ${source.dir}`);
+          continue;
+        }
+        const targetPath = join11(skillsDir, skillName);
+        const result = installLink(skillPath, targetPath);
+        if (result !== "failed") {
+          installedSkills.push(skillName);
+        } else {
+          logger.warn(`  Failed to install skill: ${skillName}`);
+        }
+      }
+    }
+    for (const agentName of manifest.agents) {
+      const agentFile = agentName.endsWith(".md") ? agentName : `${agentName}.md`;
+      const agentPath = join11(pluginDir, "agents", agentFile);
+      if (!existsSync11(agentPath)) {
+        logger.warn(`  Agent not found: ${agentFile}`);
+        continue;
+      }
+      const targetPath = join11(agentsDir, agentFile);
+      const result = installLink(agentPath, targetPath);
+      if (result !== "failed") {
+        installedAgents.push(agentFile);
+      } else {
+        logger.warn(`  Failed to install agent: ${agentFile}`);
+      }
+    }
+    installConfigFile(pluginDir, manifest.configFile, tool, level, configRoot, cwd);
+    await installExternalRepos(manifest.externalRepos, repoPath);
+    const cannbotManifest = writeCannbotManifest(
+      configRoot,
+      manifest.id,
+      manifest.version || "1.0.0",
+      level,
+      tool,
+      installedSkills,
+      installedAgents
+    );
+    return {
+      success: true,
+      skillsCount: installedSkills.length,
+      agentsCount: installedAgents.length,
+      errors: [],
+      manifest: cannbotManifest
+    };
+  } catch (error) {
     return {
       success: false,
-      pluginId: opts.pluginId,
       skillsCount: 0,
       agentsCount: 0,
-      errors: [t("error_plugin_not_found") + ": " + opts.pluginId],
-      warnings: []
+      errors: [error instanceof Error ? error.message : t("error_unknown")],
+      manifest: null
     };
   }
-  const scriptPath = join11(opts.repoPath, plugin.dir, plugin.script);
-  if (!existsSync11(scriptPath)) {
+}
+
+// src/core/installer.ts
+async function installPlugin(opts) {
+  const plugin = getPluginById(opts.pluginId);
+  if (!plugin) {
     return {
       success: false,
       pluginId: opts.pluginId,
       skillsCount: 0,
       agentsCount: 0,
-      errors: [t("error_script_not_found").replace("{path}", scriptPath)],
+      errors: [t("error_plugin_not_found") + ": " + opts.pluginId],
       warnings: []
     };
   }
-  const args = [opts.level, opts.tool];
-  if (opts.installPath) {
-    args.push(opts.installPath);
-  }
+  const pluginDir = join12(opts.repoPath, plugin.dir);
   const cwd = opts.installPath || process.cwd();
   const configRoot = getConfigRoot(opts.tool, opts.level, opts.installPath);
-  const agentsFile = join11(configRoot, getAgentsFileName(opts.tool));
+  const agentsFile = join12(configRoot, getAgentsFileName(opts.tool));
   let backupInfo = null;
-  if (existsSync11(agentsFile)) {
+  if (existsSync12(agentsFile)) {
     const currentPlugin = detectCurrentPlugin(configRoot, opts.tool);
     if (currentPlugin && currentPlugin.pluginId !== opts.pluginId) {
       let choice = "overwrite";
@@ -1923,6 +2095,73 @@ async function installPlugin(opts) {
       logger.success(`${t("backup_created")}: ${backupInfo.filePath}`);
     }
   }
+  const pluginManifest = readPluginManifest(pluginDir);
+  if (pluginManifest) {
+    const result = await installViaManifest(
+      pluginManifest,
+      pluginDir,
+      opts.repoPath,
+      opts.tool,
+      opts.level,
+      opts.installPath
+    );
+    if (result.success) {
+      try {
+        const record = scanInstalledFiles(
+          opts.pluginId,
+          plugin.displayName,
+          opts.tool,
+          opts.level,
+          cwd,
+          configRoot,
+          result.manifest
+        );
+        if (backupInfo) {
+          record.backup = {
+            filePath: backupInfo.filePath,
+            fromPluginId: backupInfo.pluginId,
+            fromPluginName: backupInfo.pluginName,
+            backupTime: backupInfo.backupTime
+          };
+        }
+        writeRecord(record);
+      } catch {
+        logger.warn(t("record_write_failed"));
+      }
+      return {
+        success: true,
+        pluginId: opts.pluginId,
+        skillsCount: result.skillsCount,
+        agentsCount: result.agentsCount,
+        errors: result.errors,
+        warnings: []
+      };
+    } else {
+      return {
+        success: false,
+        pluginId: opts.pluginId,
+        skillsCount: 0,
+        agentsCount: 0,
+        errors: result.errors,
+        warnings: []
+      };
+    }
+  }
+  const scriptPath = join12(pluginDir, plugin.script);
+  if (!existsSync12(scriptPath)) {
+    return {
+      success: false,
+      pluginId: opts.pluginId,
+      skillsCount: 0,
+      agentsCount: 0,
+      errors: [t("error_script_not_found").replace("{path}", scriptPath)],
+      warnings: []
+    };
+  }
+  const args = [opts.level, opts.tool];
+  if (opts.installPath) {
+    args.push(opts.installPath);
+  }
   try {
     const shell = process.platform === "win32" ? "sh" : "bash";
     const execOptions = {
@@ -1931,7 +2170,7 @@ async function installPlugin(opts) {
       stdio: "pipe",
       input: opts.yes ? "y\n" : void 0
     };
-    await execa3(shell, [scriptPath, ...args], execOptions);
+    await execa4(shell, [scriptPath, ...args], execOptions);
     const manifest = readManifest(configRoot);
     let skillsCount = 0;
     let agentsCount = 0;
@@ -1986,17 +2225,17 @@ async function installPlugin(opts) {
 }
 
 // src/core/skill-installer.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, symlinkSync, unlinkSync as unlinkSync4, readdirSync as readdirSync4, rmdirSync, realpathSync } from "fs";
-import { join as join12, dirname as dirname6 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, symlinkSync as symlinkSync2, unlinkSync as unlinkSync5, readdirSync as readdirSync4, rmdirSync, realpathSync as realpathSync2 } from "fs";
+import { join as join13, dirname as dirname7 } from "path";
 import { select as select3, checkbox as checkbox2, Separator as Separator2 } from "@inquirer/prompts";
 import chalk5 from "chalk";
 import Table from "cli-table3";
 async function installSkills(skillIds, tool, level, repoPath) {
   const configRoot = getConfigRoot(tool, level);
-  const skillsDir = join12(configRoot, "skills");
+  const skillsDir = join13(configRoot, "skills");
   const installPath = level === "project" ? process.cwd() : configRoot;
-  if (!existsSync12(skillsDir)) {
-    mkdirSync5(skillsDir, { recursive: true });
+  if (!existsSync13(skillsDir)) {
+    mkdirSync6(skillsDir, { recursive: true });
   }
   const results = [];
   const installedIds = [];
@@ -2007,17 +2246,17 @@ async function installSkills(skillIds, tool, level, repoPath) {
       continue;
     }
     const sourcePath = resolveSkillSourcePath(skill, repoPath);
-    const targetPath = join12(skillsDir, skillId);
-    if (!existsSync12(sourcePath)) {
+    const targetPath = join13(skillsDir, skillId);
+    if (!existsSync13(sourcePath)) {
       results.push({ skillId, success: false, error: t("error_source_not_found").replace("{path}", sourcePath) });
       continue;
     }
     try {
-      const resolvedSource = realpathSync(sourcePath);
-      if (existsSync12(targetPath) || isSymlink(targetPath)) {
-        unlinkSync4(targetPath);
+      const resolvedSource = realpathSync2(sourcePath);
+      if (existsSync13(targetPath) || isSymlink(targetPath)) {
+        unlinkSync5(targetPath);
       }
-      symlinkSync(resolvedSource, targetPath);
+      symlinkSync2(resolvedSource, targetPath);
       results.push({ skillId, success: true });
       installedIds.push(skillId);
     } catch (error) {
@@ -2035,15 +2274,15 @@ async function installSkills(skillIds, tool, level, repoPath) {
 }
 async function uninstallSkills(skillIds, tool, level) {
   const configRoot = getConfigRoot(tool, level);
-  const skillsDir = join12(configRoot, "skills");
+  const skillsDir = join13(configRoot, "skills");
   const installPath = level === "project" ? process.cwd() : configRoot;
   const results = [];
   const removedIds = [];
   for (const skillId of skillIds) {
-    const targetPath = join12(skillsDir, skillId);
+    const targetPath = join13(skillsDir, skillId);
     try {
-      if (existsSync12(targetPath) || isSymlink(targetPath)) {
-        unlinkSync4(targetPath);
+      if (existsSync13(targetPath) || isSymlink(targetPath)) {
+        unlinkSync5(targetPath);
         results.push({ skillId, success: true });
         removedIds.push(skillId);
         logger.step(`  ${t("uninstall_remove_label")}: ${skillId}`);
@@ -2058,7 +2297,7 @@ async function uninstallSkills(skillIds, tool, level) {
   if (removedIds.length > 0) {
     removeSkillsFromRecord(removedIds, tool, level, installPath);
   }
-  if (existsSync12(skillsDir)) {
+  if (existsSync13(skillsDir)) {
     try {
       const entries = readdirSync4(skillsDir);
       if (entries.length === 0) {
@@ -2241,12 +2480,12 @@ function listAllSkills() {
 }
 function resolveSkillSourcePath(skill, repoPath) {
   if (skill.filePath) {
-    const absPath = skill.filePath.startsWith("/") ? skill.filePath : join12(repoPath, skill.filePath);
-    if (existsSync12(absPath)) {
-      return dirname6(absPath);
+    const absPath = skill.filePath.startsWith("/") ? skill.filePath : join13(repoPath, skill.filePath);
+    if (existsSync13(absPath)) {
+      return dirname7(absPath);
     }
   }
-  return join12(repoPath, skill.source, skill.id);
+  return join13(repoPath, skill.source, skill.id);
 }
 
 // src/ui/display.ts
@@ -2338,13 +2577,13 @@ function printEnhancedSummary(results, tool, configRoot) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync13, readFileSync as readFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync9 } from "fs";
+import { join as join14 } from "path";
 async function initCommand() {
   const cwd = process.cwd();
-  if (existsSync13(join13(cwd, "package.json")) && (() => {
+  if (existsSync14(join14(cwd, "package.json")) && (() => {
     try {
-      const pkg = JSON.parse(readFileSync8(join13(cwd, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync9(join14(cwd, "package.json"), "utf-8"));
       return pkg.name === "@cannbot-ai/install-helper";
     } catch {
       return false;
@@ -2569,8 +2808,8 @@ async function listCommand() {
 
 // src/commands/doctor.ts
 import chalk8 from "chalk";
-import { existsSync as existsSync14, readdirSync as readdirSync5, lstatSync as lstatSync2, unlinkSync as unlinkSync5, mkdirSync as mkdirSync6 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync5, lstatSync as lstatSync2, unlinkSync as unlinkSync6, mkdirSync as mkdirSync7 } from "fs";
+import { join as join15 } from "path";
 async function doctorCommand(options = {}) {
   console.log();
   console.log(chalk8.bold(`  ${t("doctor_title")}`));
@@ -2612,7 +2851,7 @@ async function doctorCommand(options = {}) {
   const configRoot = getConfigRoot(primaryTool, "project");
   const skillsDir = getSkillsDir(configRoot);
   const agentsDir = getAgentsDir(configRoot);
-  if (existsSync14(skillsDir)) {
+  if (existsSync15(skillsDir)) {
     const brokenLinks = checkBrokenLinks(skillsDir);
     if (brokenLinks === 0) {
       const count = readdirSync5(skillsDir).length;
@@ -2629,12 +2868,12 @@ async function doctorCommand(options = {}) {
   } else {
     console.log(chalk8.dim("  \u2014") + ` ${skillsDir} \u2014 ${t("doctor_not_exist")}`);
     if (options.fix) {
-      mkdirSync6(skillsDir, { recursive: true });
+      mkdirSync7(skillsDir, { recursive: true });
       fixes++;
       console.log(chalk8.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: ${t("doctor_created").replace("{path}", skillsDir)}`);
     }
   }
-  if (existsSync14(agentsDir)) {
+  if (existsSync15(agentsDir)) {
     const brokenLinks = checkBrokenLinks(agentsDir);
     if (brokenLinks === 0) {
       const count = readdirSync5(agentsDir).length;
@@ -2651,7 +2890,7 @@ async function doctorCommand(options = {}) {
   } else {
     console.log(chalk8.dim("  \u2014") + ` ${agentsDir} \u2014 ${t("doctor_not_exist")}`);
     if (options.fix) {
-      mkdirSync6(agentsDir, { recursive: true });
+      mkdirSync7(agentsDir, { recursive: true });
       fixes++;
       console.log(chalk8.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: ${t("doctor_created").replace("{path}", agentsDir)}`);
     }
@@ -2659,8 +2898,8 @@ async function doctorCommand(options = {}) {
   console.log();
   console.log(chalk8.bold(`  ${t("doctor_config")}`));
   const configFile = getConfigFileName(primaryTool);
-  const configPath = join14(process.cwd(), configFile);
-  if (existsSync14(configPath)) {
+  const configPath = join15(process.cwd(), configFile);
+  if (existsSync15(configPath)) {
     console.log(chalk8.green("  \u2713") + ` ${configFile} ${t("doctor_config_exists")}`);
   } else {
     console.log(chalk8.dim("  \u2014") + ` ${configFile} ${t("doctor_config_not_exist")}`);
@@ -2683,11 +2922,11 @@ function checkBrokenLinks(dir) {
   try {
     const entries = readdirSync5(dir);
     for (const entry of entries) {
-      const fullPath = join14(dir, entry);
+      const fullPath = join15(dir, entry);
       try {
         const stats = lstatSync2(fullPath);
         if (stats.isSymbolicLink()) {
-          if (!existsSync14(fullPath)) {
+          if (!existsSync15(fullPath)) {
             broken++;
           }
         }
@@ -2704,12 +2943,12 @@ function fixBrokenLinks(dir) {
   try {
     const entries = readdirSync5(dir);
     for (const entry of entries) {
-      const fullPath = join14(dir, entry);
+      const fullPath = join15(dir, entry);
       try {
         const stats = lstatSync2(fullPath);
         if (stats.isSymbolicLink()) {
-          if (!existsSync14(fullPath)) {
-            unlinkSync5(fullPath);
+          if (!existsSync15(fullPath)) {
+            unlinkSync6(fullPath);
             fixed++;
           }
         }
@@ -3054,8 +3293,8 @@ async function installPlugins(pluginIds, tool, level, repoPath, installPath, yes
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync15, unlinkSync as unlinkSync6, rmdirSync as rmdirSync2, readdirSync as readdirSync6 } from "fs";
-import { resolve, basename } from "path";
+import { existsSync as existsSync16, unlinkSync as unlinkSync7, rmdirSync as rmdirSync2, readdirSync as readdirSync6 } from "fs";
+import { resolve, basename as basename2 } from "path";
 import chalk11 from "chalk";
 async function uninstallCommand(names, options) {
   const tool = options.tool ? validateTool(options.tool) : "opencode";
@@ -3096,9 +3335,9 @@ async function uninstallCommand(names, options) {
     for (const filePath of record.files) {
       if (!isSafePath(filePath)) continue;
       try {
-        if (existsSync15(filePath) || isSymlink(filePath)) {
-          unlinkSync6(filePath);
-          const name = basename(filePath);
+        if (existsSync16(filePath) || isSymlink(filePath)) {
+          unlinkSync7(filePath);
+          const name = basename2(filePath);
           logger.step(`  ${t("uninstall_remove_label")}: ${name}`);
           removedFiles++;
         }
@@ -3111,11 +3350,11 @@ async function uninstallCommand(names, options) {
         if (resolve(dirPath) === resolve(configRoot)) {
           continue;
         }
-        if (existsSync15(dirPath)) {
+        if (existsSync16(dirPath)) {
           const entries = readdirSync6(dirPath);
           if (entries.length === 0) {
             rmdirSync2(dirPath);
-            const name = basename(dirPath);
+            const name = basename2(dirPath);
             logger.step(`  ${t("uninstall_clean_empty_dir")}: ${name}/`);
             removedDirs++;
           }
@@ -3250,8 +3489,8 @@ async function updateCommand(pluginNames, options) {
 
 // src/commands/info.ts
 import chalk13 from "chalk";
-import { existsSync as existsSync16, readdirSync as readdirSync7 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync7 } from "fs";
+import { join as join16 } from "path";
 async function infoCommand(pluginName) {
   const plugin = findPlugin(pluginName);
   if (!plugin) {
@@ -3276,12 +3515,12 @@ async function infoCommand(pluginName) {
   try {
     const repoManager = createRepositoryManager();
     const repoPath = await repoManager.ensureRepo();
-    const quickstartPath = join15(repoPath, plugin.dir, "quickstart.md");
-    if (existsSync16(quickstartPath)) {
+    const quickstartPath = join16(repoPath, plugin.dir, "quickstart.md");
+    if (existsSync17(quickstartPath)) {
       console.log(`  ${chalk13.dim(t("info_quickstart") + ":")} ${quickstartPath}`);
     }
-    const agentsDir = join15(repoPath, plugin.dir, "agents");
-    if (existsSync16(agentsDir)) {
+    const agentsDir = join16(repoPath, plugin.dir, "agents");
+    if (existsSync17(agentsDir)) {
       const agentFiles = readdirSync7(agentsDir).filter((f) => f.endsWith(".md"));
       if (agentFiles.length > 0) {
         console.log();
@@ -3333,15 +3572,15 @@ async function langCommand(action, value) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname7, join as join16 } from "path";
+import { dirname as dirname8, join as join17 } from "path";
 function readVersion() {
   try {
     const __filename5 = fileURLToPath5(import.meta.url);
-    const __dirname5 = dirname7(__filename5);
-    const pkgPath = join16(__dirname5, "..", "package.json");
-    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+    const __dirname5 = dirname8(__filename5);
+    const pkgPath = join17(__dirname5, "..", "package.json");
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";