@uipath/solution-tool 0.1.11 → 0.1.12

package/dist/tool.js

@@ -39194,7 +39194,7 @@ toolsFactoryRepository5.registerProjectToolFactory(new FunctionsToolFactory);
 // package.json
 var package_default = {
   name: "@uipath/solution-tool",
-  version: "0.1.11",
+  version: "0.1.12",
   description: "Create, pack, publish, and deploy UiPath Automation Solutions.",
   repository: {
     type: "git",
@@ -39225,7 +39225,7 @@ var package_default = {
     "vlad-uipath"
   ],
   scripts: {
-    build: "bun build ./src/tool.ts --outdir dist --format esm --target node --external commander --external @uipath/common --external @uipath/auth --external @uipath/filesystem --external @uipath/solutionpackager-tool-core && bun build ./src/index.ts --outdir dist --format esm --target node --external '*/tool.js' --external commander --external @uipath/common --external @uipath/auth --external @uipath/filesystem --external @uipath/solutionpackager-tool-core",
+    build: "bun ../../tools/build-tool.ts",
     package: "bun run build && bun pm pack",
     lint: "biome check .",
     "lint:fix": "biome check --write ."
@@ -39236,7 +39236,7 @@ var package_default = {
   peerDependencies: {
     "@uipath/solutionpackager-tool-core": "workspace:*",
     commander: "^14.0.3",
-    "@uipath/common": "^0.1.12",
+    "@uipath/common": "^0.1.13",
     "@uipath/auth": "^0.1.9",
     "@uipath/filesystem": "^0.1.6"
   },
@@ -41507,7 +41507,7 @@ var TERMINAL_STATUSES = new Set([
   "FailedActivate"
 ]);
 var registerDeployActivateCommand = (program) => {
-  program.command("activate").description("Activate a deployed solution that was deployed without auto-activation. Activation provisions all solution components.").argument("<deployment-name>", "Name of the deployment to activate").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--timeout <seconds>", "Timeout in seconds for activation polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between activation status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext3, async (deploymentName, options) => {
+  program.command("activate").description("Activate a deployed solution that was deployed without auto-activation. Activation provisions all solution components.").argument("<deployment-name>", "Name of the deployment to activate. Use 'solution deploy list' to find deployment names.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--timeout <seconds>", "Timeout in seconds for activation polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between activation status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext3, async (deploymentName, options) => {
     const [authError, auth] = await catchError4(getSolutionAuthContext({
       tenant: options.tenant,
       loginValidity: options.loginValidity
@@ -41604,7 +41604,7 @@ var registerDeployActivateCommand = (program) => {
   });
 };
 
-// src/commands/deploy-config.ts
+// src/commands/deploy-config-get.ts
 import {
   catchError as catchError5,
   extractErrorDetails as extractErrorDetails3,
@@ -41612,8 +41612,8 @@ import {
   processContext as processContext4
 } from "@uipath/common";
 import { getFileSystem as getFileSystem3 } from "@uipath/filesystem";
-var registerDeployConfigCommand = (program) => {
-  program.command("config").description("Fetch the default deployment configuration for a solution package. Save to a file with -d and customize before passing to 'solution deploy run --config-file'.").argument("<package-name>", "Solution package name").option("--package-version <version>", "Package version (optional, latest if omitted)").option("-d, --destination <path>", "Write configuration to a file instead of stdout").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext4, async (packageName, options) => {
+var registerDeployConfigGetCommand = (program) => {
+  program.command("get").description("Fetch the default deployment configuration for a published solution package. The config lists all resources (assets, queues, processes, etc.) and their default settings. Save to a file with -d, then customize with 'config set' or 'config link' before deploying with 'deploy run --config-file'.").argument("<package-name>", "Solution package name. Use 'solution packages list' to find available names.").option("--package-version <version>", "Package version (optional, latest if omitted)").option("-d, --destination <path>", "Write configuration to a file instead of stdout").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext4, async (packageName, options) => {
     const [authError, auth] = await catchError5(getSolutionAuthContext({
       tenant: options.tenant,
       loginValidity: options.loginValidity
@@ -41622,7 +41622,7 @@ var registerDeployConfigCommand = (program) => {
       OutputFormatter4.error({
         Result: "Failure",
         Message: authError.message,
-        Instructions: authError.message
+        Instructions: "Run 'uip auth login' to authenticate."
       });
       processContext4.exit(1);
       return;
@@ -41682,12 +41682,348 @@ var registerDeployConfigCommand = (program) => {
   });
 };
 
+// src/commands/deploy-config-link.ts
+import { OutputFormatter as OutputFormatter5, processContext as processContext5 } from "@uipath/common";
+
+// src/commands/deploy-config-utils.ts
+import { catchError as catchError6 } from "@uipath/common";
+import { getFileSystem as getFileSystem4 } from "@uipath/filesystem";
+async function readConfigFile(filePath) {
+  const fs = getFileSystem4();
+  const resolvedPath = fs.path.resolve(filePath);
+  const [readError, rawContent] = await catchError6(fs.readFile(resolvedPath, "utf-8"));
+  if (readError || !rawContent) {
+    return [
+      readError ?? new Error(`Config file is empty: ${resolvedPath}`),
+      null
+    ];
+  }
+  const [parseError, config3] = catchError6(() => JSON.parse(rawContent));
+  if (parseError) {
+    return [
+      new Error(`Invalid JSON in config file: ${parseError.message}`),
+      null
+    ];
+  }
+  if (!config3.resources || !Array.isArray(config3.resources)) {
+    return [
+      new Error("Invalid config file: missing or invalid 'resources' array"),
+      null
+    ];
+  }
+  return [null, { config: config3, resolvedPath }];
+}
+function findResource(config3, identifier) {
+  const nameMatches = config3.resources.filter((r) => r.name === identifier);
+  if (nameMatches.length === 1) {
+    return { resource: nameMatches[0], error: null };
+  }
+  if (nameMatches.length > 1) {
+    return { resource: null, error: "duplicate" };
+  }
+  const keyMatch = config3.resources.find((r) => r.resourceKey === identifier);
+  if (keyMatch) {
+    return { resource: keyMatch, error: null };
+  }
+  return { resource: null, error: "not_found" };
+}
+function resourceErrorMessage(identifier, findResult, config3) {
+  if (findResult.error === "duplicate") {
+    const dupes = config3.resources.filter((r) => r.name === identifier).map((r) => `${r.resourceKey} (${r.kind})`).join(", ");
+    return {
+      Message: `Multiple resources named '${identifier}' found in config`,
+      Instructions: `Use resourceKey instead to target a specific one: ${dupes}`
+    };
+  }
+  const available = config3.resources.map((r) => `${r.name} (${r.kind})`).join(", ");
+  return {
+    Message: `Resource '${identifier}' not found in config`,
+    Instructions: `Available resources: ${available}`
+  };
+}
+async function writeConfigFile(filePath, config3) {
+  const fs = getFileSystem4();
+  const [writeError] = await catchError6(fs.writeFile(filePath, `${JSON.stringify(config3, null, 2)}
+`));
+  return writeError;
+}
+var TOP_LEVEL_FIELDS = new Set(["conflictFixingAction"]);
+function isTopLevelField(property) {
+  return TOP_LEVEL_FIELDS.has(property);
+}
+function getAvailableProperties(resource) {
+  const topLevel = [...TOP_LEVEL_FIELDS];
+  const configKeys = Object.keys(resource.configuration ?? {});
+  return [...topLevel, ...configKeys].join(", ");
+}
+function parseConfigValue(raw, existingValue) {
+  if (raw === "null")
+    return null;
+  if (raw === "true")
+    return true;
+  if (raw === "false")
+    return false;
+  if (typeof existingValue === "string")
+    return raw;
+  const num = Number(raw);
+  if (!Number.isNaN(num) && raw.trim() !== "")
+    return num;
+  return raw;
+}
+
+// src/commands/deploy-config-link.ts
+var registerDeployConfigLinkCommand = (program) => {
+  program.command("link").description("Link a solution resource to an existing resource in Orchestrator instead of creating a new one during deployment. Example: 'config link config.json MyQueue --name ProductionQueue --folder-path Shared/Production'. Changes are local — pass the file to 'deploy run --config-file' to apply them.").argument("<file>", "Path to the deploy config JSON file. Generate one with 'solution deploy config get <package> -d config.json'.").argument("<resource>", "Resource name or resourceKey from the config file. Open the config JSON to see available resource names.").requiredOption("-n, --name <name>", "Name of the existing Orchestrator resource to link to. Use 'uip resources <kind> list' to find existing resources.").option("--folder-path <path>", "Orchestrator folder path where the existing resource lives. Use 'uip folders list' to see available folders.").trackedAction(processContext5, async (file3, resource, options) => {
+    const [readError, result] = await readConfigFile(file3);
+    if (readError) {
+      OutputFormatter5.error({
+        Result: "Failure",
+        Message: readError.message,
+        Instructions: "Provide a valid path to a deploy config JSON file."
+      });
+      processContext5.exit(1);
+      return;
+    }
+    const findResult = findResource(result.config, resource);
+    if (findResult.error) {
+      const errMsg = resourceErrorMessage(resource, findResult, result.config);
+      OutputFormatter5.error({
+        Result: "Failure",
+        ...errMsg
+      });
+      processContext5.exit(1);
+      return;
+    }
+    const target = findResult.resource;
+    const linkToResource = {
+      name: options.name
+    };
+    if (options.folderPath) {
+      linkToResource.folderPath = options.folderPath;
+    }
+    target.linkToResource = linkToResource;
+    const writeError = await writeConfigFile(result.resolvedPath, result.config);
+    if (writeError) {
+      OutputFormatter5.error({
+        Result: "Failure",
+        Message: `Failed to write config: ${writeError.message}`,
+        Instructions: writeError.message
+      });
+      processContext5.exit(1);
+      return;
+    }
+    OutputFormatter5.success({
+      Result: "Success",
+      Code: "DeployConfigLink",
+      Data: {
+        Resource: target.name,
+        LinkedTo: linkToResource
+      }
+    });
+  });
+};
+var registerDeployConfigUnlinkCommand = (program) => {
+  program.command("unlink").description("Remove a resource link from the config file. On the next 'deploy run --config-file', the resource will be unlinked from the existing Orchestrator resource and a new one will be created instead.").argument("<file>", "Path to the deploy config JSON file. Generate one with 'solution deploy config get <package> -d config.json'.").argument("<resource>", "Resource name or resourceKey from the config file. Open the config JSON to see available resource names and their current links.").trackedAction(processContext5, async (file3, resource) => {
+    const [readError, result] = await readConfigFile(file3);
+    if (readError) {
+      OutputFormatter5.error({
+        Result: "Failure",
+        Message: readError.message,
+        Instructions: "Provide a valid path to a deploy config JSON file."
+      });
+      processContext5.exit(1);
+      return;
+    }
+    const findResult = findResource(result.config, resource);
+    if (findResult.error) {
+      const errMsg = resourceErrorMessage(resource, findResult, result.config);
+      OutputFormatter5.error({
+        Result: "Failure",
+        ...errMsg
+      });
+      processContext5.exit(1);
+      return;
+    }
+    const target = findResult.resource;
+    if (!target.linkToResource) {
+      OutputFormatter5.error({
+        Result: "Failure",
+        Message: `Resource '${target.name}' is not linked to any Orchestrator resource`,
+        Instructions: "Use 'solution deploy config link' to create a link first."
+      });
+      processContext5.exit(1);
+      return;
+    }
+    const previousLink = target.linkToResource;
+    delete target.linkToResource;
+    const writeError = await writeConfigFile(result.resolvedPath, result.config);
+    if (writeError) {
+      OutputFormatter5.error({
+        Result: "Failure",
+        Message: `Failed to write config: ${writeError.message}`,
+        Instructions: writeError.message
+      });
+      processContext5.exit(1);
+      return;
+    }
+    OutputFormatter5.success({
+      Result: "Success",
+      Code: "DeployConfigUnlink",
+      Data: {
+        Resource: target.name,
+        UnlinkedFrom: previousLink.name
+      }
+    });
+  });
+};
+
+// src/commands/deploy-config-set.ts
+import { OutputFormatter as OutputFormatter6, processContext as processContext6 } from "@uipath/common";
+var registerDeployConfigSetCommand = (program) => {
+  program.command("set").description("Set a property on a resource in a deploy config file. Examples: 'config set config.json MyQueue maxNumberOfRetries 5' to set a resource property, 'config set config.json MyQueue conflictFixingAction UseExisting' to set conflict resolution, 'config set config.json --all conflictFixingAction UseExisting' to set on all resources. Changes are local — pass the file to 'deploy run --config-file' to apply them.").argument("<file>", "Path to the deploy config JSON file. Generate one with 'solution deploy config get <package> -d config.json'.").argument("<args...>", "Without --all: <resource> <property> <value>. With --all: <property> <value>. Resource names and property names are listed in the config file. Example: MyQueue maxNumberOfRetries 5").option("--all", "Apply to all resources in the config. Only works with conflictFixingAction. Example: --all conflictFixingAction UseExisting").trackedAction(processContext6, async (file3, args, options) => {
+    let resource;
+    let property;
+    let value;
+    if (options.all) {
+      if (args.length < 2) {
+        OutputFormatter6.error({
+          Result: "Failure",
+          Message: "Usage with --all: set <file> --all <property> <value>",
+          Instructions: "Provide property and value arguments."
+        });
+        processContext6.exit(1);
+        return;
+      }
+      property = args[0];
+      value = args[1];
+    } else {
+      if (args.length < 3) {
+        OutputFormatter6.error({
+          Result: "Failure",
+          Message: "Usage: set <file> <resource> <property> <value>",
+          Instructions: "Provide resource, property, and value arguments. Use --all to apply to all resources."
+        });
+        processContext6.exit(1);
+        return;
+      }
+      resource = args[0];
+      property = args[1];
+      value = args[2];
+    }
+    const [readError, result] = await readConfigFile(file3);
+    if (readError) {
+      OutputFormatter6.error({
+        Result: "Failure",
+        Message: readError.message,
+        Instructions: "Provide a valid path to a deploy config JSON file."
+      });
+      processContext6.exit(1);
+      return;
+    }
+    if (options.all) {
+      const parsedValue = parseConfigValue(value);
+      if (!isTopLevelField(property)) {
+        OutputFormatter6.error({
+          Result: "Failure",
+          Message: `--all can only be used with conflictFixingAction`,
+          Instructions: `To set configuration properties, target a specific resource by name or resourceKey.`
+        });
+        processContext6.exit(1);
+        return;
+      }
+      const oldValues = {};
+      for (const res of result.config.resources) {
+        oldValues[res.name] = res[property];
+        res[property] = parsedValue;
+      }
+      const writeError2 = await writeConfigFile(result.resolvedPath, result.config);
+      if (writeError2) {
+        OutputFormatter6.error({
+          Result: "Failure",
+          Message: `Failed to write config: ${writeError2.message}`,
+          Instructions: writeError2.message
+        });
+        processContext6.exit(1);
+        return;
+      }
+      OutputFormatter6.success({
+        Result: "Success",
+        Code: "DeployConfigSet",
+        Data: {
+          Resource: "all",
+          Property: property,
+          NewValue: parsedValue,
+          ResourceCount: result.config.resources.length
+        }
+      });
+      return;
+    }
+    const findResult = findResource(result.config, resource);
+    if (findResult.error) {
+      const errMsg = resourceErrorMessage(resource, findResult, result.config);
+      OutputFormatter6.error({
+        Result: "Failure",
+        ...errMsg
+      });
+      processContext6.exit(1);
+      return;
+    }
+    const target = findResult.resource;
+    let oldValue;
+    if (isTopLevelField(property)) {
+      oldValue = target[property];
+      target[property] = parseConfigValue(value, oldValue);
+    } else if (target.configuration && property in target.configuration) {
+      oldValue = target.configuration[property];
+      target.configuration[property] = parseConfigValue(value, oldValue);
+    } else {
+      OutputFormatter6.error({
+        Result: "Failure",
+        Message: `Property '${property}' not found on resource '${target.name}'`,
+        Instructions: `Available properties: ${getAvailableProperties(target)}`
+      });
+      processContext6.exit(1);
+      return;
+    }
+    const writeError = await writeConfigFile(result.resolvedPath, result.config);
+    if (writeError) {
+      OutputFormatter6.error({
+        Result: "Failure",
+        Message: `Failed to write config: ${writeError.message}`,
+        Instructions: writeError.message
+      });
+      processContext6.exit(1);
+      return;
+    }
+    const newValue = isTopLevelField(property) ? target[property] : target.configuration[property];
+    OutputFormatter6.success({
+      Result: "Success",
+      Code: "DeployConfigSet",
+      Data: {
+        Resource: target.name,
+        Property: property,
+        OldValue: oldValue,
+        NewValue: newValue
+      }
+    });
+  });
+};
+
+// src/commands/deploy-config.ts
+var registerDeployConfigCommand = (program) => {
+  const config3 = program.command("config").description("Manage deployment configuration for solution packages. A config file describes the resources (assets, queues, processes, buckets, etc.) included in a solution and their settings. Workflow: 'config get' fetches the default config from the server, then 'config set' / 'config link' customize it before passing to 'deploy run --config-file'.");
+  registerDeployConfigGetCommand(config3);
+  registerDeployConfigSetCommand(config3);
+  registerDeployConfigLinkCommand(config3);
+  registerDeployConfigUnlinkCommand(config3);
+};
+
 // src/commands/deploy-list.ts
 import {
-  catchError as catchError7,
+  catchError as catchError8,
   extractErrorDetails as extractErrorDetails4,
-  OutputFormatter as OutputFormatter5,
-  processContext as processContext5
+  OutputFormatter as OutputFormatter7,
+  processContext as processContext7
 } from "@uipath/common";
 
 // ../solution-sdk/generated/src/runtime.ts
@@ -42211,7 +42547,7 @@ var TEMP_DIR2 = join2(PKG_ROOT2, "temp");
 var GENERATE_DIR2 = join2(PKG_ROOT2, "swagger");
 if (false) {}
 // src/services/folder-helper.ts
-import { catchError as catchError6 } from "@uipath/common";
+import { catchError as catchError7 } from "@uipath/common";
 
 // ../orchestrator-sdk/generated/src/runtime.ts
 var BASE_PATH3 = "https://alpha.uipath.com/uipattycyrhx/abizon_1/orchestrator_".replace(/\/+$/, "");
@@ -44562,7 +44898,7 @@ async function resolveParentFolder(options) {
   if (options.folderPath) {
     return options.folderPath;
   }
-  const [resolveError, resolved] = await catchError6(resolveFolder({ folderKey: options.folderKey }, { tenant: options.tenant, loginValidity: options.loginValidity }));
+  const [resolveError, resolved] = await catchError7(resolveFolder({ folderKey: options.folderKey }, { tenant: options.tenant, loginValidity: options.loginValidity }));
   if (resolveError) {
     throw new Error(`Failed to resolve folder key '${options.folderKey}': ${resolveError.message}`);
   }
@@ -44574,33 +44910,33 @@ async function resolveParentFolder(options) {
 
 // src/commands/deploy-list.ts
 var registerDeployListCommand = (program) => {
-  program.command("list").description("List solution deployments. Shows deployment name, status, package version, and folder path.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--folder-path <path>", "Filter by parent folder path (e.g., 'Shared')").option("--folder-key <key>", "Filter by parent folder key (GUID). Alternative to --folder-path.").option("--take <number>", "Max deployments to fetch (default: 10). Applied before --folder-path filter.", (v) => parseInt(v, 10), 10).option("--order-by <column>", "Column to order by (default: startTime)", "startTime").option("--order-direction <direction>", "Order direction: Ascending or Descending (default: Descending)", "Descending").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext5, async (options) => {
-    const [authError, auth] = await catchError7(getSolutionAuthContext({
+  program.command("list").description("List solution deployments. Shows deployment name, status, package version, and folder path.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--folder-path <path>", "Filter by parent folder path (e.g., 'Shared')").option("--folder-key <key>", "Filter by parent folder key (GUID). Alternative to --folder-path.").option("--take <number>", "Max deployments to fetch (default: 10). Applied before --folder-path filter.", (v) => parseInt(v, 10), 10).option("--order-by <column>", "Column to order by (default: startTime)", "startTime").option("--order-direction <direction>", "Order direction: Ascending or Descending (default: Descending)", "Descending").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext7, async (options) => {
+    const [authError, auth] = await catchError8(getSolutionAuthContext({
       tenant: options.tenant,
       loginValidity: options.loginValidity
     }));
     if (authError) {
-      OutputFormatter5.error({
+      OutputFormatter7.error({
         Result: "Failure",
         Message: authError.message,
         Instructions: authError.message
       });
-      processContext5.exit(1);
+      processContext7.exit(1);
       return;
     }
-    const [folderError, folderPathFilter] = await catchError7(resolveParentFolder({
+    const [folderError, folderPathFilter] = await catchError8(resolveParentFolder({
       folderPath: options.folderPath,
       folderKey: options.folderKey,
       tenant: options.tenant,
       loginValidity: options.loginValidity
     }));
     if (folderError) {
-      OutputFormatter5.error({
+      OutputFormatter7.error({
         Result: "Failure",
         Message: folderError.message,
         Instructions: "Provide a valid --folder-path or --folder-key to filter by folder."
       });
-      processContext5.exit(1);
+      processContext7.exit(1);
       return;
     }
     const configuration = new Configuration2({
@@ -44608,7 +44944,7 @@ var registerDeployListCommand = (program) => {
       accessToken: auth.accessToken
     });
     const api = new SearchApi(configuration);
-    const [listError, result] = await catchError7(api.searchSearchDeployments22({
+    const [listError, result] = await catchError8(api.searchSearchDeployments22({
       deploymentsSearchRequest2: {
         take: options.take,
         orderByColumn: options.orderBy,
@@ -44619,12 +44955,12 @@ var registerDeployListCommand = (program) => {
     }));
     if (listError) {
       const { message, details } = await extractErrorDetails4(listError);
-      OutputFormatter5.error({
+      OutputFormatter7.error({
         Result: "Failure",
         Message: message,
         Instructions: `Failed to list deployments. Details: ${details}`
       });
-      processContext5.exit(1);
+      processContext7.exit(1);
       return;
     }
     let values = result.values;
@@ -44640,7 +44976,7 @@ var registerDeployListCommand = (program) => {
       FolderPath: d.folderPath,
       CreatedAt: d.deploymentCreationTime
     }));
-    OutputFormatter5.success({
+    OutputFormatter7.success({
       Result: "Success",
       Code: "SolutionDeployList",
       Data: deployments
@@ -44650,13 +44986,13 @@ var registerDeployListCommand = (program) => {
 
 // src/commands/deploy-run.ts
 import {
-  catchError as catchError8,
+  catchError as catchError9,
   extractErrorDetails as extractErrorDetails5,
-  OutputFormatter as OutputFormatter6,
+  OutputFormatter as OutputFormatter8,
   pollUntil as pollUntil2,
-  processContext as processContext6
+  processContext as processContext8
 } from "@uipath/common";
-import { getFileSystem as getFileSystem4 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem5 } from "@uipath/filesystem";
 var TERMINAL_STATUSES2 = new Set([
   "DeploymentSucceeded",
   "DeploymentFailed",
@@ -44665,33 +45001,33 @@ var TERMINAL_STATUSES2 = new Set([
   "DeploymentScheduleError"
 ]);
 var registerDeployRunCommand = (program) => {
-  program.command("run").description("Deploy a solution package to Orchestrator. Creates a folder, provisions resources, and activates the solution. Use 'solution deploy config' to customize before deploying.").requiredOption("-n, --name <deployment-name>", "Name for the deployment").requiredOption("--package-name <name>", "Solution package name to deploy").requiredOption("--package-version <version>", "Solution package version to deploy").requiredOption("--folder-name <name>", "Name of the Orchestrator folder to create for this deployment").option("--folder-path <path>", "Parent folder path (e.g., 'Shared'). Solution folder is created under this.").option("--folder-key <key>", "Parent folder key (GUID). Alternative to --folder-path.").option("--config-file <path>", "JSON configuration file. Generate with: uip solution deploy config <name> -o config.json").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--timeout <seconds>", "Timeout in seconds for deployment polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between deployment status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext6, async (options) => {
-    const [authError, auth] = await catchError8(getSolutionAuthContext({
+  program.command("run").description("Deploy a solution package to Orchestrator. Creates a folder, provisions resources, and activates the solution. To customize resource settings before deploying, use 'config get' to fetch the default config, 'config set' / 'config link' to edit it, then pass it here with --config-file.").requiredOption("-n, --name <deployment-name>", "Name for the deployment").requiredOption("--package-name <name>", "Solution package name to deploy. Use 'solution packages list' to find available names.").requiredOption("--package-version <version>", "Solution package version to deploy. Use 'solution packages list' to find available versions.").requiredOption("--folder-name <name>", "Name of the Orchestrator folder to create for this deployment").option("--folder-path <path>", "Parent folder path (e.g., 'Shared'). Solution folder is created under this.").option("--folder-key <key>", "Parent folder key (GUID). Alternative to --folder-path.").option("--config-file <path>", "JSON configuration file. Generate with: uip solution deploy config get <name> -d config.json, then customize with 'config set' or 'config link'.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--timeout <seconds>", "Timeout in seconds for deployment polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between deployment status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext8, async (options) => {
+    const [authError, auth] = await catchError9(getSolutionAuthContext({
       tenant: options.tenant,
       loginValidity: options.loginValidity
     }));
     if (authError) {
-      OutputFormatter6.error({
+      OutputFormatter8.error({
         Result: "Failure",
         Message: authError.message,
         Instructions: authError.message
       });
-      processContext6.exit(1);
+      processContext8.exit(1);
       return;
     }
-    const [folderError, parentFolderPath] = await catchError8(resolveParentFolder({
+    const [folderError, parentFolderPath] = await catchError9(resolveParentFolder({
       folderPath: options.folderPath,
       folderKey: options.folderKey,
       tenant: options.tenant,
       loginValidity: options.loginValidity
     }));
     if (folderError) {
-      OutputFormatter6.error({
+      OutputFormatter8.error({
         Result: "Failure",
         Message: folderError.message,
         Instructions: "Provide a valid --folder-path or --folder-key for the parent folder."
       });
-      processContext6.exit(1);
+      processContext8.exit(1);
       return;
     }
     const configuration = new Configuration({
@@ -44701,31 +45037,31 @@ var registerDeployRunCommand = (program) => {
     const api = new PipelinesApi(configuration);
     let configBody;
     if (options.configFile) {
-      const fs = getFileSystem4();
+      const fs = getFileSystem5();
       const configPath = fs.path.resolve(options.configFile);
-      const [readError, configContent] = await catchError8(fs.readFile(configPath, "utf-8"));
+      const [readError, configContent] = await catchError9(fs.readFile(configPath, "utf-8"));
       if (readError) {
-        OutputFormatter6.error({
+        OutputFormatter8.error({
           Result: "Failure",
           Message: `Failed to read config file: ${configPath}`,
           Instructions: readError.message
         });
-        processContext6.exit(1);
+        processContext8.exit(1);
         return;
       }
-      const [parseError, parsed] = catchError8(() => JSON.parse(configContent));
+      const [parseError, parsed] = catchError9(() => JSON.parse(configContent));
       if (parseError) {
-        OutputFormatter6.error({
+        OutputFormatter8.error({
           Result: "Failure",
           Message: `Invalid JSON in config file: ${configPath}`,
           Instructions: parseError.message
         });
-        processContext6.exit(1);
+        processContext8.exit(1);
         return;
       }
       configBody = parsed;
     }
-    const [installError, installResult] = await catchError8(api.pipelinesInstall({
+    const [installError, installResult] = await catchError9(api.pipelinesInstall({
       deploymentName: options.name,
       packageName: options.packageName,
       packageVersion: options.packageVersion,
@@ -44735,12 +45071,12 @@ var registerDeployRunCommand = (program) => {
     }));
     if (installError) {
       const { message, details } = await extractErrorDetails5(installError);
-      OutputFormatter6.error({
+      OutputFormatter8.error({
         Result: "Failure",
         Message: message,
         Instructions: `Check package name/version with: uip solution packages list. Details: ${details}`
       });
-      processContext6.exit(1);
+      processContext8.exit(1);
       return;
     }
     const pipelineDeploymentId = installResult.pipelineDeploymentId;
@@ -44754,7 +45090,7 @@ var registerDeployRunCommand = (program) => {
       logPrefix: "deploy",
       timeoutMs: options.timeout * 1000,
       intervalMs: options.pollInterval,
-      signal: processContext6.pollSignal
+      signal: processContext8.pollSignal
     });
     if (handlePollFailure(pollResult, "Deployment", `Deployment may still be in progress. Check status with: uip solution deploy status ${pipelineDeploymentId}.`)) {
       return;
@@ -44762,15 +45098,15 @@ var registerDeployRunCommand = (program) => {
     const finalStatus = pollResult.data;
     if (finalStatus.status !== "DeploymentSucceeded") {
       const errors = finalStatus.validationResult?.validationErrors?.map((e) => e.errorText).join(", ") || "Unknown error";
-      OutputFormatter6.error({
+      OutputFormatter8.error({
         Result: "Failure",
         Message: `Deployment failed with status: ${finalStatus.status}`,
         Instructions: errors
       });
-      processContext6.exit(1);
+      processContext8.exit(1);
       return;
     }
-    OutputFormatter6.success({
+    OutputFormatter8.success({
       Result: "Success",
       Code: "SolutionDeployRun",
       Data: {
@@ -44785,24 +45121,24 @@ var registerDeployRunCommand = (program) => {
 
 // src/commands/deploy-status.ts
 import {
-  catchError as catchError9,
+  catchError as catchError10,
   extractErrorDetails as extractErrorDetails6,
-  OutputFormatter as OutputFormatter7,
-  processContext as processContext7
+  OutputFormatter as OutputFormatter9,
+  processContext as processContext9
 } from "@uipath/common";
 var registerDeployStatusCommand = (program) => {
-  program.command("status").description("Check the current status of a pipeline deployment. Returns deployment state, progress, and any errors.").argument("<pipeline-deployment-id>", "Pipeline deployment ID (GUID) to check status for.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext7, async (pipelineDeploymentId, options) => {
-    const [authError, auth] = await catchError9(getSolutionAuthContext({
+  program.command("status").description("Check the current status of a pipeline deployment. Returns deployment state, progress, and any errors.").argument("<pipeline-deployment-id>", "Pipeline deployment ID (GUID) returned by 'solution deploy run'.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext9, async (pipelineDeploymentId, options) => {
+    const [authError, auth] = await catchError10(getSolutionAuthContext({
       tenant: options.tenant,
       loginValidity: options.loginValidity
     }));
     if (authError) {
-      OutputFormatter7.error({
+      OutputFormatter9.error({
         Result: "Failure",
         Message: authError.message,
         Instructions: authError.message
       });
-      processContext7.exit(1);
+      processContext9.exit(1);
       return;
     }
     const configuration = new Configuration({
@@ -44810,20 +45146,20 @@ var registerDeployStatusCommand = (program) => {
       accessToken: auth.accessToken
     });
     const api = new PipelinesApi(configuration);
-    const [statusError, result] = await catchError9(api.pipelinesGetPipelineDeploymentStatus({
+    const [statusError, result] = await catchError10(api.pipelinesGetPipelineDeploymentStatus({
       pipelineDeploymentId
     }));
     if (statusError) {
       const { message, details } = await extractErrorDetails6(statusError);
-      OutputFormatter7.error({
+      OutputFormatter9.error({
         Result: "Failure",
         Message: message,
         Instructions: `Check the pipeline deployment ID. Get it from deploy run output. Details: ${details}`
       });
-      processContext7.exit(1);
+      processContext9.exit(1);
       return;
     }
-    OutputFormatter7.success({
+    OutputFormatter9.success({
       Result: "Success",
       Code: "SolutionDeployStatus",
       Data: {
@@ -44847,29 +45183,29 @@ var registerDeployStatusCommand = (program) => {
 
 // src/commands/deploy-uninstall.ts
 import {
-  catchError as catchError10,
+  catchError as catchError11,
   extractErrorDetails as extractErrorDetails7,
-  OutputFormatter as OutputFormatter8,
+  OutputFormatter as OutputFormatter10,
   pollUntil as pollUntil3,
-  processContext as processContext8
+  processContext as processContext10
 } from "@uipath/common";
 var TERMINAL_STATUSES3 = new Set([
   "SuccessfulUninstall",
   "FailedUninstall"
 ]);
 var registerDeployUninstallCommand = (program) => {
-  program.command("uninstall").description("Uninstall a deployed solution. Removes all provisioned resources and the solution folder.").argument("<deployment-name>", "Name of the deployment to uninstall").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--timeout <seconds>", "Timeout in seconds for uninstall polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between uninstall status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext8, async (deploymentName, options) => {
-    const [authError, auth] = await catchError10(getSolutionAuthContext({
+  program.command("uninstall").description("Uninstall a deployed solution. Removes all provisioned resources and the solution folder.").argument("<deployment-name>", "Name of the deployment to uninstall. Use 'solution deploy list' to find deployment names.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--timeout <seconds>", "Timeout in seconds for uninstall polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between uninstall status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext10, async (deploymentName, options) => {
+    const [authError, auth] = await catchError11(getSolutionAuthContext({
       tenant: options.tenant,
       loginValidity: options.loginValidity
     }));
     if (authError) {
-      OutputFormatter8.error({
+      OutputFormatter10.error({
         Result: "Failure",
         Message: authError.message,
         Instructions: authError.message
       });
-      processContext8.exit(1);
+      processContext10.exit(1);
       return;
     }
     const configuration = new Configuration({
@@ -44877,19 +45213,19 @@ var registerDeployUninstallCommand = (program) => {
       accessToken: auth.accessToken
     });
     const api = new PipelinesApi(configuration);
-    const [uninstallError, uninstallResult] = await catchError10(api.pipelinesUninstall({ deploymentName }));
+    const [uninstallError, uninstallResult] = await catchError11(api.pipelinesUninstall({ deploymentName }));
     if (uninstallError) {
       const { message, details } = await extractErrorDetails7(uninstallError);
-      OutputFormatter8.error({
+      OutputFormatter10.error({
         Result: "Failure",
         Message: message,
         Instructions: `Check deployment name matches an existing deployment. Details: ${details}`
       });
-      processContext8.exit(1);
+      processContext10.exit(1);
       return;
     }
     if (uninstallResult.complete) {
-      OutputFormatter8.success({
+      OutputFormatter10.success({
         Result: "Success",
         Code: "SolutionDeployUninstall",
         Data: {
@@ -44901,7 +45237,7 @@ var registerDeployUninstallCommand = (program) => {
     }
     const instanceId = uninstallResult.instanceId;
     if (!instanceId) {
-      OutputFormatter8.success({
+      OutputFormatter10.success({
         Result: "Success",
         Code: "SolutionDeployUninstall",
         Data: {
@@ -44922,7 +45258,7 @@ var registerDeployUninstallCommand = (program) => {
       logPrefix: "uninstall",
       timeoutMs: options.timeout * 1000,
       intervalMs: options.pollInterval,
-      signal: processContext8.pollSignal
+      signal: processContext10.pollSignal
     });
     if (handlePollFailure(pollResult, "Uninstall", "Uninstall may still be in progress.")) {
       return;
@@ -44930,15 +45266,15 @@ var registerDeployUninstallCommand = (program) => {
     const finalStatus = pollResult.data;
     if (finalStatus.status !== "SuccessfulUninstall") {
       const errors = finalStatus.errorMessage?.map((e) => e.errorMessage).join(", ") || "Unknown error";
-      OutputFormatter8.error({
+      OutputFormatter10.error({
         Result: "Failure",
         Message: `Uninstall failed with status: ${finalStatus.status}`,
         Instructions: errors
       });
-      processContext8.exit(1);
+      processContext10.exit(1);
       return;
     }
-    OutputFormatter8.success({
+    OutputFormatter10.success({
       Result: "Success",
       Code: "SolutionDeployUninstall",
       Data: {
@@ -44962,24 +45298,24 @@ var registerDeployCommand = (program) => {
 };
 
 // src/commands/new.ts
-import { catchError as catchError11, OutputFormatter as OutputFormatter9, processContext as processContext9 } from "@uipath/common";
-import { getFileSystem as getFileSystem5 } from "@uipath/filesystem";
+import { catchError as catchError12, OutputFormatter as OutputFormatter11, processContext as processContext11 } from "@uipath/common";
+import { getFileSystem as getFileSystem6 } from "@uipath/filesystem";
 var registerNewCommand = (program) => {
-  program.command("new").description("Create a new empty UiPath solution file").argument("<solutionName>", "Solution file name or path (relative or absolute). Appends .uipx if no extension is specified").trackedAction(processContext9, async (solutionName) => {
-    const fs = getFileSystem5();
+  program.command("new").description("Create a new empty UiPath solution. Creates a directory named after the solution containing a .uipx manifest file with an empty Projects array. Use 'solution project add' to add projects afterward.").argument("<solutionName>", "Solution file name or path (relative or absolute). Appends .uipx if no extension is specified").trackedAction(processContext11, async (solutionName) => {
+    const fs = getFileSystem6();
     const base = fs.path.basename(solutionName);
     const hasExtension = base.lastIndexOf(".") > 0;
     const nameWithoutExt = hasExtension ? base.slice(0, base.lastIndexOf(".")) : base;
     const fileName = hasExtension ? base : `${base}.uipx`;
     const parentDir = fs.path.resolve(fs.path.dirname(solutionName), nameWithoutExt);
-    const [mkdirError] = await catchError11(fs.mkdir(parentDir));
+    const [mkdirError] = await catchError12(fs.mkdir(parentDir));
     if (mkdirError) {
-      OutputFormatter9.error({
+      OutputFormatter11.error({
         Result: "Failure",
         Message: "Failed to create solution directory",
         Instructions: mkdirError.message
       });
-      processContext9.exit(1);
+      processContext11.exit(1);
       return;
     }
     const filePath = fs.path.join(parentDir, fileName);
@@ -44989,18 +45325,18 @@ var registerNewCommand = (program) => {
       SolutionId: crypto.randomUUID(),
       Projects: []
     };
-    const [writeFileError] = await catchError11(fs.writeFile(filePath, `${JSON.stringify(solution, null, 2)}
+    const [writeFileError] = await catchError12(fs.writeFile(filePath, `${JSON.stringify(solution, null, 2)}
 `));
     if (writeFileError) {
-      OutputFormatter9.error({
+      OutputFormatter11.error({
         Result: "Failure",
         Message: "Failed to create solution",
         Instructions: writeFileError.message
       });
-      processContext9.exit(1);
+      processContext11.exit(1);
       return;
     }
-    OutputFormatter9.success({
+    OutputFormatter11.success({
       Result: "Success",
       Code: "SolutionNew",
       Data: {
@@ -45008,23 +45344,23 @@ var registerNewCommand = (program) => {
         Path: filePath
       }
     });
-    processContext9.exit(0);
+    processContext11.exit(0);
   });
 };
 
 // src/commands/pack.ts
-import { processContext as processContext10 } from "@uipath/common";
+import { processContext as processContext12 } from "@uipath/common";
 
 // src/services/pack-command-service.ts
 import { getLoginStatusAsync as getLoginStatusAsync3 } from "@uipath/auth";
 import {
-  catchError as catchError13,
+  catchError as catchError14,
   logger as logger4,
-  OutputFormatter as OutputFormatter10,
+  OutputFormatter as OutputFormatter12,
   LogLevel as SimpleLogLevel,
   telemetry
 } from "@uipath/common";
-import { getFileSystem as getFileSystem6 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem7 } from "@uipath/filesystem";
 
 // ../packager/solution-packager/dist/node.js
 import { I18nManager as I18nManager3 } from "@uipath/solutionpackager-tool-core";
@@ -48517,7 +48853,7 @@ import {
 } from "@uipath/solutionpackager-tool-core";
 
 // src/services/packager-tool-resolver.ts
-import { catchError as catchError12, ensurePackagerFactory, logger as logger3 } from "@uipath/common";
+import { catchError as catchError13, ensurePackagerFactory, logger as logger3 } from "@uipath/common";
 import { toolsFactoryRepository as toolsFactoryRepository7 } from "@uipath/solutionpackager-tool-core";
 var PROJECT_TYPE_TO_TOOL = new Map([
   ["Process", "rpa"],
@@ -48539,7 +48875,7 @@ async function readProjectTypes(solutionDir, fs) {
   if (!content)
     return [];
   const json3 = typeof content === "string" ? content : new TextDecoder().decode(content);
-  const [parseError, solution] = catchError12(() => JSON.parse(json3));
+  const [parseError, solution] = catchError13(() => JSON.parse(json3));
   if (parseError) {
     throw new Error(`Failed to parse ${uipxFile}: ${parseError.message}`);
   }
@@ -48571,15 +48907,15 @@ class PackCommandService {
   packager = null;
   fs;
   constructor() {
-    this.fs = getFileSystem6();
+    this.fs = getFileSystem7();
   }
   async execute(solutionPath, options, context) {
     const absoluteSolutionPath = this.fs.path.resolve(solutionPath);
     const absoluteOutputPath = this.fs.path.resolve(options.output);
-    const [statError, stats] = await catchError13(this.fs.stat(absoluteSolutionPath));
+    const [statError, stats] = await catchError14(this.fs.stat(absoluteSolutionPath));
     if (statError || !stats) {
       const msg = statError?.message ?? `Solution path does not exist: ${absoluteSolutionPath}`;
-      OutputFormatter10.error({
+      OutputFormatter12.error({
         Result: "Failure",
         Message: msg,
         Instructions: msg
@@ -48601,9 +48937,9 @@ Packing solution...
     logger4.info(`  Package:  ${packageName}@${options.version}`);
     logger4.info(`  Output:   ${absoluteOutputPath}`);
     logger4.info("");
-    const [error79, result] = await catchError13(this.executeAsync(solutionPath, options));
+    const [error79, result] = await catchError14(this.executeAsync(solutionPath, options));
     if (error79) {
-      OutputFormatter10.error({
+      OutputFormatter12.error({
         Result: "Failure",
         Message: error79 instanceof Error ? error79.message : String(error79),
         Instructions: `${error79 instanceof Error ? error79.message : String(error79)}`
@@ -48616,7 +48952,7 @@ Packing solution...
       return;
     }
     if (result.errorCode !== ToolErrorCodes9.Success) {
-      OutputFormatter10.error({
+      OutputFormatter12.error({
         Result: "Failure",
         Message: `Error code: ${result.errorCode} : ${result.message}`,
         Instructions: `${result.message}`
@@ -48624,7 +48960,7 @@ Packing solution...
       context.exit(1);
       return;
     }
-    OutputFormatter10.success({
+    OutputFormatter12.success({
       Result: "Success",
       Code: "SolutionPack",
       Data: {
@@ -48652,7 +48988,7 @@ Packing solution...
     logger4.debug(`Processing: ${absoluteSolutionPath}`);
     logger4.debug(`Package: ${packageName}@${options.version}`);
     logger4.debug(`Output: ${absoluteOutputPath}`);
-    const [error79, result] = await catchError13(async () => {
+    const [error79, result] = await catchError14(async () => {
       await this.fs.mkdir(absoluteOutputPath);
       const packager = await this.ensurePackagerAsync();
       let inputPath;
@@ -48723,58 +49059,58 @@ Packing solution...
 
 // src/commands/pack.ts
 var registerPackCommand = (program) => {
-  program.command("pack").description("Pack a UiPath solution from a folder or .uis file").argument("<solutionPath>", "Solution path").argument("<outputPath>", "Output directory where the packed solution will be saved").option("-n, --name <name>", "Package name (default: solution folder name or .uis file name)").option("-v, --version <version>", "Package version (default: 1.0.0)", "1.0.0").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext10, async (solutionPath, outputPath, options) => {
+  program.command("pack").description("Pack a UiPath solution into a deployable .zip package. Accepts a solution directory (containing .uipx) or a .uis bundle file. Output is used with 'solution publish' to upload to UiPath.").argument("<solutionPath>", "Path to a solution directory (containing .uipx) or a .uis bundle file").argument("<outputPath>", "Output directory where the packed solution will be saved").option("-n, --name <name>", "Package name (default: solution folder name or .uis file name)").option("-v, --version <version>", "Package version (default: 1.0.0)", "1.0.0").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext12, async (solutionPath, outputPath, options) => {
     const service = new PackCommandService;
     await service.execute(solutionPath, {
       output: outputPath,
       name: options.name,
       version: options.version,
       loginValidity: options.loginValidity
-    }, processContext10);
+    }, processContext12);
   });
 };
 
 // src/commands/packages-delete.ts
 import {
-  catchError as catchError14,
+  catchError as catchError15,
   extractErrorDetails as extractErrorDetails8,
-  OutputFormatter as OutputFormatter11,
-  processContext as processContext11
+  OutputFormatter as OutputFormatter13,
+  processContext as processContext13
 } from "@uipath/common";
 var registerPackagesDeleteCommand = (program) => {
-  program.command("delete").description("Delete a specific version of a solution package.").argument("<packageName>", "The name of the package").argument("<packageVersion>", "The version to delete (e.g. 1.0.0)").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext11, async (packageName, packageVersion, options) => {
-    const [authError, auth] = await catchError14(getSolutionAuthContext({
+  program.command("delete").description("Delete a specific version of a solution package. " + "Use 'solution packages list' to find available package names and versions.").argument("<packageName>", "The name of the package").argument("<packageVersion>", "The version to delete (e.g. 1.0.0)").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext13, async (packageName, packageVersion, options) => {
+    const [authError, auth] = await catchError15(getSolutionAuthContext({
       tenant: options.tenant,
       loginValidity: options.loginValidity
     }));
     if (authError) {
-      OutputFormatter11.error({
+      OutputFormatter13.error({
         Result: "Failure",
         Message: authError.message,
         Instructions: "Run 'uip login' to authenticate and try again."
       });
-      processContext11.exit(1);
+      processContext13.exit(1);
       return;
     }
     const api = new PipelinesApi(new Configuration({
       basePath: auth.basePath,
       accessToken: auth.accessToken
     }));
-    const [deleteError] = await catchError14(api.pipelinesPackageDelete({
+    const [deleteError] = await catchError15(api.pipelinesPackageDelete({
       packageName,
       packageVersion
     }));
     if (deleteError) {
       const { message } = await extractErrorDetails8(deleteError);
-      OutputFormatter11.error({
+      OutputFormatter13.error({
         Result: "Failure",
         Message: message,
         Instructions: "Check that the package name and version are correct and that you have permission to delete it."
       });
-      processContext11.exit(1);
+      processContext13.exit(1);
       return;
     }
-    OutputFormatter11.success({
+    OutputFormatter13.success({
       Result: "Success",
       Code: "SolutionPackagesDelete",
       Data: {
@@ -48787,24 +49123,24 @@ var registerPackagesDeleteCommand = (program) => {
 
 // src/commands/packages-list.ts
 import {
-  catchError as catchError15,
+  catchError as catchError16,
   extractErrorDetails as extractErrorDetails9,
-  OutputFormatter as OutputFormatter12,
-  processContext as processContext12
+  OutputFormatter as OutputFormatter14,
+  processContext as processContext14
 } from "@uipath/common";
 var registerPackagesListCommand = (program) => {
-  program.command("list").description("List all solution packages available in UiPath.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--take <count>", "Number of packages to return (default: 10)", (v) => parseInt(v, 10), 10).option("--order-by <column>", "Column to order by", "publishDate").option("--order-direction <direction>", "Order direction (Ascending or Descending)", "Descending").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext12, async (options) => {
-    const [authError, auth] = await catchError15(getSolutionAuthContext({
+  program.command("list").description("List solution packages published to UiPath. Returns package name, version, and publish date. Use the package name and version from this output when running 'solution deploy run'.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").option("--take <count>", "Number of packages to return (default: 10)", (v) => parseInt(v, 10), 10).option("--order-by <column>", "Column to order by (default: publishDate)", "publishDate").option("--order-direction <direction>", "Order direction: Ascending or Descending (default: Descending)", "Descending").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext14, async (options) => {
+    const [authError, auth] = await catchError16(getSolutionAuthContext({
       tenant: options.tenant,
       loginValidity: options.loginValidity
     }));
     if (authError) {
-      OutputFormatter12.error({
+      OutputFormatter14.error({
         Result: "Failure",
         Message: authError.message,
         Instructions: authError.message
       });
-      processContext12.exit(1);
+      processContext14.exit(1);
       return;
     }
     const configuration = new Configuration2({
@@ -48812,7 +49148,7 @@ var registerPackagesListCommand = (program) => {
       accessToken: auth.accessToken
     });
     const searchApi = new SearchApi(configuration);
-    const [searchPackagesError, searchPackagesResult] = await catchError15(searchApi.searchSearchPackages({
+    const [searchPackagesError, searchPackagesResult] = await catchError16(searchApi.searchSearchPackages({
       searchFilter: {
         orderByColumn: options.orderBy,
         orderByDirection: options.orderDirection,
@@ -48821,15 +49157,15 @@ var registerPackagesListCommand = (program) => {
     }));
     if (searchPackagesError) {
       const { message, details } = await extractErrorDetails9(searchPackagesError);
-      OutputFormatter12.error({
+      OutputFormatter14.error({
         Result: "Failure",
         Message: message,
         Instructions: `Failed to list packages. Details: ${details}`
       });
-      processContext12.exit(1);
+      processContext14.exit(1);
       return;
     }
-    OutputFormatter12.success({
+    OutputFormatter14.success({
       Result: "Success",
       Code: "SolutionPackagesList",
       Data: searchPackagesResult.values
@@ -48839,22 +49175,22 @@ var registerPackagesListCommand = (program) => {
 
 // src/commands/packages.ts
 var registerPackagesCommand = (program) => {
-  const packages = program.command("packages").description("Manage solution packages in UiPath");
+  const packages = program.command("packages").description("Solution packages — packaged solution bundles published to UiPath for deployment. Use 'packages list' to find available packages for 'deploy run'.");
   registerPackagesListCommand(packages);
   registerPackagesDeleteCommand(packages);
 };
 
 // src/commands/project.ts
-import { getFileSystem as getFileSystem12 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem13 } from "@uipath/filesystem";
 
 // src/commands/project-add.ts
 import { randomUUID } from "node:crypto";
-import { OutputFormatter as OutputFormatter13, processContext as processContext13 } from "@uipath/common";
-import { getFileSystem as getFileSystem9 } from "@uipath/filesystem";
+import { OutputFormatter as OutputFormatter15, processContext as processContext15 } from "@uipath/common";
+import { getFileSystem as getFileSystem10 } from "@uipath/filesystem";
 
 // src/commands/project-utils.ts
-import { catchError as catchError17 } from "@uipath/common";
-import { getFileSystem as getFileSystem8 } from "@uipath/filesystem";
+import { catchError as catchError18 } from "@uipath/common";
+import { getFileSystem as getFileSystem9 } from "@uipath/filesystem";
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/index.js
 var import_reflect_metadata = __toESM(require_Reflect(), 1);
@@ -60250,15 +60586,15 @@ class CliAccessProvider {
 }
 
 // src/providers/file-storage-provider.ts
-import { catchError as catchError16, logger as logger5 } from "@uipath/common";
-import { getFileSystem as getFileSystem7 } from "@uipath/filesystem";
+import { catchError as catchError17, logger as logger5 } from "@uipath/common";
+import { getFileSystem as getFileSystem8 } from "@uipath/filesystem";
 
 class FileSystemFileStorageProvider {
   basePath;
   fs;
   constructor(basePath) {
     this.basePath = basePath;
-    this.fs = getFileSystem7();
+    this.fs = getFileSystem8();
   }
   async fileExistsAsync(filePath, cancellationToken) {
     this.throwIfCancelled(cancellationToken);
@@ -60317,7 +60653,7 @@ class FileSystemFileStorageProvider {
   async deleteFileAsync(filePath, cancellationToken) {
     this.throwIfCancelled(cancellationToken);
     const fullPath = this.fs.path.join(this.basePath, filePath);
-    const [deleteError] = await catchError16(this.fs.rm(fullPath));
+    const [deleteError] = await catchError17(this.fs.rm(fullPath));
     if (deleteError) {
       logger5.warn(`File not found, skipping delete: ${fullPath}`);
     }
@@ -60338,13 +60674,13 @@ class FileSystemFileStorageProvider {
     }
     this.throwIfCancelled(cancellationToken);
     const results = [];
-    const [readdirError, entries] = await catchError16(this.fs.readdir(dir));
+    const [readdirError, entries] = await catchError17(this.fs.readdir(dir));
     if (readdirError) {
       return [];
     }
     for (const entryName of entries) {
       const fullPath = this.fs.path.join(dir, entryName);
-      const [statError, stat] = await catchError16(this.fs.stat(fullPath));
+      const [statError, stat] = await catchError17(this.fs.stat(fullPath));
       if (statError || !stat) {
         continue;
       }
@@ -60395,7 +60731,7 @@ async function createResourceBuilderServices() {
 
 // src/commands/project-utils.ts
 async function findProjectFile(projectDir) {
-  const fs = getFileSystem8();
+  const fs = getFileSystem9();
   const uiprojPath = fs.path.join(projectDir, "project.uiproj");
   const jsonProjPath = fs.path.join(projectDir, "project.json");
   if (await fs.exists(uiprojPath)) {
@@ -60424,12 +60760,12 @@ async function findProjectFile(projectDir) {
   ];
 }
 async function readProjectFile(filePath, useProjectJson) {
-  const fs = getFileSystem8();
-  const [readError, rawContent] = await catchError17(fs.readFile(filePath, "utf-8"));
+  const fs = getFileSystem9();
+  const [readError, rawContent] = await catchError18(fs.readFile(filePath, "utf-8"));
   if (readError || !rawContent) {
     return [readError ?? new Error("Unable to read project file"), null];
   }
-  const [parseError, content] = catchError17(() => JSON.parse(rawContent));
+  const [parseError, content] = catchError18(() => JSON.parse(rawContent));
   if (parseError) {
     return [
       new Error(`Invalid JSON in project file: ${parseError.message}`),
@@ -60443,12 +60779,12 @@ async function readProjectFile(filePath, useProjectJson) {
   return [null, { content, projectType }];
 }
 async function readSolutionFile(filePath) {
-  const fs = getFileSystem8();
-  const [readError, rawContent] = await catchError17(fs.readFile(filePath, "utf-8"));
+  const fs = getFileSystem9();
+  const [readError, rawContent] = await catchError18(fs.readFile(filePath, "utf-8"));
   if (readError || !rawContent) {
     return [readError ?? new Error("Unable to read solution file"), null];
   }
-  const [parseError, solution] = catchError17(() => JSON.parse(rawContent));
+  const [parseError, solution] = catchError18(() => JSON.parse(rawContent));
   if (parseError) {
     return [
       new Error(`Invalid JSON in solution file: ${parseError.message}`),
@@ -60458,7 +60794,7 @@ async function readSolutionFile(filePath) {
   return [null, { solution, rawContent }];
 }
 async function resolveSolutionFilePath(solutionFileOption, searchStartDir) {
-  const fs = getFileSystem8();
+  const fs = getFileSystem9();
   if (solutionFileOption) {
     const resolved = fs.path.resolve(fs.env.cwd(), solutionFileOption);
     const exists = await fs.exists(resolved);
@@ -60467,114 +60803,114 @@ async function resolveSolutionFilePath(solutionFileOption, searchStartDir) {
     }
     return [null, resolved];
   }
-  const [findError, found] = await catchError17(findSolutionFile(searchStartDir));
+  const [findError, found] = await catchError18(findSolutionFile(searchStartDir));
   if (findError) {
     return [findError, null];
   }
   return [null, found];
 }
 async function writeSolutionFile(filePath, solution) {
-  const fs = getFileSystem8();
-  const [writeError] = await catchError17(fs.writeFile(filePath, `${JSON.stringify(solution, null, 2)}
+  const fs = getFileSystem9();
+  const [writeError] = await catchError18(fs.writeFile(filePath, `${JSON.stringify(solution, null, 2)}
 `));
   return writeError;
 }
 async function createProjectInSolutionBuilder(solutionDir, projectId, projectName, projectType) {
-  const [servicesError, services] = await catchError17(createResourceBuilderServices());
+  const [servicesError, services] = await catchError18(createResourceBuilderServices());
   if (servicesError) {
     return servicesError;
   }
-  const [builderError, solutionBuilder] = await catchError17(services.getSolutionBuilder(solutionDir));
+  const [builderError, solutionBuilder] = await catchError18(services.getSolutionBuilder(solutionDir));
   if (builderError) {
     return builderError;
   }
-  const [createError] = await catchError17(solutionBuilder.createProjectAsync({
+  const [createError] = await catchError18(solutionBuilder.createProjectAsync({
     projectKey: projectId,
     name: projectName,
     type: projectType
   }));
-  await catchError17(solutionBuilder.disposeAsync());
+  await catchError18(solutionBuilder.disposeAsync());
   return createError;
 }
 
 // src/commands/project-add.ts
 var registerProjectAddCommand = (project) => {
-  project.command("add").description("Add an existing project to a UiPath solution").argument("<projectPath>", "Path to the project folder (must contain project.uiproj or project.json)").argument("[solutionFile]", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the project path)").trackedAction(processContext13, async (projectPath, solutionFile) => {
-    const fs = getFileSystem9();
+  project.command("add").description("Register an existing project subfolder in the .uipx solution manifest. The project folder must already reside inside the solution directory. Use 'project import' instead to copy an external project into the solution.").argument("<projectPath>", "Path to the project folder (must contain project.uiproj or project.json)").argument("[solutionFile]", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the project path)").trackedAction(processContext15, async (projectPath, solutionFile) => {
+    const fs = getFileSystem10();
     const resolvedProjectPath = fs.path.resolve(fs.env.cwd(), projectPath);
     const isResolvedProjectPathValid = await fs.exists(resolvedProjectPath);
     if (!isResolvedProjectPathValid) {
-      OutputFormatter13.error({
+      OutputFormatter15.error({
         Result: "Failure",
         Message: "Failed to add project to solution",
         Instructions: `Project folder not found: ${resolvedProjectPath}`
       });
-      processContext13.exit(1);
+      processContext15.exit(1);
       return;
     }
     const [projectFileError, projectFileInfo] = await findProjectFile(resolvedProjectPath);
     if (projectFileError) {
-      OutputFormatter13.error({
+      OutputFormatter15.error({
         Result: "Failure",
         Message: "Failed to add project to solution",
         Instructions: projectFileError.message
       });
-      processContext13.exit(1);
+      processContext15.exit(1);
       return;
     }
     const [solutionFileError, resolvedSolutionFile] = await resolveSolutionFilePath(solutionFile, resolvedProjectPath);
     if (solutionFileError) {
-      OutputFormatter13.error({
+      OutputFormatter15.error({
         Result: "Failure",
         Message: "Failed to add project to solution",
         Instructions: solutionFileError.message
       });
-      processContext13.exit(1);
+      processContext15.exit(1);
       return;
     }
     const solutionDir = fs.path.dirname(resolvedSolutionFile);
     const relativePath = fs.path.relative(solutionDir, resolvedProjectPath);
     if (relativePath.startsWith("..")) {
-      OutputFormatter13.error({
+      OutputFormatter15.error({
         Result: "Failure",
         Message: "Failed to add project to solution",
         Instructions: `Project must reside within the solution folder.
   Solution: ${solutionDir}
   Project:  ${resolvedProjectPath}`
       });
-      processContext13.exit(1);
+      processContext15.exit(1);
       return;
     }
     const [readProjectError, parsedProject] = await readProjectFile(projectFileInfo.filePath, projectFileInfo.useProjectJson);
     if (readProjectError) {
-      OutputFormatter13.error({
+      OutputFormatter15.error({
         Result: "Failure",
         Message: "Failed to add project to solution",
         Instructions: readProjectError.message
       });
-      processContext13.exit(1);
+      processContext15.exit(1);
       return;
     }
     const [readSolutionError, parsedSolution] = await readSolutionFile(resolvedSolutionFile);
     if (readSolutionError) {
-      OutputFormatter13.error({
+      OutputFormatter15.error({
         Result: "Failure",
         Message: "Failed to add project to solution",
         Instructions: readSolutionError.message
       });
-      processContext13.exit(1);
+      processContext15.exit(1);
       return;
     }
     const { solution } = parsedSolution;
     const projectRelativePath = fs.path.join(relativePath, projectFileInfo.fileName);
     const alreadyExists = solution.Projects?.some((p) => p.ProjectRelativePath === projectRelativePath);
     if (alreadyExists) {
-      OutputFormatter13.error({
+      OutputFormatter15.error({
         Result: "Failure",
         Message: "Failed to add project to solution",
         Instructions: `Project already exists in solution: ${projectRelativePath}`
       });
-      processContext13.exit(1);
+      processContext15.exit(1);
       return;
     }
     const projectId = randomUUID();
@@ -60589,25 +60925,25 @@ var registerProjectAddCommand = (project) => {
     });
     const writeError = await writeSolutionFile(resolvedSolutionFile, solution);
     if (writeError) {
-      OutputFormatter13.error({
+      OutputFormatter15.error({
         Result: "Failure",
         Message: "Failed to add project to solution",
         Instructions: writeError.message
       });
-      processContext13.exit(1);
+      processContext15.exit(1);
       return;
     }
     const createError = await createProjectInSolutionBuilder(solutionDir, projectId, projectName, parsedProject.projectType);
     if (createError) {
-      OutputFormatter13.error({
+      OutputFormatter15.error({
         Result: "Failure",
         Message: "Failed to add project to solution",
         Instructions: createError.message
       });
-      processContext13.exit(1);
+      processContext15.exit(1);
       return;
     }
-    OutputFormatter13.success({
+    OutputFormatter15.success({
       Result: "Success",
       Code: "ProjectAdd",
       Data: {
@@ -60621,70 +60957,70 @@ var registerProjectAddCommand = (project) => {
 
 // src/commands/project-import.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { catchError as catchError18, OutputFormatter as OutputFormatter14, processContext as processContext14 } from "@uipath/common";
-import { getFileSystem as getFileSystem10 } from "@uipath/filesystem";
+import { catchError as catchError19, OutputFormatter as OutputFormatter16, processContext as processContext16 } from "@uipath/common";
+import { getFileSystem as getFileSystem11 } from "@uipath/filesystem";
 var registerProjectImportCommand = (project) => {
-  project.command("import").description("Import an existing project from an external folder into the solution").requiredOption("--source <path>", "Path to the project folder to import (must contain project.uiproj or project.json)").option("--solutionFile <path>", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the current directory)").trackedAction(processContext14, async (options) => {
+  project.command("import").description("Copy an external project folder into the solution directory and register it in the .uipx manifest. Unlike 'project add' which references an existing subfolder, import copies the source files into the solution tree.").requiredOption("--source <path>", "Path to the project folder to import (must contain project.uiproj or project.json)").option("--solutionFile <path>", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the current directory)").trackedAction(processContext16, async (options) => {
     const { source: sourcePath, solutionFile } = options;
-    const fs = getFileSystem10();
+    const fs = getFileSystem11();
     const cwd = fs.env.cwd();
     const resolvedSourcePath = fs.path.resolve(cwd, sourcePath);
-    const [statError, sourceStats] = await catchError18(fs.stat(resolvedSourcePath));
+    const [statError, sourceStats] = await catchError19(fs.stat(resolvedSourcePath));
     if (statError) {
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: statError.message
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     if (!sourceStats) {
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: `Source project folder not found: ${resolvedSourcePath}`
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     if (!sourceStats.isDirectory()) {
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: `Source path is not a directory: ${resolvedSourcePath}`
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     const [projectFileError, projectFileInfo] = await findProjectFile(resolvedSourcePath);
     if (projectFileError) {
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: projectFileError.message
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     const [readProjectError, parsedProject] = await readProjectFile(projectFileInfo.filePath, projectFileInfo.useProjectJson);
     if (readProjectError) {
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: readProjectError.message
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     const [solutionFileError, resolvedSolutionFile] = await resolveSolutionFilePath(solutionFile, cwd);
     if (solutionFileError) {
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: solutionFileError.message
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     const solutionDir = fs.path.dirname(resolvedSolutionFile);
@@ -60692,45 +61028,45 @@ var registerProjectImportCommand = (project) => {
     const targetProjectPath = fs.path.join(solutionDir, projectFolderName);
     const targetAlreadyExists = await fs.exists(targetProjectPath);
     if (targetAlreadyExists) {
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: `Project already exists at destination: ${targetProjectPath}`
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     const [readSolutionError, parsedSolution] = await readSolutionFile(resolvedSolutionFile);
     if (readSolutionError) {
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: readSolutionError.message
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     const { solution, rawContent: originalSolutionContent } = parsedSolution;
     const projectRelativePath = fs.path.join(projectFolderName, projectFileInfo.fileName);
     const alreadyExists = solution.Projects?.some((p) => p.ProjectRelativePath === projectRelativePath);
     if (alreadyExists) {
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: `Project already exists in solution manifest: ${projectRelativePath}`
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
-    const [copyError] = await catchError18(fs.copyDirectory(resolvedSourcePath, targetProjectPath));
+    const [copyError] = await catchError19(fs.copyDirectory(resolvedSourcePath, targetProjectPath));
     if (copyError) {
-      await catchError18(fs.rm(targetProjectPath));
-      OutputFormatter14.error({
+      await catchError19(fs.rm(targetProjectPath));
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: `Failed to copy project: ${copyError.message}`
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     const projectId = randomUUID2();
@@ -60745,31 +61081,31 @@ var registerProjectImportCommand = (project) => {
     });
     const writeError = await writeSolutionFile(resolvedSolutionFile, solution);
     if (writeError) {
-      await catchError18(fs.rm(targetProjectPath));
-      OutputFormatter14.error({
+      await catchError19(fs.rm(targetProjectPath));
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: writeError.message
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
     const rollback = async () => {
-      await catchError18(fs.rm(targetProjectPath));
-      await catchError18(fs.writeFile(resolvedSolutionFile, originalSolutionContent));
+      await catchError19(fs.rm(targetProjectPath));
+      await catchError19(fs.writeFile(resolvedSolutionFile, originalSolutionContent));
     };
     const createError = await createProjectInSolutionBuilder(solutionDir, projectId, projectName, parsedProject.projectType);
     if (createError) {
       await rollback();
-      OutputFormatter14.error({
+      OutputFormatter16.error({
         Result: "Failure",
         Message: "Failed to import project into solution",
         Instructions: createError.message
       });
-      processContext14.exit(1);
+      processContext16.exit(1);
       return;
     }
-    OutputFormatter14.success({
+    OutputFormatter16.success({
       Result: "Success",
       Code: "ProjectImport",
       Data: {
@@ -60782,54 +61118,54 @@ var registerProjectImportCommand = (project) => {
 };
 
 // src/commands/project-remove.ts
-import { catchError as catchError19, OutputFormatter as OutputFormatter15, processContext as processContext15 } from "@uipath/common";
-import { getFileSystem as getFileSystem11 } from "@uipath/filesystem";
+import { catchError as catchError20, OutputFormatter as OutputFormatter17, processContext as processContext17 } from "@uipath/common";
+import { getFileSystem as getFileSystem12 } from "@uipath/filesystem";
 var registerProjectRemoveCommand = (project) => {
-  project.command("remove").description("Remove a project from a UiPath solution").argument("<projectPath>", "Path to the project folder to remove").argument("[solutionFile]", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the project path)").trackedAction(processContext15, async (projectPath, solutionFile) => {
-    const fs = getFileSystem11();
+  project.command("remove").description("Unregister a project from the .uipx solution manifest and remove its entry from the solution builder. Does not delete the project files from disk.").argument("<projectPath>", "Path to the project folder to remove").argument("[solutionFile]", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the project path)").trackedAction(processContext17, async (projectPath, solutionFile) => {
+    const fs = getFileSystem12();
     const resolvedProjectPath = fs.path.resolve(fs.env.cwd(), projectPath);
     const [solutionFileError, resolvedSolutionFile] = await resolveSolutionFilePath(solutionFile, resolvedProjectPath);
     if (solutionFileError) {
-      OutputFormatter15.error({
+      OutputFormatter17.error({
         Result: "Failure",
         Message: "Failed to remove project from solution",
         Instructions: solutionFileError.message
       });
-      processContext15.exit(1);
+      processContext17.exit(1);
       return;
     }
     const solutionDir = fs.path.dirname(resolvedSolutionFile);
     const relativePath = fs.path.relative(solutionDir, resolvedProjectPath);
     if (relativePath.startsWith("..")) {
-      OutputFormatter15.error({
+      OutputFormatter17.error({
         Result: "Failure",
         Message: "Failed to remove project from solution",
         Instructions: `Project must reside within the solution folder.
   Solution: ${solutionDir}
   Project:  ${resolvedProjectPath}`
       });
-      processContext15.exit(1);
+      processContext17.exit(1);
       return;
     }
     const [readSolutionError, parsedSolution] = await readSolutionFile(resolvedSolutionFile);
     if (readSolutionError) {
-      OutputFormatter15.error({
+      OutputFormatter17.error({
         Result: "Failure",
         Message: "Failed to remove project from solution",
         Instructions: readSolutionError.message
       });
-      processContext15.exit(1);
+      processContext17.exit(1);
       return;
     }
     const { solution } = parsedSolution;
     const projectIndex = (solution.Projects ?? []).findIndex((p) => fs.path.dirname(p.ProjectRelativePath) === relativePath);
     if (projectIndex === -1) {
-      OutputFormatter15.error({
+      OutputFormatter17.error({
         Result: "Failure",
         Message: "Failed to remove project from solution",
         Instructions: `Project not found in solution: ${relativePath}`
       });
-      processContext15.exit(1);
+      processContext17.exit(1);
       return;
     }
     const projects = solution.Projects ?? [];
@@ -60839,46 +61175,46 @@ var registerProjectRemoveCommand = (project) => {
     solution.Projects = projects;
     const writeError = await writeSolutionFile(resolvedSolutionFile, solution);
     if (writeError) {
-      OutputFormatter15.error({
+      OutputFormatter17.error({
         Result: "Failure",
         Message: "Failed to remove project from solution",
         Instructions: writeError.message
       });
-      processContext15.exit(1);
+      processContext17.exit(1);
       return;
     }
-    const [servicesError, services] = await catchError19(createResourceBuilderServices());
+    const [servicesError, services] = await catchError20(createResourceBuilderServices());
     if (servicesError) {
-      OutputFormatter15.error({
+      OutputFormatter17.error({
         Result: "Failure",
         Message: "Failed to remove project from solution",
         Instructions: servicesError.message
       });
-      processContext15.exit(1);
+      processContext17.exit(1);
       return;
     }
-    const [builderError, solutionBuilder] = await catchError19(services.getSolutionBuilder(solutionDir));
+    const [builderError, solutionBuilder] = await catchError20(services.getSolutionBuilder(solutionDir));
     if (builderError) {
-      OutputFormatter15.error({
+      OutputFormatter17.error({
         Result: "Failure",
         Message: "Failed to remove project from solution",
         Instructions: builderError.message
       });
-      processContext15.exit(1);
+      processContext17.exit(1);
       return;
     }
-    const [deleteProjectError] = await catchError19(solutionBuilder.deleteProjectAsync(projectId));
-    await catchError19(solutionBuilder.disposeAsync());
+    const [deleteProjectError] = await catchError20(solutionBuilder.deleteProjectAsync(projectId));
+    await catchError20(solutionBuilder.disposeAsync());
     if (deleteProjectError) {
-      OutputFormatter15.error({
+      OutputFormatter17.error({
         Result: "Failure",
         Message: "Failed to remove project from solution",
         Instructions: deleteProjectError.message
       });
-      processContext15.exit(1);
+      processContext17.exit(1);
       return;
     }
-    OutputFormatter15.success({
+    OutputFormatter17.success({
       Result: "Success",
       Code: "ProjectRemove",
       Data: {
@@ -60892,7 +61228,7 @@ var registerProjectRemoveCommand = (project) => {
 
 // src/commands/project.ts
 async function findSolutionFile(startDir) {
-  const fs = getFileSystem12();
+  const fs = getFileSystem13();
   let dir = startDir;
   while (true) {
     const entries = await fs.readdir(dir);
@@ -60911,7 +61247,7 @@ async function findSolutionFile(startDir) {
   }
 }
 var registerProjectCommand = (program) => {
-  const project = program.command("project").description("Manage projects in a UiPath solution");
+  const project = program.command("project").description("Manage projects within a UiPath solution (.uipx). Add, import, or remove automation projects (workflows, test cases, libraries) from the solution manifest.");
   registerProjectAddCommand(project);
   registerProjectImportCommand(project);
   registerProjectRemoveCommand(project);
@@ -60919,57 +61255,57 @@ var registerProjectCommand = (program) => {
 
 // src/commands/publish.ts
 import {
-  catchError as catchError20,
+  catchError as catchError21,
   extractErrorDetails as extractErrorDetails10,
-  OutputFormatter as OutputFormatter16,
-  processContext as processContext16
+  OutputFormatter as OutputFormatter18,
+  processContext as processContext18
 } from "@uipath/common";
-import { getFileSystem as getFileSystem13 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem14 } from "@uipath/filesystem";
 var registerPublishCommand = (program) => {
-  program.command("publish").description("Publish a solution package (.zip) to UiPath.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").argument("<packagePath>", "Path to a .zip package file to publish.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext16, async (packagePath, options) => {
-    const [authError, auth] = await catchError20(getSolutionAuthContext({
+  program.command("publish").description("Publish a solution package (.zip) to the UiPath solution feed. The .zip must be produced by 'solution pack'. After publishing, use 'solution deploy run' to deploy it.").option("-t, --tenant <tenant-name>", "Tenant (optional, defaults to value selected during auth)").argument("<packagePath>", "Path to a .zip package file produced by 'solution pack'.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext18, async (packagePath, options) => {
+    const [authError, auth] = await catchError21(getSolutionAuthContext({
       tenant: options.tenant,
       loginValidity: options.loginValidity
     }));
     if (authError) {
-      OutputFormatter16.error({
+      OutputFormatter18.error({
         Result: "Failure",
         Message: authError.message,
         Instructions: authError.message
       });
-      processContext16.exit(1);
+      processContext18.exit(1);
       return;
     }
-    const fs = getFileSystem13();
+    const fs = getFileSystem14();
     const resolvedPath = fs.path.resolve(packagePath);
     const fileExists = await fs.exists(resolvedPath);
     if (!fileExists) {
-      OutputFormatter16.error({
+      OutputFormatter18.error({
         Result: "Failure",
         Message: `File not found: ${resolvedPath}`,
         Instructions: `Ensure the file path is correct. Build a package first with: uip solution pack`
       });
-      processContext16.exit(1);
+      processContext18.exit(1);
       return;
     }
     if (!resolvedPath.endsWith(".zip")) {
-      OutputFormatter16.error({
+      OutputFormatter18.error({
         Result: "Failure",
         Message: `Invalid file type. Expected a .zip file, got: ${resolvedPath}`,
         Instructions: `Ensure file is a valid .zip solution package from: uip solution pack`
       });
-      processContext16.exit(1);
+      processContext18.exit(1);
       return;
     }
-    const [fileBufferError, fileBuffer] = await catchError20(fs.readFile(resolvedPath));
+    const [fileBufferError, fileBuffer] = await catchError21(fs.readFile(resolvedPath));
     if (fileBufferError) {
       const { message } = await extractErrorDetails10(fileBufferError);
-      OutputFormatter16.error({
+      OutputFormatter18.error({
         Result: "Failure",
         Message: message,
         Instructions: `Unable to read file: ${resolvedPath}`
       });
-      processContext16.exit(1);
+      processContext18.exit(1);
       return;
     }
     const configuration = new Configuration({
@@ -60977,20 +61313,20 @@ var registerPublishCommand = (program) => {
       accessToken: auth.accessToken
     });
     const api = new PipelinesApi(configuration);
-    const [uploadError, uploadResult] = await catchError20(api.pipelinesPackageUpload({
+    const [uploadError, uploadResult] = await catchError21(api.pipelinesPackageUpload({
       body: fileBuffer
     }));
     if (uploadError) {
       const { message, details } = await extractErrorDetails10(uploadError);
-      OutputFormatter16.error({
+      OutputFormatter18.error({
         Result: "Failure",
         Message: message,
         Instructions: `Ensure file is a valid .zip solution package from: uip solution pack. Details: ${details}`
       });
-      processContext16.exit(1);
+      processContext18.exit(1);
       return;
     }
-    OutputFormatter16.success({
+    OutputFormatter18.success({
       Result: "Success",
       Code: "SolutionPublish",
       Data: {
@@ -61006,13 +61342,13 @@ var registerPublishCommand = (program) => {
 // src/commands/upload.ts
 import { getLoginStatusAsync as getLoginStatusAsync5 } from "@uipath/auth";
 import {
-  catchError as catchError21,
+  catchError as catchError22,
   extractErrorMessage,
   logger as logger6,
-  OutputFormatter as OutputFormatter17,
-  processContext as processContext17
+  OutputFormatter as OutputFormatter19,
+  processContext as processContext19
 } from "@uipath/common";
-import { getFileSystem as getFileSystem14 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem15 } from "@uipath/filesystem";
 class HttpError extends Error {
   status;
   constructor(status, message) {
@@ -61066,7 +61402,7 @@ async function overwriteSolution(baseUrl, organizationName, tenantId, accessToke
 async function uploadOrOverwrite(baseUrl, organizationName, tenantId, accessToken, fileBuffer, fileName, solutionId) {
   if (solutionId) {
     logger6.info(`Attempting to overwrite existing solution ${solutionId} on Studio Web...`);
-    const [overwriteError, overwriteResult] = await catchError21(overwriteSolution(baseUrl, organizationName, tenantId, accessToken, fileBuffer, fileName, solutionId));
+    const [overwriteError, overwriteResult] = await catchError22(overwriteSolution(baseUrl, organizationName, tenantId, accessToken, fileBuffer, fileName, solutionId));
     if (!overwriteError) {
       logger6.info("Solution overwritten successfully.");
       return overwriteResult;
@@ -61081,19 +61417,19 @@ async function uploadOrOverwrite(baseUrl, organizationName, tenantId, accessToke
   return importSolution(baseUrl, organizationName, tenantId, accessToken, fileBuffer, fileName);
 }
 var registerUploadCommand = (program) => {
-  program.command("upload").description("Upload a solution to UiPath Studio Web. Accepts a solution directory, .uipx file, or .uis file.").argument("<solutionPath>", "Path to a solution directory (containing .uipx), a .uipx file, or a .uis file.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext17, async (solutionPath, options) => {
-    const fs = getFileSystem14();
-    const [loginError, loginStatus] = await catchError21(getLoginStatusAsync5({
+  program.command("upload").description("Upload a solution to UiPath Studio Web for browser-based editing. Accepts a solution directory, .uipx file, or .uis file. If the solution already exists on Studio Web (matching SolutionId in .uipx), it overwrites; otherwise imports as new.").argument("<solutionPath>", "Path to a solution directory (containing .uipx), a .uipx file, or a .uis file.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext19, async (solutionPath, options) => {
+    const fs = getFileSystem15();
+    const [loginError, loginStatus] = await catchError22(getLoginStatusAsync5({
       ensureTokenValidityMinutes: options.loginValidity
     }));
     if (loginError) {
       const errorMessage3 = await extractErrorMessage(loginError);
-      OutputFormatter17.error({
+      OutputFormatter19.error({
         Result: "Failure",
         Message: errorMessage3,
         Instructions: loginError.message
       });
-      processContext17.exit(1);
+      processContext19.exit(1);
       return;
     }
     if (loginStatus.loginStatus !== "Logged in" || !loginStatus.accessToken || !loginStatus.baseUrl) {
@@ -61133,9 +61469,9 @@ var registerUploadCommand = (program) => {
     } else if (isDirectory || isUipxFile) {
       const solutionDir = resolveSolutionDir(resolvedPath);
       tempDir = await fs.getTempDir();
-      const [bundleError, bundleResult] = await catchError21(bundleSolution(solutionDir, tempDir));
+      const [bundleError, bundleResult] = await catchError22(bundleSolution(solutionDir, tempDir));
       if (bundleError) {
-        const [cleanupError] = await catchError21(fs.rm(tempDir));
+        const [cleanupError] = await catchError22(fs.rm(tempDir));
         if (cleanupError) {
           logger6.debug(`Failed to clean up temp dir: ${cleanupError.message}`);
         }
@@ -61151,21 +61487,21 @@ var registerUploadCommand = (program) => {
       return;
     }
     try {
-      const [readError, fileBuffer] = await catchError21(fs.readFile(uisPath));
+      const [readError, fileBuffer] = await catchError22(fs.readFile(uisPath));
       if (readError || !fileBuffer) {
         outputError(`Failed to read file: ${uisPath}${readError ? ` — ${readError.message}` : ""}`);
         return;
       }
       const fileName = fs.path.basename(uisPath);
-      const [uploadError, result] = await catchError21(uploadOrOverwrite(baseUrl, organizationName, tenantId, accessToken, fileBuffer, fileName, solutionId));
+      const [uploadError, result] = await catchError22(uploadOrOverwrite(baseUrl, organizationName, tenantId, accessToken, fileBuffer, fileName, solutionId));
       if (uploadError) {
         const errorMessage3 = await extractErrorMessage(uploadError);
-        OutputFormatter17.error({
+        OutputFormatter19.error({
           Result: "Failure",
           Message: errorMessage3,
           Instructions: uploadError.message
         });
-        processContext17.exit(1);
+        processContext19.exit(1);
         return;
       }
       const returnedSolutionId = result.id ?? result.solutionId ?? solutionId;
@@ -61175,7 +61511,7 @@ var registerUploadCommand = (program) => {
       const projectId = result.projects?.[0]?.id;
       const designerSolutionId = returnedSolutionId ?? solutionId;
       const designerUrl = projectId && designerSolutionId ? `${baseUrl}/${organizationName}/studio_/designer/${projectId}?solutionId=${designerSolutionId}` : undefined;
-      OutputFormatter17.success({
+      OutputFormatter19.success({
         Result: "Success",
         Code: "SolutionUpload",
         Data: {
@@ -61187,7 +61523,7 @@ var registerUploadCommand = (program) => {
       });
     } finally {
       if (tempDir) {
-        const [cleanupError] = await catchError21(fs.rm(tempDir));
+        const [cleanupError] = await catchError22(fs.rm(tempDir));
         if (cleanupError) {
           logger6.debug(`Failed to clean up temp dir: ${cleanupError.message}`);
         }
@@ -61196,12 +61532,12 @@ var registerUploadCommand = (program) => {
   });
 };
 function outputError(message) {
-  OutputFormatter17.error({
+  OutputFormatter19.error({
     Result: "Failure",
     Message: message,
     Instructions: message
   });
-  processContext17.exit(1);
+  processContext19.exit(1);
 }
 
 // src/tool.ts