@uipath/cli 1.197.0 → 1.197.1-preview.76

package/dist/index.js

@@ -45866,7 +45866,7 @@ var init_package = __esm(() => {
   package_default = {
     name: "@uipath/cli",
     license: "MIT",
-    version: "1.197.0",
+    version: "1.197.1-preview.76",
     description: "Cross platform CLI for UiPath",
     repository: {
       type: "git",
@@ -82430,11 +82430,26 @@ function renderTableHelp(cmd, helper) {
 `)}
 `;
 }
+function rendersTableHelp() {
+  return getOutputFormat() === "table" || !getOutputFormatExplicit() && getOutputSink().capabilities.isInteractive;
+}
+function stripHelpTextEventsForStructuredHelp(root) {
+  if (rendersTableHelp()) {
+    return;
+  }
+  const stack = [root];
+  while (stack.length > 0) {
+    const cmd = stack.pop();
+    for (const event of HELP_TEXT_EVENTS) {
+      cmd.removeAllListeners(event);
+    }
+    stack.push(...cmd.commands);
+  }
+}
 function createHelpConfiguration(isBrowser3) {
   const config2 = {
     formatHelp(cmd, helper) {
-      const format2 = getOutputFormat();
-      if (format2 === "table" || !getOutputFormatExplicit() && getOutputSink().capabilities.isInteractive) {
+      if (rendersTableHelp()) {
         return renderTableHelp(cmd, helper);
       }
       const baseHelp = extractCommandHelp(cmd, helper);
@@ -82478,7 +82493,7 @@ function createHelpConfiguration(isBrowser3) {
   }
   return config2;
 }
-var GLOBAL_OPTIONS, BUILT_IN_ROOT_COMMANDS, GETTING_STARTED_ROWS;
+var GLOBAL_OPTIONS, BUILT_IN_ROOT_COMMANDS, GETTING_STARTED_ROWS, HELP_TEXT_EVENTS;
 var init_helpFormatter = __esm(() => {
   init_src2();
   GLOBAL_OPTIONS = [
@@ -82527,6 +82542,12 @@ var init_helpFormatter = __esm(() => {
       Description: "Install AI-agent skills for this CLI"
     }
   ];
+  HELP_TEXT_EVENTS = [
+    "beforeAllHelp",
+    "beforeHelp",
+    "afterHelp",
+    "afterAllHelp"
+  ];
 });
 
 // src/utils/parseError.ts
@@ -107468,42 +107489,72 @@ var init_autopilot = __esm(() => {
 
 // src/commands/skills/contentStore.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname2 } from "node:path";
 import { gunzipSync } from "node:zlib";
 function loadChildProcess2() {
   childProcessModulePromise2 ??= import("node:child_process");
   return childProcessModulePromise2;
 }
-async function fetchSkillsTo(targetPath, _rootDir) {
-  const fs7 = getFileSystem();
-  const packageInfo = await fetchMatchingSkillsPackageInfo();
-  logger.info(`Downloading ${SKILLS_PACKAGE_NAME}@${packageInfo.version} content store...`);
-  const tmpPath = fs7.path.join(fs7.env.tmpdir(), `uipath-skills-store-${randomUUID5()}`);
+async function resolveLocalSkillsStore(fs7) {
+  const hasSkillsDir = async (d) => !!d && await fs7.exists(fs7.path.join(d, "skills"));
+  const envDir = process.env.UIPATH_SKILLS_LOCAL_DIR?.trim();
+  if (envDir && await hasSkillsDir(envDir))
+    return envDir;
+  const [reqErr, require2] = catchError(() => createRequire2(import.meta.url));
+  if (reqErr || !require2)
+    return;
+  const [resErr, pkgJsonPath] = catchError(() => require2.resolve(`${SKILLS_PACKAGE_NAME}/package.json`));
+  if (resErr || !pkgJsonPath)
+    return;
+  const dir = dirname2(pkgJsonPath);
+  return await hasSkillsDir(dir) ? dir : undefined;
+}
+async function copySkillsStore(fs7, sourceDir, targetPath) {
   const manifestPath = fs7.path.join(targetPath, MANIFEST_NAME);
   let savedManifest = null;
   if (await fs7.exists(targetPath)) {
-    savedManifest = await fs7.readFile(manifestPath, {
-      encoding: "utf-8"
-    });
+    savedManifest = await fs7.readFile(manifestPath, { encoding: "utf-8" });
+    await fs7.rm(targetPath);
+  }
+  await fs7.mkdir(targetPath);
+  await fs7.copyDirectory(sourceDir, targetPath);
+  if (savedManifest !== null) {
+    await fs7.writeFile(manifestPath, savedManifest);
+  }
+}
+async function fetchSkillsTo(targetPath, _rootDir) {
+  const fs7 = getFileSystem();
+  const [infoErr, resolved] = await catchError(resolveSkillsDownload());
+  if (infoErr || !resolved) {
+    const localStore = await resolveLocalSkillsStore(fs7);
+    if (localStore) {
+      logger.info(`Could not resolve ${SKILLS_PACKAGE_NAME} from a registry (${infoErr?.message ?? "unknown error"}); using the locally-installed package at ${localStore}.`);
+      await copySkillsStore(fs7, localStore, targetPath);
+      return;
+    }
+    throw infoErr ?? new Error(`Could not resolve ${SKILLS_PACKAGE_NAME}.`);
   }
+  const { pm, packageInfo } = resolved;
+  logger.info(`Downloading ${SKILLS_PACKAGE_NAME}@${packageInfo.version} content store with ${pm}...`);
+  const tmpPath = fs7.path.join(fs7.env.tmpdir(), `uipath-skills-store-${randomUUID5()}`);
   try {
     await fs7.mkdir(tmpPath);
-    await downloadAndExtractPackage(packageInfo, tmpPath);
+    await materializePackage(pm, packageInfo, tmpPath);
     if (!await fs7.exists(fs7.path.join(tmpPath, "skills"))) {
       throw new Error(`${SKILLS_PACKAGE_NAME}@${packageInfo.version} does not contain a skills/ directory`);
     }
     await writeSourceMarker(tmpPath, packageInfo);
-    if (await fs7.exists(targetPath)) {
-      await fs7.rm(targetPath);
-    }
-    await fs7.mkdir(targetPath);
-    await fs7.copyDirectory(tmpPath, targetPath);
-    if (savedManifest !== null) {
-      await fs7.writeFile(manifestPath, savedManifest);
-    }
+    await copySkillsStore(fs7, tmpPath, targetPath);
   } finally {
     await catchError(fs7.rm(tmpPath));
   }
 }
+async function resolveSkillsDownload() {
+  const pm = await resolvePackageManager();
+  const packageInfo = await fetchMatchingSkillsPackageInfo(pm);
+  return { pm, packageInfo };
+}
 async function getContentStore(rootDir) {
   const fs7 = getFileSystem();
   const storePath = fs7.path.join(rootDir, STORE_NAME);
@@ -107623,16 +107674,6 @@ async function removeFromManifest(storePath, skillNames, agents) {
   }
   await writeManifest(storePath, manifest);
 }
-function registryPackagePath(packageName) {
-  return packageName.replaceAll("/", "%2f");
-}
-function trimTrailingSlashes(value) {
-  let end = value.length;
-  while (end > 0 && value.codePointAt(end - 1) === 47) {
-    end--;
-  }
-  return value.slice(0, end);
-}
 function asRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return;
@@ -107757,45 +107798,57 @@ function matchesCliVersionLine(version2, cliVersion) {
 function isStableVersion(version2) {
   return parseSemver(version2)?.prerelease === undefined;
 }
-function getGhNpmRegistryToken() {
-  const envToken = globalThis.process?.env?.GH_NPM_REGISTRY_TOKEN;
-  return envToken || undefined;
+function isPackageManager(value) {
+  return PM_PREFERENCE.includes(value);
+}
+async function resolvePackageManager() {
+  const override = getFileSystem().env.getenv(PM_OVERRIDE_ENV)?.toLowerCase();
+  if (override) {
+    if (!isPackageManager(override)) {
+      throw new Error(`${PM_OVERRIDE_ENV}="${override}" is not supported. Use one of: ${PM_PREFERENCE.join(", ")}.`);
+    }
+    return override;
+  }
+  if (!cachedPackageManager) {
+    cachedPackageManager = detectPackageManager();
+  }
+  return cachedPackageManager;
 }
-function validateNpmArgument(arg) {
+async function detectPackageManager() {
+  for (const pm of PM_PREFERENCE) {
+    if (await commandOnPath(pm)) {
+      logger.debug(`Using ${pm} to download ${SKILLS_PACKAGE_NAME}`);
+      return pm;
+    }
+  }
+  throw new Error(`No supported package manager found on PATH to download ${SKILLS_PACKAGE_NAME}. Install one of: ${PM_PREFERENCE.join(", ")}.`);
+}
+function validatePmArgument(arg) {
   if (!SHELL_SAFE_ARG2.test(arg)) {
-    throw new Error(`Unsafe npm argument: '${arg}'`);
+    throw new Error(`Unsafe package-manager argument: '${arg}'`);
   }
 }
-function validateNpmArguments(args) {
+function validatePmArguments(args) {
   for (const arg of args) {
-    validateNpmArgument(arg);
+    validatePmArgument(arg);
   }
 }
-function packageFetchHeaders(accept, authToken) {
-  return {
-    Accept: accept,
-    ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
-  };
-}
-async function runNpmCommand(args, label, timeoutMs, cwd) {
-  validateNpmArguments(args);
+async function runPmCommand(pm, args, label, timeoutMs, cwd, extraEnv) {
+  validatePmArguments(args);
   const { spawn: spawn2 } = await loadChildProcess2();
   const isWindows = process.platform === "win32";
+  const env = extraEnv ? { ...process.env, ...extraEnv } : undefined;
   return await new Promise((resolve2, reject) => {
     let proc;
     if (isWindows) {
-      if (!SHELL_SAFE_ARG2.test("npm")) {
-        reject(new Error("Unsafe executable: 'npm'"));
-        return;
-      }
-      const commandLine = ["npm", ...args].join(" ");
+      const commandLine = [pm, ...args].join(" ");
       if (!SHELL_SAFE_COMMAND_LINE2.test(commandLine)) {
         reject(new Error(`Unsafe command line: '${commandLine}'`));
         return;
       }
-      proc = spawn2(commandLine, [], { cwd, shell: true });
+      proc = spawn2(commandLine, [], { cwd, shell: true, env });
     } else {
-      proc = spawn2("npm", args, { cwd });
+      proc = spawn2(pm, args, { cwd, env });
     }
     let stdout = "";
     let stderr = "";
@@ -107810,11 +107863,11 @@ async function runNpmCommand(args, label, timeoutMs, cwd) {
     });
     const timer = setTimeout(() => {
       proc.kill("SIGTERM");
-      reject(new Error(`npm ${label} timed out after ${timeoutMs / 1000}s`));
+      reject(new Error(`${pm} ${label} timed out after ${timeoutMs / 1000}s`));
     }, timeoutMs);
     proc.on("error", (error51) => {
       clearTimeout(timer);
-      reject(mapNpmError(label, stderr, error51));
+      reject(mapPmError(pm, label, stderr, error51));
     });
     proc.on("close", (code) => {
       clearTimeout(timer);
@@ -107822,41 +107875,95 @@ async function runNpmCommand(args, label, timeoutMs, cwd) {
         resolve2(stdout);
         return;
       }
-      reject(mapNpmError(label, stderr, code));
+      reject(mapPmError(pm, label, stderr, code));
     });
   });
 }
-function mapNpmError(label, stderr, codeOrError) {
-  if (/E404/.test(stderr) || /404/.test(stderr)) {
+function mapPmError(pm, label, stderr, codeOrError) {
+  if (/E404|\b404\b|not found|Couldn't find|no matching version/i.test(stderr)) {
     return new Error(`${SKILLS_PACKAGE_NAME} not found in the registry`);
   }
-  if (/E401|E403|ENEEDAUTH|need(s)? auth|authentication/i.test(stderr)) {
-    return new Error(`Authentication required for ${SKILLS_PACKAGE_NAME} (configure @uipath:registry and an auth token in .npmrc, or set GH_NPM_REGISTRY_TOKEN)`);
+  if (/E401|E403|\b401\b|\b403\b|ENEEDAUTH|unauthor|forbidden|need(s)? auth|authentication/i.test(stderr)) {
+    return new Error(`Authentication required for ${SKILLS_PACKAGE_NAME}. ${REGISTRY_AUTH_HINT}`);
   }
   const detail = stderr.trim() || (codeOrError instanceof Error ? codeOrError.message : `exit ${codeOrError}`);
-  return new Error(`npm ${label} failed: ${detail}`);
+  return new Error(`${pm} ${label} failed: ${detail}`);
 }
-function parseNpmJson(stdout, label) {
+function parsePmJson(pm, stdout, label) {
   const [parseError, parsed] = catchError(() => JSON.parse(stdout));
   if (parseError) {
-    throw new Error(`Unexpected npm ${label} output`);
+    throw new Error(`Unexpected ${pm} ${label} output`);
   }
   return parsed;
 }
-async function npmViewJson(args) {
-  const stdout = await runNpmCommand(["view", ...args, "--json"], `view ${args.join(" ")}`, NPM_VIEW_TIMEOUT_MS2);
-  return parseNpmJson(stdout, "view");
+async function pmViewJson(pm, args) {
+  const label = `view ${args.join(" ")}`;
+  const pmArgs = pm === "bun" ? ["info", ...args, "--json"] : ["view", ...args, "--json"];
+  return await withTempProject(async (dir) => {
+    const stdout = await runPmCommand(pm, pmArgs, label, NPM_VIEW_TIMEOUT_MS2, dir);
+    return parseViewOutput(pm, stdout);
+  });
 }
-function normalizeVersionList(value) {
-  if (Array.isArray(value)) {
-    return value.filter((version2) => {
-      return typeof version2 === "string";
-    });
+function parseViewOutput(pm, stdout) {
+  if (!stdout.trim())
+    return;
+  return parsePmJson(pm, stdout, "view");
+}
+async function yarnInfo(args) {
+  const label = `info ${args.join(" ")}`;
+  const stdout = await withTempProject((dir) => runPmCommand("yarn", ["info", ...args, "--json"], label, NPM_VIEW_TIMEOUT_MS2, dir));
+  if (!stdout.trim())
+    return;
+  for (const line of stdout.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const [, parsed] = catchError(() => JSON.parse(trimmed));
+    const record3 = asRecord(parsed);
+    if (record3 && "data" in record3) {
+      return record3.data;
+    }
   }
-  if (typeof value === "string") {
-    return [value];
+  throw new Error(`Unexpected yarn ${label} output`);
+}
+async function queryVersions(pm, spec) {
+  const raw = pm === "yarn" ? await yarnInfo([spec, "versions"]) : await pmViewJson(pm, [spec, "versions"]);
+  return normalizeVersionList(raw);
+}
+async function pmListVersions(pm, cliVersion) {
+  const primary = await queryVersions(pm, SKILLS_PACKAGE_NAME);
+  if (primary.length > 0)
+    return primary;
+  const lineSpec = `${SKILLS_PACKAGE_NAME}@~${cliVersion.major}.${cliVersion.minor}.0-0`;
+  const [err, versions2] = await catchError(queryVersions(pm, lineSpec));
+  if (err) {
+    logger.debug(`Line-scoped version lookup for ${lineSpec} failed: ${err.message}`);
+    return [];
   }
-  return [];
+  return versions2;
+}
+async function pmResolveTarball(pm, version2) {
+  const spec = `${SKILLS_PACKAGE_NAME}@${version2}`;
+  const [error51, value] = await catchError(pm === "yarn" ? yarnInfo([spec, "dist.tarball"]) : pmViewJson(pm, [spec, "dist.tarball"]));
+  if (error51) {
+    logger.debug(`Could not resolve dist.tarball for ${spec}: ${error51}`);
+    return;
+  }
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function normalizeVersionList(value) {
+  const collected = new Set;
+  const walk = (node2) => {
+    if (typeof node2 === "string") {
+      collected.add(node2);
+    } else if (Array.isArray(node2)) {
+      for (const child of node2)
+        walk(child);
+    }
+  };
+  walk(value);
+  return [...collected];
 }
 function requireString(value, message) {
   if (typeof value !== "string" || value.length === 0) {
@@ -107868,31 +107975,22 @@ function registryFromTarball(tarballUrl) {
   const [urlError, parsedUrl] = catchError(() => new URL(tarballUrl));
   return urlError ? SKILLS_REGISTRY_URL : parsedUrl.origin;
 }
-async function fetchJson(url2, authToken) {
-  const response = await fetch(url2, {
-    headers: packageFetchHeaders("application/json", authToken),
-    signal: AbortSignal.timeout(60000)
-  });
-  if (!response.ok) {
-    throw new Error(`Registry returned ${response.status} ${response.statusText} for ${SKILLS_PACKAGE_NAME}`);
-  }
-  const data = asRecord(await response.json());
-  if (!data) {
-    throw new Error(`Registry returned invalid metadata for ${SKILLS_PACKAGE_NAME}`);
-  }
-  return data;
-}
-async function fetchMatchingSkillsPackageInfo() {
+async function fetchMatchingSkillsPackageInfo(pm) {
   const cliVersion = parseSemver(package_default.version);
   if (!cliVersion) {
     throw new Error(`Invalid CLI version ${package_default.version}; expected semantic version major.minor.patch`);
   }
-  const ghToken = getGhNpmRegistryToken();
-  if (ghToken) {
-    logger.debug(`GH_NPM_REGISTRY_TOKEN found; using ${SKILLS_GITHUB_REGISTRY_URL}`);
-    return await fetchMatchingSkillsPackageInfoFromRegistry(cliVersion, SKILLS_GITHUB_REGISTRY_URL, ghToken);
-  }
-  return await fetchMatchingSkillsPackageInfoWithNpm(cliVersion);
+  const versions2 = await pmListVersions(pm, cliVersion);
+  const selectedVersion = pickMatchingSkillsVersion(versions2, cliVersion);
+  const tarballUrl = pm === "npm" || pm === "pnpm" ? requireString(await pmViewJson(pm, [
+    `${SKILLS_PACKAGE_NAME}@${selectedVersion}`,
+    "dist.tarball"
+  ]), `${SKILLS_PACKAGE_NAME}@${selectedVersion} does not declare dist.tarball`) : await pmResolveTarball(pm, selectedVersion);
+  return {
+    version: selectedVersion,
+    tarballUrl: tarballUrl ?? "",
+    registryUrl: tarballUrl ? registryFromTarball(tarballUrl) : SKILLS_REGISTRY_URL
+  };
 }
 function pickMatchingSkillsVersion(versions2, cliVersion) {
   const matchingVersions = versions2.filter((version2) => matchesCliVersionLine(version2, cliVersion));
@@ -107903,64 +108001,32 @@ function pickMatchingSkillsVersion(versions2, cliVersion) {
   }
   return selectedVersion;
 }
-async function fetchMatchingSkillsPackageInfoWithNpm(cliVersion) {
-  const versions2 = normalizeVersionList(await npmViewJson([SKILLS_PACKAGE_NAME, "versions"]));
-  const selectedVersion = pickMatchingSkillsVersion(versions2, cliVersion);
-  const tarballUrl = requireString(await npmViewJson([
-    `${SKILLS_PACKAGE_NAME}@${selectedVersion}`,
-    "dist.tarball"
-  ]), `${SKILLS_PACKAGE_NAME}@${selectedVersion} does not declare dist.tarball`);
-  return {
-    version: selectedVersion,
-    tarballUrl,
-    registryUrl: registryFromTarball(tarballUrl)
-  };
-}
-async function fetchMatchingSkillsPackageInfoFromRegistry(cliVersion, registryUrl, authToken) {
-  const [urlError] = catchError(() => new URL(registryUrl));
-  if (urlError) {
-    throw new Error(`Invalid registry URL: "${registryUrl}"`);
-  }
-  const url2 = `${trimTrailingSlashes(registryUrl)}/${registryPackagePath(SKILLS_PACKAGE_NAME)}`;
-  const data = await fetchJson(url2, authToken);
-  const versions2 = asRecord(data.versions);
-  const selectedVersion = pickMatchingSkillsVersion(Object.keys(versions2 ?? {}), cliVersion);
-  const selectedPackageVersion = asRecord(versions2?.[selectedVersion]);
-  const dist = asRecord(selectedPackageVersion?.dist);
-  const tarballUrl = typeof dist?.tarball === "string" ? dist.tarball : undefined;
-  if (!tarballUrl) {
-    throw new Error(`${SKILLS_PACKAGE_NAME}@${selectedVersion} does not declare dist.tarball`);
+async function withTempProject(fn) {
+  const fs7 = getFileSystem();
+  const projectDir = fs7.path.join(fs7.env.tmpdir(), `uipath-skills-pm-${randomUUID5()}`);
+  try {
+    await fs7.mkdir(projectDir);
+    await fs7.writeFile(fs7.path.join(projectDir, "package.json"), `${JSON.stringify({ name: "uipath-skills-fetch", version: "0.0.0", private: true }, null, 2)}
+`);
+    return await fn(projectDir);
+  } finally {
+    await catchError(fs7.rm(projectDir));
   }
-  return {
-    version: selectedVersion,
-    tarballUrl,
-    registryUrl,
-    authToken
-  };
 }
-async function downloadAndExtractPackage(packageInfo, destinationPath) {
-  if (!packageInfo.authToken) {
-    await packAndExtractPackage(packageInfo, destinationPath);
+async function materializePackage(pm, packageInfo, destinationPath) {
+  if (pm === "npm") {
+    await packAndExtractWithNpm(packageInfo, destinationPath);
     return;
   }
-  const response = await fetch(packageInfo.tarballUrl, {
-    headers: packageFetchHeaders("application/octet-stream", packageInfo.authToken),
-    signal: AbortSignal.timeout(60000)
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to download ${SKILLS_PACKAGE_NAME}@${packageInfo.version}: ${response.status} ${response.statusText}`);
-  }
-  const arrayBuffer = await response.arrayBuffer();
-  const tarData = gunzipSync(new Uint8Array(arrayBuffer));
-  await extractNpmTarballToDir(tarData, destinationPath);
+  await addAndCopyPackage(pm, packageInfo, destinationPath);
 }
-async function packAndExtractPackage(packageInfo, destinationPath) {
+async function packAndExtractWithNpm(packageInfo, destinationPath) {
   const fs7 = getFileSystem();
   const packDir = fs7.path.join(fs7.env.tmpdir(), `uipath-skills-pack-${randomUUID5()}`);
   try {
     await fs7.mkdir(packDir);
-    const stdout = await runNpmCommand(["pack", `${SKILLS_PACKAGE_NAME}@${packageInfo.version}`, "--json"], `pack ${SKILLS_PACKAGE_NAME}@${packageInfo.version}`, NPM_PACK_TIMEOUT_MS, packDir);
-    const packOutput = parseNpmJson(stdout, "pack");
+    const stdout = await runPmCommand("npm", ["pack", `${SKILLS_PACKAGE_NAME}@${packageInfo.version}`, "--json"], `pack ${SKILLS_PACKAGE_NAME}@${packageInfo.version}`, NPM_PACK_TIMEOUT_MS, packDir);
+    const packOutput = parsePmJson("npm", stdout, "pack");
     const packedFile = readPackedFileName(packOutput);
     const packedPath = fs7.path.join(packDir, packedFile);
     const packedContent = await fs7.readFile(packedPath);
@@ -107973,6 +108039,20 @@ async function packAndExtractPackage(packageInfo, destinationPath) {
     await catchError(fs7.rm(packDir));
   }
 }
+async function addAndCopyPackage(pm, packageInfo, destinationPath) {
+  const fs7 = getFileSystem();
+  const spec = `${SKILLS_PACKAGE_NAME}@${packageInfo.version}`;
+  const extraEnv = pm === "yarn" ? { YARN_NODE_LINKER: "node-modules" } : undefined;
+  await withTempProject(async (projectDir) => {
+    await runPmCommand(pm, ["add", spec, "--ignore-scripts"], `add ${spec}`, NPM_PACK_TIMEOUT_MS, projectDir, extraEnv);
+    const installed = fs7.path.join(projectDir, "node_modules", SKILLS_PACKAGE_NAME);
+    if (!await fs7.exists(installed)) {
+      throw new Error(`${pm} add did not install ${SKILLS_PACKAGE_NAME}`);
+    }
+    const realInstalled = await fs7.realpath(installed);
+    await fs7.copyDirectory(realInstalled, destinationPath);
+  });
+}
 function readPackedFileName(packOutput) {
   if (!Array.isArray(packOutput)) {
     throw new TypeError(`Unexpected npm pack output for ${SKILLS_PACKAGE_NAME}`);
@@ -108151,15 +108231,17 @@ async function extractNpmTarballToDir(tarData, destinationDir) {
     await extractTarEntry2(fs7, destinationDir, entryName, entry);
   }
 }
-var SKILLS_PACKAGE_NAME = "@uipath/skills", SKILLS_REGISTRY_URL = "https://registry.npmjs.org", SKILLS_GITHUB_REGISTRY_URL = "https://npm.pkg.github.com/", REPO_URL = "https://www.npmjs.com/package/@uipath/skills", SOURCE_MARKER_NAME = ".uipath-skills-source.json", STORE_NAME, TAR_BLOCK_SIZE = 512, NPM_VIEW_TIMEOUT_MS2 = 30000, NPM_PACK_TIMEOUT_MS = 60000, SHELL_SAFE_ARG2, SHELL_SAFE_COMMAND_LINE2, childProcessModulePromise2, MANIFEST_NAME = "manifest.json";
+var SKILLS_PACKAGE_NAME = "@uipath/skills", SKILLS_REGISTRY_URL = "https://registry.npmjs.org", REPO_URL = "https://www.npmjs.com/package/@uipath/skills", SOURCE_MARKER_NAME = ".uipath-skills-source.json", STORE_NAME, TAR_BLOCK_SIZE = 512, NPM_VIEW_TIMEOUT_MS2 = 30000, NPM_PACK_TIMEOUT_MS = 60000, SHELL_SAFE_ARG2, SHELL_SAFE_COMMAND_LINE2, PM_PREFERENCE, PM_OVERRIDE_ENV = "UIP_SKILLS_PM", childProcessModulePromise2, MANIFEST_NAME = "manifest.json", cachedPackageManager = null, REGISTRY_AUTH_HINT = "The package manager could not authenticate to the registry. If you are installing an alpha/internal build from GitHub Packages, add to your .npmrc: '@uipath:registry=https://npm.pkg.github.com/' and '//npm.pkg.github.com/:_authToken=<token>', where <token> is a GitHub PAT with the 'read:packages' scope, authorized for the UiPath org via 'Configure SSO'. This is a different credential from your 'uip login' token.";
 var init_contentStore = __esm(() => {
   init_src2();
   init_src();
   init_js_yaml();
   init_package();
+  init_detect();
   STORE_NAME = `${UIPATH_HOME_DIR}/.skills`;
-  SHELL_SAFE_ARG2 = /^[a-zA-Z0-9@/._-]+$/;
-  SHELL_SAFE_COMMAND_LINE2 = /^[a-zA-Z0-9@/._\- ]+$/;
+  SHELL_SAFE_ARG2 = /^[a-zA-Z0-9@/._~-]+$/;
+  SHELL_SAFE_COMMAND_LINE2 = /^[a-zA-Z0-9@/._~\- ]+$/;
+  PM_PREFERENCE = ["npm", "pnpm", "bun", "yarn"];
 });
 
 // src/commands/skills/agents/claude.ts
@@ -108956,17 +109038,6 @@ async function resolveSkillsContext(options, operation) {
   const isLocal = !!options.local;
   const fs7 = getFileSystem();
   const rootDir = isLocal ? fs7.env.cwd() : fs7.env.homedir();
-  const storePath = await getContentStore(rootDir);
-  const availableSkills = await getAvailableSkills(storePath);
-  const selectedSkills = availableSkills.filter((skill) => skill.name !== SKILL_CATALOG_SKILL_NAME);
-  if (selectedSkills.length === 0) {
-    OutputFormatter.error({
-      Result: RESULTS.ConfigError,
-      Message: "No skills found in content store.",
-      Instructions: "Check that the @uipath/skills package contains skills in the skills/ directory."
-    });
-    return null;
-  }
   let agents;
   if (options.agent) {
     const agent = options.agent.trim().toLowerCase();
@@ -109001,6 +109072,17 @@ async function resolveSkillsContext(options, operation) {
       agents = selected;
     }
   }
+  const storePath = await getContentStore(rootDir);
+  const availableSkills = await getAvailableSkills(storePath);
+  const selectedSkills = availableSkills.filter((skill) => skill.name !== SKILL_CATALOG_SKILL_NAME);
+  if (selectedSkills.length === 0) {
+    OutputFormatter.error({
+      Result: RESULTS.ConfigError,
+      Message: "No skills found in content store.",
+      Instructions: "Check that the @uipath/skills package contains skills in the skills/ directory."
+    });
+    return null;
+  }
   return { rootDir, storePath, selectedSkills, agents, isLocal };
 }
 async function detectInstalledAgents(isLocal) {
@@ -115045,6 +115127,7 @@ function registerToolCommands(program2, discovered, context) {
         });
         return;
       }
+      stripHelpTextEventsForStructuredHelp(realCommand);
       const toolArgs = context.args.slice(2);
       const candidates = [entry.commandPrefix, ...aliases];
       const prefixIdx = toolArgs.findIndex((a) => candidates.includes(a));
@@ -115068,6 +115151,7 @@ function registerToolCommands(program2, discovered, context) {
 var init_registerToolCommands = __esm(() => {
   init_src2();
   init_tools_whitelist();
+  init_helpFormatter();
   init_toolLoader();
 });
 
@@ -115086,16 +115170,16 @@ async function resolveToolsDirectories(context) {
     return { toolsDirs, toolsDir };
   }
   logger.warn("Unable to determine tools directory. Please ensure the CLI is installed correctly.");
-  const { dirname: dirname2, join: join2 } = fs7.path;
+  const { dirname: dirname3, join: join2 } = fs7.path;
   const isInstalledPackage = process.execPath.includes(join2("@uipath", "cli", "dist", "uip"));
   if (isInstalledPackage) {
-    const execDir = dirname2(process.execPath);
-    const packageDir = dirname2(execDir);
-    const fallbackDir2 = dirname2(packageDir);
+    const execDir = dirname3(process.execPath);
+    const packageDir = dirname3(execDir);
+    const fallbackDir2 = dirname3(packageDir);
     logger.debug(`Fallback (installed package): ${fallbackDir2}`);
     return { toolsDirs: [fallbackDir2], toolsDir: fallbackDir2 };
   }
-  const fallbackDir = join2(dirname2(currentFilePath), "..");
+  const fallbackDir = join2(dirname3(currentFilePath), "..");
   logger.debug(`Fallback (development mode): ${fallbackDir}`);
   return { toolsDirs: [fallbackDir], toolsDir: fallbackDir };
 }
@@ -115356,4 +115440,4 @@ export {
   ready
 };
 
-//# debugId=F57483DDAE741E3264756E2164756E21
+//# debugId=23FF6BC7E4F26FA564756E2164756E21

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/cli",
   "license": "MIT",
-  "version": "1.197.0",
+  "version": "1.197.1-preview.76",
   "description": "Cross platform CLI for UiPath",
   "repository": {
     "type": "git",
@@ -34,5 +34,5 @@
     "mihaigirleanu",
     "vlad-uipath"
   ],
-  "gitHead": "56f68b263cec4ea1f2a39d738bd99ecf52f88fea"
+  "gitHead": "e66bcea788dcf20d4032933a353a64baab9b22a9"
 }