@uipath/cli 0.2.0 → 0.2.2

package/dist/index.js

@@ -47604,7 +47604,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@uipath/cli",
-    version: "0.2.0",
+    version: "0.2.2",
     description: "Cross platform CLI for UiPath",
     repository: {
       type: "git",
@@ -82938,6 +82938,70 @@ Supported agents:
 ` + "  Codex            .agents/skills/<skill>/";
 });
 
+// src/utils/globalNpmRoot.ts
+async function getGlobalNpmUipathDir() {
+  if (cachedLookup)
+    return cachedLookup;
+  cachedLookup = resolveGlobalNpmUipathDir();
+  return cachedLookup;
+}
+async function resolveGlobalNpmUipathDir() {
+  const root = await runNpmRootGlobal();
+  if (!root) {
+    logger.debug("npm root -g lookup failed; skipping global plugin fallback");
+    return null;
+  }
+  const fs7 = getFileSystem();
+  const candidate = fs7.path.join(root, "@uipath");
+  const [existsError, exists] = await catchError(fs7.exists(candidate));
+  if (existsError) {
+    logger.debug(`fs.exists check failed for ${candidate}: ${String(existsError)}`);
+    return null;
+  }
+  if (!exists) {
+    logger.debug(`Global @uipath not present at ${candidate}`);
+    return null;
+  }
+  logger.debug(`Global @uipath resolved via npm root -g: ${candidate}`);
+  return candidate;
+}
+async function runNpmRootGlobal() {
+  const { spawn: spawn2 } = await import("node:child_process");
+  const isWindows = process.platform === "win32";
+  return new Promise((resolve2) => {
+    const proc = isWindows ? spawn2("npm", ["root", "-g"], {
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    }) : spawn2("npm", ["root", "-g"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    proc.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    proc.stderr?.on("data", () => {});
+    const timer = setTimeout(() => {
+      proc.kill("SIGTERM");
+      resolve2(null);
+    }, NPM_ROOT_TIMEOUT_MS);
+    proc.on("error", () => {
+      clearTimeout(timer);
+      resolve2(null);
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      const trimmed = stdout.trim();
+      resolve2(code === 0 && trimmed ? trimmed : null);
+    });
+  });
+}
+var NPM_ROOT_TIMEOUT_MS = 5000, cachedLookup = null;
+var init_globalNpmRoot = __esm(() => {
+  init_src();
+  init_src2();
+});
+
 // src/services/tools-whitelist.ts
 var TOOLS_WHITELIST, WHITELIST_BY_COMMAND, WHITELIST_BY_SHORT_NAME;
 var init_tools_whitelist = __esm(() => {
@@ -83346,13 +83410,25 @@ ${errors5.map((e) => `  - ${e}`).join(`
   }
   async uninstall(packageName, destination, options) {
     const fs7 = getFileSystem();
-    const nodeModulesDir = fs7.path.resolve(destination, "node_modules");
-    const packageDir = fs7.path.resolve(fs7.path.join(destination, "node_modules", packageName));
-    if (!packageDir.startsWith(`${nodeModulesDir}/`) && !packageDir.startsWith(`${nodeModulesDir}\\`)) {
-      throw new Error(`Refusing to uninstall '${packageName}': resolved path escapes node_modules`);
+    let containerDir;
+    let relativeName;
+    if (options?.global) {
+      const globalUipathDir = await getGlobalNpmUipathDir();
+      if (!globalUipathDir) {
+        throw new Error(`Cannot locate '${packageName}': npm root -g unavailable`);
+      }
+      containerDir = globalUipathDir;
+      relativeName = packageName.replace(/^@uipath\//, "");
+    } else {
+      containerDir = fs7.path.resolve(destination, "node_modules");
+      relativeName = packageName;
+    }
+    const packageDir = fs7.path.resolve(fs7.path.join(containerDir, relativeName));
+    if (!packageDir.startsWith(`${containerDir}/`) && !packageDir.startsWith(`${containerDir}\\`)) {
+      throw new Error(`Refusing to uninstall '${packageName}': resolved path escapes ${containerDir}`);
     }
     if (!await fs7.exists(packageDir)) {
-      throw new Error(`Package '${packageName}' is not installed at ${destination}`);
+      throw new Error(`Package '${packageName}' is not installed at ${packageDir}`);
     }
     const [statError, stat2] = await catchError(fs7.stat(packageDir));
     if (!statError && !stat2) {
@@ -83398,6 +83474,7 @@ var SEMVER_RE, SAFE_PACKAGE_SPEC, SAFE_VERSION, NPM_TIMEOUT_MS = 180000, NPM_MAX
 var init_toolService = __esm(() => {
   init_src();
   init_src2();
+  init_globalNpmRoot();
   init_tools_whitelist();
   init_tools_whitelist();
   SEMVER_RE = /^\d+\.\d+\.\d+(-[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*)?(\+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*)?$/;
@@ -83729,6 +83806,47 @@ var init_tools = __esm(() => {
   init_update2();
 });
 
+// src/utils/localWorkspace.ts
+function isInsideNodeModules(dir) {
+  const segments = dir.replace(/\\/g, "/").split("/").filter(Boolean);
+  return segments.includes("node_modules");
+}
+async function isLocalWorkspaceDir(dir) {
+  const fs7 = getFileSystem();
+  const pkgJsonPath = fs7.path.join(dir, "package.json");
+  const [, exists] = await catchError(fs7.exists(pkgJsonPath));
+  if (!exists)
+    return false;
+  const [, raw] = await catchError(fs7.readFile(pkgJsonPath, "utf-8"));
+  if (!raw)
+    return false;
+  const [, pkg] = catchError(() => JSON.parse(raw));
+  if (!pkg)
+    return false;
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  return CLI_PACKAGE_NAME in deps || !!pkg.workspaces;
+}
+async function hasGoverningLocalProject(startDir) {
+  const fs7 = getFileSystem();
+  const { dirname: dirname3 } = fs7.path;
+  let path4 = startDir;
+  for (let i2 = 0;i2 < MAX_WALK_DEPTH; i2++) {
+    if (!isInsideNodeModules(path4) && await isLocalWorkspaceDir(path4)) {
+      return true;
+    }
+    const parent = dirname3(path4);
+    if (parent === path4)
+      break;
+    path4 = parent;
+  }
+  return false;
+}
+var MAX_WALK_DEPTH = 10, CLI_PACKAGE_NAME = "@uipath/cli";
+var init_localWorkspace = __esm(() => {
+  init_src();
+  init_src2();
+});
+
 // src/services/installPath.ts
 function createInstallPathResolver(toolsDir, isBrowser3) {
   return async (packageName) => {
@@ -83741,32 +83859,13 @@ function createInstallPathResolver(toolsDir, isBrowser3) {
     const { dirname: dirnameFn, join: joinFn } = fsLocal.path;
     if (toolsDir) {
       let path4 = dirnameFn(dirnameFn(toolsDir));
-      while (insideNodeModules(path4)) {
+      while (isInsideNodeModules(path4)) {
         const parent = dirnameFn(path4);
         if (parent === path4)
           break;
         path4 = parent;
       }
-      let isGlobal = true;
-      const pkgJsonPath = joinFn(path4, "package.json");
-      if (await fsLocal.exists(pkgJsonPath)) {
-        const [, raw] = await catchError(fsLocal.readFile(pkgJsonPath, "utf-8"));
-        if (raw) {
-          const [, pkgJson] = catchError(() => JSON.parse(raw));
-          if (pkgJson) {
-            const deps = {
-              ...pkgJson.dependencies,
-              ...pkgJson.devDependencies
-            };
-            if (deps && "@uipath/cli" in deps) {
-              isGlobal = false;
-            }
-            if (pkgJson.workspaces) {
-              isGlobal = false;
-            }
-          }
-        }
-      }
+      const isGlobal = !await isLocalWorkspaceDir(path4);
       logger.debug(`Install path resolved: ${path4} (global: ${isGlobal})`);
       return { path: path4, global: isGlobal };
     }
@@ -83786,9 +83885,9 @@ function createInstallPathResolver(toolsDir, isBrowser3) {
     throw new Error("Unable to determine install location. No node_modules found in parent directories.");
   };
 }
-var insideNodeModules = (dir) => /[\\/]node_modules([\\/]|$)/.test(dir);
 var init_installPath = __esm(() => {
   init_src();
+  init_localWorkspace();
 });
 
 // src/services/storage.ts
@@ -84013,10 +84112,6 @@ async function discoverTools(toolsDirs) {
   }
   return tools;
 }
-function isInsideNodeModules(dir) {
-  const segments = dir.replace(/\\/g, "/").split("/").filter(Boolean);
-  return segments.includes("node_modules");
-}
 async function findNearestToolsDir(startDir, seen) {
   const fs7 = getFileSystem();
   const { dirname: dirname3, join: join2 } = fs7.path;
@@ -84049,17 +84144,44 @@ async function resolveToolsDirs(cliFilePath, cwd) {
   const { dirname: dirname3 } = fs7.path;
   const seen = new Set;
   const dirs = [];
-  dirs.push(...await findNearestToolsDir(dirname3(cliFilePath), seen));
+  const cliDir = dirname3(cliFilePath);
+  dirs.push(...await findNearestToolsDir(cliDir, seen));
   dirs.push(...await findNearestToolsDir(cwd, seen));
+  if (!await hasGoverningLocalProject(cliDir) && !await dirsContainAnyPlugin(dirs)) {
+    const globalUipath = await getGlobalNpmUipathDir();
+    if (globalUipath && !seen.has(globalUipath)) {
+      seen.add(globalUipath);
+      dirs.push(globalUipath);
+    }
+  }
   return dirs;
 }
-var _isRunningFromSource, _isBrowser, MAX_WALK_DEPTH = 10;
+async function dirsContainAnyPlugin(dirs) {
+  if (dirs.length === 0)
+    return false;
+  const fs7 = getFileSystem();
+  for (const dir of dirs) {
+    const [error48, entries] = await catchError(fs7.readdir(dir));
+    if (error48) {
+      logger.debug(`fs.readdir failed for ${dir}: ${String(error48)}`);
+      continue;
+    }
+    for (const entry of entries) {
+      if (WHITELIST_BY_SHORT_NAME.has(entry))
+        return true;
+    }
+  }
+  return false;
+}
+var _isRunningFromSource, _isBrowser;
 var init_toolLoader = __esm(() => {
   init_src();
   init_src2();
   init_esm();
   init_storage();
   init_toolService();
+  init_globalNpmRoot();
+  init_localWorkspace();
   _isRunningFromSource = isRunningFromSource();
   _isBrowser = !(typeof process !== "undefined" && process.versions && process.versions.node);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/cli",
-    "version": "0.2.0",
+    "version": "0.2.2",
     "description": "Cross platform CLI for UiPath",
     "repository": {
         "type": "git",