@uipath/cli 0.1.16 → 0.1.19

package/dist/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@uipath/cli",
-    version: "0.1.16",
+    version: "0.1.19",
     description: "Cross platform CLI for UiPath",
     repository: {
       type: "git",
@@ -60,7 +60,7 @@ var init_package = __esm(() => {
       directory: "packages/cli"
     },
     publishConfig: {
-      registry: "https://registry.npmjs.org/"
+      registry: "https://npm.pkg.github.com/@uipath"
     },
     type: "module",
     main: "./dist/index.js",
@@ -103,7 +103,7 @@ var init_package = __esm(() => {
     },
     peerDependencies: {
       commander: "^14.0.3",
-      "@uipath/common": "^0.1.12",
+      "@uipath/common": "^0.1.13",
       "@uipath/auth": "^0.1.9",
       "@uipath/filesystem": "^0.1.6"
     }
@@ -179,7 +179,11 @@ var init_auth = __esm(() => {
 
 // src/commands/login.ts
 import { DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME } from "@uipath/auth";
-import { catchError, OutputFormatter } from "@uipath/common";
+import {
+  catchError,
+  OutputFormatter,
+  resolveEnvReference
+} from "@uipath/common";
 import { getFileSystem } from "@uipath/filesystem";
 function resolveAuthFilePath(folder) {
   if (folder) {
@@ -188,13 +192,28 @@ function resolveAuthFilePath(folder) {
   return DEFAULT_ENV_FILENAME;
 }
 function registerLoginCommand(program, context) {
-  const loginCommand = program.command("login").description("Login to UiPath Cloud").option("-f, --file <folder>", "Path to credentials folder").option("--authority <url>", "Custom authority URL").option("--client-id <id>", "Client Id or Application Id (default: uses built-in client for interactive login)").option("--client-secret <secret>", "Client Secret or Application Secret (External Apps)").option("-s, --scope <scopes>", "Custom scopes or Application scopes (External Apps). Space separated values.").option("-t, --tenant <name>", "Tenant name (non-interactive mode)").option("--it, --interactive", "Interactively select tenant from list").trackedAction(context, async (options) => {
+  const loginCommand = program.command("login").description("Login to UiPath Cloud").option("-f, --file <folder>", "Path to credentials folder").option("--authority <url>", "Custom authority URL").option("--client-id <id>", "Client Id or Application Id. Use env.ENV_NAME to read from an environment variable").option("--client-secret <secret>", "Client Secret or Application Secret. Use env.ENV_NAME to read from an environment variable").option("-s, --scope <scopes>", "Custom scopes or Application scopes (External Apps). Space separated values.").option("-t, --tenant <name>", "Tenant name (non-interactive mode)").option("--it, --interactive", "Interactively select tenant from list").trackedAction(context, async (options) => {
     const envFilePath = resolveAuthFilePath(options.file);
+    let clientId;
+    let clientSecret;
+    try {
+      clientId = resolveEnvReference(options.clientId);
+      clientSecret = resolveEnvReference(options.clientSecret);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      OutputFormatter.error({
+        Result: "Failure",
+        Message: message,
+        Instructions: "Inspect command arguments and try again."
+      });
+      context.exit(1);
+      return;
+    }
     const [error, authResult] = await catchError(auth.interactiveLogin({
       envFilePath,
       authority: options.authority,
-      clientId: options.clientId,
-      clientSecret: options.clientSecret,
+      clientId,
+      clientSecret,
       scope: options.scope ? options.scope.split(" ") : undefined,
       tenant: options.tenant,
       interactive: options.interactive
@@ -29739,23 +29758,323 @@ function registerMcpCommand(program) {
 }
 var init_mcp2 = () => {};
 
+// src/services/deviceId.ts
+import { randomUUID } from "node:crypto";
+import { catchError as catchError4, logger, UIPATH_HOME_DIR } from "@uipath/common";
+import { getFileSystem as getFileSystem3 } from "@uipath/filesystem";
+async function getOrCreateDeviceId() {
+  const fs = getFileSystem3();
+  const homeDir = fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR);
+  const filePath = fs.path.join(homeDir, DEVICE_ID_FILENAME);
+  const existing = await fs.readFile(filePath, "utf-8");
+  if (existing?.trim()) {
+    return existing.trim();
+  }
+  const newId = randomUUID();
+  const [writeError] = await catchError4((async () => {
+    if (!await fs.exists(homeDir)) {
+      await fs.mkdir(homeDir);
+    }
+    await fs.writeFile(filePath, newId);
+  })());
+  if (writeError) {
+    logger.warn(`Failed to persist device ID: ${writeError.message}`);
+  }
+  return newId;
+}
+var DEVICE_ID_FILENAME = "cli-device-id";
+var init_deviceId = () => {};
+
+// src/services/environmentInfo.ts
+import { arch as osArch, release as osRelease, type as osType } from "node:os";
+import { catchError as catchError5 } from "@uipath/common";
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3)
+    return;
+  const base643 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base643 + "=".repeat((4 - base643.length % 4) % 4);
+  const [, parsed] = catchError5(() => JSON.parse(atob(padded)));
+  return parsed;
+}
+async function getAuthContext() {
+  const [statusError, status] = await catchError5(auth.getLoginStatus());
+  if (statusError || status.loginStatus !== "Logged in" || !status.accessToken) {
+    return {};
+  }
+  const claims = decodeJwtPayload(status.accessToken);
+  return {
+    email: claims?.email ?? claims?.preferred_username,
+    userId: claims?.sub,
+    organizationId: status.organizationId,
+    organizationName: status.organizationName,
+    tenantId: status.tenantId,
+    tenantName: status.tenantName
+  };
+}
+function buildEnvironmentString(authCtx) {
+  const lines = [
+    `CLI Version: ${package_default.version}`,
+    `Node Version: ${process.version}`,
+    `OS: ${osType()} ${osRelease()} (${osArch()})`,
+    `Platform: ${process.platform}`
+  ];
+  if (authCtx.userId)
+    lines.push(`Cloud User ID: ${authCtx.userId}`);
+  if (authCtx.organizationName)
+    lines.push(`Cloud Organization: ${authCtx.organizationName}`);
+  if (authCtx.organizationId)
+    lines.push(`Cloud Organization ID: ${authCtx.organizationId}`);
+  if (authCtx.tenantName)
+    lines.push(`Tenant: ${authCtx.tenantName}`);
+  if (authCtx.tenantId)
+    lines.push(`Tenant ID: ${authCtx.tenantId}`);
+  return lines.join(`
+`);
+}
+var init_environmentInfo = __esm(() => {
+  init_package();
+  init_auth();
+});
+
+// src/services/feedbackService.ts
+import { catchError as catchError6, DEFAULT_FETCH_TIMEOUT_MS } from "@uipath/common";
+import { getFileSystem as getFileSystem4 } from "@uipath/filesystem";
+async function createFeedbackIssue(options) {
+  const feedbackType = FEEDBACK_TYPE_MAP[options.type];
+  const priorityId = PRIORITY_MAP[options.priority];
+  const descriptionParts = [options.description];
+  if (options.email) {
+    descriptionParts.push(`User Email: ${options.email}`);
+  }
+  const body = {
+    fields: {
+      project: { id: PROJECT_ID },
+      components: [{ id: CLI_COMPONENT_ID }],
+      versions: [],
+      summary: options.title,
+      description: descriptionParts.join(`
+`),
+      issuetype: { id: feedbackType.id, name: feedbackType.name },
+      [FIELD_ENVIRONMENT]: options.environment,
+      [FIELD_STEPS_TO_REPRODUCE]: "",
+      labels: [],
+      priority: { id: priorityId }
+    }
+  };
+  const response = await fetch(`${FEEDBACK_ENDPOINT}/issue/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Accept-Encoding": "gzip, deflate",
+      deviceId: options.deviceId
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(DEFAULT_FETCH_TIMEOUT_MS)
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    if (response.status === 429) {
+      throw new Error("Too many feedback submissions. Please wait and try again later.");
+    }
+    throw new Error(`Failed to create feedback issue: ${text}`);
+  }
+  const [parseError, result] = catchError6(() => JSON.parse(text));
+  if (parseError || !result?.key) {
+    throw new Error(`Unexpected response from feedback service: ${text}`);
+  }
+  return { key: result.key, sig: result.sig ?? "" };
+}
+async function uploadAttachment(issueId, signature, deviceId, filePath) {
+  const fs = getFileSystem4();
+  const fileBuffer = await fs.readFile(filePath);
+  if (!fileBuffer) {
+    throw new Error(`Could not read attachment: "${fs.path.basename(filePath)}"`);
+  }
+  const fileName = fs.path.basename(filePath);
+  const formData = new FormData;
+  formData.append("file", new Blob([fileBuffer]), fileName);
+  const response = await fetch(`${FEEDBACK_ENDPOINT}/issue/${issueId}/attachments`, {
+    method: "POST",
+    headers: {
+      "X-SIG": signature,
+      deviceId,
+      "Accept-Encoding": "gzip, deflate"
+    },
+    body: formData,
+    signal: AbortSignal.timeout(DEFAULT_FETCH_TIMEOUT_MS)
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`Failed to upload attachment "${fileName}": ${text}`);
+  }
+}
+async function validateAttachment(filePath) {
+  const MAX_FILE_SIZE = 10 * 1024 * 1024;
+  const fs = getFileSystem4();
+  const stat = await fs.stat(filePath);
+  if (!stat) {
+    throw new Error(`Attachment not found: "${fs.path.basename(filePath)}"`);
+  }
+  if (stat.size > MAX_FILE_SIZE) {
+    throw new Error(`Attachment "${fs.path.basename(filePath)}" exceeds 10 MB limit (${Math.round(stat.size / 1024 / 1024)} MB).`);
+  }
+}
+var FEEDBACK_ENDPOINT, PROJECT_ID = "10677", CLI_COMPONENT_ID = "29590", FIELD_ENVIRONMENT = "customfield_11434", FIELD_STEPS_TO_REPRODUCE = "customfield_11433", FEEDBACK_TYPE_MAP, PRIORITY_MAP;
+var init_feedbackService = __esm(() => {
+  FEEDBACK_ENDPOINT = atob("aHR0cHM6Ly9zdHVkaW8tZmVlZGJhY2suYXp1cmUtYXBpLm5ldC9jb2RpbmctYWdlbnRz");
+  FEEDBACK_TYPE_MAP = {
+    bug: { id: "1", name: "Bug" },
+    improvement: { id: "4", name: "Improvement" }
+  };
+  PRIORITY_MAP = {
+    critical: "3",
+    normal: "5",
+    minor: "4"
+  };
+});
+
+// src/commands/send-feedback.ts
+import { catchError as catchError7, logger as logger2, OutputFormatter as OutputFormatter3 } from "@uipath/common";
+import { getFileSystem as getFileSystem5 } from "@uipath/filesystem";
+function registerFeedbackCommand(program, context) {
+  const feedback = program.command("feedback").description("Send bug reports and improvement suggestions");
+  feedback.command("send").description("Send feedback (bug report or improvement suggestion) to the UiPath team").requiredOption("--type <type>", "Feedback type: bug or improvement").requiredOption("--title <title>", "Issue title / summary").requiredOption("--description <text>", "Detailed description or steps to reproduce").option("--priority <priority>", "Priority: critical, normal, or minor (default: normal)", "normal").option("--email <email>", "Contact email address").option("--attachment <paths...>", "File(s) to attach (max 10, max 10MB each)").trackedAction(context, async (options) => {
+    if (!VALID_TYPES.includes(options.type)) {
+      OutputFormatter3.error({
+        Result: "Failure",
+        Message: `Invalid feedback type: "${options.type}"`,
+        Instructions: `--type must be one of: ${VALID_TYPES.join(", ")}`
+      });
+      context.exit(1);
+      return;
+    }
+    if (!VALID_PRIORITIES.includes(options.priority)) {
+      OutputFormatter3.error({
+        Result: "Failure",
+        Message: `Invalid priority: "${options.priority}"`,
+        Instructions: `--priority must be one of: ${VALID_PRIORITIES.join(", ")}`
+      });
+      context.exit(1);
+      return;
+    }
+    const attachments = options.attachment ?? [];
+    if (attachments.length > MAX_ATTACHMENTS) {
+      OutputFormatter3.error({
+        Result: "Failure",
+        Message: `Too many attachments: ${attachments.length}`,
+        Instructions: `Maximum ${MAX_ATTACHMENTS} attachments allowed.`
+      });
+      context.exit(1);
+      return;
+    }
+    const fs = getFileSystem5();
+    for (const filePath of attachments) {
+      if (!await fs.exists(filePath)) {
+        OutputFormatter3.error({
+          Result: "Failure",
+          Message: `Attachment not found: "${filePath}"`,
+          Instructions: "Check the file path and try again."
+        });
+        context.exit(1);
+        return;
+      }
+      const [validateError] = await catchError7(validateAttachment(filePath));
+      if (validateError) {
+        OutputFormatter3.error({
+          Result: "Failure",
+          Message: validateError.message,
+          Instructions: "Reduce the file size or choose a different file."
+        });
+        context.exit(1);
+        return;
+      }
+    }
+    const [deviceIdError, deviceId] = await catchError7(getOrCreateDeviceId());
+    if (deviceIdError) {
+      OutputFormatter3.error({
+        Result: "Failure",
+        Message: deviceIdError.message,
+        Instructions: "Failed to generate device ID."
+      });
+      context.exit(1);
+      return;
+    }
+    const authCtx = await getAuthContext();
+    const email3 = options.email ?? authCtx.email;
+    const feedbackOptions = {
+      type: options.type,
+      priority: options.priority,
+      title: options.title,
+      description: options.description,
+      email: email3,
+      environment: buildEnvironmentString(authCtx),
+      deviceId
+    };
+    const [createError, result] = await catchError7(createFeedbackIssue(feedbackOptions));
+    if (createError) {
+      OutputFormatter3.error({
+        Result: "Failure",
+        Message: createError.message,
+        Instructions: "Failed to submit feedback. Check your network connection and try again."
+      });
+      context.exit(1);
+      return;
+    }
+    let attachmentsUploaded = 0;
+    for (const filePath of attachments) {
+      const [attachError] = await catchError7(uploadAttachment(result.key, result.sig, deviceId, filePath));
+      if (attachError) {
+        logger2.warn(`Failed to upload attachment "${filePath}": ${attachError.message}`);
+      } else {
+        attachmentsUploaded++;
+      }
+    }
+    OutputFormatter3.success({
+      Result: "Success",
+      Code: "FeedbackSent",
+      Data: {
+        IssueKey: result.key,
+        Type: options.type,
+        Title: options.title,
+        ...attachments.length > 0 && {
+          AttachmentsUploaded: `${attachmentsUploaded}/${attachments.length}`
+        }
+      }
+    });
+  }, (options) => ({
+    feedbackType: options.type,
+    priority: options.priority,
+    hasEmail: !!options.email,
+    attachmentCount: options.attachment?.length ?? 0
+  }));
+}
+var VALID_TYPES, VALID_PRIORITIES, MAX_ATTACHMENTS = 10;
+var init_send_feedback = __esm(() => {
+  init_deviceId();
+  init_environmentInfo();
+  init_feedbackService();
+  VALID_TYPES = ["bug", "improvement"];
+  VALID_PRIORITIES = ["critical", "normal", "minor"];
+});
+
 // src/commands/skills/agents/claude.ts
 var exports_claude = {};
 __export(exports_claude, {
   uninstall: () => uninstall,
   install: () => install
 });
-import { logger } from "@uipath/common";
-import { getFileSystem as getFileSystem3 } from "@uipath/filesystem";
+import { logger as logger3 } from "@uipath/common";
+import { getFileSystem as getFileSystem6 } from "@uipath/filesystem";
 async function install(skill, rootDir) {
-  const fs = getFileSystem3();
+  const fs = getFileSystem6();
   const target = fs.path.join(rootDir, ".claude", "skills", skill.name);
   await fs.mkdir(target);
   await fs.copyDirectory(skill.skillDir, target);
-  logger.info(`  claude: installed ${skill.name}`);
+  logger3.info(`  claude: installed ${skill.name}`);
 }
 async function uninstall(skillName, rootDir) {
-  const fs = getFileSystem3();
+  const fs = getFileSystem6();
   const target = fs.path.join(rootDir, ".claude", "skills", skillName);
   if (await fs.exists(target)) {
     await fs.rm(target);
@@ -32412,23 +32731,23 @@ var init_js_yaml = __esm(() => {
 
 // src/commands/skills/contentStore.ts
 import { spawn } from "node:child_process";
-import { catchError as catchError4, logger as logger2, UIPATH_HOME_DIR } from "@uipath/common";
-import { getFileSystem as getFileSystem4 } from "@uipath/filesystem";
+import { catchError as catchError8, logger as logger4, UIPATH_HOME_DIR as UIPATH_HOME_DIR2 } from "@uipath/common";
+import { getFileSystem as getFileSystem7 } from "@uipath/filesystem";
 async function getContentStore(rootDir) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const storePath = fs.path.join(rootDir, STORE_NAME);
   let needsClone = true;
   if (await fs.exists(fs.path.join(storePath, ".git"))) {
-    logger2.info("Updating content store...");
-    const [pullError] = await catchError4(runGit(["pull", "--ff-only"], storePath));
+    logger4.info("Updating content store...");
+    const [pullError] = await catchError8(runGit(["pull", "--ff-only"], storePath));
     if (pullError) {
-      logger2.warn("git pull failed, re-cloning...");
+      logger4.warn("git pull failed, re-cloning...");
     } else {
       needsClone = false;
     }
   }
   if (needsClone) {
-    logger2.info("Downloading content store...");
+    logger4.info("Downloading content store...");
     let savedManifest = null;
     const manifestPath = fs.path.join(storePath, MANIFEST_NAME);
     if (await fs.exists(storePath)) {
@@ -32438,9 +32757,9 @@ async function getContentStore(rootDir) {
       await fs.rm(storePath);
     }
     await fs.mkdir(storePath);
-    const [cloneError] = await catchError4(runGit(["clone", "--depth", "1", REPO_URL, storePath], rootDir));
+    const [cloneError] = await catchError8(runGit(["clone", "--depth", "1", REPO_URL, storePath], rootDir));
     if (cloneError) {
-      logger2.info("git clone failed, falling back to zip download...");
+      logger4.info("git clone failed, falling back to zip download...");
       await downloadAndExtractZip(storePath);
     }
     if (savedManifest !== null) {
@@ -32450,7 +32769,7 @@ async function getContentStore(rootDir) {
   return storePath;
 }
 async function readSkillDescription(fs, skillMdPath) {
-  const [err, content] = await catchError4(fs.readFile(skillMdPath, { encoding: "utf-8" }));
+  const [err, content] = await catchError8(fs.readFile(skillMdPath, { encoding: "utf-8" }));
   if (err || !content)
     return;
   const head = content.length > 2048 ? content.slice(0, 2048) : content;
@@ -32458,7 +32777,7 @@ async function readSkillDescription(fs, skillMdPath) {
   return meta3.description;
 }
 async function getAvailableSkills(storePath) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const skills = [];
   const rootSkillsDir = fs.path.join(storePath, "skills");
   if (await fs.exists(rootSkillsDir)) {
@@ -32504,7 +32823,7 @@ function parseSkillMd(content) {
   return { meta: meta3, body: fmMatch[2] };
 }
 async function getSkillMetadata(skillMdPath) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const content = await fs.readFile(skillMdPath, { encoding: "utf-8" });
   if (content === null) {
     throw new Error(`Skill metadata not found: ${skillMdPath}`);
@@ -32512,7 +32831,7 @@ async function getSkillMetadata(skillMdPath) {
   return parseSkillMd(content);
 }
 function rewriteBody(body, skillDir, targetDir) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const relFromTarget = fs.path.relative(targetDir, skillDir).split("\\").join("/");
   return body.replace(/(\[.*?\]\()(?!https?:\/\/|\/)([^)]+?)(\))/g, (_match, prefix, relPath, suffix) => {
     const rewritten = [relFromTarget, relPath].join("/").replace(/\/+/g, "/");
@@ -32522,7 +32841,7 @@ function rewriteBody(body, skillDir, targetDir) {
 async function setMarkedBlock(filePath, marker, content, commentStyle = "hash") {
   const startTag = commentStyle === "html" ? `<!-- ${marker} START -->` : `# ${marker} START`;
   const endTag = commentStyle === "html" ? `<!-- ${marker} END -->` : `# ${marker} END`;
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const block = `${startTag}
 ${content}
 ${endTag}`;
@@ -32541,7 +32860,7 @@ ${endTag}`;
   }
 }
 async function removeMarkedBlock(filePath, marker, commentStyle = "hash") {
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const startTag = commentStyle === "html" ? `<!-- ${marker} START -->` : `# ${marker} START`;
   const endTag = commentStyle === "html" ? `<!-- ${marker} END -->` : `# ${marker} END`;
   const existing = await fs.readFile(filePath, { encoding: "utf-8" });
@@ -32558,7 +32877,7 @@ async function removeMarkedBlock(filePath, marker, commentStyle = "hash") {
   await fs.writeFile(filePath, updated);
 }
 async function addToGitignore(rootDir, entry) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const gitignorePath = fs.path.join(rootDir, ".gitignore");
   const content = await fs.readFile(gitignorePath, { encoding: "utf-8" }) ?? "";
   const lines = content.split(`
@@ -32572,19 +32891,19 @@ async function addToGitignore(rootDir, entry) {
   }
 }
 async function readManifest(storePath) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const manifestPath = fs.path.join(storePath, MANIFEST_NAME);
   const content = await fs.readFile(manifestPath, { encoding: "utf-8" });
   if (content === null) {
     return { skills: {} };
   }
-  const [parseError, parsed] = catchError4(() => JSON.parse(content));
+  const [parseError, parsed] = catchError8(() => JSON.parse(content));
   if (parseError)
     return { skills: {} };
   return parsed;
 }
 async function writeManifest(storePath, manifest) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const manifestPath = fs.path.join(storePath, MANIFEST_NAME);
   await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 4)}
 `);
@@ -32650,7 +32969,7 @@ function runGit(args, cwd) {
   });
 }
 async function downloadAndExtractZip(storePath) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem7();
   const response = await fetch(ZIP_URL, {
     signal: AbortSignal.timeout(60000)
   });
@@ -32692,7 +33011,7 @@ async function downloadAndExtractZip(storePath) {
 var REPO_URL = "https://github.com/UiPath/skills.git", ZIP_URL = "https://github.com/UiPath/skills/archive/refs/heads/main.zip", STORE_NAME, MANIFEST_NAME = "manifest.json";
 var init_contentStore = __esm(() => {
   init_js_yaml();
-  STORE_NAME = `${UIPATH_HOME_DIR}/.skills`;
+  STORE_NAME = `${UIPATH_HOME_DIR2}/.skills`;
 });
 
 // src/commands/skills/agents/codex.ts
@@ -32701,10 +33020,10 @@ __export(exports_codex, {
   uninstall: () => uninstall2,
   install: () => install2
 });
-import { logger as logger3 } from "@uipath/common";
-import { getFileSystem as getFileSystem5 } from "@uipath/filesystem";
+import { logger as logger5 } from "@uipath/common";
+import { getFileSystem as getFileSystem8 } from "@uipath/filesystem";
 async function install2(skill, rootDir) {
-  const fs = getFileSystem5();
+  const fs = getFileSystem8();
   const isGlobal = fs.path.resolve(rootDir) === fs.path.resolve(fs.env.homedir());
   const targetFile = isGlobal ? fs.path.join(rootDir, ".codex", "instructions.md") : fs.path.join(rootDir, "codex.md");
   await fs.mkdir(fs.path.dirname(targetFile));
@@ -32713,10 +33032,10 @@ async function install2(skill, rootDir) {
   const marker = `uipath-skill:${skill.name}`;
   const content = `See ${relPath} for ${skill.name} instructions.`;
   await setMarkedBlock(targetFile, marker, content, "html");
-  logger3.info(`  codex: installed ${skill.name}`);
+  logger5.info(`  codex: installed ${skill.name}`);
 }
 async function uninstall2(skillName, rootDir) {
-  const fs = getFileSystem5();
+  const fs = getFileSystem8();
   const isGlobal = fs.path.resolve(rootDir) === fs.path.resolve(fs.env.homedir());
   const targetFile = isGlobal ? fs.path.join(rootDir, ".codex", "instructions.md") : fs.path.join(rootDir, "codex.md");
   const marker = `uipath-skill:${skillName}`;
@@ -32732,10 +33051,10 @@ __export(exports_copilot, {
   uninstall: () => uninstall3,
   install: () => install3
 });
-import { logger as logger4 } from "@uipath/common";
-import { getFileSystem as getFileSystem6 } from "@uipath/filesystem";
+import { logger as logger6 } from "@uipath/common";
+import { getFileSystem as getFileSystem9 } from "@uipath/filesystem";
 async function install3(skill, rootDir) {
-  const fs = getFileSystem6();
+  const fs = getFileSystem9();
   const skillMdPath = fs.path.join(skill.skillDir, "SKILL.md");
   const { meta: meta3, body } = await getSkillMetadata(skillMdPath);
   const targetDir = fs.path.join(rootDir, ".github", "instructions");
@@ -32746,10 +33065,10 @@ applyTo: "${Array.isArray(meta3.globs) ? meta3.globs.join(", ") : meta3.globs}"
 ---
 ` : "";
   await fs.writeFile(fs.path.join(targetDir, `${skill.name}.instructions.md`), header + rewritten);
-  logger4.info(`  copilot: installed ${skill.name}`);
+  logger6.info(`  copilot: installed ${skill.name}`);
 }
 async function uninstall3(skillName, rootDir) {
-  const fs = getFileSystem6();
+  const fs = getFileSystem9();
   const target = fs.path.join(rootDir, ".github", "instructions", `${skillName}.instructions.md`);
   if (await fs.exists(target)) {
     await fs.rm(target);
@@ -32765,10 +33084,10 @@ __export(exports_cursor, {
   uninstall: () => uninstall4,
   install: () => install4
 });
-import { logger as logger5 } from "@uipath/common";
-import { getFileSystem as getFileSystem7 } from "@uipath/filesystem";
+import { logger as logger7 } from "@uipath/common";
+import { getFileSystem as getFileSystem10 } from "@uipath/filesystem";
 async function install4(skill, rootDir) {
-  const fs = getFileSystem7();
+  const fs = getFileSystem10();
   const skillMdPath = fs.path.join(skill.skillDir, "SKILL.md");
   const { meta: meta3, body } = await getSkillMetadata(skillMdPath);
   const targetDir = fs.path.join(rootDir, ".cursor", "rules");
@@ -32776,10 +33095,10 @@ async function install4(skill, rootDir) {
   const rewritten = rewriteBody(body, skill.skillDir, targetDir);
   const mdc = buildMdc(skill.name, meta3, rewritten);
   await fs.writeFile(fs.path.join(targetDir, `${skill.name}.mdc`), mdc);
-  logger5.info(`  cursor: installed ${skill.name}`);
+  logger7.info(`  cursor: installed ${skill.name}`);
 }
 async function uninstall4(skillName, rootDir) {
-  const fs = getFileSystem7();
+  const fs = getFileSystem10();
   const target = fs.path.join(rootDir, ".cursor", "rules", `${skillName}.mdc`);
   if (await fs.exists(target)) {
     await fs.rm(target);
@@ -32810,10 +33129,10 @@ __export(exports_gemini, {
   uninstall: () => uninstall5,
   install: () => install5
 });
-import { logger as logger6 } from "@uipath/common";
-import { getFileSystem as getFileSystem8 } from "@uipath/filesystem";
+import { logger as logger8 } from "@uipath/common";
+import { getFileSystem as getFileSystem11 } from "@uipath/filesystem";
 async function install5(skill, rootDir) {
-  const fs = getFileSystem8();
+  const fs = getFileSystem11();
   const geminiDir = fs.path.join(rootDir, ".gemini");
   const geminiMd = fs.path.join(geminiDir, "GEMINI.md");
   await fs.mkdir(geminiDir);
@@ -32822,10 +33141,10 @@ async function install5(skill, rootDir) {
   const marker = `uipath-skill:${skill.name}`;
   const content = `@import ${relPath}`;
   await setMarkedBlock(geminiMd, marker, content, "html");
-  logger6.info(`  gemini: installed ${skill.name}`);
+  logger8.info(`  gemini: installed ${skill.name}`);
 }
 async function uninstall5(skillName, rootDir) {
-  const fs = getFileSystem8();
+  const fs = getFileSystem11();
   const geminiMd = fs.path.join(rootDir, ".gemini", "GEMINI.md");
   const marker = `uipath-skill:${skillName}`;
   await removeMarkedBlock(geminiMd, marker, "html");
@@ -34756,23 +35075,23 @@ var init_prompt = __esm(() => {
 });
 
 // src/commands/skills/skillsService.ts
-import { catchError as catchError5, logger as logger7, OutputFormatter as OutputFormatter3 } from "@uipath/common";
-import { getFileSystem as getFileSystem9 } from "@uipath/filesystem";
+import { catchError as catchError9, logger as logger9, OutputFormatter as OutputFormatter4 } from "@uipath/common";
+import { getFileSystem as getFileSystem12 } from "@uipath/filesystem";
 function handlePromptCancellation(err, operation) {
   if (err instanceof Error && err.name === "ExitPromptError") {
-    logger7.warn(`${operation.charAt(0).toUpperCase() + operation.slice(1)} cancelled.`);
+    logger9.warn(`${operation.charAt(0).toUpperCase() + operation.slice(1)} cancelled.`);
     throw Object.assign(new Error("cancelled"), { exitCode: 130 });
   }
   throw err;
 }
 async function resolveSkillsContext(options, operation) {
   const isLocal = !!options.local;
-  const fs = getFileSystem9();
+  const fs = getFileSystem12();
   const rootDir = isLocal ? fs.env.cwd() : fs.env.homedir();
   const storePath = await getContentStore(rootDir);
   const availableSkills = await getAvailableSkills(storePath);
   if (availableSkills.length === 0) {
-    OutputFormatter3.error({
+    OutputFormatter4.error({
       Result: "Failure",
       Message: "No skills found in content store.",
       Instructions: "Check that the skills repository contains skills in the skills/ directory."
@@ -34782,7 +35101,7 @@ async function resolveSkillsContext(options, operation) {
   }
   let selectedSkills = availableSkills;
   if (!options.skills && !options.agents) {
-    const [skillErr, chosen] = await catchError5(promptSkillSelection(availableSkills, operation));
+    const [skillErr, chosen] = await catchError9(promptSkillSelection(availableSkills, operation));
     if (skillErr)
       handlePromptCancellation(skillErr, operation);
     selectedSkills = availableSkills.filter((s) => chosen.includes(s.name));
@@ -34801,7 +35120,7 @@ async function resolveSkillsContext(options, operation) {
       if (neverSeen.length > 0) {
         parts.push(`Unknown skills: ${neverSeen.join(", ")}`);
       }
-      OutputFormatter3.error({
+      OutputFormatter4.error({
         Result: "Failure",
         Message: parts.join(" "),
         Instructions: `Available skills: ${availableNames.join(", ")}`
@@ -34816,7 +35135,7 @@ async function resolveSkillsContext(options, operation) {
     agents = options.agents.split(",").map((s) => s.trim().toLowerCase());
     const unknown3 = agents.filter((a) => !ALL_AGENTS.includes(a));
     if (unknown3.length > 0) {
-      OutputFormatter3.error({
+      OutputFormatter4.error({
         Result: "Failure",
         Message: `Unknown agents: ${unknown3.join(", ")}`,
         Instructions: `Available agents: ${ALL_AGENTS.join(", ")}`
@@ -34825,7 +35144,7 @@ async function resolveSkillsContext(options, operation) {
       return null;
     }
   } else {
-    const [agentErr, selected] = await catchError5(promptAgentSelection(operation));
+    const [agentErr, selected] = await catchError9(promptAgentSelection(operation));
     if (agentErr)
       handlePromptCancellation(agentErr, operation);
     agents = selected;
@@ -34838,9 +35157,9 @@ async function runAgentInstalls(resolved) {
   for (const agent of agents) {
     const handler = getAgentHandler(agent);
     for (const skill of selectedSkills) {
-      const [installError] = await catchError5(handler.install(skill, rootDir));
+      const [installError] = await catchError9(handler.install(skill, rootDir));
       if (installError) {
-        OutputFormatter3.error({
+        OutputFormatter4.error({
           Result: "Failure",
           Message: `Failed to install ${skill.name} for ${agent}: ${installError.message}`,
           Instructions: "Check that the content store is intact and you have write permissions."
@@ -34851,9 +35170,9 @@ async function runAgentInstalls(resolved) {
       installed.push(`${agent}:${skill.name}`);
     }
   }
-  const [manifestError] = await catchError5(updateManifestAfterInstall(storePath, selectedSkills.map((s) => s.name), agents));
+  const [manifestError] = await catchError9(updateManifestAfterInstall(storePath, selectedSkills.map((s) => s.name), agents));
   if (manifestError) {
-    OutputFormatter3.error({
+    OutputFormatter4.error({
       Result: "Failure",
       Message: `Failed to update manifest: ${manifestError.message}`,
       Instructions: "Check that the content store is intact and you have write permissions."
@@ -34862,9 +35181,9 @@ async function runAgentInstalls(resolved) {
     return null;
   }
   if (isLocal) {
-    const [gitignoreError] = await catchError5(addToGitignore(rootDir, `${STORE_NAME}/`));
+    const [gitignoreError] = await catchError9(addToGitignore(rootDir, `${STORE_NAME}/`));
     if (gitignoreError) {
-      OutputFormatter3.error({
+      OutputFormatter4.error({
         Result: "Failure",
         Message: `Failed to update .gitignore: ${gitignoreError.message}`,
         Instructions: "Check that you have write permissions to the project directory."
@@ -34882,17 +35201,17 @@ var init_skillsService = __esm(() => {
 });
 
 // src/commands/skills/install.ts
-import { catchError as catchError6, OutputFormatter as OutputFormatter4, processContext as processContext2 } from "@uipath/common";
+import { catchError as catchError10, OutputFormatter as OutputFormatter5, processContext as processContext2 } from "@uipath/common";
 function registerInstallCommand(skillsCommand) {
   skillsCommand.command("install").description("Download skills from UiPath and install them for your coding agents.").option("--agents <agents>", "Target agents: claude, cursor, copilot, gemini, codex (comma-separated)").option("--skills <skills>", "Specific skills to install (comma-separated)").option("--local", "Install to current project instead of globally").trackedAction(processContext2, async (options) => {
-    const [contextError, resolved] = await catchError6(resolveSkillsContext(options, "install"));
+    const [contextError, resolved] = await catchError10(resolveSkillsContext(options, "install"));
     if (contextError || !resolved) {
       if (contextError) {
         if (contextError.exitCode === 130) {
           processContext2.exit(130);
           return;
         }
-        OutputFormatter4.error({
+        OutputFormatter5.error({
           Result: "Failure",
           Message: `Failed to install skills: ${contextError.message}`,
           Instructions: "Check network connectivity and try again. Ensure git is installed. For zip-based installs, make sure PowerShell (on Windows) or the 'unzip' command (on macOS/Linux) is available."
@@ -34904,7 +35223,7 @@ function registerInstallCommand(skillsCommand) {
     const installed = await runAgentInstalls(resolved);
     if (!installed)
       return;
-    OutputFormatter4.success({
+    OutputFormatter5.success({
       Result: "Success",
       Code: "SkillsInstall",
       Data: {
@@ -34922,15 +35241,15 @@ var init_install = __esm(() => {
 
 // src/commands/skills/uninstall.ts
 import {
-  catchError as catchError7,
-  logger as logger8,
-  OutputFormatter as OutputFormatter5,
+  catchError as catchError11,
+  logger as logger10,
+  OutputFormatter as OutputFormatter6,
   processContext as processContext3
 } from "@uipath/common";
-import { getFileSystem as getFileSystem10 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem13 } from "@uipath/filesystem";
 function registerUninstallCommand(skillsCommand) {
   skillsCommand.command("uninstall").description("Remove previously installed skills from agent configurations.").option("--agents <agents>", "Target agents: claude, cursor, copilot, gemini, codex (comma-separated)").option("--skills <skills>", "Specific skills to uninstall (comma-separated)").option("--local", "Uninstall from current project instead of globally").trackedAction(processContext3, async (options) => {
-    const [contextError, resolved] = await catchError7(resolveSkillsContext(options, "uninstall"));
+    const [contextError, resolved] = await catchError11(resolveSkillsContext(options, "uninstall"));
     const isLocal = !!options.local;
     let rootDir;
     let storePath;
@@ -34941,7 +35260,7 @@ function registerUninstallCommand(skillsCommand) {
         processContext3.exit(130);
         return;
       }
-      OutputFormatter5.error({
+      OutputFormatter6.error({
         Result: "Failure",
         Message: `Failed to uninstall skills: ${contextError.message}`,
         Instructions: "Check network connectivity and try again. Ensure git is installed."
@@ -34958,14 +35277,14 @@ function registerUninstallCommand(skillsCommand) {
       if (!options.skills || !options.agents) {
         return;
       }
-      const fs = getFileSystem10();
+      const fs = getFileSystem13();
       rootDir = isLocal ? fs.env.cwd() : fs.env.homedir();
       storePath = fs.path.join(rootDir, STORE_NAME);
       const manifest = await readManifest(storePath);
       const requested = options.skills.split(",").map((s) => s.trim());
       const inManifest = requested.filter((s) => manifest.skills[s]);
       if (inManifest.length === 0) {
-        OutputFormatter5.error({
+        OutputFormatter6.error({
           Result: "Failure",
           Message: `Skills not found in manifest: ${requested.join(", ")}`,
           Instructions: "These skills are not currently installed. Use 'uipath skills install' to install them first."
@@ -34977,7 +35296,7 @@ function registerUninstallCommand(skillsCommand) {
       agents = options.agents.split(",").map((s) => s.trim().toLowerCase());
       const unknownAgents = agents.filter((a) => !ALL_AGENTS.includes(a));
       if (unknownAgents.length > 0) {
-        OutputFormatter5.error({
+        OutputFormatter6.error({
           Result: "Failure",
           Message: `Unknown agents: ${unknownAgents.join(", ")}`,
           Instructions: `Available agents: ${ALL_AGENTS.join(", ")}`
@@ -34985,15 +35304,15 @@ function registerUninstallCommand(skillsCommand) {
         processContext3.exit(1);
         return;
       }
-      logger8.info(`Uninstalling skills from manifest: ${inManifest.join(", ")}`);
+      logger10.info(`Uninstalling skills from manifest: ${inManifest.join(", ")}`);
     }
     const uninstalled = [];
     for (const agent of agents) {
       const handler = getAgentHandler(agent);
       for (const name of skillNames) {
-        const [uninstallError] = await catchError7(handler.uninstall(name, rootDir));
+        const [uninstallError] = await catchError11(handler.uninstall(name, rootDir));
         if (uninstallError) {
-          OutputFormatter5.error({
+          OutputFormatter6.error({
             Result: "Failure",
             Message: `Failed to uninstall ${name} for ${agent}: ${uninstallError.message}`,
             Instructions: "Check that the skill files exist and you have write permissions."
@@ -35005,7 +35324,7 @@ function registerUninstallCommand(skillsCommand) {
       }
     }
     await removeFromManifest(storePath, skillNames, agents);
-    OutputFormatter5.success({
+    OutputFormatter6.success({
       Result: "Success",
       Code: "SkillsUninstall",
       Data: {
@@ -35026,21 +35345,21 @@ var init_uninstall = __esm(() => {
 
 // src/commands/skills/update.ts
 import {
-  catchError as catchError8,
-  logger as logger9,
-  OutputFormatter as OutputFormatter6,
+  catchError as catchError12,
+  logger as logger11,
+  OutputFormatter as OutputFormatter7,
   processContext as processContext4
 } from "@uipath/common";
 function registerUpdateCommand(skillsCommand) {
   skillsCommand.command("update").description("Re-fetch skills from UiPath and reinstall to get the latest versions.").option("--agents <agents>", "Target agents: claude, cursor, copilot, gemini, codex (comma-separated)").option("--skills <skills>", "Specific skills to update (comma-separated)").option("--local", "Update in current project instead of globally").trackedAction(processContext4, async (options) => {
-    const [contextError, resolved] = await catchError8(resolveSkillsContext(options, "update"));
+    const [contextError, resolved] = await catchError12(resolveSkillsContext(options, "update"));
     if (contextError || !resolved) {
       if (contextError) {
         if (contextError.exitCode === 130) {
           processContext4.exit(130);
           return;
         }
-        OutputFormatter6.error({
+        OutputFormatter7.error({
           Result: "Failure",
           Message: `Failed to update skills: ${contextError.message}`,
           Instructions: "Check network connectivity and try again. Ensure git is installed. On Windows, ensure PowerShell is available. On macOS/Linux, ensure the 'unzip' utility is installed."
@@ -35050,20 +35369,20 @@ function registerUpdateCommand(skillsCommand) {
       return;
     }
     if (!options.skills) {
-      const [manifestErr, manifest] = await catchError8(readManifest(resolved.storePath));
-      const [skillsErr, availableSkills] = await catchError8(getAvailableSkills(resolved.storePath));
+      const [manifestErr, manifest] = await catchError12(readManifest(resolved.storePath));
+      const [skillsErr, availableSkills] = await catchError12(getAvailableSkills(resolved.storePath));
       if (!manifestErr && !skillsErr && availableSkills) {
         const availableNames = availableSkills.map((s) => s.name);
         const removed = Object.keys(manifest.skills).filter((s) => !availableNames.includes(s));
         if (removed.length > 0) {
-          logger9.warn(`Previously installed skills no longer available: ${removed.join(", ")}. They may have been removed or renamed. Use 'uipath skills uninstall --skills ${removed.join(",")}' to clean up.`);
+          logger11.warn(`Previously installed skills no longer available: ${removed.join(", ")}. They may have been removed or renamed. Use 'uipath skills uninstall --skills ${removed.join(",")}' to clean up.`);
         }
       }
     }
     const updated = await runAgentInstalls(resolved);
     if (!updated)
       return;
-    OutputFormatter6.success({
+    OutputFormatter7.success({
       Result: "Success",
       Code: "SkillsUpdate",
       Data: {
@@ -35113,15 +35432,15 @@ var exports_npmrc = {};
 __export(exports_npmrc, {
   findNpmrcConfig: () => findNpmrcConfig
 });
-import { catchError as catchError9, logger as logger10 } from "@uipath/common";
-import { getFileSystem as getFileSystem11 } from "@uipath/filesystem";
+import { catchError as catchError13, logger as logger12 } from "@uipath/common";
+import { getFileSystem as getFileSystem14 } from "@uipath/filesystem";
 function expandEnvVars(raw) {
   let hasMissing = false;
   const expanded = raw.replace(/\$\{([^}]+)\}/g, (_, v) => {
     const val = process.env[v];
     if (val === undefined) {
       hasMissing = true;
-      logger10.warn(`Warning: .npmrc references \${${v}} but it is not set.`);
+      logger12.warn(`Warning: .npmrc references \${${v}} but it is not set.`);
       return "";
     }
     return val;
@@ -35154,13 +35473,13 @@ function parseNpmrc(content) {
   return result;
 }
 function registryHost(url2) {
-  const [error48, parsed] = catchError9(() => new URL(url2));
+  const [error48, parsed] = catchError13(() => new URL(url2));
   if (error48)
     return;
   return parsed.host;
 }
 async function findNpmrcConfig() {
-  const fs = getFileSystem11();
+  const fs = getFileSystem14();
   const paths = [];
   let dir = fs.env.cwd();
   for (let i2 = 0;i2 < 20; i2++) {
@@ -35171,29 +35490,29 @@ async function findNpmrcConfig() {
     dir = parent;
   }
   paths.push(fs.path.join(fs.env.homedir(), ".npmrc"));
-  logger10.debug(`Searching for .npmrc in ${paths.length} locations`);
+  logger12.debug(`Searching for .npmrc in ${paths.length} locations`);
   let scopedRegistry;
   let prefix;
   const allTokensByHost = new Map;
   for (const p of paths) {
-    const [readError, content] = await catchError9(fs.readFile(p, "utf-8"));
+    const [readError, content] = await catchError13(fs.readFile(p, "utf-8"));
     if (readError) {
       continue;
     }
-    logger10.debug(`Found .npmrc at ${p}`);
+    logger12.debug(`Found .npmrc at ${p}`);
     if (!content)
       continue;
     const parsed = parseNpmrc(content);
     if (parsed.scopedRegistry && !scopedRegistry) {
       scopedRegistry = parsed.scopedRegistry;
-      logger10.debug(`@uipath:registry = ${scopedRegistry} (from ${p})`);
+      logger12.debug(`@uipath:registry = ${scopedRegistry} (from ${p})`);
     }
     if (parsed.prefix && !prefix)
       prefix = parsed.prefix;
     for (const [host, token] of parsed.tokensByHost) {
       if (!allTokensByHost.has(host)) {
         allTokensByHost.set(host, token);
-        logger10.debug(`Auth token found for host '${host}' (from ${p})`);
+        logger12.debug(`Auth token found for host '${host}' (from ${p})`);
       }
     }
   }
@@ -35210,12 +35529,12 @@ var init_npmrc = () => {};
 
 // src/services/toolService.ts
 import {
-  catchError as catchError10,
-  DEFAULT_FETCH_TIMEOUT_MS,
+  catchError as catchError14,
+  DEFAULT_FETCH_TIMEOUT_MS as DEFAULT_FETCH_TIMEOUT_MS2,
   extractErrorMessageSync,
-  logger as logger11
+  logger as logger13
 } from "@uipath/common";
-import { getFileSystem as getFileSystem12 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem15 } from "@uipath/filesystem";
 function isValidSemver(v) {
   return SEMVER_RE.test(v);
 }
@@ -35291,8 +35610,8 @@ function parsePackageSpec(spec) {
   };
 }
 async function isDevMode() {
-  const [error48, result] = await catchError10((async () => {
-    const fs = getFileSystem12();
+  const [error48, result] = await catchError14((async () => {
+    const fs = getFileSystem15();
     let dir = fs.env.cwd();
     for (let i2 = 0;i2 < 10; i2++) {
       const pkgPath = fs.path.join(dir, "package.json");
@@ -35303,7 +35622,7 @@ async function isDevMode() {
           if (pkg.workspaces && pkg.private) {
             const bunLockPath = fs.path.join(dir, "bun.lock");
             if (await fs.exists(bunLockPath)) {
-              logger11.debug(`Dev mode detected — found monorepo root at ${dir}`);
+              logger13.debug(`Dev mode detected — found monorepo root at ${dir}`);
               return true;
             }
           }
@@ -35317,12 +35636,12 @@ async function isDevMode() {
     return false;
   })());
   if (error48) {
-    logger11.debug("Dev mode not detected — using npm");
+    logger13.debug("Dev mode not detected — using npm");
     return false;
   }
   if (result)
     return true;
-  logger11.debug("Dev mode not detected — using npm");
+  logger13.debug("Dev mode not detected — using npm");
   return false;
 }
 async function runPackageManager(args, cwd) {
@@ -35335,7 +35654,7 @@ async function runPackageManager(args, cwd) {
   const isWindows = process.platform === "win32";
   const useBun = await isDevMode();
   const pm = useBun ? "bun" : "npm";
-  logger11.debug(`Running package manager: ${pm} ${args.join(" ")}${cwd ? ` (cwd: ${cwd})` : ""}`);
+  logger13.debug(`Running package manager: ${pm} ${args.join(" ")}${cwd ? ` (cwd: ${cwd})` : ""}`);
   const pmArgs = useBun ? args.filter((a) => a !== "-g").map((a) => a === "uninstall" ? "remove" : a) : args;
   return new Promise((resolve, reject) => {
     const proc = isWindows ? spawn2([pm, ...pmArgs].map((a) => a.includes(" ") ? `"${a}"` : a).join(" "), [], {
@@ -35349,7 +35668,7 @@ async function runPackageManager(args, cwd) {
     let stderr = "";
     const MAX_STDERR = 65536;
     proc.stdout?.on("data", (d) => {
-      logger11.info(d.toString().trimEnd());
+      logger13.info(d.toString().trimEnd());
     });
     proc.stderr?.on("data", (d) => {
       if (stderr.length < MAX_STDERR) {
@@ -35371,20 +35690,20 @@ async function runPackageManager(args, cwd) {
   });
 }
 async function resolveRegistry() {
-  logger11.debug("Resolving npm registry for @uipath packages...");
+  logger13.debug("Resolving npm registry for @uipath packages...");
   const { findNpmrcConfig: findNpmrcConfig2 } = await Promise.resolve().then(() => (init_npmrc(), exports_npmrc));
   const config2 = await findNpmrcConfig2();
   const registryUrl = config2.scopedRegistry || DEFAULT_REGISTRY;
-  logger11.debug(`Registry URL: ${registryUrl}${config2.scopedRegistry ? " (from .npmrc)" : " (default)"}`);
-  const [urlError] = catchError10(() => new URL(registryUrl));
+  logger13.debug(`Registry URL: ${registryUrl}${config2.scopedRegistry ? " (from .npmrc)" : " (default)"}`);
+  const [urlError] = catchError14(() => new URL(registryUrl));
   if (urlError) {
     throw new Error(`Invalid @uipath:registry URL in .npmrc: "${registryUrl}"`);
   }
   const envToken = globalThis.process?.env?.GH_NPM_REGISTRY_TOKEN;
   const authToken = envToken || config2.authToken || undefined;
-  logger11.debug(`Auth token: ${authToken ? `found (source: ${envToken ? "GH_NPM_REGISTRY_TOKEN env" : ".npmrc"})` : "not found"}`);
+  logger13.debug(`Auth token: ${authToken ? `found (source: ${envToken ? "GH_NPM_REGISTRY_TOKEN env" : ".npmrc"})` : "not found"}`);
   if (authToken && !config2.scopedRegistry) {
-    logger11.warn("Auth token found but no @uipath:registry configured in .npmrc — " + "token will be sent to the default registry (npmjs.org)");
+    logger13.warn("Auth token found but no @uipath:registry configured in .npmrc — " + "token will be sent to the default registry (npmjs.org)");
   }
   return { registryUrl, authToken };
 }
@@ -35393,14 +35712,14 @@ class NodeToolService {
   async fetchPackageInfo(registryUrl, packageName, headers) {
     const encodedName = packageName.replaceAll("/", "%2f");
     const url2 = `${registryUrl.replace(/\/+$/, "")}/${encodedName}`;
-    logger11.debug(`Fetching package info: ${url2}`);
+    logger13.debug(`Fetching package info: ${url2}`);
     const fetchHeaders = {
       Accept: "application/json",
       ...headers
     };
     const response = await fetch(url2, {
       headers: fetchHeaders,
-      signal: AbortSignal.timeout(DEFAULT_FETCH_TIMEOUT_MS)
+      signal: AbortSignal.timeout(DEFAULT_FETCH_TIMEOUT_MS2)
     });
     if (response.status === 401 || response.status === 403) {
       throw new Error(`Registry ${registryUrl} returned ${response.status} for ${packageName} (authentication required)`);
@@ -35410,10 +35729,10 @@ class NodeToolService {
     }
     const data = await response.json();
     const latestVersion = data["dist-tags"]?.latest;
-    const [labelError, parsedUrl] = catchError10(() => new URL(registryUrl));
+    const [labelError, parsedUrl] = catchError14(() => new URL(registryUrl));
     const registryLabel = labelError ? registryUrl : parsedUrl.host;
     const availableVersions = Object.keys(data.versions || {}).filter(isValidSemver).sort((a, b) => compareSemver(b, a));
-    logger11.debug(`Package '${packageName}': latest=${latestVersion ?? "unknown"}, ${availableVersions.length} versions available`);
+    logger13.debug(`Package '${packageName}': latest=${latestVersion ?? "unknown"}, ${availableVersions.length} versions available`);
     return {
       name: data.name,
       version: latestVersion || "latest",
@@ -35450,7 +35769,7 @@ ${errors5.map((e) => `  - ${e}`).join(`
     return results;
   }
   async searchLatestVersion(packageName, versionPrefix) {
-    logger11.debug(`Searching latest version of '${packageName}'${versionPrefix ? ` with prefix '${versionPrefix}'` : ""}`);
+    logger13.debug(`Searching latest version of '${packageName}'${versionPrefix ? ` with prefix '${versionPrefix}'` : ""}`);
     const { registryUrl, authToken } = await resolveRegistry();
     const headers = {};
     if (authToken)
@@ -35460,24 +35779,24 @@ ${errors5.map((e) => `  - ${e}`).join(`
       const matching = info.availableVersions.filter((v) => v.startsWith(versionPrefix));
       const stable = matching.find((v) => !v.includes("-"));
       if (stable) {
-        logger11.debug(`Resolved version: ${stable} (stable, prefix match)`);
+        logger13.debug(`Resolved version: ${stable} (stable, prefix match)`);
         return stable;
       }
       if (matching.length > 0) {
-        logger11.debug(`Resolved version: ${matching[0]} (prerelease, prefix match)`);
+        logger13.debug(`Resolved version: ${matching[0]} (prerelease, prefix match)`);
         return matching[0];
       }
-      logger11.debug(`No version found matching prefix '${versionPrefix}'`);
+      logger13.debug(`No version found matching prefix '${versionPrefix}'`);
       return null;
     }
-    logger11.debug(`Resolved version: ${info.version ?? "null"} (latest)`);
+    logger13.debug(`Resolved version: ${info.version ?? "null"} (latest)`);
     return info.version ?? null;
   }
   async install(packageName, destination, options) {
     validatePackageSpec(packageName);
     const baseArgs = options?.global ? ["install", "-g", packageName] : ["install", packageName];
     for (let attempt = 0;attempt <= NPM_MAX_RETRIES; attempt++) {
-      const [err] = await catchError10(runPackageManager(baseArgs, destination));
+      const [err] = await catchError14(runPackageManager(baseArgs, destination));
       if (!err) {
         return;
       }
@@ -35487,12 +35806,12 @@ ${errors5.map((e) => `  - ${e}`).join(`
         throw err;
       }
       const delayMs = 1000 * (attempt + 1);
-      logger11.warn(`npm install failed with transient error (attempt ${attempt + 1}/${NPM_MAX_RETRIES + 1}), retrying in ${delayMs}ms: ${msg}`);
+      logger13.warn(`npm install failed with transient error (attempt ${attempt + 1}/${NPM_MAX_RETRIES + 1}), retrying in ${delayMs}ms: ${msg}`);
       await new Promise((r) => setTimeout(r, delayMs));
     }
   }
   async uninstall(packageName, destination, options) {
-    const fs = getFileSystem12();
+    const fs = getFileSystem15();
     const nodeModulesDir = fs.path.resolve(destination, "node_modules");
     const packageDir = fs.path.resolve(fs.path.join(destination, "node_modules", packageName));
     if (!packageDir.startsWith(`${nodeModulesDir}/`) && !packageDir.startsWith(`${nodeModulesDir}\\`)) {
@@ -35501,10 +35820,10 @@ ${errors5.map((e) => `  - ${e}`).join(`
     if (!await fs.exists(packageDir)) {
       throw new Error(`Package '${packageName}' is not installed at ${destination}`);
     }
-    const [statError, stat] = await catchError10(fs.stat(packageDir));
+    const [statError, stat] = await catchError14(fs.stat(packageDir));
     if (!statError && !stat) {
       await fs.rm(packageDir);
-      logger11.info(`Removed workspace-linked package '${packageName}'`);
+      logger13.info(`Removed workspace-linked package '${packageName}'`);
       return;
     }
     if (options?.global) {
@@ -35514,7 +35833,7 @@ ${errors5.map((e) => `  - ${e}`).join(`
     }
     if (await fs.exists(packageDir)) {
       await fs.rm(packageDir);
-      logger11.info(`Package directory for '${packageName}' still existed after uninstall — removed manually`);
+      logger13.info(`Package directory for '${packageName}' still existed after uninstall — removed manually`);
     }
   }
 }
@@ -35550,7 +35869,7 @@ var init_toolService = __esm(() => {
   TOOLS_WHITELIST = new Map([
     ["@uipath/solution-tool", "solution"],
     ["@uipath/agent-tool", "agent"],
-    ["@uipath/codedagents-tool", "codedagents"],
+    ["@uipath/codedagents-tool", "codedagent"],
     ["@uipath/codedapp-tool", "codedapp"],
     ["@uipath/integrationservice-tool", "is"],
     ["@uipath/orchestrator-tool", "or"],
@@ -35558,7 +35877,7 @@ var init_toolService = __esm(() => {
     ["@uipath/flow-tool", "flow"],
     ["@uipath/case-tool", "case"],
     ["@uipath/test-manager-tool", "tm"],
-    ["@uipath/resources-tool", "resources"],
+    ["@uipath/resources-tool", "resource"],
     ["@uipath/api-workflow-tool", "api-workflow"],
     ["@uipath/maestro-tool", "maestro"],
     ["@uipath/docsai-tool", "docsai"],
@@ -35574,9 +35893,9 @@ var init_toolService = __esm(() => {
 
 // src/commands/tools/install.ts
 import {
-  catchError as catchError11,
-  logger as logger12,
-  OutputFormatter as OutputFormatter7,
+  catchError as catchError15,
+  logger as logger14,
+  OutputFormatter as OutputFormatter8,
   processContext as processContext5
 } from "@uipath/common";
 function registerInstallCommand2(toolsCommand, _context, state) {
@@ -35584,7 +35903,7 @@ function registerInstallCommand2(toolsCommand, _context, state) {
   toolsCommand.command("install").description("Install a tool from registry").argument("<package-name>", "Name of the package to install (optionally with @version)").trackedAction(processContext5, async (packageArg) => {
     const { name: rawName, version: explicitVersion } = parsePackageSpec(packageArg);
     if (explicitVersion && !isValidSemver(explicitVersion)) {
-      OutputFormatter7.error({
+      OutputFormatter8.error({
         Result: "Failure",
         Message: `Invalid version '${explicitVersion}'.`,
         Instructions: "Version must be a valid semver string (e.g. 1.0.0 or 1.0.0-beta.1)."
@@ -35594,7 +35913,7 @@ function registerInstallCommand2(toolsCommand, _context, state) {
     }
     const packageName = resolveToolPackageName(rawName);
     if (!TOOLS_WHITELIST.has(packageName)) {
-      OutputFormatter7.error({
+      OutputFormatter8.error({
         Result: "Failure",
         Message: `Unknown tool '${packageArg}'.`,
         Instructions: "Run 'uip tools search' to see available tools."
@@ -35602,7 +35921,7 @@ function registerInstallCommand2(toolsCommand, _context, state) {
       processContext5.exit(1);
       return;
     }
-    const [error48] = await catchError11((async () => {
+    const [error48] = await catchError15((async () => {
       const location = await resolveInstallPath(packageName);
       let packageSpec;
       if (explicitVersion) {
@@ -35618,8 +35937,8 @@ function registerInstallCommand2(toolsCommand, _context, state) {
       await toolService.install(packageSpec, location.path, {
         global: location.global
       });
-      logger12.info(`Installed to ${location.path}`);
-      OutputFormatter7.success({
+      logger14.info(`Installed to ${location.path}`);
+      OutputFormatter8.success({
         Result: "Success",
         Code: "Message",
         Data: {
@@ -35628,7 +35947,7 @@ function registerInstallCommand2(toolsCommand, _context, state) {
       });
     })());
     if (error48) {
-      OutputFormatter7.error({
+      OutputFormatter8.error({
         Result: "Failure",
         Message: `Failed to install '${packageName}': ${error48.message}`,
         Instructions: "Please check the package name and try again."
@@ -35641,17 +35960,22 @@ var init_install2 = __esm(() => {
   init_toolService();
 });
 
+// src/commands/tools/tool-helpers.ts
+function getInstalledTools(state) {
+  return (state.discoveredTools ?? []).map((d) => ({
+    name: d.toolName,
+    version: d.version,
+    description: d.description,
+    commandPrefix: d.commandPrefix
+  }));
+}
+
 // src/commands/tools/list.ts
-import { OutputFormatter as OutputFormatter8, processContext as processContext6 } from "@uipath/common";
+import { OutputFormatter as OutputFormatter9, processContext as processContext6 } from "@uipath/common";
 function registerListCommand(toolsCommand, state) {
   toolsCommand.command("list").description("List installed tools").trackedAction(processContext6, async () => {
-    const data = state.tools.length > 0 ? state.tools.map((tool) => tool.metadata) : (state.discoveredTools ?? []).map((d) => ({
-      name: d.toolName,
-      version: d.version,
-      description: d.description,
-      commandPrefix: d.commandPrefix
-    }));
-    OutputFormatter8.success({
+    const data = getInstalledTools(state);
+    OutputFormatter9.success({
       Result: "Success",
       Code: "ToolList",
       Data: data
@@ -35661,12 +35985,12 @@ function registerListCommand(toolsCommand, state) {
 var init_list = () => {};
 
 // src/commands/tools/search.ts
-import { catchError as catchError12, OutputFormatter as OutputFormatter9, processContext as processContext7 } from "@uipath/common";
+import { catchError as catchError16, OutputFormatter as OutputFormatter10, processContext as processContext7 } from "@uipath/common";
 function registerSearchCommand(toolsCommand, _context) {
   toolsCommand.command("search").description("Search for tools in the configured registry").argument("[query]", "Search query (name or keyword)").trackedAction(processContext7, async (query) => {
-    const [error48, results] = await catchError12(toolService.search(query));
+    const [error48, results] = await catchError16(toolService.search(query));
     if (error48) {
-      OutputFormatter9.error({
+      OutputFormatter10.error({
         Result: "Failure",
         Message: "No matching tools found.",
         Instructions: error48.message
@@ -35678,7 +36002,7 @@ function registerSearchCommand(toolsCommand, _context) {
       ...r,
       availableVersions: r.availableVersions ? truncateVersionsForDisplay(r.availableVersions) : undefined
     }));
-    OutputFormatter9.success({
+    OutputFormatter10.success({
       Result: "Success",
       Code: "SearchResult",
       Data: displayResults
@@ -35690,13 +36014,13 @@ var init_search = __esm(() => {
 });
 
 // src/commands/tools/uninstall.ts
-import { catchError as catchError13, OutputFormatter as OutputFormatter10, processContext as processContext8 } from "@uipath/common";
+import { catchError as catchError17, OutputFormatter as OutputFormatter11, processContext as processContext8 } from "@uipath/common";
 function registerUninstallCommand2(toolsCommand, _context, state) {
   const { resolveInstallPath } = state;
   toolsCommand.command("uninstall").description("Uninstall an installed tool").argument("<package-name>", "Package name (e.g. @uipath/rpa-tool) or command alias (e.g. rpa)").trackedAction(processContext8, async (packageArg) => {
     const packageName = resolveToolPackageName(packageArg);
     if (!TOOLS_WHITELIST.has(packageName)) {
-      OutputFormatter10.error({
+      OutputFormatter11.error({
         Result: "Failure",
         Message: `Unknown tool '${packageArg}'.`,
         Instructions: `Use 'uip tools list' to see installed tools.`
@@ -35704,12 +36028,12 @@ function registerUninstallCommand2(toolsCommand, _context, state) {
       processContext8.exit(1);
       return;
     }
-    const [error48] = await catchError13((async () => {
+    const [error48] = await catchError17((async () => {
       const location = await resolveInstallPath();
       await toolService.uninstall(packageName, location.path, {
         global: location.global
       });
-      OutputFormatter10.success({
+      OutputFormatter11.success({
         Result: "Success",
         Code: "Message",
         Data: {
@@ -35718,7 +36042,7 @@ function registerUninstallCommand2(toolsCommand, _context, state) {
       });
     })());
     if (error48) {
-      OutputFormatter10.error({
+      OutputFormatter11.error({
         Result: "Failure",
         Message: `Failed to uninstall '${packageName}': ${error48.message}`,
         Instructions: "Use 'uip tools list' to see installed tools."
@@ -35733,17 +36057,18 @@ var init_uninstall2 = __esm(() => {
 
 // src/commands/tools/update.ts
 import {
-  catchError as catchError14,
-  logger as logger13,
-  OutputFormatter as OutputFormatter11,
+  catchError as catchError18,
+  logger as logger15,
+  OutputFormatter as OutputFormatter12,
   processContext as processContext9
 } from "@uipath/common";
-import { getFileSystem as getFileSystem13 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem16 } from "@uipath/filesystem";
 function registerUpdateCommand2(toolsCommand, _context, state) {
-  const { tools, toolsDirs, resolveInstallPath, getCliVersionPrefix } = state;
+  const { toolsDirs, resolveInstallPath, getCliVersionPrefix } = state;
   toolsCommand.command("update").description("Update installed tools").option("--name <scoped-tool-name>", "scoped package name").option("--version <version>", "package version to install", "latest").trackedAction(processContext9, async (options) => {
-    if (tools.length === 0) {
-      OutputFormatter11.error({
+    const installed = getInstalledTools(state);
+    if (installed.length === 0) {
+      OutputFormatter12.error({
         Result: "Failure",
         Message: "No tools installed.",
         Instructions: "Use 'uip tools install <package>' to install a tool."
@@ -35751,9 +36076,9 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
       processContext9.exit(1);
       return;
     }
-    const [locationError, location] = await catchError14(resolveInstallPath());
+    const [locationError, location] = await catchError18(resolveInstallPath());
     if (locationError) {
-      OutputFormatter11.error({
+      OutputFormatter12.error({
         Result: "Failure",
         Message: locationError.message,
         Instructions: "Please ensure the CLI is installed correctly."
@@ -35762,9 +36087,9 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
       return;
     }
     const resolvedName = options.name ? resolveToolPackageName(options.name) : undefined;
-    const toUpdate = resolvedName ? tools.filter((t) => t.metadata.name === resolvedName || `@uipath/${t.metadata.name}` === resolvedName) : tools;
+    const toUpdate = resolvedName ? installed.filter((t) => t.name === resolvedName || `@uipath/${t.name}` === resolvedName) : installed;
     if (resolvedName && toUpdate.length === 0) {
-      OutputFormatter11.error({
+      OutputFormatter12.error({
         Result: "Failure",
         Message: `Tool '${options.name}' is not installed.`,
         Instructions: "Use 'uip tools list' to see installed tools."
@@ -35773,9 +36098,9 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
       return;
     }
     if (options.version !== "latest") {
-      const [validateError] = catchError14(() => validateVersionString(options.version));
+      const [validateError] = catchError18(() => validateVersionString(options.version));
       if (validateError) {
-        OutputFormatter11.error({
+        OutputFormatter12.error({
           Result: "Failure",
           Message: validateError.message,
           Instructions: "Use a valid semver version (e.g. 1.2.3) or 'latest'."
@@ -35785,10 +36110,10 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
       }
     }
     const results = [];
-    const previousVersions = new Map(toUpdate.map((t) => [t.metadata.name, t.metadata.version]));
+    const previousVersions = new Map(toUpdate.map((t) => [t.name, t.version]));
     for (const tool of toUpdate) {
-      const fullName = `@uipath/${tool.metadata.name}`;
-      const [updateError] = await catchError14((async () => {
+      const fullName = `@uipath/${tool.name}`;
+      const [updateError] = await catchError18((async () => {
         let targetVersion = options.version;
         if (targetVersion === "latest") {
           const cliPrefix = getCliVersionPrefix();
@@ -35797,18 +36122,18 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
             targetVersion = latest;
           } else {
             results.push({
-              name: tool.metadata.name,
+              name: tool.name,
               status: "failed",
-              from: tool.metadata.version,
+              from: tool.version,
               error: `No compatible version found for CLI v${cliPrefix}x`
             });
             return;
           }
         }
-        const currentVersion = tool.metadata.version;
+        const currentVersion = tool.version;
         if (currentVersion === targetVersion) {
           results.push({
-            name: tool.metadata.name,
+            name: tool.name,
             status: "up-to-date",
             from: currentVersion,
             to: currentVersion
@@ -35820,26 +36145,26 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
       })());
       if (updateError) {
         results.push({
-          name: tool.metadata.name,
+          name: tool.name,
           status: "failed",
           error: updateError.message
         });
       }
     }
-    const fs = getFileSystem13();
+    const fs = getFileSystem16();
     const updatedVersions = new Map;
     for (const dir of toolsDirs) {
       for (const tool of toUpdate) {
-        const name = tool.metadata.name;
+        const name = tool.name;
         if (updatedVersions.has(name))
           continue;
         const pkgPath = fs.path.join(dir, name, "package.json");
         if (!await fs.exists(pkgPath))
           continue;
-        const [readError, raw] = await catchError14(fs.readFile(pkgPath, "utf-8"));
+        const [readError, raw] = await catchError18(fs.readFile(pkgPath, "utf-8"));
         if (readError || !raw)
           continue;
-        const [parseError, pkg] = catchError14(() => JSON.parse(raw));
+        const [parseError, pkg] = catchError18(() => JSON.parse(raw));
         if (parseError || !pkg.version)
           continue;
         updatedVersions.set(name, pkg.version);
@@ -35847,7 +36172,7 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
     }
     const recordedNames = new Set(results.map((r) => r.name));
     for (const tool of toUpdate) {
-      const name = tool.metadata.name;
+      const name = tool.name;
       if (recordedNames.has(name))
         continue;
       const from = previousVersions.get(name) ?? "unknown";
@@ -35865,13 +36190,13 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
       }
     }
     const failed = results.filter((r) => r.status === "failed");
-    OutputFormatter11.success({
+    OutputFormatter12.success({
       Result: "Success",
       Code: "UpdateResult",
       Data: results
     });
     if (failed.length > 0) {
-      logger13.error(`Failed to update ${failed.length} tool(s): ${failed.map((f) => `${f.name}: ${f.error}`).join("; ")}`);
+      logger15.error(`Failed to update ${failed.length} tool(s): ${failed.map((f) => `${f.name}: ${f.error}`).join("; ")}`);
       processContext9.exit(1);
     }
   });
@@ -35898,15 +36223,15 @@ var init_tools = __esm(() => {
 });
 
 // src/services/installPath.ts
-import { catchError as catchError15, logger as logger14 } from "@uipath/common";
+import { catchError as catchError19, logger as logger16 } from "@uipath/common";
 function createInstallPathResolver(toolsDir, isBrowser2) {
   return async (packageName) => {
     if (isBrowser2) {
       const path = packageName ? `/tools/${packageName.replace(/[/@]/g, "_")}` : "/tools";
       return { path, global: false };
     }
-    const { getFileSystem: getFileSystem14 } = await import("@uipath/filesystem");
-    const fsLocal = getFileSystem14();
+    const { getFileSystem: getFileSystem17 } = await import("@uipath/filesystem");
+    const fsLocal = getFileSystem17();
     const { dirname: dirnameFn, join: joinFn } = fsLocal.path;
     if (toolsDir) {
       let path = dirnameFn(dirnameFn(toolsDir));
@@ -35919,9 +36244,9 @@ function createInstallPathResolver(toolsDir, isBrowser2) {
       let isGlobal = true;
       const pkgJsonPath = joinFn(path, "package.json");
       if (await fsLocal.exists(pkgJsonPath)) {
-        const [, raw] = await catchError15(fsLocal.readFile(pkgJsonPath, "utf-8"));
+        const [, raw] = await catchError19(fsLocal.readFile(pkgJsonPath, "utf-8"));
         if (raw) {
-          const [, pkgJson] = catchError15(() => JSON.parse(raw));
+          const [, pkgJson] = catchError19(() => JSON.parse(raw));
           if (pkgJson) {
             const deps = {
               ...pkgJson.dependencies,
@@ -35936,15 +36261,15 @@ function createInstallPathResolver(toolsDir, isBrowser2) {
           }
         }
       }
-      logger14.debug(`Install path resolved: ${path} (global: ${isGlobal})`);
+      logger16.debug(`Install path resolved: ${path} (global: ${isGlobal})`);
       return { path, global: isGlobal };
     }
     let searchDir = fsLocal.env.cwd();
     for (let i2 = 0;i2 < 10; i2++) {
       const nodeModulesPath = joinFn(searchDir, "node_modules");
-      const [, exists] = await catchError15(fsLocal.exists(nodeModulesPath));
+      const [, exists] = await catchError19(fsLocal.exists(nodeModulesPath));
       if (exists) {
-        logger14.debug(`Install path resolved via fallback: ${searchDir}`);
+        logger16.debug(`Install path resolved via fallback: ${searchDir}`);
         return { path: searchDir, global: false };
       }
       const parentDir = dirnameFn(searchDir);
@@ -35959,17 +36284,24 @@ var insideNodeModules = (dir) => /[\\/]node_modules([\\/]|$)/.test(dir);
 var init_installPath = () => {};
 
 // src/services/storage.ts
-import { logger as logger15 } from "@uipath/common";
-import { getFileSystem as getFileSystem14, getFileSystemAsync } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem17, getFileSystemAsync } from "@uipath/filesystem";
 
 class GeneralizedStorage {
+  _initPromise;
   async init() {
-    logger15.debug("Initializing filesystem...");
-    await getFileSystemAsync();
-    logger15.debug("Filesystem initialized");
+    if (this._initPromise)
+      return this._initPromise;
+    const promise3 = getFileSystemAsync().then(() => {
+      return;
+    });
+    this._initPromise = promise3;
+    promise3.catch(() => {
+      this._initPromise = undefined;
+    });
+    return promise3;
   }
   get fs() {
-    return getFileSystem14();
+    return getFileSystem17();
   }
   async read(path) {
     const res = await this.fs.readFile(path);
@@ -36007,11 +36339,11 @@ var init_storage = __esm(() => {
 });
 
 // src/utils/toolLoader.ts
-import { catchError as catchError16, logger as logger16 } from "@uipath/common";
-import { getFileSystem as getFileSystem15 } from "@uipath/filesystem";
+import { catchError as catchError20, logger as logger17 } from "@uipath/common";
+import { getFileSystem as getFileSystem18 } from "@uipath/filesystem";
 import { Command } from "commander";
 function isRunningFromSource() {
-  const [error48, mainUrl] = catchError16(() => import.meta.url);
+  const [error48, mainUrl] = catchError20(() => import.meta.url);
   if (error48) {
     return false;
   }
@@ -36021,9 +36353,9 @@ function joinPath(...parts) {
   return parts.filter((p) => p).join("/").replace(/\/+/g, "/");
 }
 async function discoverToolPaths(toolsDirs) {
-  const [initError] = await catchError16(storage.init());
+  const [initError] = await catchError20(storage.init());
   if (initError) {
-    logger16.error("Storage initialization failed:", initError);
+    logger17.error("Storage initialization failed:", initError);
     return [];
   }
   const dirs = Array.isArray(toolsDirs) ? toolsDirs : [toolsDirs];
@@ -36031,10 +36363,9 @@ async function discoverToolPaths(toolsDirs) {
   const seenPrefixes = new Set;
   for (const toolsDir of dirs) {
     if (!await storage.exists(toolsDir)) {
-      logger16.debug(`Tools directory does not exist, skipping: ${toolsDir}`);
+      logger17.debug(`Tools directory does not exist, skipping: ${toolsDir}`);
       continue;
     }
-    logger16.debug(`Scanning tools directory: ${toolsDir}`);
     const toolNames = [...WHITELIST_BY_SHORT_NAME.keys()];
     const resolvedPaths = await Promise.all(toolNames.map(async (toolName) => {
       const toolDir = joinPath(toolsDir, toolName);
@@ -36064,7 +36395,7 @@ async function discoverToolPaths(toolsDirs) {
       let description = "";
       let version2 = "";
       if (pkgJson) {
-        const [parseErr, pkg] = catchError16(() => JSON.parse(pkgJson));
+        const [parseErr, pkg] = catchError20(() => JSON.parse(pkgJson));
         if (!parseErr) {
           description = pkg.description ?? "";
           version2 = pkg.version ?? "";
@@ -36086,20 +36417,20 @@ async function discoverToolPaths(toolsDirs) {
       version: version2
     } of resolvedPaths) {
       if (!toolPath) {
-        logger16.debug(`Tool '${toolName}' not found in ${joinPath(toolsDir, toolName)}`);
         continue;
       }
       const packageName = WHITELIST_BY_SHORT_NAME.get(toolName);
       const commandPrefix = packageName ? TOOLS_WHITELIST.get(packageName) : undefined;
       if (!commandPrefix || !packageName) {
-        logger16.warn(`Tool '${toolName}' found at ${toolPath} but not in whitelist, skipping`);
+        logger17.warn(`Tool '${toolName}' found at ${toolPath} but not in whitelist, skipping`);
         continue;
       }
       if (seenPrefixes.has(commandPrefix)) {
-        logger16.info(`Tool ${toolName} (command '${commandPrefix}') already found from a higher-priority path, skipping`);
+        logger17.info(`Tool ${toolName} (command '${commandPrefix}') already found from a higher-priority path, skipping`);
         continue;
       }
       seenPrefixes.add(commandPrefix);
+      logger17.debug(`Discovered tool '${toolName}' v${version2 || "unknown"} at ${toolPath}`);
       discovered.push({
         toolName,
         toolPath,
@@ -36109,21 +36440,20 @@ async function discoverToolPaths(toolsDirs) {
         version: version2,
         packagerToolPath
       });
-      logger16.debug(`Discovered tool '${toolName}' at ${toolPath} (prefix: ${commandPrefix})`);
     }
   }
   return discovered;
 }
 async function importModuleByPath(modulePath) {
   const savedTrackedAction = Command.prototype.trackedAction;
-  const [error48, mod] = await catchError16((async () => {
+  const [error48, mod] = await catchError20((async () => {
     if (_isBrowser) {
       const content = await storage.readText(modulePath);
       if (!content)
         return;
       const blob = new Blob([content], { type: "text/javascript" });
       const blobUrl = URL.createObjectURL(blob);
-      const [importError, imported] = await catchError16(import(blobUrl));
+      const [importError, imported] = await catchError20(import(blobUrl));
       URL.revokeObjectURL(blobUrl);
       if (importError)
         throw importError;
@@ -36136,7 +36466,7 @@ async function importModuleByPath(modulePath) {
   })());
   if (savedTrackedAction && Command.prototype.trackedAction !== savedTrackedAction) {
     Command.prototype.trackedAction = savedTrackedAction;
-    logger16.warn(`Import of ${modulePath} overwrote Command.prototype.trackedAction — restored CLI version.`);
+    logger17.warn(`Import of ${modulePath} overwrote Command.prototype.trackedAction — restored CLI version.`);
   }
   if (error48)
     throw error48;
@@ -36144,26 +36474,26 @@ async function importModuleByPath(modulePath) {
 }
 async function importTool(discovered) {
   const { toolName, toolPath } = discovered;
-  logger16.debug(`Loading tool '${toolName}' from ${toolPath}`);
-  const [error48, toolModule] = await catchError16(importModuleByPath(toolPath));
+  logger17.debug(`Loading tool '${toolName}' from ${toolPath}`);
+  const [error48, toolModule] = await catchError20(importModuleByPath(toolPath));
   if (error48) {
-    logger16.error(`Failed to load tool ${toolName}:`, error48);
+    logger17.error(`Failed to load tool ${toolName} (version: ${discovered.version || "unknown"}, path: ${toolPath}):`, error48);
     return;
   }
   const { metadata, registerCommands } = toolModule ?? {};
   if (!metadata || !registerCommands) {
-    logger16.warn(`Tool ${toolName} missing required exports (metadata or registerCommands), skipping`);
+    logger17.warn(`Tool ${toolName} missing required exports (metadata or registerCommands), skipping`);
     return;
   }
-  logger16.debug(`Tool '${toolName}' loaded successfully (prefix: ${metadata.commandPrefix}, version: ${metadata.version ?? "unknown"})`);
+  logger17.debug(`Tool '${toolName}' loaded successfully (prefix: ${metadata.commandPrefix}, version: ${metadata.version ?? "unknown"})`);
   return { metadata, registerCommands };
 }
 async function importPackagerTool(discovered) {
   const { toolName, packagerToolPath } = discovered;
   if (!packagerToolPath)
     return;
-  logger16.debug(`Loading packager factory for '${toolName}' from ${packagerToolPath}`);
-  const [error48] = await catchError16(importModuleByPath(packagerToolPath));
+  logger17.debug(`Loading packager factory for '${toolName}' from ${packagerToolPath}`);
+  const [error48] = await catchError20(importModuleByPath(packagerToolPath));
   if (error48) {
     throw new Error(`Failed to load packager factory for '${toolName}' from ${packagerToolPath}: ${error48 instanceof Error ? error48.message : error48}`);
   }
@@ -36184,25 +36514,23 @@ function isInsideNodeModules(dir) {
   return segments.includes("node_modules");
 }
 async function findNearestToolsDir(startDir, seen) {
-  const fs = getFileSystem15();
+  const fs = getFileSystem18();
   const { dirname, join } = fs.path;
   const results = [];
   let searchPath = startDir;
   for (let i2 = 0;i2 < MAX_WALK_DEPTH; i2++) {
     const candidate = join(searchPath, "node_modules", "@uipath");
-    const [, exists] = await catchError16(fs.exists(candidate));
+    const [, exists] = await catchError20(fs.exists(candidate));
     if (exists) {
       if (seen.has(candidate)) {
-        logger16.debug(`Tools directory already seen, stopping walk: ${candidate}`);
         break;
       }
       seen.add(candidate);
       results.push(candidate);
-      logger16.debug(`Found tools directory: ${candidate}`);
       if (!isInsideNodeModules(searchPath)) {
         break;
       }
-      logger16.debug("Search path is inside node_modules, continuing walk for hoisted packages");
+      logger17.debug("Search path is inside node_modules, continuing walk for hoisted packages");
     }
     const parentPath = dirname(searchPath);
     if (parentPath === searchPath) {
@@ -36210,19 +36538,15 @@ async function findNearestToolsDir(startDir, seen) {
     }
     searchPath = parentPath;
   }
-  if (results.length === 0) {
-    logger16.debug(`No tools directory found walking up from ${startDir}`);
-  }
   return results;
 }
 async function resolveToolsDirs(cliFilePath, cwd) {
-  const fs = getFileSystem15();
+  const fs = getFileSystem18();
   const { dirname } = fs.path;
   const seen = new Set;
   const dirs = [];
   dirs.push(...await findNearestToolsDir(dirname(cliFilePath), seen));
   dirs.push(...await findNearestToolsDir(cwd, seen));
-  logger16.debug(`Resolved ${dirs.length} tool directories: ${dirs.join(", ") || "(none)"}`);
   return dirs;
 }
 var _isRunningFromSource, _isBrowser, MAX_WALK_DEPTH = 10;
@@ -36234,7 +36558,7 @@ var init_toolLoader = __esm(() => {
 });
 
 // src/services/tool-manager.ts
-import { logger as logger17 } from "@uipath/common";
+import { logger as logger18 } from "@uipath/common";
 
 class ToolManager {
   toolsDirs;
@@ -36256,33 +36580,33 @@ class ToolManager {
   }
   async ensureAvailable(verb) {
     if (this.isInstalled(verb)) {
-      logger17.debug(`Tool '${verb}' is already installed`);
+      logger18.debug(`Tool '${verb}' is already installed`);
       return;
     }
     const packageName = WHITELIST_BY_COMMAND.get(verb);
     if (!packageName) {
       throw new Error(`Unknown tool verb '${verb}'.`);
     }
-    logger17.info(`Tool '${verb}' is not installed. Searching for compatible version...`);
-    logger17.debug(`Searching latest version of '${packageName}' with prefix '${this.cliVersionPrefix}'`);
+    logger18.info(`Tool '${verb}' is not installed. Searching for compatible version...`);
+    logger18.debug(`Searching latest version of '${packageName}' with prefix '${this.cliVersionPrefix}'`);
     const version2 = await toolService.searchLatestVersion(packageName, this.cliVersionPrefix);
     if (!version2) {
       throw new Error(`No compatible version of '${packageName}' found for CLI (needs ${this.cliVersionPrefix}x).`);
     }
     const packageSpec = `${packageName}@${version2}`;
     const location = await this.resolveInstallPath();
-    logger17.debug(`Installing ${packageSpec} to ${location.path} (global: ${location.global})`);
+    logger18.debug(`Installing ${packageSpec} to ${location.path} (global: ${location.global})`);
     await toolService.install(packageSpec, location.path, {
       global: location.global
     });
-    logger17.info(`Installed ${packageSpec} successfully.`);
-    logger17.debug("Re-discovering tools after install...");
+    logger18.info(`Installed ${packageSpec} successfully.`);
+    logger18.debug("Re-discovering tools after install...");
     this.tools = await discoverTools(this.toolsDirs);
   }
   async ensurePackagerFactory(verb) {
     let entry = this.discoveredTools.find((d) => d.commandPrefix === verb);
     if (!entry) {
-      logger17.info(`Tool '${verb}' not found on disk. Attempting install...`);
+      logger18.info(`Tool '${verb}' not found on disk. Attempting install...`);
       await this.installTool(verb);
       entry = this.discoveredTools.find((d) => d.commandPrefix === verb);
       if (!entry) {
@@ -36291,14 +36615,14 @@ class ToolManager {
       }
     }
     if (entry.packagerToolPath) {
-      logger17.debug(`Loading packager factory for '${verb}' from ${entry.packagerToolPath}`);
+      logger18.debug(`Loading packager factory for '${verb}' from ${entry.packagerToolPath}`);
       await importPackagerTool(entry);
       return;
     }
-    logger17.debug(`Tool '${verb}' has no packager-tool entry point, falling back to full tool import`);
+    logger18.debug(`Tool '${verb}' has no packager-tool entry point, falling back to full tool import`);
     const tool = await importTool(entry);
     if (!tool) {
-      throw new Error(`Tool '${verb}' was discovered on disk but failed to load. ` + `Entry point: ${entry.toolPath}`);
+      throw new Error(`Tool '${verb}' was discovered on disk but failed to load. ` + `Entry point: ${entry.toolPath}, ` + `Version: ${entry.version || "unknown"}, ` + `Package: ${entry.packageName}`);
     }
   }
   getTools() {
@@ -36309,22 +36633,22 @@ class ToolManager {
     if (!packageName) {
       throw new Error(`Unknown tool verb '${verb}'.`);
     }
-    logger17.info(`Tool '${verb}' is not installed. Searching for compatible version...`);
+    logger18.info(`Tool '${verb}' is not installed. Searching for compatible version...`);
     const version2 = await toolService.searchLatestVersion(packageName, this.cliVersionPrefix);
     if (!version2) {
       throw new Error(`No compatible version of '${packageName}' found for CLI (needs ${this.cliVersionPrefix}x).`);
     }
     const packageSpec = `${packageName}@${version2}`;
     const location = await this.resolveInstallPath();
-    logger17.debug(`Installing ${packageSpec} to ${location.path} (global: ${location.global})`);
+    logger18.debug(`Installing ${packageSpec} to ${location.path} (global: ${location.global})`);
     await toolService.install(packageSpec, location.path, {
       global: location.global
     });
-    logger17.info(`Installed ${packageSpec} successfully.`);
-    logger17.debug(`Re-discovering tools in [${this.toolsDirs.join(", ")}]...`);
+    logger18.info(`Installed ${packageSpec} successfully.`);
+    logger18.debug(`Re-discovering tools in [${this.toolsDirs.join(", ")}]...`);
     this.discoveredTools = await discoverToolPaths(this.toolsDirs);
     this.discoveredPrefixes = new Set(this.discoveredTools.map((d) => d.commandPrefix));
-    logger17.debug(`After install, discovered: [${this.discoveredTools.map((d) => d.commandPrefix).join(", ") || "none"}]`);
+    logger18.debug(`After install, discovered: [${this.discoveredTools.map((d) => d.commandPrefix).join(", ") || "none"}]`);
   }
 }
 var init_tool_manager = __esm(() => {
@@ -36333,7 +36657,7 @@ var init_tool_manager = __esm(() => {
 });
 
 // src/utils/autoInstall.ts
-import { catchError as catchError17, logger as logger18, OutputFormatter as OutputFormatter12 } from "@uipath/common";
+import { catchError as catchError21, logger as logger19, OutputFormatter as OutputFormatter13 } from "@uipath/common";
 async function autoInstallToolIfNeeded(args, program, toolManager, context) {
   if (context.capabilities.isBrowser)
     return false;
@@ -36353,10 +36677,10 @@ async function autoInstallToolIfNeeded(args, program, toolManager, context) {
     break;
   }
   if (requestedVerb && !toolManager.isInstalled(requestedVerb)) {
-    logger18.debug(`Tool '${requestedVerb}' not installed — attempting auto-install`);
-    const [error48] = await catchError17(toolManager.ensureAvailable(requestedVerb));
+    logger19.debug(`Tool '${requestedVerb}' not installed — attempting auto-install`);
+    const [error48] = await catchError21(toolManager.ensureAvailable(requestedVerb));
     if (error48) {
-      OutputFormatter12.error({
+      OutputFormatter13.error({
         Result: "Failure",
         Message: `Failed to auto-install '${requestedVerb}': ${error48.message}`,
         Instructions: `Run 'uip tools install ${requestedVerb}' to install manually.`
@@ -36434,7 +36758,13 @@ function stripGlobalOptions(args) {
     cleaned.push(args[i2]);
   }
   const resolvedFormat = format ?? (getOutputSink2().capabilities.isInteractive ? "table" : "json");
-  return { args: cleaned, format: resolvedFormat, filter, logLevel, logFile };
+  return {
+    args: cleaned,
+    format: resolvedFormat,
+    filter,
+    logLevel,
+    logFile
+  };
 }
 var VALID_FORMATS, VALID_LOG_LEVELS;
 var init_globalOptions = __esm(() => {
@@ -36452,7 +36782,7 @@ import {
   extractCommandHelp,
   getOutputFormat,
   getOutputSink as getOutputSink3,
-  OutputFormatter as OutputFormatter13
+  OutputFormatter as OutputFormatter14
 } from "@uipath/common";
 function getCommandPath(cmd) {
   const names = [];
@@ -36708,7 +37038,7 @@ function createHelpConfiguration(isBrowser2) {
         Code: "Help",
         Data: helpData
       };
-      return OutputFormatter13.formatToString(output);
+      return OutputFormatter14.formatToString(output);
     }
   };
   if (isBrowser2) {
@@ -36765,7 +37095,7 @@ var init_telemetry_events = __esm(() => {
 
 // src/utils/parseError.ts
 import {
-  OutputFormatter as OutputFormatter14,
+  OutputFormatter as OutputFormatter15,
   telemetry,
   telemetryFlushAndShutdown
 } from "@uipath/common";
@@ -36784,7 +37114,7 @@ async function handleParseError(error48, cleanedArgs, context) {
       context.exit(exitCode ?? 0);
       return;
     }
-    OutputFormatter14.error({
+    OutputFormatter15.error({
       Result: "ValidationError",
       Message: message,
       Instructions: "Check command arguments and options. Use --help for usage information."
@@ -36801,19 +37131,17 @@ var init_parseError = __esm(() => {
 });
 
 // src/utils/registerToolCommands.ts
-import { catchError as catchError18, logger as logger19, OutputFormatter as OutputFormatter15 } from "@uipath/common";
-function registerLazyToolCommands(program, discovered, context) {
-  logger19.debug("Registering lazy tool commands...");
+import { catchError as catchError22, logger as logger20, OutputFormatter as OutputFormatter16 } from "@uipath/common";
+function registerToolCommands(program, discovered, context) {
   for (const entry of discovered) {
-    logger19.debug(`Registering lazy command for tool '${entry.toolName}' (prefix: ${entry.commandPrefix})`);
     const toolCommand = program.command(entry.commandPrefix).description(entry.description).allowUnknownOption().allowExcessArguments(true).helpOption(false);
     toolCommand.action(async () => {
-      logger19.debug(`Lazy-loading tool '${entry.toolName}' on first use...`);
+      logger20.debug(`Loading tool '${entry.toolName}'...`);
       const tool = await importTool(entry);
       if (!tool) {
-        OutputFormatter15.error({
+        OutputFormatter16.error({
           Result: "Failure",
-          Message: `Failed to load tool '${entry.toolName}'.`,
+          Message: `Failed to load tool '${entry.toolName}' (version: ${entry.version || "unknown"}, path: ${entry.toolPath}).`,
           Instructions: `Try reinstalling with 'uip tools install ${entry.commandPrefix}'.`
         });
         context.exit(1);
@@ -36824,9 +37152,9 @@ function registerLazyToolCommands(program, discovered, context) {
         program.commands.splice(idx, 1);
       }
       const realCommand = program.command(tool.metadata.commandPrefix).description(tool.metadata.description);
-      const [regError] = await catchError18(tool.registerCommands(realCommand));
+      const [regError] = await catchError22(tool.registerCommands(realCommand));
       if (regError) {
-        OutputFormatter15.error({
+        OutputFormatter16.error({
           Result: "Failure",
           Message: `Failed to register commands from tool '${tool.metadata.name}': ${regError.message}`,
           Instructions: "This might be due to a command name conflict with existing commands."
@@ -36844,32 +37172,32 @@ var init_registerToolCommands = __esm(() => {
 
 // src/utils/resolveToolsDirectories.ts
 import { fileURLToPath } from "node:url";
-import { logger as logger20 } from "@uipath/common";
-import { getFileSystem as getFileSystem16 } from "@uipath/filesystem";
+import { logger as logger21 } from "@uipath/common";
+import { getFileSystem as getFileSystem19 } from "@uipath/filesystem";
 async function resolveToolsDirectories(context) {
   if (context.capabilities.isBrowser) {
-    logger20.debug("Browser mode — tools directory: /tools");
+    logger21.debug("Browser mode — tools directory: /tools");
     return { toolsDirs: ["/tools"], toolsDir: "/tools" };
   }
   const currentFilePath = fileURLToPath(import.meta.url);
-  const fs = getFileSystem16();
+  const fs = getFileSystem19();
   const toolsDirs = await resolveToolsDirs(currentFilePath, fs.env.cwd());
   const toolsDir = toolsDirs[0];
   if (toolsDirs.length > 0) {
     return { toolsDirs, toolsDir };
   }
-  logger20.warn("Unable to determine tools directory. Please ensure the CLI is installed correctly.");
+  logger21.warn("Unable to determine tools directory. Please ensure the CLI is installed correctly.");
   const { dirname, join } = fs.path;
   const isInstalledPackage = process.execPath.includes(join("@uipath", "cli", "dist", "uip"));
   if (isInstalledPackage) {
     const execDir = dirname(process.execPath);
     const packageDir = dirname(execDir);
     const fallbackDir2 = dirname(packageDir);
-    logger20.debug(`Fallback (installed package): ${fallbackDir2}`);
+    logger21.debug(`Fallback (installed package): ${fallbackDir2}`);
     return { toolsDirs: [fallbackDir2], toolsDir: fallbackDir2 };
   }
   const fallbackDir = join(dirname(currentFilePath), "..");
-  logger20.debug(`Fallback (development mode): ${fallbackDir}`);
+  logger21.debug(`Fallback (development mode): ${fallbackDir}`);
   return { toolsDirs: [fallbackDir], toolsDir: fallbackDir };
 }
 var init_resolveToolsDirectories = __esm(() => {
@@ -36882,10 +37210,10 @@ __export(exports_cli, {
   run: () => run
 });
 import {
-  catchError as catchError19,
+  catchError as catchError23,
   configureLogger,
   LogLevel,
-  logger as logger21,
+  logger as logger22,
   registerHelpAll,
   setOutputFilter,
   setOutputFormat,
@@ -36904,13 +37232,14 @@ function getCliVersionPrefix() {
 async function buildProgram(context) {
   const program = new Command2;
   program.name("uip").description(`UiPath CLI ${package_default.version}`).version(package_default.version, "-v, --version").enablePositionalOptions();
+  const globalOptions = stripGlobalOptions(context.args);
   const {
     args: cleanedArgs,
     format: helpFormat,
     filter,
     logLevel,
     logFile
-  } = stripGlobalOptions(context.args);
+  } = globalOptions;
   context.args = cleanedArgs;
   setOutputFormat(helpFormat);
   setOutputFilter(filter);
@@ -36918,7 +37247,7 @@ async function buildProgram(context) {
     ...logLevel !== undefined && { level: logLevel },
     ...logFile !== undefined && { logFile }
   });
-  logger21.debug(`CLI v${package_default.version} starting — output=${helpFormat}, logLevel=${logLevel !== undefined ? LogLevel[logLevel].toLowerCase() : "default"}, logFile=${logFile ?? "none"}`);
+  logger22.debug(`CLI v${package_default.version} starting — output=${helpFormat}, logLevel=${logLevel !== undefined ? LogLevel[logLevel].toLowerCase() : "default"}, logFile=${logFile ?? "none"}`);
   program.exitOverride();
   program.configureOutput({
     writeOut: context.output.writeOut,
@@ -36929,8 +37258,7 @@ async function buildProgram(context) {
   });
   program.configureHelp(createHelpConfiguration(context.capabilities.isBrowser));
   const storageAndToolsDirsPromise = (async () => {
-    logger21.debug("Initializing storage...");
-    const [storageError] = await catchError19(storage.init());
+    const [storageError] = await catchError23(storage.init());
     if (storageError) {
       if (context.capabilities.isBrowser) {
         context.output.writeErr(`Storage initialization failed: ${errorMessage(storageError)}`);
@@ -36938,24 +37266,25 @@ async function buildProgram(context) {
         throw storageError;
       }
     } else {
-      logger21.debug("Storage initialized");
+      logger22.debug("Storage initialized");
     }
-    logger21.debug("Resolving tool directories...");
     const result = await resolveToolsDirectories(context);
-    logger21.debug(`Resolved ${result.toolsDirs.length} tool directories: ${result.toolsDirs.join(", ") || "(none)"}`);
+    logger22.debug(`Resolved ${result.toolsDirs.length} tool directories: ${result.toolsDirs.join(", ") || "(none)"}`);
     return result;
   })();
   const [, { toolsDirs, toolsDir }] = await Promise.all([
-    telemetryInit({ uip_version: package_default.version }).then(() => logger21.debug("Telemetry initialized")).catch((err) => logger21.warn(`Telemetry init failed (non-fatal): ${errorMessage(err)}`)),
+    telemetryInit({ uip_version: package_default.version }).then(() => logger22.debug("Telemetry initialized")).catch((err) => logger22.warn(`Telemetry init failed (non-fatal): ${errorMessage(err)}`)),
     storageAndToolsDirsPromise
   ]);
-  logger21.debug("Registering login/logout commands");
   registerLoginCommand(program, context);
   registerLogoutCommand(program, context);
+  if (!context.capabilities.isBrowser) {
+    registerFeedbackCommand(program, context);
+    registerSkillsCommand(program);
+  }
+  registerMcpCommand(program);
   const resolveInstallPath = createInstallPathResolver(toolsDir, context.capabilities.isBrowser);
-  logger21.debug("Discovering tool paths...");
   let discoveredTools = await discoverToolPaths(toolsDirs);
-  logger21.debug(`Discovered ${discoveredTools.length} tools: ${discoveredTools.map((t) => t.commandPrefix).join(", ") || "(none)"}`);
   const toolManager = new ToolManager([], toolsDirs, resolveInstallPath, getCliVersionPrefix(), discoveredTools);
   setPackagerFactoryProvider((verb) => toolManager.ensurePackagerFactory(verb));
   if (toolsDir) {
@@ -36964,7 +37293,7 @@ async function buildProgram(context) {
       discoveredTools = await discoverToolPaths(toolsDirs);
     }
   }
-  registerLazyToolCommands(program, discoveredTools, context);
+  registerToolCommands(program, discoveredTools, context);
   registerToolsCommand(program, context, {
     tools: toolManager.getTools(),
     discoveredTools,
@@ -36972,36 +37301,33 @@ async function buildProgram(context) {
     resolveInstallPath,
     getCliVersionPrefix
   });
-  if (!context.capabilities.isBrowser) {
-    logger21.debug("Registering skills command");
-    registerSkillsCommand(program);
-  }
-  logger21.debug("Registering MCP command");
-  registerMcpCommand(program);
+  logger22.debug(`Discovered ${discoveredTools.length} tools: ${discoveredTools.map((t) => t.commandPrefix).join(", ") || "(none)"}`);
   registerHelpAll(program);
   for (const cmd of program.commands) {
     registerHelpAll(cmd);
   }
-  logger21.debug("Program built successfully — ready to parse args");
-  return { program, cleanedArgs };
+  logger22.debug("Program built successfully — ready to parse args");
+  return { program, cleanedArgs, globalOptions };
 }
 async function run(context) {
   const { program, cleanedArgs } = await buildProgram(context);
-  logger21.debug(`Parsing args: ${cleanedArgs.slice(2).join(" ")}`);
-  const [parseError] = await catchError19(program.parseAsync(cleanedArgs));
+  logger22.debug(`Parsing args: ${cleanedArgs.slice(2).join(" ")}`);
+  const [parseError] = await catchError23(program.parseAsync(cleanedArgs));
   if (parseError) {
     await handleParseError(parseError, cleanedArgs, context);
-    return;
   }
-  logger21.debug("Command completed — flushing telemetry");
+  if (!process.exitCode || process.exitCode === 0) {
+    logger22.debug("Command completed — flushing telemetry");
+    context.exit(0);
+  }
   await telemetryFlushAndShutdown2();
-  context.exit(0);
 }
 var init_cli = __esm(() => {
   init_package();
   init_login();
   init_logout();
   init_mcp2();
+  init_send_feedback();
   init_skills();
   init_tools();
   init_installPath();