@walkeros/cli 0.5.1-next.0 → 0.7.0-next.0

package/dist/index.js

@@ -2,10 +2,30 @@
 
 // src/index.ts
 import { Command } from "commander";
+import { VERSION as DOCKER_VERSION2 } from "@walkeros/docker";
+
+// src/version.ts
 import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath } from "url";
 import { dirname, join } from "path";
-import { VERSION as DOCKER_VERSION2 } from "@walkeros/docker";
+var versionFilename = fileURLToPath(import.meta.url);
+var versionDirname = dirname(versionFilename);
+function findPackageJson() {
+  const paths = [
+    join(versionDirname, "../package.json"),
+    // dist/ or src/
+    join(versionDirname, "../../package.json")
+    // src/core/ (not used, but safe)
+  ];
+  for (const p of paths) {
+    try {
+      return readFileSync(p, "utf-8");
+    } catch {
+    }
+  }
+  return JSON.stringify({ version: "0.0.0" });
+}
+var VERSION = JSON.parse(findPackageJson()).version;
 
 // src/commands/bundle/index.ts
 import path9 from "path";
@@ -135,6 +155,7 @@ function formatBytes(bytes) {
 // src/core/docker.ts
 import { spawn } from "child_process";
 import path2 from "path";
+import fs2 from "fs-extra";
 import { VERSION as DOCKER_VERSION } from "@walkeros/docker";
 
 // src/config/utils.ts
@@ -264,8 +285,7 @@ async function loadJsonFromSource(source, options) {
 }
 
 // src/core/docker.ts
-var CLI_VERSION = true ? "0.5.0" : "0.0.0";
-var CLI_DOCKER_IMAGE = process.env.WALKEROS_CLI_DOCKER_IMAGE || `walkeros/cli:${CLI_VERSION}`;
+var CLI_DOCKER_IMAGE = process.env.WALKEROS_CLI_DOCKER_IMAGE || `walkeros/cli:${VERSION}`;
 var RUNTIME_DOCKER_IMAGE = process.env.WALKEROS_RUNTIME_DOCKER_IMAGE || `walkeros/docker:${DOCKER_VERSION}`;
 function buildCommonDockerArgs(options) {
   const args = [options.config];
@@ -305,29 +325,44 @@ function buildDockerCommand(command, args, options = {}, configFile) {
   return cmd;
 }
 async function executeInDocker(command, args, options = {}, configFile) {
-  const containerArgs = [...args, "--local"];
-  const dockerCmd = buildDockerCommand(
-    command,
-    containerArgs,
-    options,
-    configFile
-  );
-  return new Promise((resolve, reject) => {
-    const proc = spawn(dockerCmd[0], dockerCmd.slice(1), {
-      stdio: options.silent ? "ignore" : "inherit",
-      shell: false
-    });
-    proc.on("error", (error) => {
-      reject(new Error(`Docker execution failed: ${error.message}`));
+  let tempFile;
+  let effectiveConfigFile = configFile;
+  try {
+    if (configFile && isUrl(configFile)) {
+      tempFile = await downloadFromUrl(configFile);
+      effectiveConfigFile = tempFile;
+    }
+    const containerArgs = [...args, "--local"];
+    const dockerCmd = buildDockerCommand(
+      command,
+      containerArgs,
+      options,
+      effectiveConfigFile
+    );
+    return await new Promise((resolve, reject) => {
+      const proc = spawn(dockerCmd[0], dockerCmd.slice(1), {
+        stdio: options.silent ? "ignore" : "inherit",
+        shell: false
+      });
+      proc.on("error", (error) => {
+        reject(new Error(`Docker execution failed: ${error.message}`));
+      });
+      proc.on("exit", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          process.exit(code || 1);
+        }
+      });
     });
-    proc.on("exit", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        process.exit(code || 1);
+  } finally {
+    if (tempFile) {
+      try {
+        await fs2.remove(tempFile);
+      } catch {
       }
-    });
-  });
+    }
+  }
 }
 async function isDockerAvailable() {
   return new Promise((resolve) => {
@@ -440,16 +475,16 @@ async function executeCommand(localHandler, dockerCommand, dockerArgs, options,
 
 // src/core/temp-manager.ts
 import { getHashServer } from "@walkeros/server-core";
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 
 // src/core/asset-resolver.ts
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { existsSync } from "fs";
 import path3 from "path";
 var cachedAssetDir;
 function getAssetDir() {
   if (cachedAssetDir) return cachedAssetDir;
-  const currentFile = fileURLToPath(import.meta.url);
+  const currentFile = fileURLToPath2(import.meta.url);
   let dir = path3.dirname(currentFile);
   while (dir !== path3.dirname(dir)) {
     if (existsSync(path3.join(dir, "examples"))) {
@@ -462,6 +497,9 @@ function getAssetDir() {
   return cachedAssetDir;
 }
 function resolveAsset(assetPath, assetType, baseDir) {
+  if (isUrl(assetPath)) {
+    return assetPath;
+  }
   if (!assetPath.includes("/") && !assetPath.includes("\\")) {
     const assetDir = getAssetDir();
     return path3.join(assetDir, "examples", assetPath);
@@ -479,22 +517,22 @@ function getErrorMessage(error) {
 
 // src/core/local-packages.ts
 import path4 from "path";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
   const absolutePath = path4.isAbsolute(localPath) ? localPath : path4.resolve(configDir, localPath);
-  if (!await fs3.pathExists(absolutePath)) {
+  if (!await fs4.pathExists(absolutePath)) {
     throw new Error(
       `Local package path not found: ${localPath} (resolved to ${absolutePath})`
     );
   }
   const pkgJsonPath = path4.join(absolutePath, "package.json");
-  if (!await fs3.pathExists(pkgJsonPath)) {
+  if (!await fs4.pathExists(pkgJsonPath)) {
     throw new Error(
       `No package.json found at ${absolutePath}. Is this a valid package directory?`
     );
   }
   const distPath = path4.join(absolutePath, "dist");
-  const hasDistFolder = await fs3.pathExists(distPath);
+  const hasDistFolder = await fs4.pathExists(distPath);
   if (!hasDistFolder) {
     logger2.warn(
       `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
@@ -509,18 +547,18 @@ async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
 }
 async function copyLocalPackage(localPkg, targetDir, logger2) {
   const packageDir = path4.join(targetDir, "node_modules", localPkg.name);
-  await fs3.ensureDir(path4.dirname(packageDir));
-  await fs3.copy(
+  await fs4.ensureDir(path4.dirname(packageDir));
+  await fs4.copy(
     path4.join(localPkg.absolutePath, "package.json"),
     path4.join(packageDir, "package.json")
   );
   if (localPkg.hasDistFolder) {
-    await fs3.copy(localPkg.distPath, path4.join(packageDir, "dist"));
+    await fs4.copy(localPkg.distPath, path4.join(packageDir, "dist"));
   } else {
-    const entries = await fs3.readdir(localPkg.absolutePath);
+    const entries = await fs4.readdir(localPkg.absolutePath);
     for (const entry of entries) {
       if (!["node_modules", ".turbo", ".git"].includes(entry)) {
-        await fs3.copy(
+        await fs4.copy(
           path4.join(localPkg.absolutePath, entry),
           path4.join(packageDir, entry)
         );
@@ -587,7 +625,7 @@ function getDefaultOutput(platform) {
 
 // src/config/loader.ts
 import path5 from "path";
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 import { getFlowConfig, getPlatform } from "@walkeros/core";
 var DEFAULT_INCLUDE_FOLDER = "./shared";
 function loadBundleConfig(rawConfig, options) {
@@ -614,7 +652,7 @@ function loadBundleConfig(rawConfig, options) {
   let includes = setup.include;
   if (!includes) {
     const defaultIncludePath = path5.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
-    if (fs4.pathExistsSync(defaultIncludePath)) {
+    if (fs5.pathExistsSync(defaultIncludePath)) {
       includes = [DEFAULT_INCLUDE_FOLDER];
     }
   }
@@ -677,13 +715,13 @@ function loadAllFlows(rawConfig, options) {
 // src/commands/bundle/bundler.ts
 import esbuild from "esbuild";
 import path8 from "path";
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 import { packageNameToVariable } from "@walkeros/core";
 
 // src/commands/bundle/package-manager.ts
 import pacote from "pacote";
 import path6 from "path";
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 
 // src/core/cache-utils.ts
 import { getHashServer as getHashServer2 } from "@walkeros/server-core";
@@ -726,7 +764,7 @@ async function getCachedPackagePath(pkg, tempDir) {
 }
 async function isPackageCached(pkg, tempDir) {
   const cachedPath = await getCachedPackagePath(pkg, tempDir);
-  return fs5.pathExists(cachedPath);
+  return fs6.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -761,11 +799,11 @@ async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PUR
   visited.add(pkgKey);
   try {
     const packageJsonPath = path6.join(packageDir, "package.json");
-    if (await fs5.pathExists(packageJsonPath)) {
-      const packageJson2 = await fs5.readJson(packageJsonPath);
+    if (await fs6.pathExists(packageJsonPath)) {
+      const packageJson = await fs6.readJson(packageJsonPath);
       const deps = {
-        ...packageJson2.dependencies,
-        ...packageJson2.peerDependencies
+        ...packageJson.dependencies,
+        ...packageJson.peerDependencies
       };
       for (const [name, versionSpec] of Object.entries(deps)) {
         if (typeof versionSpec === "string") {
@@ -789,7 +827,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     }
   }
   validateNoDuplicatePackages(packages);
-  await fs5.ensureDir(targetDir);
+  await fs6.ensureDir(targetDir);
   while (downloadQueue.length > 0) {
     const pkg = downloadQueue.shift();
     const pkgKey = `${pkg.name}@${pkg.version}`;
@@ -824,8 +862,8 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     if (useCache && await isPackageCached(pkg, targetDir)) {
       logger2.debug(`Using cached ${packageSpec}...`);
       try {
-        await fs5.ensureDir(path6.dirname(packageDir));
-        await fs5.copy(cachedPath, packageDir);
+        await fs6.ensureDir(path6.dirname(packageDir));
+        await fs6.copy(cachedPath, packageDir);
         packagePaths.set(pkg.name, packageDir);
         const deps = await resolveDependencies(pkg, packageDir, logger2);
         for (const dep of deps) {
@@ -843,7 +881,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     }
     logger2.debug(`Downloading ${packageSpec}...`);
     try {
-      await fs5.ensureDir(path6.dirname(packageDir));
+      await fs6.ensureDir(path6.dirname(packageDir));
       const cacheDir = process.env.NPM_CACHE_DIR || path6.join(process.cwd(), ".npm-cache");
       await pacote.extract(packageSpec, packageDir, {
         // Force npm registry download, prevent workspace resolution
@@ -857,8 +895,8 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
       });
       if (useCache) {
         try {
-          await fs5.ensureDir(path6.dirname(cachedPath));
-          await fs5.copy(packageDir, cachedPath);
+          await fs6.ensureDir(path6.dirname(cachedPath));
+          await fs6.copy(packageDir, cachedPath);
           logger2.debug(`Cached ${packageSpec} for future use`);
         } catch (cacheError) {
           logger2.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
@@ -880,7 +918,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
 }
 
 // src/core/build-cache.ts
-import fs6 from "fs-extra";
+import fs7 from "fs-extra";
 import path7 from "path";
 var BUILD_CACHE_DIR = path7.join(".tmp", "cache", "builds");
 async function getBuildCachePath(configContent, cacheDir = BUILD_CACHE_DIR) {
@@ -889,17 +927,17 @@ async function getBuildCachePath(configContent, cacheDir = BUILD_CACHE_DIR) {
 }
 async function isBuildCached(configContent, cacheDir = BUILD_CACHE_DIR) {
   const cachePath = await getBuildCachePath(configContent, cacheDir);
-  return fs6.pathExists(cachePath);
+  return fs7.pathExists(cachePath);
 }
 async function cacheBuild(configContent, buildOutput, cacheDir = BUILD_CACHE_DIR) {
   const cachePath = await getBuildCachePath(configContent, cacheDir);
-  await fs6.ensureDir(path7.dirname(cachePath));
-  await fs6.writeFile(cachePath, buildOutput, "utf-8");
+  await fs7.ensureDir(path7.dirname(cachePath));
+  await fs7.writeFile(cachePath, buildOutput, "utf-8");
 }
 async function getCachedBuild(configContent, cacheDir = BUILD_CACHE_DIR) {
   const cachePath = await getBuildCachePath(configContent, cacheDir);
-  if (await fs6.pathExists(cachePath)) {
-    return await fs6.readFile(cachePath, "utf-8");
+  if (await fs7.pathExists(cachePath)) {
+    return await fs7.readFile(cachePath, "utf-8");
   }
   return null;
 }
@@ -910,8 +948,8 @@ async function copyIncludes(includes, sourceDir, outputDir, logger2) {
     const sourcePath = path8.resolve(sourceDir, include);
     const folderName = path8.basename(include);
     const destPath = path8.join(outputDir, folderName);
-    if (await fs7.pathExists(sourcePath)) {
-      await fs7.copy(sourcePath, destPath);
+    if (await fs8.pathExists(sourcePath)) {
+      await fs8.copy(sourcePath, destPath);
       logger2.debug(`Copied ${include} to output`);
     } else {
       logger2.debug(`Include folder not found: ${include}`);
@@ -941,12 +979,12 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       if (cachedBuild) {
         logger2.info("\u2728 Using cached build");
         const outputPath = path8.resolve(buildOptions.output);
-        await fs7.ensureDir(path8.dirname(outputPath));
-        await fs7.writeFile(outputPath, cachedBuild);
+        await fs8.ensureDir(path8.dirname(outputPath));
+        await fs8.writeFile(outputPath, cachedBuild);
         logger2.gray(`Output: ${outputPath}`);
         logger2.success("\u2705 Build completed (from cache)");
         if (showStats) {
-          const stats = await fs7.stat(outputPath);
+          const stats = await fs8.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
             ([name, pkg]) => ({
               name: `${name}@${pkg.version || "latest"}`,
@@ -967,7 +1005,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
   }
   try {
     if (!buildOptions.tempDir) {
-      await fs7.emptyDir(TEMP_DIR);
+      await fs8.emptyDir(TEMP_DIR);
     }
     logger2.debug("Cleaned temporary directory");
     logger2.info("\u{1F4E5} Downloading packages...");
@@ -990,7 +1028,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
         const pkgJsonPath = path8.join(pkgPath, "package.json");
-        const pkgJson = await fs7.readJSON(pkgJsonPath);
+        const pkgJson = await fs8.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -998,12 +1036,12 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
               require: pkgJson.main
             }
           };
-          await fs7.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs8.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
     const packageJsonPath = path8.join(TEMP_DIR, "package.json");
-    await fs7.writeFile(
+    await fs8.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
@@ -1014,10 +1052,10 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       packagePaths
     );
     const entryPath = path8.join(TEMP_DIR, "entry.js");
-    await fs7.writeFile(entryPath, entryContent);
+    await fs8.writeFile(entryPath, entryContent);
     logger2.info("\u26A1 Bundling with esbuild...");
     const outputPath = path8.resolve(buildOptions.output);
-    await fs7.ensureDir(path8.dirname(outputPath));
+    await fs8.ensureDir(path8.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
@@ -1037,7 +1075,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     logger2.gray(`Output: ${outputPath}`);
     if (buildOptions.cache !== false) {
       const configContent = generateCacheKeyContent(flowConfig, buildOptions);
-      const buildOutput = await fs7.readFile(outputPath, "utf-8");
+      const buildOutput = await fs8.readFile(outputPath, "utf-8");
       await cacheBuild(configContent, buildOutput);
       logger2.debug("Build cached for future use");
     }
@@ -1060,20 +1098,20 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       );
     }
     if (!buildOptions.tempDir) {
-      await fs7.remove(TEMP_DIR);
+      await fs8.remove(TEMP_DIR);
       logger2.debug("Cleaned up temporary files");
     }
     return stats;
   } catch (error) {
     if (!buildOptions.tempDir) {
-      await fs7.remove(TEMP_DIR).catch(() => {
+      await fs8.remove(TEMP_DIR).catch(() => {
       });
     }
     throw error;
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs7.stat(outputPath);
+  const stats = await fs8.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1587,7 +1625,7 @@ async function bundle(configOrPath, options = {}) {
 
 // src/commands/simulate/simulator.ts
 import path10 from "path";
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
 import { getPlatform as getPlatform2 } from "@walkeros/core";
 
 // src/commands/simulate/tracker.ts
@@ -1670,7 +1708,7 @@ var CallTracker = class {
 
 // src/commands/simulate/jsdom-executor.ts
 import { JSDOM, VirtualConsole } from "jsdom";
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 function buildSandboxFromEnvs(envs, destinations, tracker) {
   const baseBrowserMocks = {
     Image: class MockImage {
@@ -1739,7 +1777,7 @@ async function executeInJSDOM(bundlePath, destinations, event, tracker, envs, ti
   const sandbox = buildSandboxFromEnvs(envs, destinations, tracker);
   Object.assign(window, sandbox.window);
   Object.assign(window.document, sandbox.document);
-  const bundleCode = await fs8.readFile(bundlePath, "utf8");
+  const bundleCode = await fs9.readFile(bundlePath, "utf8");
   try {
     window.eval(bundleCode);
   } catch (error) {
@@ -1946,7 +1984,7 @@ async function executeSimulation(event, configPath) {
       );
     }
     const typedEvent = event;
-    await fs9.ensureDir(tempDir);
+    await fs10.ensureDir(tempDir);
     const rawConfig = await loadJsonConfig(configPath);
     const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
       configPath
@@ -2020,7 +2058,7 @@ async function executeSimulation(event, configPath) {
     };
   } finally {
     if (tempDir) {
-      await fs9.remove(tempDir).catch(() => {
+      await fs10.remove(tempDir).catch(() => {
       });
     }
   }
@@ -2098,7 +2136,7 @@ async function simulate(configOrPath, event, options = {}) {
 // src/commands/push/index.ts
 import path11 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 import { getPlatform as getPlatform3 } from "@walkeros/core";
 import { schemas as schemas2 } from "@walkeros/core/dev";
 async function pushCommand(options) {
@@ -2148,7 +2186,7 @@ async function pushCommand(options) {
           ".tmp",
           `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
         );
-        await fs10.ensureDir(tempDir);
+        await fs11.ensureDir(tempDir);
         const tempPath = path11.join(
           tempDir,
           `bundle.${platform === "web" ? "js" : "mjs"}`
@@ -2213,7 +2251,7 @@ async function pushCommand(options) {
           }
         }
         try {
-          await fs10.remove(tempDir);
+          await fs11.remove(tempDir);
         } catch {
         }
       } catch (error) {
@@ -2258,7 +2296,7 @@ async function executeWebPush(bundlePath, event, logger2) {
     });
     const { window } = dom;
     logger2.debug("Loading bundle...");
-    const bundleCode = await fs10.readFile(bundlePath, "utf8");
+    const bundleCode = await fs11.readFile(bundlePath, "utf8");
     window.eval(bundleCode);
     logger2.debug("Waiting for elb...");
     await waitForWindowProperty2(
@@ -2399,7 +2437,7 @@ function validatePort(port) {
 
 // src/commands/run/utils.ts
 import path12 from "path";
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
   const configDir = path12.dirname(path12.resolve(configPath));
   const tempDir = path12.join(
@@ -2407,7 +2445,7 @@ async function prepareBundleForRun(configPath, options) {
     ".tmp",
     `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
-  await fs11.ensureDir(tempDir);
+  await fs12.ensureDir(tempDir);
   const tempPath = path12.join(tempDir, "bundle.mjs");
   await bundle(configPath, {
     cache: true,
@@ -2594,20 +2632,20 @@ async function run(mode, options) {
 }
 
 // src/commands/cache.ts
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 import path14 from "path";
 var CACHE_DIR = path14.join(".tmp", "cache");
 function registerCacheCommand(program2) {
   const cache = program2.command("cache").description("Manage the CLI cache");
   cache.command("clear").description("Clear all cached packages and builds").option("--packages", "Clear only package cache").option("--builds", "Clear only build cache").action(async (options) => {
     if (options.packages) {
-      await fs12.remove(path14.join(CACHE_DIR, "packages"));
+      await fs13.remove(path14.join(CACHE_DIR, "packages"));
       console.log("Package cache cleared");
     } else if (options.builds) {
-      await fs12.remove(path14.join(CACHE_DIR, "builds"));
+      await fs13.remove(path14.join(CACHE_DIR, "builds"));
       console.log("Build cache cleared");
     } else {
-      await fs12.remove(CACHE_DIR);
+      await fs13.remove(CACHE_DIR);
       console.log("All caches cleared");
     }
   });
@@ -2622,18 +2660,12 @@ function registerCacheCommand(program2) {
   });
 }
 async function countEntries(dir) {
-  if (!await fs12.pathExists(dir)) return 0;
-  const entries = await fs12.readdir(dir);
+  if (!await fs13.pathExists(dir)) return 0;
+  const entries = await fs13.readdir(dir);
   return entries.length;
 }
 
 // src/index.ts
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname = dirname(__filename);
-var packageJson = JSON.parse(
-  readFileSync(join(__dirname, "../package.json"), "utf-8")
-);
-var VERSION = packageJson.version;
 var program = new Command();
 program.name("walkeros").description("walkerOS CLI - Bundle and deploy walkerOS components").version(VERSION);
 program.hook("preAction", (thisCommand, actionCommand) => {