@uipath/rpa-tool 1.198.1 → 1.198.2

package/dist/index.js

@@ -2197,7 +2197,7 @@ var {
 
 // src/commander-polyfill.ts
 if (!Command.prototype.trackedAction) {
-  Command.prototype.trackedAction = function(context, fn) {
+  Command.prototype.trackedAction = function(context, fn, _properties) {
     return this.action(async (...args) => {
       try {
         await fn(...args);

package/dist/tool.js

@@ -3245,8 +3245,8 @@ async function refreshTokenFingerprint(refreshToken) {
     const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
     return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
   }
-  const { createHash } = await import("node:crypto");
-  return createHash("sha256").update(refreshToken).digest("hex").slice(0, 16);
+  const { createHash: createHash2 } = await import("node:crypto");
+  return createHash2("sha256").update(refreshToken).digest("hex").slice(0, 16);
 }
 function breakerPathFor(authPath) {
   return `${authPath}${BREAKER_SUFFIX}`;
@@ -3986,19 +3986,19 @@ var __create3, __getProtoOf3, __defProp3, __getOwnPropNames3, __hasOwnProp3, __t
   }
   const subprocess = childProcess32.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve3(subprocess);
+        resolve4(subprocess);
       });
     });
   }
   if (isFallbackAttempt) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       subprocess.once("error", reject);
       subprocess.once("spawn", () => {
         subprocess.once("close", (exitCode) => {
@@ -4008,17 +4008,17 @@ var __create3, __getProtoOf3, __defProp3, __getOwnPropNames3, __hasOwnProp3, __t
             return;
           }
           subprocess.unref();
-          resolve3(subprocess);
+          resolve4(subprocess);
         });
       });
     });
   }
   subprocess.unref();
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     subprocess.once("error", reject);
     subprocess.once("spawn", () => {
       subprocess.off("error", reject);
-      resolve3(subprocess);
+      resolve4(subprocess);
     });
   });
 }, open2 = (target, options) => {
@@ -36901,19 +36901,19 @@ var isDockerCached3, cachedResult3, hasContainerEnv3 = () => {
   }
   const subprocess = childProcess33.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve4(subprocess);
+        resolve5(subprocess);
       });
     });
   }
   if (isFallbackAttempt) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       subprocess.once("error", reject);
       subprocess.once("spawn", () => {
         subprocess.once("close", (exitCode) => {
@@ -36923,17 +36923,17 @@ var isDockerCached3, cachedResult3, hasContainerEnv3 = () => {
             return;
           }
           subprocess.unref();
-          resolve4(subprocess);
+          resolve5(subprocess);
         });
       });
     });
   }
   subprocess.unref();
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     subprocess.once("error", reject);
     subprocess.once("spawn", () => {
       subprocess.off("error", reject);
-      resolve4(subprocess);
+      resolve5(subprocess);
     });
   });
 }, open3 = (target, options) => {
@@ -49534,7 +49534,7 @@ function withTrailingSeparator(p) {
 }
 
 // src/tool.ts
-import { resolve as resolve11 } from "node:path";
+import { resolve as resolve12 } from "node:path";
 
 // node_modules/@uipath/common/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
@@ -59091,7 +59091,7 @@ var {
 // package.json
 var package_default = {
   name: "@uipath/rpa-tool",
-  version: "1.198.1",
+  version: "1.198.2",
   description: "Tool for creating and managing UiPath RPA projects",
   keywords: [
     "uipcli-tool",
@@ -59234,7 +59234,7 @@ function attachWrapperOptions(cmd) {
 
 // src/commander-polyfill.ts
 if (!Command2.prototype.trackedAction) {
-  Command2.prototype.trackedAction = function(context, fn) {
+  Command2.prototype.trackedAction = function(context, fn, _properties) {
     return this.action(async (...args) => {
       try {
         await fn(...args);
@@ -59370,18 +59370,231 @@ var registerListInstancesCommand = (program3) => {
 };
 
 // src/commands/packager/analyze.ts
-import { isAbsolute as isAbsolute5, join as join9 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join11 } from "node:path";
+
+// src/telemetry/project-shape.ts
+import { readdirSync as readdirSync2, readFileSync } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+
+// src/telemetry/project-json-path.ts
+import { statSync } from "node:fs";
+import { basename as basename2, join as join3, resolve as resolve2 } from "node:path";
+function resolveProjectJsonPath(input) {
+  const abs = resolve2(input);
+  let stats;
+  try {
+    stats = statSync(abs);
+  } catch {
+    return;
+  }
+  if (stats.isDirectory()) {
+    return join3(abs, "project.json");
+  }
+  return basename2(abs).toLowerCase() === "project.json" ? abs : undefined;
+}
+
+// src/telemetry/project-shape.ts
+var MAX_FILES = 500;
+var MAX_WALK_MS = 50;
+var SKIP_DIRS = new Set(["obj", "bin", "node_modules"]);
+function countActivities(xamlPath) {
+  try {
+    const matches = readFileSync(xamlPath, "utf8").match(/WorkflowViewState\.IdRef=/g);
+    return matches ? matches.length : 0;
+  } catch {
+    return 0;
+  }
+}
+function isTestCaseEntry(entry) {
+  if (typeof entry !== "object" || entry === null) {
+    return false;
+  }
+  const record = entry;
+  if (record.isTestCase === true) {
+    return true;
+  }
+  if (typeof record.testCaseId === "string" && record.testCaseId.length > 0) {
+    return true;
+  }
+  for (const key of ["testCaseType", "editorType", "fileType", "type"]) {
+    const value = record[key];
+    if (typeof value === "string" && /test/i.test(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function readManifestCounts(jsonPath) {
+  const counts = {};
+  let project;
+  try {
+    project = JSON.parse(readFileSync(jsonPath, "utf8"));
+  } catch {
+    return counts;
+  }
+  if (project.dependencies && typeof project.dependencies === "object") {
+    counts.dependencyCount = String(Object.keys(project.dependencies).length);
+  }
+  if (Array.isArray(project.entryPoints)) {
+    counts.entryPointCount = String(project.entryPoints.length);
+  }
+  const fileInfo = project.designOptions?.fileInfoCollection;
+  if (Array.isArray(fileInfo)) {
+    counts.testCaseCount = String(fileInfo.filter(isTestCaseEntry).length);
+  }
+  return counts;
+}
+function getProjectShapeProps(projectDirInput) {
+  if (!projectDirInput) {
+    return {};
+  }
+  const jsonPath = resolveProjectJsonPath(projectDirInput);
+  if (!jsonPath) {
+    return {};
+  }
+  const projectDir = dirname2(jsonPath);
+  const shape = readManifestCounts(jsonPath);
+  let fileCount = 0;
+  let workflowCount = 0;
+  let codedWorkflowCount = 0;
+  let activityCount = 0;
+  let truncated = false;
+  const start = performance.now();
+  const stack = [projectDir];
+  while (stack.length > 0 && !truncated) {
+    const dir = stack.pop();
+    if (dir === undefined) {
+      break;
+    }
+    let entries;
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (fileCount >= MAX_FILES || performance.now() - start > MAX_WALK_MS) {
+        truncated = true;
+        break;
+      }
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !SKIP_DIRS.has(entry.name)) {
+          stack.push(join4(dir, entry.name));
+        }
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      fileCount++;
+      const lower2 = entry.name.toLowerCase();
+      if (lower2.endsWith(".xaml")) {
+        workflowCount++;
+        activityCount += countActivities(join4(dir, entry.name));
+      } else if (lower2.endsWith(".cs")) {
+        codedWorkflowCount++;
+      }
+    }
+  }
+  shape.fileCount = String(fileCount);
+  shape.workflowCount = String(workflowCount);
+  shape.codedWorkflowCount = String(codedWorkflowCount);
+  shape.activityCount = String(activityCount);
+  if (truncated) {
+    shape.shapeTruncated = "true";
+  }
+  return shape;
+}
+
+// src/telemetry/studio-shaped-props.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// src/telemetry/authoring-session.ts
+import { hostname } from "node:os";
+
+// src/telemetry/identity-hash.ts
+import { createHash } from "node:crypto";
+function identityHash(value) {
+  return createHash("sha256").update(value.trim().toLowerCase()).digest("hex").slice(0, 16);
+}
+
+// src/telemetry/authoring-session.ts
+var SESSION_ID_ENV = "UIPATH_SESSION_ID";
+function getAuthoringSessionProps() {
+  const explicit = process.env[SESSION_ID_ENV];
+  if (explicit && explicit.trim().length > 0) {
+    return {
+      authoringSessionId: identityHash(explicit),
+      authoringSessionSource: "explicit"
+    };
+  }
+  try {
+    return {
+      authoringSessionId: identityHash(`${process.ppid}:${hostname()}`),
+      authoringSessionSource: "ppid"
+    };
+  } catch {
+    return {};
+  }
+}
+
+// src/telemetry/studio-shaped-props.ts
+var TELEMETRY_SOURCE = "rpa-tool";
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function readProjectFields(input) {
+  const path3 = resolveProjectJsonPath(input);
+  if (!path3) {
+    return {};
+  }
+  let project;
+  try {
+    project = JSON.parse(readFileSync2(path3, "utf8"));
+  } catch {
+    return {};
+  }
+  const fields = {};
+  const set = (key, value) => {
+    const str = asNonEmptyString(value);
+    if (str) {
+      fields[key] = str;
+    }
+  };
+  const projectId = asNonEmptyString(project.projectId);
+  if (projectId) {
+    fields.projectIdHash = identityHash(projectId);
+    const noDash = projectId.trim().toLowerCase().replaceAll("-", "");
+    if (/^[0-9a-f]{32}$/.test(noDash)) {
+      fields.projectIdNoDash = noDash;
+    }
+  }
+  set("targetFramework", project.targetFramework);
+  set("expressionLanguage", project.expressionLanguage);
+  set("projectType", project.designOptions?.outputType);
+  set("projectVersion", project.projectVersion);
+  return fields;
+}
+function buildStudioShapedProps(projectDir, extra) {
+  const fields = projectDir ? readProjectFields(projectDir) : {};
+  return {
+    source: TELEMETRY_SOURCE,
+    ...getAuthoringSessionProps(),
+    ...fields,
+    ...extra
+  };
+}
 
 // src/commands/packager/packager-shared.ts
 import {
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync4,
   rmSync as rmSync2,
-  statSync,
+  statSync as statSync2,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
-import { basename as basename5, dirname as dirname5, join as join8, resolve as resolve5 } from "node:path";
+import { basename as basename6, dirname as dirname6, join as join10, resolve as resolve6 } from "node:path";
 
 // src/load-packager-tool.ts
 async function loadPackagerTool() {
@@ -59401,7 +59614,7 @@ async function loadPackagerTool() {
 // src/resolution/orchestrator-restore-feeds.ts
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 var ORCHESTRATOR_RESTORE_FEEDS_ENV = "UIPATH_ORCHESTRATOR_RESTORE_FEEDS";
 var FEEDS_TIMEOUT_MS = 1e4;
 var LIBRARIES_PURPOSE = "Libraries";
@@ -59452,8 +59665,8 @@ async function fetchLibraryFeeds(orchestratorUrl, accessToken, tenantId, log) {
   return feeds.filter((f) => f.purpose === LIBRARIES_PURPOSE && !!f.feedUrl).map((f) => ({ Url: f.feedUrl, AccessToken: accessToken }));
 }
 function writeFeedsFile(feeds) {
-  const dir = mkdtempSync(join4(tmpdir4(), "uip-rpa-feeds-"));
-  const path4 = join4(dir, "nuget-feeds.json");
+  const dir = mkdtempSync(join6(tmpdir4(), "uip-rpa-feeds-"));
+  const path4 = join6(dir, "nuget-feeds.json");
   writeFileSync(path4, JSON.stringify(feeds));
   process.on("exit", () => {
     try {
@@ -59464,11 +59677,11 @@ function writeFeedsFile(feeds) {
 }
 
 // src/resolution/robot-bin-resolver.ts
-import { join as join5, posix, win32 } from "node:path";
+import { join as join7, posix, win32 } from "node:path";
 
 // src/resolution/resolver-deps.ts
 import { execFileSync as execFileSync5, spawn } from "node:child_process";
-import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync } from "node:fs";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 
 // src/ipc/IpcCall.ts
@@ -60087,7 +60300,7 @@ class IpcCall {
     const call = operation(this.proxy, this.ict);
     if (this.timeoutMs == null)
       return call;
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       let settled = false;
       const timer = setTimeout(() => {
         if (settled)
@@ -60100,7 +60313,7 @@ class IpcCall {
         if (!settled) {
           settled = true;
           clearTimeout(timer);
-          resolve3(val);
+          resolve4(val);
         }
       }, (err) => {
         if (!settled) {
@@ -60357,10 +60570,10 @@ var defaultResolverDeps = {
     return existsSync3(path4);
   },
   readFile(path4) {
-    return readFileSync(path4, "utf-8");
+    return readFileSync3(path4, "utf-8");
   },
   readDir(path4) {
-    return readdirSync2(path4);
+    return readdirSync3(path4);
   },
   resolveModule(specifier) {
     return createRequire4(import.meta.url).resolve(specifier);
@@ -60382,7 +60595,7 @@ var defaultResolverDeps = {
     child.unref();
   },
   sleep(ms) {
-    return new Promise((resolve3) => setTimeout(resolve3, ms));
+    return new Promise((resolve4) => setTimeout(resolve4, ms));
   },
   log(_message) {},
   fetchFeatures(pipeName) {
@@ -60409,7 +60622,7 @@ var HELM_EXE = process.platform === "win32" ? "UiPath.Studio.Helm.exe" : "UiPath
 // src/resolution/robot-bin-resolver.ts
 var LOCAL_ROBOT_FEEDS_ENV = "UIPATH_LOCAL_ROBOT_FEEDS";
 function robotNugetConfigPath(robotDir) {
-  return join5(robotDir, "NuGet.config");
+  return join7(robotDir, "NuGet.config");
 }
 var ROBOT_WINDOWS_MARKER = "UiRobot.exe";
 var ROBOT_MACOS_MARKER = "UiRobot.dll";
@@ -60477,7 +60690,7 @@ var MIN_BUNDLED_DOTNET_MAJOR = 8;
 function detectDotnetRuntimeMajor(dotnetRoot, deps) {
   let entries;
   try {
-    entries = deps.readDir(join5(dotnetRoot, "shared", "Microsoft.NETCore.App"));
+    entries = deps.readDir(join7(dotnetRoot, "shared", "Microsoft.NETCore.App"));
   } catch {
     return;
   }
@@ -60496,10 +60709,10 @@ function detectDotnetRuntimeMajor(dotnetRoot, deps) {
 function resolveBundledDotnet(robotDir, deps) {
   if (!robotDir)
     return;
-  const exePath = process.platform === "win32" ? join5(robotDir, "dotnet.exe") : join5(robotDir, "dotnet", "dotnet");
+  const exePath = process.platform === "win32" ? join7(robotDir, "dotnet.exe") : join7(robotDir, "dotnet", "dotnet");
   if (!deps.fileExists(exePath))
     return;
-  const dotnetRoot = process.platform === "win32" ? robotDir : join5(robotDir, "dotnet");
+  const dotnetRoot = process.platform === "win32" ? robotDir : join7(robotDir, "dotnet");
   const runtimeMajor = detectDotnetRuntimeMajor(dotnetRoot, deps);
   if (runtimeMajor === undefined || runtimeMajor < MIN_BUNDLED_DOTNET_MAJOR) {
     const reason = runtimeMajor === undefined ? "could not determine its .NET runtime version" : `highest .NET runtime major ${runtimeMajor} is below the required ${MIN_BUNDLED_DOTNET_MAJOR}`;
@@ -60570,6 +60783,55 @@ async function resolveSessionConnection() {
   }
 }
 
+// src/telemetry/failure-classification.ts
+var NUGET_MISSING = /\bNU110[12]\b/;
+var COMPILER_DIAGNOSTIC = /\b(?:CS|BC)[0-9]{3,5}\b/;
+function classifyFailure(signal) {
+  if (signal.exitCode === 130) {
+    return "user_cancelled";
+  }
+  if (signal.isFileLock || signal.errorCode === "permission_denied") {
+    return "internal";
+  }
+  const codes = `${signal.errorCode ?? ""} ${signal.message ?? ""}`;
+  if (NUGET_MISSING.test(codes)) {
+    return "missing_dependency";
+  }
+  if (COMPILER_DIAGNOSTIC.test(codes)) {
+    return "validation";
+  }
+  return "unknown";
+}
+function extractRunExceptionType(rawResult) {
+  let parsed;
+  try {
+    parsed = JSON.parse(rawResult);
+  } catch {
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return;
+  }
+  const record = parsed;
+  const direct = asTypeName(record.ExceptionType ?? record.exceptionType);
+  if (direct) {
+    return direct;
+  }
+  const debugDetails = record.DebugDetails ?? record.debugDetails;
+  if (typeof debugDetails === "string") {
+    try {
+      const details = JSON.parse(debugDetails);
+      return asTypeName(details.ExceptionType ?? details.exceptionType);
+    } catch {
+      return;
+    }
+  }
+  return;
+}
+function asTypeName(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
 // src/commands/packager/packager-shared.ts
 var LOG_LEVEL_NAMES = ["Debug", "Info", "Warn", "Error"];
 var GOVERNANCE_FILE_TYPES = ["Default", "AutomationOps", "Studio"];
@@ -60609,22 +60871,22 @@ async function buildBaseOptions(opts) {
   return options;
 }
 function resolveProjectInput(projectDir) {
-  const abs = resolve5(projectDir);
+  const abs = resolve6(projectDir);
   let stats;
   try {
-    stats = statSync(abs);
+    stats = statSync2(abs);
   } catch {
     return abs;
   }
   if (!stats.isFile()) {
     return abs;
   }
-  const fileName = basename5(abs).toLowerCase();
+  const fileName = basename6(abs).toLowerCase();
   if (fileName === "project.json") {
-    return dirname5(abs);
+    return dirname6(abs);
   }
   if (fileName.endsWith(".uip")) {
-    return new Uint8Array(readFileSync2(abs));
+    return new Uint8Array(readFileSync4(abs));
   }
   throw new Error(`Unsupported project input: ${abs}. Provide a project directory, project.json file, or .uip archive.`);
 }
@@ -60632,8 +60894,8 @@ function createTemporaryFeedsConfig(feeds) {
   if (feeds.length === 0) {
     return;
   }
-  const directory = mkdtempSync2(join8(tmpdir7(), "rpa-tool-nuget-"));
-  const path4 = join8(directory, "nuget-feeds.json");
+  const directory = mkdtempSync2(join10(tmpdir7(), "rpa-tool-nuget-"));
+  const path4 = join10(directory, "nuget-feeds.json");
   try {
     writeFileSync2(path4, JSON.stringify(feeds));
   } catch (error) {
@@ -60654,7 +60916,7 @@ function cleanupTemporaryFeedsConfig(config) {
 function readFeedSourcesFromFile(path4) {
   let raw;
   try {
-    raw = readFileSync2(path4, "utf8");
+    raw = readFileSync4(path4, "utf8");
   } catch {
     return null;
   }
@@ -60717,7 +60979,7 @@ async function runPackagerCommand(opts, config) {
     OutputFormatter.error(new FailureOutput("Failure", `${config.label} failed: project directory must not be empty.`, config.hint));
     return false;
   }
-  const projectDir = resolve5(rawProjectDir);
+  const projectDir = resolve6(rawProjectDir);
   opts = { ...opts, projectDir };
   const LOGGER_LEVELS = {
     Debug: LogLevel.DEBUG,
@@ -60754,11 +61016,24 @@ async function runPackagerCommand(opts, config) {
       return true;
     }
     const rawFailure = result.message ?? (result.errorCode ? `Error code: ${result.errorCode}` : "Unknown error");
-    OutputFormatter.error(detectLockedProjectFilesFailure(config.label, rawFailure) ?? new FailureOutput("Failure", `${config.label} failed: ${rawFailure}`, config.hint));
+    const lockFailure = detectLockedProjectFilesFailure(config.label, rawFailure);
+    const failure = lockFailure ?? new FailureOutput("Failure", `${config.label} failed: ${rawFailure}`, config.hint);
+    failure.TelemetryErrorClass = classifyFailure({
+      errorCode: result.errorCode,
+      message: rawFailure,
+      isFileLock: lockFailure !== null
+    });
+    OutputFormatter.error(failure);
     return false;
   } catch (error) {
     const rawFailure = error instanceof Error ? error.message : String(error);
-    OutputFormatter.error(detectLockedProjectFilesFailure(config.label, rawFailure) ?? new FailureOutput("Failure", `${config.label} failed: ${rawFailure}`, config.hint));
+    const lockFailure = detectLockedProjectFilesFailure(config.label, rawFailure);
+    const failure = lockFailure ?? new FailureOutput("Failure", `${config.label} failed: ${rawFailure}`, config.hint);
+    failure.TelemetryErrorClass = classifyFailure({
+      message: rawFailure,
+      isFileLock: lockFailure !== null
+    });
+    OutputFormatter.error(failure);
     return false;
   } finally {
     cleanupTemporaryFeedsConfig(temporaryFeedsConfig);
@@ -60797,22 +61072,30 @@ function registerAnalyzeCommand(program4) {
       isSuccessfulResult: (result) => result.isSuccess || extractFindings(result).length > 0,
       formatSuccess: (result) => {
         const findings = extractFindings(result);
+        const summary = summarizeFindings(findings);
+        emitAnalyzeResult(opts.projectDir, findings, summary);
         return {
           Success: true,
-          Summary: summarizeFindings(findings),
+          Summary: summary,
           Findings: findings
         };
       }
     });
     if (!success)
       processContext.exit(1);
+  }, (projectDir, opts) => {
+    const dir = resolveProjectDir(projectDir, opts);
+    return buildStudioShapedProps(dir, {
+      action: "analyze",
+      ...getProjectShapeProps(dir)
+    });
   });
 }
 function resolveProjectDir(projectDir, opts) {
   if (!opts.repositoryPath || isAbsolute5(projectDir)) {
     return projectDir;
   }
-  return join9(opts.repositoryPath, projectDir);
+  return join11(opts.repositoryPath, projectDir);
 }
 function resolveGovernanceFileType(opts) {
   if (opts.policyFileType)
@@ -60906,6 +61189,29 @@ function summarizeFindings(findings) {
   }
   return summary;
 }
+function emitAnalyzeResult(projectDir, findings, summary) {
+  try {
+    const topRuleIds = distinctRuleIds(findings).slice(0, 10).join(",");
+    telemetry.trackEvent("uip.rpa.analyze.result", redactProperties({
+      ...buildStudioShapedProps(projectDir, { action: "analyze" }),
+      findingCount: String(findings.length),
+      errorCount: String(summary.Critical + summary.Error),
+      warningCount: String(summary.Warning),
+      infoCount: String(summary.Information + summary.Verbose),
+      ...topRuleIds ? { topRuleIds } : {}
+    }));
+  } catch {}
+}
+function distinctRuleIds(findings) {
+  const ids = new Set;
+  for (const finding of findings) {
+    const id = finding.ErrorCode || finding.RuleName;
+    if (id) {
+      ids.add(id);
+    }
+  }
+  return [...ids];
+}
 function normalizeLevel(value) {
   switch (value.toLowerCase()) {
     case "critical":
@@ -60964,11 +61270,14 @@ function registerBuildCommand(program4) {
     });
     if (!success)
       processContext.exit(1);
-  });
+  }, (projectDir) => buildStudioShapedProps(projectDir, {
+    action: "build",
+    ...getProjectShapeProps(projectDir)
+  }));
 }
 
 // src/commands/packager/pack.ts
-import { isAbsolute as isAbsolute6, resolve as resolve6 } from "node:path";
+import { isAbsolute as isAbsolute6, resolve as resolve7 } from "node:path";
 function registerPackCommand(program4) {
   const cmd = program4.command("pack").description("Pack a UiPath project into a .nupkg (compiles, validates, and bundles).");
   cmd.argument("<project-dir>", "Path to the UiPath project directory, project.json file, or .uip archive").argument("<output-path>", "Directory where .nupkg is written");
@@ -61029,6 +61338,7 @@ function registerPackCommand(program4) {
         const firstPackage = packages[0] ?? "";
         const packagePath = firstPackage ? absolutePath(firstPackage) : "";
         const packageMetadata = inferPackageMetadata(packagePath, opts.packageVersion);
+        emitPackResult(opts.projectDir, packageMetadata);
         return {
           Success: true,
           Packages: packages,
@@ -61042,10 +61352,22 @@ function registerPackCommand(program4) {
     });
     if (!success)
       processContext.exit(1);
-  });
+  }, (projectDir) => buildStudioShapedProps(projectDir, {
+    action: "pack",
+    ...getProjectShapeProps(projectDir)
+  }));
 }
 function absolutePath(filePath) {
-  return isAbsolute6(filePath) ? filePath : resolve6(filePath);
+  return isAbsolute6(filePath) ? filePath : resolve7(filePath);
+}
+function emitPackResult(projectDir, meta) {
+  try {
+    telemetry.trackEvent("uip.rpa.pack.result", redactProperties({
+      ...buildStudioShapedProps(projectDir, { action: "pack" }),
+      ...meta.packageName ? { packageIdHash: identityHash(meta.packageName) } : {},
+      ...meta.packageVersion ? { packageVersion: meta.packageVersion } : {}
+    }));
+  } catch {}
 }
 function inferPackageMetadata(packagePath, explicitVersion) {
   const packageVersion = explicitVersion || inferPackageVersion(packagePath);
@@ -61075,10 +61397,10 @@ function packageFileStem(packagePath) {
 // src/commands/packager/restore.ts
 import { mkdtempSync as mkdtempSync3 } from "node:fs";
 import { tmpdir as tmpdir8 } from "node:os";
-import { isAbsolute as isAbsolute7, join as join10, relative as relative5, resolve as resolve7 } from "node:path";
+import { isAbsolute as isAbsolute7, join as join12, relative as relative5, resolve as resolve8 } from "node:path";
 function isWithinOrEqual(parent, candidate) {
   const norm = process.platform === "win32" ? (p) => p.toLowerCase() : (p) => p;
-  const rel = relative5(norm(resolve7(parent)), norm(resolve7(candidate)));
+  const rel = relative5(norm(resolve8(parent)), norm(resolve8(candidate)));
   if (rel === "")
     return true;
   return !rel.startsWith("..") && !isAbsolute7(rel);
@@ -61097,7 +61419,7 @@ function registerRestoreCommand(program4) {
       label: "Restore",
       hint: "Check project path and NuGet configuration.",
       execute: async (packager, options) => {
-        options.outputPath = outputPath ?? mkdtempSync3(join10(tmpdir8(), "rpa-tool-restore-"));
+        options.outputPath = outputPath ?? mkdtempSync3(join12(tmpdir8(), "rpa-tool-restore-"));
         return packager.restoreProjectAsync(options);
       }
     });
@@ -61116,7 +61438,7 @@ function kebabToCamel(name) {
 }
 
 // src/cli/structured-input.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 
 class StructuredInputError extends Error {
   constructor(message) {
@@ -61129,7 +61451,7 @@ var defaultStructuredValueReader = {
   readText(path4) {
     let bytes;
     try {
-      bytes = readFileSync3(path4);
+      bytes = readFileSync5(path4);
     } catch (cause) {
       throw new StructuredInputError(`Cannot read file '${path4}': ${cause instanceof Error ? cause.message : String(cause)}. ` + `File paths resolve relative to the current directory.`);
     }
@@ -61954,7 +62276,53 @@ var CLI_DERIVED_COMMANDS = [
   }
 ];
 
+// src/telemetry/tool-enrichment.ts
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function globalProjectDir() {
+  return extractArg(process.argv, "project-dir", process.cwd()) ?? process.cwd();
+}
+var TOOL_ENRICHERS = {
+  [ToolName.RunFile]: (opts, lockedCommand) => buildStudioShapedProps(globalProjectDir(), {
+    action: "run",
+    runKind: String(lockedCommand ?? opts.command ?? "StartExecution")
+  }),
+  [ToolName.CreateProject]: (opts) => {
+    const extra = { action: "create" };
+    const targetFramework = asString(opts.targetFramework);
+    if (targetFramework)
+      extra.targetFramework = targetFramework;
+    const expressionLanguage = asString(opts.expressionLanguage);
+    if (expressionLanguage)
+      extra.expressionLanguage = expressionLanguage;
+    const templateId = asString(opts.templateId);
+    if (templateId)
+      extra.templateId = templateId;
+    return buildStudioShapedProps(undefined, extra);
+  },
+  [ToolName.OpenProject]: (opts) => buildStudioShapedProps(asString(opts.projectDir) ?? globalProjectDir(), {
+    action: "handoff-to-studio"
+  }),
+  [ToolName.GetErrors]: () => buildStudioShapedProps(globalProjectDir(), { action: "diagnose" }),
+  [ToolName.InstallOrUpdatePackages]: () => buildStudioShapedProps(globalProjectDir(), {
+    action: "manage-dependencies"
+  })
+};
+function hasToolEnricher(toolName) {
+  return Object.hasOwn(TOOL_ENRICHERS, toolName);
+}
+function studioShapedPropsForTool(toolName, opts, lockedCommand) {
+  return TOOL_ENRICHERS[toolName]?.(opts, lockedCommand);
+}
+
 // src/commands/register-mcp-commands.ts
+function studioShapedPropsCallback(toolName, lockedCommand) {
+  if (!hasToolEnricher(toolName)) {
+    return;
+  }
+  return (opts) => studioShapedPropsForTool(toolName, opts, lockedCommand) ?? {};
+}
 async function registerMcpCommands(program4, client) {
   const tools = await client.listTools();
   const groupCache = new Map;
@@ -62011,7 +62379,7 @@ function registerDerivedCommand(program4, baseTool, derived, cache, client) {
     if (output.exitCode !== 0) {
       processContext.exit(output.exitCode);
     }
-  });
+  }, studioShapedPropsCallback(baseTool.name, derived.lockedArgs.command));
 }
 function getOrCreateGroup(program4, segments, cache) {
   let parent = program4;
@@ -62054,7 +62422,7 @@ function registerSubcommand(program4, tool, cliCmd, hidden, client) {
     if (output.exitCode !== 0) {
       processContext.exit(output.exitCode);
     }
-  });
+  }, studioShapedPropsCallback(tool.name));
 }
 function applyStructuredArgErrorHint(sub3, flags) {
   const structured = flags.filter((f) => f.typeHint === "json" || f.typeHint === "jsonArray");
@@ -62135,7 +62503,7 @@ function addFlagToCommand(sub3, flag) {
 }
 
 // src/resolution/helm-npm-resolver.ts
-import { dirname as dirname6, join as join11 } from "node:path";
+import { dirname as dirname7, join as join13 } from "node:path";
 function helmPackageName() {
   const key = `${process.platform}-${process.arch}`;
   switch (key) {
@@ -62158,7 +62526,7 @@ function helmPackageName() {
 function resolveHelmFromNpm(deps) {
   const localDir = process.env.HELM_LOCAL_DIR;
   if (localDir) {
-    const helmExePath2 = join11(localDir, HELM_EXE);
+    const helmExePath2 = join13(localDir, HELM_EXE);
     if (deps.fileExists(helmExePath2)) {
       deps.log(`Using local Helm from HELM_LOCAL_DIR: ${localDir}`);
       return { toolsDir: localDir, helmExePath: helmExePath2 };
@@ -62174,8 +62542,8 @@ function resolveHelmFromNpm(deps) {
     const detail = err2 instanceof Error ? err2.message : String(err2);
     throw new Error(`Helm binary package '${packageName}' is not installed. It installs ` + "automatically as an optionalDependency of @uipath/rpa-tool for " + `${process.platform}/${process.arch}. If you installed with ` + "--omit=optional or --no-optional, reinstall without that flag, or " + `set HELM_LOCAL_DIR to a Helm tools directory. (${detail})`);
   }
-  const toolsDir = join11(dirname6(packageJsonPath), "tools");
-  const helmExePath = join11(toolsDir, HELM_EXE);
+  const toolsDir = join13(dirname7(packageJsonPath), "tools");
+  const helmExePath = join13(toolsDir, HELM_EXE);
   if (!deps.fileExists(helmExePath)) {
     throw new Error(`Helm binary not found at ${helmExePath} inside package ` + `'${packageName}'. The package may be corrupt or incomplete.`);
   }
@@ -62218,17 +62586,17 @@ import {
   existsSync as existsSync6,
   mkdirSync as mkdirSync2,
   openSync as openSync2,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync4,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync6,
   renameSync,
   rmSync as rmSync3,
-  statSync as statSync2,
+  statSync as statSync3,
   unlinkSync as unlinkSync2,
   utimesSync,
   writeSync
 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join14 } from "node:path";
 var DEFAULT_MAX_SLOTS = 3;
 var READY_MARKER = ".ready";
 var STAGING_DIR = ".staging";
@@ -62242,20 +62610,20 @@ function resolveHelmCacheRoot() {
   if (override)
     return override;
   if (process.platform === "win32") {
-    const base = process.env.LOCALAPPDATA ?? join12(homedir5(), "AppData", "Local");
-    return join12(base, "UiPath", "Helm");
+    const base = process.env.LOCALAPPDATA ?? join14(homedir5(), "AppData", "Local");
+    return join14(base, "UiPath", "Helm");
   }
   if (process.platform === "darwin") {
-    return join12(homedir5(), "Library", "Caches", "UiPath", "Helm");
+    return join14(homedir5(), "Library", "Caches", "UiPath", "Helm");
   }
-  const xdg = process.env.XDG_CACHE_HOME ?? join12(homedir5(), ".cache");
-  return join12(xdg, "uipath", "helm");
+  const xdg = process.env.XDG_CACHE_HOME ?? join14(homedir5(), ".cache");
+  return join14(xdg, "uipath", "helm");
 }
 function slotName(version) {
   return version.replace(/[\\/]/g, "_");
 }
 function helmSlotDir(root, version) {
-  return join12(root, slotName(version));
+  return join14(root, slotName(version));
 }
 function touch(path4) {
   try {
@@ -62271,7 +62639,7 @@ function tryAcquireLock(lockPath, log) {
     return true;
   } catch {
     try {
-      const raw = readFileSync4(lockPath, "utf-8");
+      const raw = readFileSync6(lockPath, "utf-8");
       const { pid, ts } = JSON.parse(raw);
       const dead = typeof pid === "number" && !isProcessAlive(pid);
       const old = typeof ts === "number" && Date.now() - ts > STALE_LOCK_MS;
@@ -62290,14 +62658,14 @@ function releaseLock(lockPath) {
   } catch {}
 }
 function publishSlot(sourceToolsDir, slot, root, version, log) {
-  const stagingRoot = join12(root, STAGING_DIR);
+  const stagingRoot = join14(root, STAGING_DIR);
   mkdirSync2(stagingRoot, { recursive: true });
-  const staging = join12(stagingRoot, `${slotName(version)}-${process.pid}-${Date.now().toString(36)}`);
+  const staging = join14(stagingRoot, `${slotName(version)}-${process.pid}-${Date.now().toString(36)}`);
   rmSync3(staging, { recursive: true, force: true });
   log(`Materializing Helm slot ${slot} from ${sourceToolsDir}`);
   cpSync(sourceToolsDir, staging, { recursive: true });
   const now = new Date;
-  const markerFd = openSync2(join12(staging, READY_MARKER), "w");
+  const markerFd = openSync2(join14(staging, READY_MARKER), "w");
   writeSync(markerFd, now.getTime().toString());
   closeSync2(markerFd);
   rmSync3(slot, { recursive: true, force: true });
@@ -62308,14 +62676,14 @@ function publishSlot(sourceToolsDir, slot, root, version, log) {
   }
 }
 function evictSlots(root, targetSlot, liveBinDirs, maxSlots, log) {
-  const entries = readdirSync3(root, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== STAGING_DIR).map((e) => join12(root, e.name)).filter((dir) => existsSync6(join12(dir, READY_MARKER)));
+  const entries = readdirSync4(root, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== STAGING_DIR).map((e) => join14(root, e.name)).filter((dir) => existsSync6(join14(dir, READY_MARKER)));
   if (entries.length <= maxSlots)
     return;
   const targetNorm = normalizePath(targetSlot);
   const now = Date.now();
   const readyMtime = (dir) => {
     try {
-      return statSync2(join12(dir, READY_MARKER)).mtimeMs;
+      return statSync3(join14(dir, READY_MARKER)).mtimeMs;
     } catch {
       return 0;
     }
@@ -62340,20 +62708,20 @@ function evictSlots(root, targetSlot, liveBinDirs, maxSlots, log) {
   }
 }
 function cleanupStale(root) {
-  const stagingRoot = join12(root, STAGING_DIR);
+  const stagingRoot = join14(root, STAGING_DIR);
   let entries;
   try {
-    entries = readdirSync3(stagingRoot);
+    entries = readdirSync4(stagingRoot);
   } catch {
     return;
   }
   const now = Date.now();
   for (const name of entries) {
-    const dir = join12(stagingRoot, name);
+    const dir = join14(stagingRoot, name);
     const parts = name.split("-");
     const pid = Number.parseInt(parts[parts.length - 2] ?? "", 10);
     try {
-      const age = now - statSync2(dir).mtimeMs;
+      const age = now - statSync3(dir).mtimeMs;
       const ownerDead = Number.isNaN(pid) || !isProcessAlive(pid);
       if (ownerDead && age > STALE_STAGING_MS) {
         rmSync3(dir, { recursive: true, force: true });
@@ -62367,14 +62735,14 @@ async function ensureHelmSlot(opts) {
   const root = opts.cacheRoot ?? resolveHelmCacheRoot();
   const maxSlots = opts.maxSlots ?? DEFAULT_MAX_SLOTS;
   const slot = helmSlotDir(root, opts.version);
-  const readyPath = join12(slot, READY_MARKER);
+  const readyPath = join14(slot, READY_MARKER);
   const fromSource = () => ({
     toolsDir: opts.sourceToolsDir,
-    helmExePath: join12(opts.sourceToolsDir, opts.helmExeName)
+    helmExePath: join14(opts.sourceToolsDir, opts.helmExeName)
   });
   const fromSlot = () => {
     touch(readyPath);
-    return { toolsDir: slot, helmExePath: join12(slot, opts.helmExeName) };
+    return { toolsDir: slot, helmExePath: join14(slot, opts.helmExeName) };
   };
   if (existsSync6(readyPath)) {
     log(`Using cached Helm slot: ${slot}`);
@@ -62386,7 +62754,7 @@ async function ensureHelmSlot(opts) {
     log(`Cannot create Helm cache root ${root}; running from source.`);
     return fromSource();
   }
-  const lockPath = join12(root, `${slotName(opts.version)}.lock`);
+  const lockPath = join14(root, `${slotName(opts.version)}.lock`);
   const deadline = Date.now() + MAX_WAIT_MS;
   while (true) {
     if (existsSync6(readyPath))
@@ -62422,7 +62790,7 @@ async function ensureHelmSlot(opts) {
 }
 
 // src/resolution/studio-bin-resolver.ts
-import { join as join13, win32 as win322 } from "node:path";
+import { join as join15, win32 as win322 } from "node:path";
 function getProcessExecutablePath(pid, deps) {
   const exePath = deps.executeCommand("powershell", [
     "-NoProfile",
@@ -62517,7 +62885,7 @@ function getStudioFileVersion(binDir, deps) {
   }
 }
 function readManifest(binDir, filename, deps) {
-  const manifestPath = join13(binDir, filename);
+  const manifestPath = join15(binDir, filename);
   try {
     const content = deps.readFile(manifestPath);
     return JSON.parse(content);
@@ -62530,7 +62898,7 @@ function readInteropManifest(binDir, deps) {
   return readManifest(binDir, INTEROP_MANIFEST, deps);
 }
 function validateInteropSupport(binDir, deps) {
-  const manifestPath = join13(binDir, INTEROP_MANIFEST);
+  const manifestPath = join15(binDir, INTEROP_MANIFEST);
   if (!deps.fileExists(manifestPath)) {
     const version = getStudioFileVersion(binDir, deps);
     throw new Error(`Studio ${version} does not support rpa-tool. Please upgrade to the latest version of UiPath Studio.`);
@@ -62538,8 +62906,8 @@ function validateInteropSupport(binDir, deps) {
 }
 
 // src/resolution/studio-startup.ts
-import { chmodSync, statSync as statSync3 } from "node:fs";
-import { join as join14 } from "node:path";
+import { chmodSync, statSync as statSync4 } from "node:fs";
+import { join as join16 } from "node:path";
 async function waitForInstanceAvailability(processId, deps, timeoutMs = DEFAULT_TIMEOUT_MS2) {
   const deadline = Date.now() + timeoutMs;
   let pollCount = 0;
@@ -62568,7 +62936,7 @@ async function waitForInstanceAvailability(processId, deps, timeoutMs = DEFAULT_
 async function startStudioAndWait(binDir, deps, timeoutMs = DEFAULT_TIMEOUT_MS2) {
   const existingPids = new Set(deps.discoverInstances().instances.map((i2) => i2.processId));
   deps.log(`Existing Studio PIDs: [${[...existingPids].join(", ")}]`);
-  const exePath = join14(binDir, STUDIO_EXE);
+  const exePath = join16(binDir, STUDIO_EXE);
   deps.log(`Starting Studio: ${exePath}`);
   deps.spawnDetached(exePath, []);
   const deadline = Date.now() + timeoutMs;
@@ -62603,7 +62971,7 @@ function ensureExecutable(exePath, log) {
   if (process.platform === "win32")
     return;
   try {
-    chmodSync(exePath, statSync3(exePath).mode | 73);
+    chmodSync(exePath, statSync4(exePath).mode | 73);
   } catch (err2) {
     log(`Could not set +x on ${exePath}: ${err2 instanceof Error ? err2.message : String(err2)}`);
   }
@@ -63279,8 +63647,8 @@ function createInterpolator(values) {
 }
 
 // src/external-cli/discovery.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+import { join as join17 } from "node:path";
 
 class MissingAllDependenciesError extends Error {
   projectDir;
@@ -63312,10 +63680,10 @@ class PackageRootMissingError extends Error {
 }
 var defaultDeps = {
   fileExists: existsSync7,
-  readFile: (path4) => readFileSync5(path4, "utf-8")
+  readFile: (path4) => readFileSync7(path4, "utf-8")
 };
 function discoverPackageRoot(params, deps = defaultDeps) {
-  const depsFile = join15(params.projectDir, ".local", "AllDependencies.json");
+  const depsFile = join17(params.projectDir, ".local", "AllDependencies.json");
   if (!deps.fileExists(depsFile)) {
     throw new MissingAllDependenciesError(params.projectDir, depsFile);
   }
@@ -63325,7 +63693,7 @@ function discoverPackageRoot(params, deps = defaultDeps) {
   if (packageFolders.length === 0) {
     throw new Error("No packageFolders found in AllDependencies.json.");
   }
-  const packageRoot = join15(packageFolders[0], library.path);
+  const packageRoot = join17(packageFolders[0], library.path);
   if (!deps.fileExists(packageRoot)) {
     throw new PackageRootMissingError(packageRoot);
   }
@@ -63347,23 +63715,23 @@ function findLibraryEntry(allDeps, packageId) {
 import {
   existsSync as existsSync8,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync6,
-  statSync as statSync4,
+  readFileSync as readFileSync8,
+  statSync as statSync5,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { dirname as dirname7, join as join16 } from "node:path";
+import { dirname as dirname8, join as join18 } from "node:path";
 var defaultDeps2 = {
   fileExists: existsSync8,
-  readFile: (path4) => readFileSync6(path4, "utf-8"),
+  readFile: (path4) => readFileSync8(path4, "utf-8"),
   writeFile: (path4, content) => {
-    mkdirSync3(dirname7(path4), { recursive: true });
+    mkdirSync3(dirname8(path4), { recursive: true });
     writeFileSync3(path4, content, "utf-8");
   },
-  getModifiedTime: (path4) => statSync4(path4).mtimeMs
+  getModifiedTime: (path4) => statSync5(path4).mtimeMs
 };
 function discoverPackageRootCached(params, deps = defaultDeps2) {
-  const cacheFilePath = join16(params.projectDir, ".local", "rpa-tool", `${params.commandName}.json`);
-  const allDepsPath = join16(params.projectDir, ".local", "AllDependencies.json");
+  const cacheFilePath = join18(params.projectDir, ".local", "rpa-tool", `${params.commandName}.json`);
+  const allDepsPath = join18(params.projectDir, ".local", "AllDependencies.json");
   let entry;
   if (deps.fileExists(cacheFilePath)) {
     try {
@@ -63419,7 +63787,7 @@ function mergeEnv(extra) {
   return { ...process.env, ...extra };
 }
 function spawnForward(exePath, args, env) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const child = spawn3(exePath, args, {
       stdio: "inherit",
       env: mergeEnv(env)
@@ -63428,12 +63796,12 @@ function spawnForward(exePath, args, env) {
       reject(new Error(`Failed to spawn '${exePath}': ${err2.message}`));
     });
     child.on("close", (code) => {
-      resolve8(code ?? 1);
+      resolve9(code ?? 1);
     });
   });
 }
 function spawnCapture(exePath, args, env) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const child = spawn3(exePath, args, {
       stdio: ["inherit", "pipe", "pipe"],
       env: mergeEnv(env)
@@ -63449,7 +63817,7 @@ function spawnCapture(exePath, args, env) {
       reject(new Error(`Failed to spawn '${exePath}': ${err2.message}`));
     });
     child.on("close", (code) => {
-      resolve8({
+      resolve9({
         exitCode: code ?? 1,
         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr: Buffer.concat(stderrChunks).toString("utf8")
@@ -63460,12 +63828,12 @@ function spawnCapture(exePath, args, env) {
 
 // src/external-cli/manifest-reader.ts
 import { execFileSync as execFileSync8 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "node:fs";
+import { join as join19 } from "node:path";
 var MANIFEST_FILENAME = "cli.manifest.json";
 var defaultDeps3 = {
   fileExists: existsSync9,
-  readFile: (path4) => readFileSync7(path4, "utf-8")
+  readFile: (path4) => readFileSync9(path4, "utf-8")
 };
 function isRosettaTranslated() {
   try {
@@ -63517,7 +63885,7 @@ function resolveExecutableRelativePath(manifest, manifestPath, platformKey) {
   throw new Error(`Manifest ${manifestPath} declares neither 'tool.executable' nor 'tool.executables'.`);
 }
 function readCliManifest(packageRoot, deps = defaultDeps3) {
-  const manifestPath = join17(packageRoot, MANIFEST_FILENAME);
+  const manifestPath = join19(packageRoot, MANIFEST_FILENAME);
   if (!deps.fileExists(manifestPath)) {
     throw new Error(`CLI manifest not found at ${manifestPath}. ` + `Ensure the package includes a ${MANIFEST_FILENAME} file.`);
   }
@@ -63532,7 +63900,7 @@ function readCliManifest(packageRoot, deps = defaultDeps3) {
   }
   const platformKey = (deps.getPlatformKey ?? getCurrentPlatformKey)();
   const relExe = resolveExecutableRelativePath(manifest, manifestPath, platformKey);
-  const exePath = join17(packageRoot, relExe);
+  const exePath = join19(packageRoot, relExe);
   if (!deps.fileExists(exePath)) {
     throw new Error(`Executable not found at ${exePath} as declared in ${manifestPath}.`);
   }
@@ -67288,19 +67656,19 @@ var baseOpen5 = async (options) => {
   }
   const subprocess = childProcess35.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve9(subprocess);
+        resolve10(subprocess);
       });
     });
   }
   if (isFallbackAttempt) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       subprocess.once("error", reject);
       subprocess.once("spawn", () => {
         subprocess.once("close", (exitCode) => {
@@ -67310,17 +67678,17 @@ var baseOpen5 = async (options) => {
             return;
           }
           subprocess.unref();
-          resolve9(subprocess);
+          resolve10(subprocess);
         });
       });
     });
   }
   subprocess.unref();
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     subprocess.once("error", reject);
     subprocess.once("spawn", () => {
       subprocess.off("error", reject);
-      resolve9(subprocess);
+      resolve10(subprocess);
     });
   });
 };
@@ -75396,7 +75764,7 @@ function getDefaultActivityXamlTool(session) {
 
 // src/tools/local/get-errors.ts
 import { existsSync as existsSync11 } from "node:fs";
-import { isAbsolute as isAbsolute9, resolve as resolve9 } from "node:path";
+import { isAbsolute as isAbsolute9, resolve as resolve10 } from "node:path";
 var SEVERITIES = ["error", "warning", "info", "verbose"];
 var LEVEL_BY_NAME = Object.fromEntries(SEVERITIES.map((name, i3) => [name, i3 + 1]));
 var NAME_BY_LEVEL = Object.fromEntries(SEVERITIES.map((name, i3) => [i3 + 1, name]));
@@ -75454,7 +75822,7 @@ function resolveTargetedFile(filePath, projectDir) {
   if (isAbsolute9(filePath)) {
     return filePath;
   }
-  return projectDir !== undefined ? resolve9(projectDir, filePath) : undefined;
+  return projectDir !== undefined ? resolve10(projectDir, filePath) : undefined;
 }
 function getErrorsTool(session) {
   return createToolHandler(session, {
@@ -76688,6 +77056,22 @@ class HelmRunService {
 }
 
 // src/tools/local/run-file.ts
+function emitRunExceptionType(resultText, projectDir) {
+  if (!resultText) {
+    return;
+  }
+  try {
+    const exceptionType = extractRunExceptionType(resultText);
+    if (!exceptionType) {
+      return;
+    }
+    const dir = projectDir ?? extractArg(process.argv, "project-dir", process.cwd());
+    telemetry.trackEvent("uip.rpa.run.result", redactProperties({
+      ...buildStudioShapedProps(dir, { action: "run" }),
+      exceptionType
+    }));
+  } catch {}
+}
 var EXPRESSION_COMMANDS = new Set(["TestActivity", "StartDebuggingFromHere"]);
 var START_COMMANDS2 = new Set([
   "StartExecution",
@@ -76815,7 +77199,7 @@ function runFileTool(session) {
       },
       required: ["filePath"]
     }
-  }, async (session2, args, _projectDir) => {
+  }, async (session2, args, projectDir) => {
     const command = args.command || "StartExecution";
     const filePath = args.filePath;
     const inputArguments = toJsonText(args.inputArguments);
@@ -76868,6 +77252,7 @@ function runFileTool(session) {
         }
         const helmRun = new HelmRunService(session2);
         const helmResult = await helmRun.runFile(filePath, inputArguments ?? "", logLevel, command, skipBuild, profiling, folderPath, waitTimeoutSeconds, breakpoints);
+        emitRunExceptionType(helmResult.runResult, projectDir);
         return {
           content: [
             {
@@ -76894,6 +77279,7 @@ function runFileTool(session) {
         }
       }
       const result = await session2.execute((instance) => instance.services.run.executeCommand(command, filePath, inputArguments ?? "", inputVariables ?? "", logLevel, profiling), { requiresProject: true });
+      emitRunExceptionType(result, projectDir);
       return {
         content: [
           {
@@ -77080,18 +77466,18 @@ function stopExecutionTool(hostStudioPid) {
 // src/tools/local/tm-config.ts
 import { existsSync as existsSync12 } from "node:fs";
 import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname9, join as join19, resolve as resolve10 } from "node:path";
+import { dirname as dirname10, join as join21, resolve as resolve11 } from "node:path";
 var TM_DATA_DIR = ".tmh";
 var TM_CONFIG_FILE = "config.json";
 var PROJECT_FILE2 = "project.json";
 function resolveProjectDir2(projectDir) {
-  return resolve10(projectDir ?? process.cwd());
+  return resolve11(projectDir ?? process.cwd());
 }
 function tmConfigPath(projectDir) {
-  return join19(projectDir, TM_DATA_DIR, TM_CONFIG_FILE);
+  return join21(projectDir, TM_DATA_DIR, TM_CONFIG_FILE);
 }
 function assertIsProject(projectDir) {
-  if (!existsSync12(join19(projectDir, PROJECT_FILE2))) {
+  if (!existsSync12(join21(projectDir, PROJECT_FILE2))) {
     throw new Error(`No UiPath project found at '${projectDir}' (missing ${PROJECT_FILE2}). ` + `Pass --project-dir pointing at the project root.`);
   }
 }
@@ -77109,7 +77495,7 @@ async function readTmSettings(projectDir) {
 }
 async function writeTmSettings(projectDir, settings) {
   const path4 = tmConfigPath(projectDir);
-  await mkdir6(dirname9(path4), { recursive: true });
+  await mkdir6(dirname10(path4), { recursive: true });
   const text = JSON.stringify(settings, (_key, value) => value === null ? undefined : value, 2);
   await writeFile6(path4, text, "utf8");
   return path4;
@@ -77123,7 +77509,7 @@ function isSameTestManagerServer(a, b) {
 }
 var TM_LIVE_RELOAD_STUDIO_VERSION = "26.0.197";
 function normalizeDir(path4) {
-  return resolve10(path4).replace(/[\\/]+$/, "").toLowerCase();
+  return resolve11(path4).replace(/[\\/]+$/, "").toLowerCase();
 }
 function findOpenStudioInstance(projectDir, instances) {
   const target = normalizeDir(projectDir);
@@ -77606,7 +77992,7 @@ var registerCommands = async (program5, options) => {
     hostStudioPid: process.env.UIPATH_STUDIO_PID ? parseInt(process.env.UIPATH_STUDIO_PID, 10) : undefined,
     timeoutSeconds: parseInt(extractArg(process.argv, "timeout", "300") ?? "300", 10)
   };
-  resolved.projectDir = resolve11(resolved.projectDir);
+  resolved.projectDir = resolve12(resolved.projectDir);
   mirrorRobotDirToEnv(resolved.robotDir);
   if (!options) {
     const displayDefaults = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/rpa-tool",
-  "version": "1.198.1",
+  "version": "1.198.2",
   "description": "Tool for creating and managing UiPath RPA projects",
   "keywords": [
     "uipcli-tool",
@@ -59,11 +59,11 @@
     "typescript": "^5.7.2"
   },
   "optionalDependencies": {
-    "@uipath/studio-helm-win32-x64": "1.198.1",
-    "@uipath/studio-helm-win32-arm64": "1.198.1",
-    "@uipath/studio-helm-linux-x64": "1.198.1",
-    "@uipath/studio-helm-linux-arm64": "1.198.1",
-    "@uipath/studio-helm-darwin-x64": "1.198.1",
-    "@uipath/studio-helm-darwin-arm64": "1.198.1"
+    "@uipath/studio-helm-win32-x64": "1.198.2",
+    "@uipath/studio-helm-win32-arm64": "1.198.2",
+    "@uipath/studio-helm-linux-x64": "1.198.2",
+    "@uipath/studio-helm-linux-arm64": "1.198.2",
+    "@uipath/studio-helm-darwin-x64": "1.198.2",
+    "@uipath/studio-helm-darwin-arm64": "1.198.2"
   }
 }